maneira mais curta de substituir caracteres em uma variável

Existem várias maneiras de substituir caracteres em uma variável.

A maneira mais curta que descobri é traté agora:

OUTPUT=a\'b\"c\`d_123and_a_lot_more
OUTPUT=$(echo "$OUTPUT"|tr -d "'\`\"")
echo $OUTPUT

Existe uma maneira mais rápida? E é este citando-seguro para citações como ', "e `si?

Vamos ver. O mais curto que posso apresentar é uma emenda da sua trsolução:

OUTPUT="$(tr -d "\"\`'" <<<$OUTPUT)"

Outras alternativas incluem a substituição de variável já mencionada, que pode ser mais curta do que a mostrada até agora:

OUTPUT="${OUTPUT//[\'\"\`]}"

E é sedclaro que isso é mais longo em termos de caracteres:

OUTPUT="$(sed s/[\'\"\`]//g <<<$OUTPUT)"

Não tenho certeza se você quer dizer o menor tempo ou o tempo gasto. Em termos de comprimento, esses dois são os mais curtos possíveis (ou, de qualquer maneira,) quando se trata de remover esses caracteres específicos. Então, qual é o mais rápido? Testei definindo a OUTPUTvariável para o que você tinha no seu exemplo, mas repeti várias dezenas de vezes:

$ echo ${#OUTPUT} 
4900

$ time tr -d "\"\`'" <<<$OUTPUT
real    0m0.002s
user    0m0.004s
sys     0m0.000s
$ time sed s/[\'\"\`]//g <<<$OUTPUT
real    0m0.005s
user    0m0.000s
sys     0m0.000s
$ time echo ${OUTPUT//[\'\"\`]}
real    0m0.027s
user    0m0.028s
sys     0m0.000s

Como você pode ver, o tré claramente o mais rápido, seguido de perto sed. Além disso, parece que o uso echoé realmente um pouco mais rápido que o uso <<<:

$ for i in {1..10}; do 
    ( time echo $OUTPUT | tr -d "\"\`'" > /dev/null ) 2>&1
done | grep -oP 'real.*m\K[\d.]+' | awk '{k+=$1;} END{print k/NR}'; 
0.0025
$ for i in {1..10}; do 
    ( time tr -d "\"\`'" <<<$OUTPUT > /dev/null ) 2>&1 
  done | grep -oP 'real.*m\K[\d.]+' | awk '{k+=$1;} END{print k/NR}'; 
0.0029

Como a diferença é pequena, executei os testes acima 10 vezes para cada um dos dois, e o mais rápido é realmente o que você tinha para começar:

echo $OUTPUT | tr -d "\"\`'" 

No entanto, isso muda quando você leva em conta a sobrecarga de atribuir a uma variável, aqui, usar tré um pouco mais lenta que a simples substituição:

$ for i in {1..10}; do
    ( time OUTPUT=${OUTPUT//[\'\"\`]} ) 2>&1
  done | grep -oP 'real.*m\K[\d.]+' | awk '{k+=$1;} END{print k/NR}'; 
0.0032

$ for i in {1..10}; do
    ( time OUTPUT=$(echo $OUTPUT | tr -d "\"\`'")) 2>&1
  done | grep -oP 'real.*m\K[\d.]+' | awk '{k+=$1;} END{print k/NR}'; 
0.0044

Portanto, em conclusão, quando você simplesmente deseja visualizar os resultados, use, trmas se quiser reatribuir a uma variável, o uso dos recursos de manipulação de string do shell é mais rápido, pois evita a sobrecarga de executar um subshell separado.

Você poderia usar substituição de variável :

$ OUTPUT=a\'b\"c\`d
$ echo "$OUTPUT"
a'b"c`d

Use essa sintaxe: ${parameter//pattern/string}para substituir todas as ocorrências do padrão pela sequência.

$ echo "${OUTPUT//\'/x}"
axb"c`d
$ echo "${OUTPUT//\"/x}"
a'bxc`d
$ echo "${OUTPUT//\`/x}"
a'b"cxd
$ echo "${OUTPUT//[\'\"\`]/x}"
axbxcxd

No bash ou zsh é:

OUTPUT="${OUTPUT//[\`\"\']/}"

Observe que ${VAR//PATTERN/}remove todas as instâncias do padrão. Para obter mais informações, expansão do parâmetro bash

Essa solução deve ser mais rápida para cadeias curtas, porque não envolve a execução de nenhum programa externo. No entanto, para strings muito longas, o oposto é verdadeiro - é melhor usar uma ferramenta dedicada para operações de texto, por exemplo:

$ OUTPUT="$(cat /usr/src/linux/.config)"

$ time (echo $OUTPUT | OUTPUT="${OUTPUT//set/abc}")
real    0m1.766s
user    0m1.681s
sys     0m0.002s

$ time (echo $OUTPUT | sed s/set/abc/g >/dev/null)
real    0m0.094s
user    0m0.078s
sys     0m0.006s

Se, por acaso, você estiver apenas tentando manipular cotações para reutilizar o shell, poderá fazer isso sem removê-las, e também é simples:

aq() { sh -c 'for a do
       alias "$((i=$i+1))=$a"
       done; alias' -- "$@"
}

Essa função shell cita qualquer matriz arg que você a entrega e incrementa sua saída por argumento iterável.

Aqui está com alguns argumentos:

aq \
"here's an
ugly one" \
"this one is \$PATHpretty bad, too" \
'this one```****```; totally sucks'

RESULTADO

1='here'"'"'s an
ugly one'
2='this one is $PATHpretty bad, too'
3='this one```****```; totally sucks'

Essa saída é da dashqual tipicamente aspas seguras saem entre aspas '"'"'. bashfaria '\''.

Substituir uma seleção de bytes únicos, sem espaço em branco e não nulos por outro byte único provavelmente pode ser feito mais rapidamente em qualquer shell POSIX com $IFSe $*.

set -f; IFS=\"\'\`; set -- $var; printf %s "$*"

RESULTADO

"some ""crazy """"""""string ""here

Aí eu apenas printfpara que você possa ver, mas é claro, se eu tivesse feito:

var="$*"

... ao invés do valor do printfcomando $var, seria o que você vê na saída.

Quando set -finstruo o shell a não glob - caso a string contenha caracteres que possam ser interpretados como padrões glob. Eu faço isso porque o analisador de shells expande os padrões glob depois de executar a divisão de campo nas variáveis. globbing pode ser reativado como set +f. Em geral - em scripts - acho útil definir meu estilo como:

#!/usr/bin/sh -f

E, em seguida, para ativar explicitamente englobamento com set +fem qualquer linha que eu poderia desejar.

A divisão do campo ocorre com base nos caracteres em $IFS.

Existem dois tipos de $IFSvalores - $IFSespaço em branco e $IFSnão-espaço em branco. $IFSos campos delimitados por espaço em branco (espaço, tabulação, nova linha) são especificados para eleger, por sequência, um único campo (ou nenhum, se não precederem outra coisa) - então ...

IFS=\ ; var='      '; printf '<%s>' $var
<>

Mas todos os outros são especificados para avaliar um único campo por ocorrência - eles não são truncados.

IFS=/; var='/////'; printf '<%s>' $var
<><><><><>

Todas as expansões variáveis ​​são, por padrão, $IFSmatrizes de dados delimitadas - elas são divididas em campos separados de acordo com $IFS. Ao "citar uma, você substitui a propriedade da matriz e a avalia como uma única sequência.

Então, quando eu faço ...

IFS=\"\'\`; set -- $var

Estou definindo a matriz de argumentos do shell para os muitos $IFScampos delimitados gerados pela $varexpansão do. Quando é expandido, seus valores constituintes para os caracteres contidos $IFSsão perdidos - eles são apenas separadores de campo agora - eles são \0NUL.

"$*"- como outras expansões variáveis ​​de aspas duplas - também substitui as qualidades de divisão de campos de $IFS. Mas, além disso , ele substitui o primeiro byte no $IFS para cada campo delimitado em "$@". Então, porque "foi o primeiro valor em $IFS todos os delimitadores subseqüentes "em que se tornou "$*". E a "necessidade também não está presente $IFSquando você a divide. Você poderia alterar $IFS depois set -- $args para outro valor completamente e seu novo primeiro byte apareceria para os delimitadores de campo em "$*". Além disso, você pode remover todos os traços deles como:

set -- $var; IFS=; printf %s "$*"

RESULTADO

some crazy string here