Quais caracteres precisam ser escapados ao usar o Bash?

Existe alguma lista abrangente de caracteres que precisam ser escapados no Bash? Pode ser verificado apenas com sed?

Em particular, eu estava verificando se é %necessário escapar ou não. eu tentei

echo "h%h" | sed 's/%/i/g'

e funcionou bem, sem escapar %. Isso significa %que não precisa ser escapado? Essa foi uma boa maneira de verificar a necessidade?

E mais geral: eles são os mesmos personagens para escapar shelle bash?

Existem duas regras fáceis e seguras que funcionam não apenas shcomo também bash.

1. Coloque a string inteira entre aspas simples

Isso funciona para todos os caracteres, exceto as aspas simples. Para escapar da aspas simples, feche as aspas antes dela, insira a aspas simples e reabra a aspas.

'I'\''m a s@fe $tring which ends in newline
'

comando sed: sed -e "s/'/'\\\\''/g; 1s/^/'/; \$s/\$/'/"

2. Escape de todos os caracteres com uma barra invertida

Isso funciona para todos os caracteres, exceto nova linha. Para caracteres de nova linha, use aspas simples ou duplas. As strings vazias ainda devem ser manuseadas - substitua por""

\I\'\m\ \a\ \s\@\f\e\ \$\t\r\i\n\g\ \w\h\i\c\h\ \e\n\d\s\ \i\n\ \n\e\w\l\i\n\e"
"

comando sed: sed -e 's/./\\&/g; 1{$s/^$/""/}; 1!s/^/"/; $!s/$/"/'.

2b. Versão mais legível do 2

Há um conjunto fácil de caracteres seguro, como [a-zA-Z0-9,._+:@%/-], que pode ser deixado sem escape para mantê-lo mais legível

I\'m\ a\ s@fe\ \$tring\ which\ ends\ in\ newline"
"

comando sed: LC_ALL=C sed -e 's/[^a-zA-Z0-9,._+@%/-]/\\&/g; 1{$s/^$/""/}; 1!s/^/"/; $!s/$/"/'.

Observe que em um programa sed, não se pode saber se a última linha de entrada termina com um byte de nova linha (exceto quando está vazio). É por isso que ambos os comandos sed acima assumem que não. Você pode adicionar uma nova linha entre aspas manualmente.

Observe que variáveis ​​de shell são definidas apenas para texto no sentido POSIX. O processamento de dados binários não está definido. Para as implementações importantes, o binário funciona com exceção de bytes NUL (porque as variáveis ​​são implementadas com cadeias C e devem ser usadas como cadeias C, ou seja, argumentos de programa), mas você deve alternar para um código de idioma "binário", como latin1 .

(Você pode validar facilmente as regras lendo a especificação POSIX para sh. Para o bash, consulte o manual de referência vinculado por @AustinPhillips)

formato que pode ser reutilizado como entrada do shell

Existe uma diretiva de formato especial printf ( %q) criada para este tipo de solicitação:

formato printf [-v var] [argumentos]

 %q     causes printf to output the corresponding argument
        in a format that can be reused as shell input.

Algumas amostras:

read foo
Hello world
printf "%q\n" "$foo"
Hello\ world

printf "%q\n" $'Hello world!\n'
$'Hello world!\n'

Isso também pode ser usado através de variáveis:

printf -v var "%q" "$foo
"
echo "$var"
$'Hello world\n'

Verificação rápida com todos os (128) bytes ascii:

Observe que todos os bytes de 128 a 255 precisam ser escapados.

for i in {0..127} ;do
    printf -v var \\%o $i
    printf -v var $var
    printf -v res "%q" "$var"
    esc=E
    [ "$var" = "$res" ] && esc=-
    printf "%02X %s %-7s\n" $i $esc "$res"
done |
    column

Isso deve render algo como:

00 E ''         1A E $'\032'    34 - 4          4E - N          68 - h      
01 E $'\001'    1B E $'\E'      35 - 5          4F - O          69 - i      
02 E $'\002'    1C E $'\034'    36 - 6          50 - P          6A - j      
03 E $'\003'    1D E $'\035'    37 - 7          51 - Q          6B - k      
04 E $'\004'    1E E $'\036'    38 - 8          52 - R          6C - l      
05 E $'\005'    1F E $'\037'    39 - 9          53 - S          6D - m      
06 E $'\006'    20 E \          3A - :          54 - T          6E - n      
07 E $'\a'      21 E \!         3B E \;         55 - U          6F - o      
08 E $'\b'      22 E \"         3C E \<         56 - V          70 - p      
09 E $'\t'      23 E \#         3D - =          57 - W          71 - q      
0A E $'\n'      24 E \$         3E E \>         58 - X          72 - r      
0B E $'\v'      25 - %          3F E \?         59 - Y          73 - s      
0C E $'\f'      26 E \&         40 - @          5A - Z          74 - t      
0D E $'\r'      27 E \'         41 - A          5B E \[         75 - u      
0E E $'\016'    28 E \(         42 - B          5C E \\         76 - v      
0F E $'\017'    29 E \)         43 - C          5D E \]         77 - w      
10 E $'\020'    2A E \*         44 - D          5E E \^         78 - x      
11 E $'\021'    2B - +          45 - E          5F - _          79 - y      
12 E $'\022'    2C E \,         46 - F          60 E \`         7A - z      
13 E $'\023'    2D - -          47 - G          61 - a          7B E \{     
14 E $'\024'    2E - .          48 - H          62 - b          7C E \|     
15 E $'\025'    2F - /          49 - I          63 - c          7D E \}     
16 E $'\026'    30 - 0          4A - J          64 - d          7E E \~     
17 E $'\027'    31 - 1          4B - K          65 - e          7F E $'\177'
18 E $'\030'    32 - 2          4C - L          66 - f      
19 E $'\031'    33 - 3          4D - M          67 - g      

Onde o primeiro campo é o valor hexa do byte, o segundo contém Ese o caractere precisa ser escapado e o terceiro campo mostra a apresentação do caractere escapado.

Por que ,?

Você pode ver alguns caracteres que nem sempre precisam ser escapados, como ,, }e {.

Então nem sempre, mas em algum momento :

echo test 1, 2, 3 and 4,5.
test 1, 2, 3 and 4,5.

ou

echo test { 1, 2, 3 }
test { 1, 2, 3 }

mas cuidado:

echo test{1,2,3}
test1 test2 test3

echo test\ {1,2,3}
test 1 test 2 test 3

echo test\ {\ 1,\ 2,\ 3\ }
test  1 test  2 test  3

echo test\ {\ 1\,\ 2,\ 3\ }
test  1, 2 test  3 

Para evitar que outra pessoa precise RTFM ... no bash :

Anexando caracteres entre aspas duplas preserva o valor literal de todos os caracteres entre as aspas, com exceção de $, `, \, e, quando a expansão história está habilitado, !.

... então, se você escapar desses (e da própria citação, é claro), provavelmente estará bem.

Se você adotar uma abordagem mais conservadora 'em caso de dúvida, escape', deve ser possível evitar obter caracteres com significado especial, não escapando aos caracteres identificadores (ou seja, letras ASCII, números ou '_'). É muito improvável que eles tenham um significado especial e, portanto, precisem ser escapados.

Usando a print '%q' técnica , podemos executar um loop para descobrir quais caracteres são especiais:

#!/bin/bash
special=$'`!@#$%^&*()-_+={}|[]\\;\':",.<>?/ '
for ((i=0; i < ${#special}; i++)); do
    char="${special:i:1}"
    printf -v q_char '%q' "$char"
    if [[ "$char" != "$q_char" ]]; then
        printf 'Yes - character %s needs to be escaped\n' "$char"
    else
        printf 'No - character %s does not need to be escaped\n' "$char"
    fi
done | sort

Dá esta saída:

No, character % does not need to be escaped
No, character + does not need to be escaped
No, character - does not need to be escaped
No, character . does not need to be escaped
No, character / does not need to be escaped
No, character : does not need to be escaped
No, character = does not need to be escaped
No, character @ does not need to be escaped
No, character _ does not need to be escaped
Yes, character   needs to be escaped
Yes, character ! needs to be escaped
Yes, character " needs to be escaped
Yes, character # needs to be escaped
Yes, character $ needs to be escaped
Yes, character & needs to be escaped
Yes, character ' needs to be escaped
Yes, character ( needs to be escaped
Yes, character ) needs to be escaped
Yes, character * needs to be escaped
Yes, character , needs to be escaped
Yes, character ; needs to be escaped
Yes, character < needs to be escaped
Yes, character > needs to be escaped
Yes, character ? needs to be escaped
Yes, character [ needs to be escaped
Yes, character \ needs to be escaped
Yes, character ] needs to be escaped
Yes, character ^ needs to be escaped
Yes, character ` needs to be escaped
Yes, character { needs to be escaped
Yes, character | needs to be escaped
Yes, character } needs to be escaped

Alguns dos resultados, como ,parecem um pouco suspeitos. Seria interessante obter as contribuições de @ CharlesDuffy sobre isso.

Os caracteres que precisam ser escapados são diferentes no shell Bourne ou POSIX e no Bash. Geralmente (muito) o Bash é um superconjunto dessas conchas; portanto, tudo o que você escapar shelldeve escapar no Bash.

Uma boa regra geral seria "em caso de dúvida, escape". Mas escapar de alguns personagens lhes dá um significado especial, como \n. Eles estão listados nas man bashpáginas em Quotinge echo.

Fora isso, escape de qualquer caractere que não seja alfanumérico; é mais seguro. Não conheço uma única lista definitiva.

As páginas de manual listam todas elas em algum lugar, mas não em um só lugar. Aprenda o idioma, esse é o caminho para ter certeza.

Um que me chamou a atenção é !. Este é um caractere especial (expansão do histórico) no Bash (e csh), mas não no shell Korn. Até echo "Hello world!"dá problemas. Usar aspas simples, como sempre, remove o significado especial.

Presumo que você esteja falando sobre strings do bash. Existem diferentes tipos de strings que possuem um conjunto diferente de requisitos para escapar. por exemplo. As strings de aspas simples são diferentes das strings de aspas duplas.

A melhor referência é a citação seção do manual bash.

Explica quais caracteres precisam ser escapados. Observe que alguns caracteres podem precisar ser escapados, dependendo de quais opções estão ativadas, como a expansão do histórico.

Notei que o bash escapa automaticamente alguns caracteres ao usar o preenchimento automático.

Por exemplo, se você tiver um diretório chamado dir:A, o bash será concluído automaticamente paradir\:A

Usando isso, realizei algumas experiências usando caracteres da tabela ASCII e derivou as seguintes listas:

Caracteres que o bash escapa ao concluir automaticamente : (inclui espaço)

 !"$&'()*,:;<=>?@[\]^`{|}

Personagens que o bash não escapa :

#%+-.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz~

(Excluí /, pois não pode ser usado em nomes de diretório)