Como escapar aspas simples em cadeias de caracteres entre aspas simples

Digamos que você tenha um Bash aliascomo:

alias rxvt='urxvt'

o que funciona bem

Contudo:

alias rxvt='urxvt -fg '#111111' -bg '#111111''

não funcionará e nem:

alias rxvt='urxvt -fg \'#111111\' -bg \'#111111\''

Então, como você acaba combinando as aspas de abertura e fechamento dentro de uma string depois de ter escapado das aspas?

alias rxvt='urxvt -fg'\''#111111'\'' -bg '\''#111111'\''

parece desajeitado, embora represente a mesma string se você puder concatená-las dessa maneira.

Se você realmente deseja usar aspas simples na camada mais externa, lembre-se de colar os dois tipos de cotação. Exemplo:

 alias rxvt='urxvt -fg '"'"'#111111'"'"' -bg '"'"'#111111'"'"
 #                     ^^^^^       ^^^^^     ^^^^^       ^^^^
 #                     12345       12345     12345       1234

Explicação de como '"'"'é interpretado como justo ':

1. ' Finalize a primeira cotação que usa aspas simples.
2. " Inicie a segunda cotação, usando aspas duplas.
3. ' Caractere citado.
4. " Finalize a segunda cotação, usando aspas duplas.
5. ' Inicie a terceira cotação, usando aspas simples.

Se você não colocar espaços em branco entre (1) e (2) ou entre (4) e (5), o shell interpretará essa sequência como uma palavra longa.

Eu sempre substituo cada aspas simples incorporada pela sequência: '\''(que é: aspas de barra invertida entre aspas) que fecha a sequência, anexa uma aspas simples escapada e reabre a sequência.

Costumo criar uma função "quotify" nos meus scripts Perl para fazer isso por mim. Os passos seriam:

s/'/'\\''/g    # Handle each embedded quote
$_ = qq['$_']; # Surround result with single quotes.

Isso praticamente cuida de todos os casos.

A vida fica mais divertida quando você introduz evalseus scripts de shell. Você basicamente tem que refazer tudo novamente!

Por exemplo, crie um script Perl chamado quotify contendo as instruções acima:

#!/usr/bin/perl -pl
s/'/'\\''/g;
$_ = qq['$_'];

use-o para gerar uma sequência de caracteres corretamente citada:

$ quotify
urxvt -fg '#111111' -bg '#111111'

resultado:

'urxvt -fg '\''#111111'\'' -bg '\''#111111'\'''

que pode ser copiado / colado no comando alias:

alias rxvt='urxvt -fg '\''#111111'\'' -bg '\''#111111'\'''

(Se você precisar inserir o comando em uma avaliação, execute o quotify novamente:

 $ quotify
 alias rxvt='urxvt -fg '\''#111111'\'' -bg '\''#111111'\'''

resultado:

'alias rxvt='\''urxvt -fg '\''\'\'''\''#111111'\''\'\'''\'' -bg '\''\'\'''\''#111111'\''\'\'''\'''\'''

que pode ser copiado / colado em uma avaliação:

eval 'alias rxvt='\''urxvt -fg '\''\'\'''\''#111111'\''\'\'''\'' -bg '\''\'\'''\''#111111'\''\'\'''\'''\'''

Desde a sintaxe do Bash 2.04$'string' (em vez de apenas 'string'; aviso: não confunda com $('string')) é outro mecanismo de citação que permite seqüências de escape do tipo ANSI C e faz expansão para a versão de citação única.

Exemplo simples:

  $> echo $'aa\'bb'
  aa'bb

  $> alias myvar=$'aa\'bb'
  $> alias myvar
  alias myvar='aa'\''bb'

No seu caso:

$> alias rxvt=$'urxvt -fg \'#111111\' -bg \'#111111\''
$> alias rxvt
alias rxvt='urxvt -fg '\''#111111'\'' -bg '\''#111111'\'''

Sequências de escape comuns funcionam conforme o esperado:

\'     single quote
\"     double quote
\\     backslash
\n     new line
\t     horizontal tab
\r     carriage return

Abaixo está a cópia + documentação relacionada colada de man bash(versão 4.4):

Palavras da forma $ 'string' são tratadas especialmente. A palavra se expande para cadeia, com caracteres de escape com barra invertida substituídos conforme especificado pelo padrão ANSI C. Seqüências de escape de barra invertida, se presentes, são decodificadas da seguinte maneira:

    \a     alert (bell)
    \b     backspace
    \e
    \E     an escape character
    \f     form feed
    \n     new line
    \r     carriage return
    \t     horizontal tab
    \v     vertical tab
    \\     backslash
    \'     single quote
    \"     double quote
    \?     question mark
    \nnn   the eight-bit character whose value is the octal 
           value nnn (one to three digits)
    \xHH   the eight-bit character whose value is the hexadecimal
           value HH (one or two hex digits)
    \uHHHH the Unicode (ISO/IEC 10646) character whose value is 
           the hexadecimal value HHHH (one to four hex digits)
    \UHHHHHHHH the Unicode (ISO/IEC 10646) character whose value 
               is the hexadecimal value HHHHHHHH (one to eight 
               hex digits)
    \cx    a control-x character

O resultado expandido é de aspas simples, como se o cifrão não estivesse presente.

Veja Citações e escape: ANSI C como strings no wiki do bash-hackers.org para mais detalhes. Observe também que o arquivo "Bash Changes" ( visão geral aqui ) menciona muito as alterações e correções de bugs relacionadas ao $'string'mecanismo de cotação.

De acordo com unix.stackexchange.com Como usar um caractere especial como normal? deve funcionar (com algumas variações) no bash, zsh, mksh, ksh93 e FreeBSD e busybox sh.

Não vejo a entrada em seu blog (link pls?), Mas de acordo com o manual de referência do gnu :

Os caracteres entre aspas simples ('' ') preservam o valor literal de cada caractere entre aspas. Uma aspas simples pode não ocorrer entre aspas simples, mesmo quando precedida por uma barra invertida.

então bash não vai entender:

alias x='y \'z '

no entanto, você pode fazer isso se estiver entre aspas duplas:

alias x="echo \'y "
> x
> 'y

Posso confirmar que o uso '\''de uma única citação dentro de uma sequência de aspas simples funciona no Bash e pode ser explicado da mesma maneira que o argumento "colar" anteriormente no thread. Suponha que tenhamos uma string entre aspas: 'A '\''B'\'' C'(todas as aspas aqui são aspas simples). Se ele é passado para echo, ele imprime o seguinte: A 'B' C. Em cada uma, '\''a primeira citação fecha a cadeia de citação única atual, a seguir \'cola uma citação única na cadeia de caracteres anterior ( \'é uma maneira de especificar uma citação única sem iniciar uma cadeia de citação) e a última citação abre outra cadeia de citação única.

Ambas as versões estão funcionando, com concatenação usando o caractere de aspas simples (\ ') ou com concatenação colocando o caractere de aspas simples entre aspas duplas ("'").

O autor da pergunta não percebeu que havia uma citação única extra (') no final de sua última tentativa de fuga:

alias rxvt='urxvt -fg'\''#111111'\'' -bg '\''#111111'\''
           │         │┊┊|       │┊┊│     │┊┊│       │┊┊│
           └─STRING──┘┊┊└─STRIN─┘┊┊└─STR─┘┊┊└─STRIN─┘┊┊│
                      ┊┊         ┊┊       ┊┊         ┊┊│
                      ┊┊         ┊┊       ┊┊         ┊┊│
                      └┴─────────┴┴───┰───┴┴─────────┴┘│
                          All escaped single quotes    │
                                                       │
                                                       ?

Como você pode ver na bela peça anterior da arte ASCII / Unicode, a última aspas simples (\ ') com escape é seguida por uma aspas simples desnecessária ('). Usar um marcador de sintaxe como o presente no Notepad ++ pode ser muito útil.

O mesmo vale para outro exemplo como o seguinte:

alias rc='sed '"'"':a;N;$!ba;s/\n/, /g'"'"
alias rc='sed '\'':a;N;$!ba;s/\n/, /g'\'

Essas duas belas instâncias de aliases mostram de maneira muito complexa e ofuscada como um arquivo pode ser alinhado. Ou seja, de um arquivo com muitas linhas, você obtém apenas uma linha com vírgulas e espaços entre o conteúdo das linhas anteriores. Para entender o comentário anterior, a seguir é um exemplo:

$ cat Little_Commas.TXT
201737194
201802699
201835214

$ rc Little_Commas.TXT
201737194, 201802699, 201835214

Exemplo simples de escape de aspas no shell:

$ echo 'abc'\''abc'
abc'abc
$ echo "abc"\""abc"
abc"abc

Isso é feito finalizando um já aberto ( '), colocando um escapado ( \') e depois outro ( '). Essa sintaxe funciona para todos os comandos. É uma abordagem muito semelhante à 1ª resposta.

Não estou abordando especificamente a questão das citações porque, bem, às vezes, é apenas razoável considerar uma abordagem alternativa.

rxvt() { urxvt -fg "#${1:-000000}" -bg "#${2:-FFFFFF}"; }

que você pode chamar como:

rxvt 123456 654321

a ideia é que agora você pode alias isso sem se preocupar com aspas:

alias rxvt='rxvt 123456 654321'

ou, se você precisar incluir #todas as chamadas por algum motivo:

rxvt() { urxvt -fg "${1:-#000000}" -bg "${2:-#FFFFFF}"; }

que você pode chamar como:

rxvt '#123456' '#654321'

então, é claro, um alias é:

alias rxvt="rxvt '#123456' '#654321'"

(opa, acho que meio que resolvi a citação :)

Como não é possível colocar aspas simples em seqüências de caracteres entre aspas, a opção mais simples e legível é usar uma sequência HEREDOC

command=$(cat <<'COMMAND'
urxvt -fg '#111111' -bg '#111111'
COMMAND
)

alias rxvt=$command

No código acima, o HEREDOC é enviado ao catcomando e a saída disso é atribuída a uma variável por meio da notação de substituição de comando$(..)

É necessário colocar uma única cotação no HEREDOC, pois ele está dentro de um $()

Eu apenas uso códigos de shell ... por exemplo, \x27ou \\x22conforme aplicável. Sem problemas, realmente.

A maioria dessas respostas ocorre no caso específico sobre o qual você está perguntando. Há uma abordagem geral que um amigo e tenho desenvolvido que permite arbitrária citando em caso de necessidade de citação do bash comandos através de várias camadas de expansão shell, por exemplo, através de ssh, su -c, bash -c, etc. Há um núcleo primitivo você precisa, aqui no bash nativo:

quote_args() {
    local sq="'"
    local dq='"'
    local space=""
    local arg
    for arg; do
        echo -n "$space'${arg//$sq/$sq$dq$sq$dq$sq}'"
        space=" "
    done
}

Isso faz exatamente o que diz: aspas de cada argumento individualmente (após a expansão do bash, é claro):

$ quote_args foo bar
'foo' 'bar'
$ quote_args arg1 'arg2 arg2a' arg3
'arg1' 'arg2 arg2a' 'arg3'
$ quote_args dq'"'
'dq"'
$ quote_args dq'"' sq"'"
'dq"' 'sq'"'"''
$ quote_args "*"
'*'
$ quote_args /b*
'/bin' '/boot'

Faz o óbvio para uma camada de expansão:

$ bash -c "$(quote_args echo a'"'b"'"c arg2)"
a"b'c arg2

(Observe que as aspas duplas $(quote_args ...)são necessárias para transformar o resultado em um único argumento para bash -c.) E pode ser usado de maneira mais geral para citar corretamente através de várias camadas de expansão:

$ bash -c "$(quote_args bash -c "$(quote_args echo a'"'b"'"c arg2)")"
a"b'c arg2

O exemplo acima:

1. aspas shell cada argumento para o interior quote_args individualmente e, em seguida, combina a saída resultante em um único argumento com as aspas duplas internas.
2. citações do shell bash,-c e o resultado já uma vez citado a partir do passo 1, e em seguida, combina o resultado em uma única discussão com as aspas duplas exteriores.
3. envia essa bagunça como argumento para o exterior bash -c.

Essa é a ideia em poucas palavras. Você pode fazer algumas coisas bem complicadas com isso, mas precisa ter cuidado com a ordem da avaliação e com quais substrings são citados. Por exemplo, o seguinte faz as coisas erradas (para alguma definição de "errado"):

$ (cd /tmp; bash -c "$(quote_args cd /; pwd 1>&2)")
/tmp
$ (cd /tmp; bash -c "$(quote_args cd /; [ -e *sbin ] && echo success 1>&2 || echo failure 1>&2)")
failure

No primeiro exemplo, o bash se expande imediatamente quote_args cd /; pwd 1>&2para dois comandos separados quote_args cd /e pwd 1>&2, portanto, o CWD permanece /tmpquando o pwdcomando é executado. O segundo exemplo ilustra um problema semelhante para globbing. De fato, o mesmo problema básico ocorre com todas as expansões do bash. O problema aqui é que uma substituição de comando não é uma chamada de função: está literalmente avaliando um script bash e usando sua saída como parte de outro script bash.

Se você tentar simplesmente escapar dos operadores de shell, falhará porque a cadeia resultante transmitida bash -cé apenas uma sequência de cadeias citadas individualmente que não são interpretadas como operadores, o que é fácil de ver se você faz eco à cadeia que seria foram passados ​​para o bash:

$ (cd /tmp; echo "$(quote_args cd /\; pwd 1\>\&2)")
'cd' '/;' 'pwd' '1>&2'
$ (cd /tmp; echo "$(quote_args cd /\; \[ -e \*sbin \] \&\& echo success 1\>\&2 \|\| echo failure 1\>\&2)")
'cd' '/;' '[' '-e' '*sbin' ']' '&&' 'echo' 'success' '1>&2' '||' 'echo' 'failure' '1>&2'

O problema aqui é que você está citando demais. O que você precisa é que os operadores não sejam cotados como entrada para o anexo bash -c, o que significa que eles precisam estar fora da $(quote_args ...)substituição de comando.

Consequentemente, o que você precisa fazer no sentido mais geral é citar shell cada palavra do comando que não pretende ser expandida no momento da substituição do comando separadamente e não aplicar nenhuma citação extra aos operadores do shell:

$ (cd /tmp; echo "$(quote_args cd /); $(quote_args pwd) 1>&2")
'cd' '/'; 'pwd' 1>&2
$ (cd /tmp; bash -c "$(quote_args cd /); $(quote_args pwd) 1>&2")
/
$ (cd /tmp; echo "$(quote_args cd /); [ -e *$(quote_args sbin) ] && $(quote_args echo success) 1>&2 || $(quote_args echo failure) 1>&2")
'cd' '/'; [ -e *'sbin' ] && 'echo' 'success' 1>&2 || 'echo' 'failure' 1>&2
$ (cd /tmp; bash -c "$(quote_args cd /); [ -e *$(quote_args sbin) ] && $(quote_args echo success) 1>&2 || $(quote_args echo failure) 1>&2")
success

Depois de fazer isso, a sequência inteira é um jogo justo para citar ainda mais os níveis arbitrários de avaliação:

$ bash -c "$(quote_args cd /tmp); $(quote_args bash -c "$(quote_args cd /); $(quote_args pwd) 1>&2")"
/
$ bash -c "$(quote_args bash -c "$(quote_args cd /tmp); $(quote_args bash -c "$(quote_args cd /); $(quote_args pwd) 1>&2")")"
/
$ bash -c "$(quote_args bash -c "$(quote_args bash -c "$(quote_args cd /tmp); $(quote_args bash -c "$(quote_args cd /); $(quote_args pwd) 1>&2")")")"
/
$ bash -c "$(quote_args cd /tmp); $(quote_args bash -c "$(quote_args cd /); [ -e *$(quote_args sbin) ] && $(quote_args echo success) 1>&2 || $(quote_args echo failure) 1>&2")"
success
$ bash -c "$(quote_args bash -c "$(quote_args cd /tmp); $(quote_args bash -c "$(quote_args cd /); [ -e *sbin ] && $(quote_args echo success) 1>&2 || $(quote_args echo failure) 1>&2")")"
success
$ bash -c "$(quote_args bash -c "$(quote_args bash -c "$(quote_args cd /tmp); $(quote_args bash -c "$(quote_args cd /); [ -e *$(quote_args sbin) ] && $(quote_args echo success) 1>&2 || $(quote_args echo failure) 1>&2")")")"
success

etc.

Esses exemplos podem parecer exagerados, considerando que palavras como success, sbine pwdnão precisam ser citadas pelo shell, mas o ponto-chave a ser lembrado ao escrever um script com entrada arbitrária é que você deseja citar tudo o que não tem certeza absoluta de que não é ' Não é necessário citar, porque você nunca sabe quando um usuário lançará um Robert'; rm -rf /.

Para entender melhor o que está acontecendo debaixo das cobertas, você pode brincar com duas pequenas funções auxiliares:

debug_args() {
    for (( I=1; $I <= $#; I++ )); do
        echo -n "$I:<${!I}> " 1>&2
    done
    echo 1>&2
}

debug_args_and_run() {
    debug_args "$@"
    "$@"
}

que enumerará cada argumento em um comando antes de executá-lo:

$ debug_args_and_run echo a'"'b"'"c arg2
1:<echo> 2:<a"b'c> 3:<arg2> 
a"b'c arg2

$ bash -c "$(quote_args debug_args_and_run echo a'"'b"'"c arg2)"
1:<echo> 2:<a"b'c> 3:<arg2> 
a"b'c arg2

$ bash -c "$(quote_args debug_args_and_run bash -c "$(quote_args debug_args_and_run echo a'"'b"'"c arg2)")"
1:<bash> 2:<-c> 3:<'debug_args_and_run' 'echo' 'a"b'"'"'c' 'arg2'> 
1:<echo> 2:<a"b'c> 3:<arg2> 
a"b'c arg2

$ bash -c "$(quote_args debug_args_and_run bash -c "$(quote_args debug_args_and_run bash -c "$(quote_args debug_args_and_run echo a'"'b"'"c arg2)")")"
1:<bash> 2:<-c> 3:<'debug_args_and_run' 'bash' '-c' ''"'"'debug_args_and_run'"'"' '"'"'echo'"'"' '"'"'a"b'"'"'"'"'"'"'"'"'c'"'"' '"'"'arg2'"'"''> 
1:<bash> 2:<-c> 3:<'debug_args_and_run' 'echo' 'a"b'"'"'c' 'arg2'> 
1:<echo> 2:<a"b'c> 3:<arg2> 
a"b'c arg2

$ bash -c "$(quote_args debug_args_and_run bash -c "$(quote_args debug_args_and_run bash -c "$(quote_args debug_args_and_run bash -c "$(quote_args debug_args_and_run echo a'"'b"'"c arg2)")")")"
1:<bash> 2:<-c> 3:<'debug_args_and_run' 'bash' '-c' ''"'"'debug_args_and_run'"'"' '"'"'bash'"'"' '"'"'-c'"'"' '"'"''"'"'"'"'"'"'"'"'debug_args_and_run'"'"'"'"'"'"'"'"' '"'"'"'"'"'"'"'"'echo'"'"'"'"'"'"'"'"' '"'"'"'"'"'"'"'"'a"b'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'c'"'"'"'"'"'"'"'"' '"'"'"'"'"'"'"'"'arg2'"'"'"'"'"'"'"'"''"'"''> 
1:<bash> 2:<-c> 3:<'debug_args_and_run' 'bash' '-c' ''"'"'debug_args_and_run'"'"' '"'"'echo'"'"' '"'"'a"b'"'"'"'"'"'"'"'"'c'"'"' '"'"'arg2'"'"''> 
1:<bash> 2:<-c> 3:<'debug_args_and_run' 'echo' 'a"b'"'"'c' 'arg2'> 
1:<echo> 2:<a"b'c> 3:<arg2> 
a"b'c arg2

IMHO, a resposta real é que você não pode escapar de aspas simples em strings de aspas simples.

É impossível.

Se presumimos que estamos usando o bash.

Do manual do bash ...

Enclosing characters in single quotes preserves the literal value of each
character within the quotes.  A single quote may not occur
between single quotes, even when preceded by a backslash.

Você precisa usar um dos outros mecanismos de escape de cadeia "ou \

Não há nada mágico sobre alias nisso que exija o uso de aspas simples.

Ambos os trabalhos a seguir no bash.

alias rxvt="urxvt -fg '#111111' -bg '#111111'"
alias rxvt=urxvt\ -fg\ \'#111111\'\ -bg\ \'#111111\'

O último está usando \ para escapar do caractere de espaço.

Também não há nada mágico no # 111111 que exija aspas simples.

As seguintes opções alcançam o mesmo resultado que as outras duas opções, pois o alias rxvt funciona conforme o esperado.

alias rxvt='urxvt -fg "#111111" -bg "#111111"'
alias rxvt="urxvt -fg \"#111111\" -bg \"#111111\""

Você também pode escapar do problemático # diretamente

alias rxvt="urxvt -fg \#111111 -bg \#111111"

No exemplo dado, basta usar aspas duplas em vez de aspas simples como mecanismo de escape externo:

alias rxvt="urxvt -fg '#111111' -bg '#111111'"

Essa abordagem é adequada para muitos casos em que você apenas deseja passar uma string fixa para um comando: verifique como o shell interpretará a string de aspas duplas por meio de um echo e, se necessário, escape caracteres com barra invertida.

No exemplo, você verá que aspas duplas são suficientes para proteger a string:

$ echo "urxvt -fg '#111111' -bg '#111111'"
urxvt -fg '#111111' -bg '#111111'

Obviamente, seria mais fácil simplesmente colocar entre aspas duplas, mas qual é o desafio nisso? Aqui está a resposta usando apenas aspas simples. Estou usando uma variável em vez de, aliasentão é mais fácil imprimir para prova, mas é o mesmo que usar alias.

$ rxvt='urxvt -fg '\''#111111'\'' -bg '\''#111111'\'
$ echo $rxvt
urxvt -fg '#111111' -bg '#111111'

Explicação

A chave é que você pode fechar a aspas simples e reabri-las quantas vezes quiser. Por exemplo, foo='a''b'é o mesmo que foo='ab'. Assim, você pode fechar a aspas simples, inserir uma aspas simples literal \'e reabrir a próxima aspas simples.

Diagrama de detalhamento

Este diagrama deixa claro usando colchetes para mostrar onde as aspas simples são abertas e fechadas. As aspas não são "aninhadas", como podem ser parênteses. Você também pode prestar atenção ao realce de cores, que é aplicado corretamente. As strings citadas são marrons, enquanto as \'são pretas.

'urxvt -fg '\''#111111'\'' -bg '\''#111111'\'    # original
[^^^^^^^^^^] ^[^^^^^^^] ^[^^^^^] ^[^^^^^^^] ^    # show open/close quotes
 urxvt -fg   ' #111111  '  -bg   ' #111111  '    # literal characters remaining

(Essa é essencialmente a mesma resposta que a de Adrian, mas acho que isso explica melhor. Também a resposta dele tem duas aspas simples supérfluas no final.)

Aqui está uma elaboração sobre A resposta verdadeira única, mencionada acima:

Às vezes eu vou baixar usando o rsync over ssh e tenho que escapar de um nome de arquivo com um 'DUAS VEZES! (OMG!) Uma vez para o bash e outra para o ssh. O mesmo princípio de delimitadores de cotação alternados está em ação aqui.

Por exemplo, digamos que queremos obter: as histórias de Louis Theroux em LA ...

1. Primeiro, você coloca Louis Theroux entre aspas simples para bash e aspas duplas para ssh: '"Louis Theroux"'
2. Então você usa aspas simples para escapar de aspas duplas '"'
3. O uso de aspas duplas para escapar do apóstrofo "'"
4. Em seguida, repita o número 2, usando aspas simples para escapar de aspas duplas '"'
5. Em seguida, coloque LA Stories entre aspas simples para bash e aspas duplas para ssh: '"LA Stories"'

E eis! Você acaba com isso:

rsync -ave ssh '"Louis Theroux"''"'"'"'"''"s LA Stories"'

que é muito trabalho para um pouco '- mas lá vai você

shell_escape () {
    printf '%s' "'${1//\'/\'\\\'\'}'"
}

Explicação da implementação:

• aspas duplas, para que possamos gerar facilmente aspas simples e usar a ${...}sintaxe

• A pesquisa e substituição do bash se parece com: ${varname//search/replacement}

• estamos substituindo 'por'\''

• '\''codifica um único 'assim:

  1. ' termina a citação única

  2. \'codifica a '(a barra invertida é necessária porque não estamos entre aspas)

  3. ' inicia a citação única novamente

  4. o bash concatena automaticamente as strings sem espaço em branco entre

• há um \antes de cada \e 'porque essas são as regras de escape ${...//.../...}.

string="That's "'#@$*&^`(@#'
echo "original: $string"
echo "encoded:  $(shell_escape "$string")"
echo "expanded: $(bash -c "echo $(shell_escape "$string")")"

PS Sempre codifique para seqüências de caracteres simples entre aspas, porque elas são muito mais simples do que cadeias de caracteres entre aspas duplas.

Outra maneira de corrigir o problema de muitas camadas de cotação aninhada:

Você está tentando colocar muito em um espaço muito pequeno, então use uma função bash.

O problema é que você está tentando ter muitos níveis de aninhamento, e a tecnologia básica de alias não é poderosa o suficiente para acomodar. Use uma função bash como esta para fazer com que as aspas simples e duplas de retorno e os parâmetros passados ​​sejam todos tratados normalmente como seria de esperar:

lets_do_some_stuff() {
    tmp=$1                       #keep a passed in parameter.
    run_your_program $@          #use all your passed parameters.
    echo -e '\n-------------'    #use your single quotes.
    echo `date`                  #use your back ticks.
    echo -e "\n-------------"    #use your double quotes.
}
alias foobarbaz=lets_do_some_stuff

Em seguida, você pode usar suas variáveis ​​$ 1 e $ 2 e aspas simples e duplas e back ticks sem se preocupar com a função de alias que destrói sua integridade.

Este programa imprime:

el@defiant ~/code $ foobarbaz alien Dyson ring detected @grid 10385
alien Dyson ring detected @grid 10385
-------------
Mon Oct 26 20:30:14 EDT 2015
-------------

Se você possui o GNU Parallel instalado, pode usar sua citação interna:

$ parallel --shellquote
L's 12" record
<Ctrl-D>
'L'"'"'s 12" record'
$ echo 'L'"'"'s 12" record'
L's 12" record

A partir da versão 20190222, você pode até --shellquotevárias vezes:

$ parallel --shellquote --shellquote --shellquote
L's 12" record
<Ctrl-D>
'"'"'"'"'"'"'L'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'s 12" record'"'"'"'"'"'"'
$ eval eval echo '"'"'"'"'"'"'L'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'"'s 12" record'"'"'"'"'"'"'
L's 12" record

Ele irá citar a string em todos os shells suportados (não apenas bash).

Esta função:

quote () 
{ 
    local quoted=${1//\'/\'\\\'\'};
    printf "'%s'" "$quoted"
}

permite citar 'dentro '. Use como este:

$ quote "urxvt -fg '#111111' -bg '#111111'"
'urxvt -fg '\''#111111'\'' -bg '\''#111111'\'''

Se a linha a citar se tornar mais complexa, como aspas duplas misturadas com aspas simples, pode ser bastante complicado fazer com que a string cite dentro de uma variável. Quando tais casos aparecerem, escreva a linha exata que você precisa citar dentro de um script (semelhante a este).

#!/bin/bash

quote ()
{
    local quoted=${1//\'/\'\\\'\'};
    printf "'%s'" "$quoted"
}

while read line; do
    quote "$line"
done <<-\_lines_to_quote_
urxvt -fg '#111111' -bg '#111111'
Louis Theroux's LA Stories
'single quote phrase' "double quote phrase"
_lines_to_quote_

Saída:

'urxvt -fg '\''#111111'\'' -bg '\''#111111'\'''
'Louis Theroux'\''s LA Stories'
''\''single quote phrase'\'' "double quote phrase"'

Todas as cadeias citadas corretamente entre aspas simples.

Se você estiver gerando a string do shell no Python 2 ou Python 3, o seguinte pode ajudar a citar os argumentos:

#!/usr/bin/env python

from __future__ import print_function

try:  # py3
    from shlex import quote as shlex_quote
except ImportError:  # py2
    from pipes import quote as shlex_quote

s = """foo ain't "bad" so there!"""

print(s)
print(" ".join([shlex_quote(t) for t in s.split()]))

Isso produzirá:

foo ain't "bad" so there!
foo 'ain'"'"'t' '"bad"' so 'there!'

Aqui estão meus dois centavos - no caso, se alguém quiser ser shportável, não apenas bashespecífico (a solução não é muito eficiente, porém, ao iniciar um programa externo sed):

• coloque isso quote.sh(ou apenas quote) em algum lugar do seu PATH:

# isso funciona com entrada padrão (stdin)
quote () {
  eco -n "'";
  sed 's / \ ([' "'"'] ['"' '' * *) / '"' "'" \ 1 "'" '' '/ g';
  eco -n "'"
}

caso "$ 1" em
 -) citação ;;
 *) echo "use: cat ... | quote - # entrada de aspas simples para o shell Bourne" 2> & 1 ;;
esac

Um exemplo:

$ echo -n "Bom dia, companheiro!" | ./quote.sh -
'G' "'"' dia, companheiro! '

E, claro, isso se converte novamente:

$ echo 'G' "'"' dia, companheiro! '
Bom dia, companheiro!

Explicação: basicamente temos que incluir a entrada entre aspas 'e, em seguida, também substituir qualquer aspas simples nesse micro-monstro: '"'"'(finalize a cotação de abertura com um emparelhamento ', escape da aspas simples encontrada envolvendo-as com aspas duplas - "'"e então finalmente emitir uma nova abertura aspas simples 'ou em pseudo-notação: ' + "'" + ' == '"'"')

Uma maneira padrão de fazer isso seria usar sedo seguinte comando de substituição:

s/\(['][']*\)/'"\1"'/g 

Um pequeno problema, porém, é que, para usá-lo no shell, é necessário escapar de todos esses caracteres de aspas simples na própria expressão sed - o que leva a algo como

sed 's/\(['"'"']['"'"']*\)/'"'"'"\1"'"'"'/g' 

(e uma boa maneira de criar esse resultado é alimentar a expressão original s/\(['][']*\)/'"\1"'/gnos scripts de Kyle Rose 'ou George V. Reilly).

Finalmente, faz sentido esperar que a entrada venha, stdinjá que passá-la por argumentos da linha de comando já pode ser um problema demais.

(Ah, e pode ser que desejemos adicionar uma pequena mensagem de ajuda para que o script não pare quando alguém o executa como se ./quote.sh --helpperguntando o que ele faz.)

Aqui está outra solução. Essa função usa um único argumento e o cita adequadamente usando o caractere de aspas simples, assim como a resposta votada acima explica:

single_quote() {
  local quoted="'"
  local i=0
  while [ $i -lt ${#1} ]; do
    local ch="${1:i:1}"
    if [[ "$ch" != "'" ]]; then
      quoted="$quoted$ch"
    else
      local single_quotes="'"
      local j=1
      while [ $j -lt ${#1} ] && [[ "${1:i+j:1}" == "'" ]]; do
        single_quotes="$single_quotes'"
        ((j++))
      done
      quoted="$quoted'\"$single_quotes\"'"
      ((i+=j-1))
    fi
    ((i++))
  done
  echo "$quoted'"
}

Então, você pode usá-lo desta maneira:

single_quote "1 2 '3'"
'1 2 '"'"'3'"'"''

x="this text is quoted: 'hello'"
eval "echo $(single_quote "$x")"
this text is quoted: 'hello'