So vermeiden Sie einfache Anführungszeichen in Zeichenfolgen in einfachen Anführungszeichen

Angenommen, Sie haben einen Bash aliaswie:

alias rxvt='urxvt'

das funktioniert gut.

Jedoch:

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

wird nicht funktionieren und auch nicht:

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

Wie können Sie also das Öffnen und Schließen von Anführungszeichen in einer Zeichenfolge abgleichen, wenn Sie den Anführungszeichen entkommen sind?

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

scheint unansehnlich, obwohl es die gleiche Zeichenfolge darstellen würde, wenn Sie sie so verketten dürfen.

Wenn Sie wirklich einfache Anführungszeichen in der äußersten Ebene verwenden möchten, denken Sie daran, dass Sie beide Arten von Anführungszeichen kleben können. Beispiel:

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

Erklärung, wie dies '"'"'als gerecht interpretiert wird ':

1. ' Beenden Sie das erste Anführungszeichen mit einfachen Anführungszeichen.
2. " Starten Sie das zweite Zitat mit doppelten Anführungszeichen.
3. ' Zitierter Charakter.
4. " Beenden Sie das zweite Anführungszeichen mit doppelten Anführungszeichen.
5. ' Beginnen Sie das dritte Zitat mit einfachen Anführungszeichen.

Wenn Sie keine Leerzeichen zwischen (1) und (2) oder zwischen (4) und (5) platzieren, interpretiert die Shell diese Zeichenfolge als ein einziges langes Wort.

Ich ersetze immer nur jedes eingebettete einfache Anführungszeichen durch die folgende Sequenz '\''(dh Anführungszeichen-Backslash-Anführungszeichen), die die Zeichenfolge schließt, ein maskiertes einfaches Anführungszeichen anfügt und die Zeichenfolge erneut öffnet.

Ich rufe in meinen Perl-Skripten häufig eine "Anführungszeichen" -Funktion auf, um dies für mich zu tun. Die Schritte wären:

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

Dies kümmert sich so ziemlich um alle Fälle.

Das Leben macht mehr Spaß, wenn Sie es evalin Ihre Shell-Skripte einführen . Sie müssen im Wesentlichen alles neu zitieren!

Erstellen Sie beispielsweise ein Perl-Skript namens quotify, das die obigen Anweisungen enthält:

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

Verwenden Sie es dann, um eine korrekt in Anführungszeichen gesetzte Zeichenfolge zu generieren:

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

Ergebnis:

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

die dann in den Alias-Befehl kopiert / eingefügt werden kann:

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

(Wenn Sie den Befehl in eine Auswertung einfügen müssen, führen Sie das Anführungszeichen erneut aus:

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

Ergebnis:

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

die kopiert / in eine Bewertung eingefügt werden kann:

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

Da die Bash 2.04- Syntax $'string'(statt nur 'string'; Warnung: nicht verwechseln mit $('string')) ein weiterer Anführungsmechanismus ist, der ANSI C-ähnliche Escape-Sequenzen ermöglicht und eine Erweiterung auf eine einfache Anführungszeichenversion ermöglicht.

Einfaches Beispiel:

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

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

In Ihrem Fall:

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

Häufige Escape-Sequenzen funktionieren wie erwartet:

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

Unten finden Sie eine Kopie + eingefügte Dokumentation aus man bash(Version 4.4):

Wörter der Form $ 'string' werden speziell behandelt. Das Wort wird zu Zeichenfolge erweitert, wobei Zeichen mit Backslash-Escapezeichen gemäß ANSI C-Standard ersetzt werden. Backslash-Escape-Sequenzen werden, falls vorhanden, wie folgt dekodiert:

    \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

Das erweiterte Ergebnis wird in einfachen Anführungszeichen gesetzt, als ob das Dollarzeichen nicht vorhanden gewesen wäre.

Siehe Zitate und Flucht: ANSI C wie Strings auf bash-hackers.org um weitere Informationen zu Wiki. Beachten Sie auch, dass in der Datei "Bash Changes" ( Übersicht hier ) häufig Änderungen und Fehlerbehebungen im Zusammenhang mit dem $'string'Angebotsmechanismus erwähnt werden.

Laut unix.stackexchange.com Wie verwende ich ein Sonderzeichen als normales? Es sollte (mit einigen Variationen) in Bash, Zsh, Mksh, Ksh93 und FreeBSD und Busybox Sh funktionieren.

Ich sehe den Eintrag nicht in seinem Blog (Link pls?), Aber laut Gnu-Referenzhandbuch :

Durch das Einschließen von Zeichen in einfache Anführungszeichen ('' ') wird der Literalwert jedes Zeichens in den Anführungszeichen beibehalten. Ein einfaches Anführungszeichen darf nicht zwischen einfachen Anführungszeichen stehen, selbst wenn ein Backslash vorangestellt ist.

Bash wird also nicht verstehen:

alias x='y \'z '

Sie können dies jedoch tun, wenn Sie doppelte Anführungszeichen verwenden:

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

Ich kann bestätigen, dass die Verwendung '\''eines einfachen Anführungszeichens in einer Zeichenfolge in einfachen Anführungszeichen in Bash funktioniert, und dies kann auf die gleiche Weise erklärt werden wie das Argument "Kleben" von früher im Thread. Angenommen, wir haben eine Zeichenfolge in 'A '\''B'\'' C'Anführungszeichen : (Alle Anführungszeichen hier sind einfache Anführungszeichen). Wenn es an echo übergeben wird, wird Folgendes ausgegeben : A 'B' C. In jedem '\''der ersten Anführungszeichen wird die aktuelle Zeichenfolge in einfachen Anführungszeichen geschlossen, im Folgenden wird \'ein einfaches Anführungszeichen an die vorherige Zeichenfolge geklebt ( \'eine Möglichkeit, ein einfaches Anführungszeichen anzugeben, ohne eine Zeichenfolge in Anführungszeichen zu setzen), und im letzten Anführungszeichen wird eine weitere Zeichenfolge in einfachen Anführungszeichen geöffnet.

Beide Versionen funktionieren entweder mit Verkettung unter Verwendung des maskierten einfachen Anführungszeichens (\ ') oder mit Verkettung durch Einschließen des einfachen Anführungszeichens in doppelte Anführungszeichen ("'").

Der Autor der Frage bemerkte nicht, dass am Ende seines letzten Fluchtversuchs ein zusätzliches einfaches Anführungszeichen (') stand:

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

Wie Sie im vorherigen schönen Stück ASCII / Unicode-Grafik sehen können, folgt auf das letzte maskierte einfache Anführungszeichen (\ ') ein unnötiges einfaches Anführungszeichen ('). Die Verwendung eines Syntax-Textmarkers wie dem in Notepad ++ kann sich als sehr hilfreich erweisen.

Gleiches gilt für ein anderes Beispiel wie das folgende:

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

Diese beiden schönen Beispiele für Aliase zeigen auf sehr komplizierte und verschleierte Weise, wie eine Datei in einer Reihe angeordnet werden kann. Das heißt, aus einer Datei mit vielen Zeilen erhalten Sie nur eine Zeile mit Kommas und Leerzeichen zwischen den Inhalten der vorherigen Zeilen. Um den vorherigen Kommentar zu verstehen, ist das Folgende ein Beispiel:

$ cat Little_Commas.TXT
201737194
201802699
201835214

$ rc Little_Commas.TXT
201737194, 201802699, 201835214

Einfaches Beispiel für das Entkommen von Anführungszeichen in der Shell:

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

Dazu beenden Sie bereits geöffnete ( '), platzieren Escape ( \') und öffnen dann eine weitere ( '). Diese Syntax funktioniert für alle Befehle. Es ist sehr ähnlich wie bei der ersten Antwort.

Ich gehe nicht speziell auf das Problem des Zitierens ein, da es manchmal nur sinnvoll ist, einen alternativen Ansatz in Betracht zu ziehen.

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

die Sie dann anrufen können als:

rxvt 123456 654321

Die Idee ist, dass Sie dies jetzt ohne Rücksicht auf Anführungszeichen aliasisieren können:

alias rxvt='rxvt 123456 654321'

oder, wenn Sie das #aus irgendeinem Grund in alle Anrufe einbeziehen müssen:

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

die Sie dann anrufen können als:

rxvt '#123456' '#654321'

dann lautet ein Alias ​​natürlich:

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

(Ups, ich denke, ich habe das Zitat irgendwie angesprochen :)

Da man keine einfachen Anführungszeichen in einfache Anführungszeichen setzen kann, ist die einfachste und am besten lesbare Option die Verwendung einer HEREDOC-Zeichenfolge

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

alias rxvt=$command

Im obigen Code wird das HEREDOC an den catBefehl gesendet und die Ausgabe davon wird einer Variablen über die Befehlsersetzungsnotation zugewiesen$(..)

Es ist erforderlich, ein einfaches Anführungszeichen um das HEREDOC zu setzen, da es sich innerhalb von a befindet $()

Ich benutze nur Shell-Codes .. zB \x27oder \\x22wie zutreffend. Kein Ärger, nie wirklich.

Die meisten dieser Antworten treffen auf den speziellen Fall, nach dem Sie fragen. Es gibt einen allgemeinen Ansatz , dass ein Freund und ich habe entwickelt, das für beliebige zitieren , falls erlaubt müssen Sie zitieren bash Befehle durch mehrere Schichten von Shell - Erweiterung, zum Beispiel durch ssh, su -c, bash -cetc. Es gibt einen Kern primitiv ist , dass Sie benötigen, hier in native bash:

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
}

Dies macht genau das, was es sagt: Es zitiert jedes Argument einzeln (natürlich nach der Bash-Erweiterung):

$ 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'

Es ist das Offensichtliche für eine Expansionsschicht:

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

(Beachten Sie, dass die doppelten Anführungszeichen $(quote_args ...)erforderlich sind, um das Ergebnis in ein einziges Argument umzuwandeln bash -c.) Und es kann allgemeiner verwendet werden, um durch mehrere Erweiterungsebenen richtig zu zitieren:

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

Das obige Beispiel:

1. Shell zitiert jedes Argument quote_argseinzeln in das Innere und kombiniert dann die resultierende Ausgabe zu einem einzigen Argument mit den inneren doppelten Anführungszeichen.
2. Shell-Zitate bash, -cund das schon einmal zitierte Ergebnis aus Schritt 1, und kombinieren dann das Ergebnis in ein einziges Argument mit den äußeren Anführungszeichen.
3. sendet dieses Chaos als Argument an die äußere bash -c.

Das ist die Idee auf den Punkt gebracht. Sie können einige ziemlich komplizierte Dinge damit machen, aber Sie müssen vorsichtig sein, in welcher Reihenfolge die Bewertung erfolgt und welche Teilzeichenfolgen zitiert werden. Zum Beispiel machen die folgenden Dinge die falschen Dinge (für eine Definition von "falsch"):

$ (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

Im ersten Beispiel, dehnt bash sofort quote_args cd /; pwd 1>&2in zwei getrennte Befehle, quote_args cd /und pwd 1>&2, so wie vor der CWD ist , /tmpwenn der pwdBefehl ausgeführt wird. Das zweite Beispiel zeigt ein ähnliches Problem beim Globbing. In der Tat tritt das gleiche Grundproblem bei allen Bash-Erweiterungen auf. Das Problem hierbei ist, dass eine Befehlssubstitution kein Funktionsaufruf ist: Sie wertet buchstäblich ein Bash-Skript aus und verwendet seine Ausgabe als Teil eines anderen Bash-Skripts.

Wenn Sie versuchen, den Shell-Operatoren einfach zu entkommen, schlagen Sie fehl, da die resultierende Zeichenfolge, an die übergeben bash -cwird, nur eine Folge von Zeichenfolgen in Anführungszeichen ist, die dann nicht als Operatoren interpretiert werden. Dies ist leicht zu erkennen, wenn Sie die Zeichenfolge wiedergeben, die dies tun würde wurden an bash übergeben:

$ (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'

Das Problem hier ist, dass Sie zu viel zitieren. Was Sie brauchen, ist, dass die Operatoren nicht als Eingabe für das Gehäuse in Anführungszeichen gesetzt werden bash -c, was bedeutet, dass sie sich außerhalb der $(quote_args ...)Befehlsersetzung befinden müssen.

Folglich müssen Sie im allgemeinsten Sinne jedes Wort des Befehls in Shell zitieren, das zum Zeitpunkt der Befehlssubstitution nicht erweitert werden soll, und keine zusätzlichen Anführungszeichen auf die Shell-Operatoren anwenden:

$ (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

Sobald Sie dies getan haben, ist die gesamte Zeichenfolge ein faires Spiel, um weitere Bewertungsstufen zu zitieren:

$ 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

usw.

Diese Beispiele können overwrought scheinen gegeben , dass Worte wie success, sbinund pwdnicht seine muschel zitiert müssen, aber der entscheidende Punkt zu erinnern , wenn ein Skript unter beliebiger Eingabe zu schreiben ist , dass man alles zitieren wollen Sie nicht absolut sicher doesn‘ Ich brauche kein Zitat, weil Sie nie wissen, wann ein Benutzer eine einwirft Robert'; rm -rf /.

Um besser zu verstehen, was unter der Decke vor sich geht, können Sie mit zwei kleinen Hilfsfunktionen herumspielen:

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

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

Dadurch werden alle Argumente zu einem Befehl aufgelistet, bevor sie ausgeführt werden:

$ 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 ist die wirkliche Antwort, dass Sie einfache Anführungszeichen in einfachen Anführungszeichen nicht entkommen können.

Es ist unmöglich.

Wenn wir davon ausgehen, dass wir Bash verwenden.

Aus dem Bash-Handbuch ...

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.

Sie müssen einen der anderen String-Escape-Mechanismen verwenden "oder \

Es ist nichts Magisches daran, aliasdass es einfache Anführungszeichen erfordert.

Beide folgenden Arbeiten in Bash.

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

Letzterer verwendet \, um dem Leerzeichen zu entkommen.

Es gibt auch nichts Magisches an # 111111, das einfache Anführungszeichen erfordert.

Die folgenden Optionen erzielen das gleiche Ergebnis wie die beiden anderen Optionen, da der rxvt-Alias ​​wie erwartet funktioniert.

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

Sie können dem lästigen # auch direkt entkommen

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

Verwenden Sie im angegebenen Beispiel einfach doppelte Anführungszeichen anstelle von einfachen Anführungszeichen als äußeren Escape-Mechanismus:

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

Dieser Ansatz eignet sich für viele Fälle, in denen Sie nur eine feste Zeichenfolge an einen Befehl übergeben möchten: Überprüfen Sie einfach, wie die Shell die Zeichenfolge in doppelten Anführungszeichen durch a interpretiert echo, und maskieren Sie Zeichen bei Bedarf mit Backslash.

Im Beispiel sehen Sie, dass doppelte Anführungszeichen ausreichen, um die Zeichenfolge zu schützen:

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

Natürlich wäre es einfacher, einfach mit doppelten Anführungszeichen zu umgeben, aber wo liegt die Herausforderung dabei? Hier ist die Antwort nur in einfachen Anführungszeichen. Ich verwende stattdessen eine Variable, aliasdamit es einfacher ist, sie als Proof zu drucken, aber es ist dasselbe wie bei der Verwendung alias.

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

Erläuterung

Der Schlüssel ist, dass Sie das einfache Anführungszeichen schließen und es so oft öffnen können, wie Sie möchten. Zum Beispiel foo='a''b'ist das gleiche wie foo='ab'. Sie können also das einfache Anführungszeichen schließen, ein wörtliches einfaches Anführungszeichen \'eingeben und das nächste einfache Anführungszeichen erneut öffnen.

Aufschlüsselungsdiagramm

Dieses Diagramm verdeutlicht anhand von Klammern, wo die einfachen Anführungszeichen geöffnet und geschlossen werden. Anführungszeichen sind nicht wie in Klammern "verschachtelt". Sie können auch auf die korrekte Farbhervorhebung achten. Die zitierten Saiten sind kastanienbraun, während die \'schwarz sind.

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

(Dies ist im Wesentlichen die gleiche Antwort wie die von Adrian, aber ich denke, das erklärt es besser. Auch seine Antwort enthält am Ende zwei überflüssige einfache Anführungszeichen.)

Hier ist eine Ausarbeitung zu The One True Answer, auf die oben Bezug genommen wurde:

Manchmal lade ich mit rsync über ssh herunter und muss einem Dateinamen mit einem 'darin ZWEIMAL entkommen! (OMG!) Einmal für Bash und einmal für SSH. Hier gilt das gleiche Prinzip alternierender Anführungszeichen.

Nehmen wir zum Beispiel an, wir wollen: Louis Therouxs LA Stories ...

1. Zuerst schließen Sie Louis Theroux in einfache Anführungszeichen für Bash und doppelte Anführungszeichen für SSH ein: "Louis Theroux"
2. Dann verwenden Sie einfache Anführungszeichen, um einem doppelten Anführungszeichen '"' zu entgehen.
3. Verwenden Sie doppelte Anführungszeichen, um dem Apostroph "'" zu entkommen.
4. Wiederholen Sie dann # 2 mit einfachen Anführungszeichen, um einem doppelten Anführungszeichen '"' zu entgehen.
5. Schließen Sie dann LA Stories in einfache Anführungszeichen für Bash und doppelte Anführungszeichen für ssh ein: '"LA Stories"'

Und siehe da! Sie landen damit:

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

Das ist eine Menge Arbeit für ein kleines Kind - aber los geht's

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

Erklärung zur Implementierung:

• doppelte Anführungszeichen, damit wir einfache einfache Anführungszeichen ausgeben und die ${...}Syntax verwenden können

• Das Suchen und Ersetzen von bash sieht folgendermaßen aus: ${varname//search/replacement}

• wir ersetzen 'durch'\''

• '\''codiert eine Single 'wie folgt:

  1. ' beendet das einfache Anführungszeichen

  2. \'codiert a '(der Backslash wird benötigt, da wir uns nicht in Anführungszeichen befinden)

  3. ' Startet das einfache Anführungszeichen erneut

  4. bash verkettet automatisch Zeichenfolgen ohne Leerzeichen dazwischen

• Es gibt ein \vor jedem \und 'weil das die Fluchtregeln für sind ${...//.../...}.

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

PS Codieren Sie immer in Zeichenfolgen in einfachen Anführungszeichen, da diese viel einfacher sind als Zeichenfolgen in doppelten Anführungszeichen.

Eine andere Möglichkeit, das Problem zu vieler Ebenen verschachtelter Anführungszeichen zu beheben:

Sie versuchen, zu viel in einen zu kleinen Raum zu stopfen, verwenden Sie also eine Bash-Funktion.

Das Problem ist, dass Sie versuchen, zu viele Verschachtelungsebenen zu haben, und die grundlegende Alias-Technologie nicht leistungsfähig genug ist, um sie zu berücksichtigen. Verwenden Sie eine Bash-Funktion wie diese, damit die Ticks mit einfachen, doppelten Anführungszeichen und übergebenen Parametern wie erwartet normal behandelt werden:

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

Dann können Sie Ihre $ 1- und $ 2-Variablen sowie einfache, doppelte Anführungszeichen und Back-Ticks verwenden, ohne sich Gedanken über die Alias-Funktion machen zu müssen, die deren Integrität beeinträchtigt.

Dieses Programm druckt:

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

Wenn Sie GNU Parallel installiert haben, können Sie das interne Angebot verwenden:

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

Ab Version 20190222 können Sie sogar --shellquotemehrmals:

$ 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

Die Zeichenfolge wird in allen unterstützten Shells (nicht nur bash) zitiert .

Diese Funktion:

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

ermöglicht das Zitieren von 'innen '. Verwenden Sie wie folgt:

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

Wenn die zu zitierende Zeile komplexer wird, z. B. doppelte Anführungszeichen gemischt mit einfachen Anführungszeichen, kann es ziemlich schwierig werden, die Zeichenfolge innerhalb einer Variablen in Anführungszeichen zu setzen. Wenn solche Fälle auftreten, schreiben Sie die genaue Zeile, die Sie zitieren müssen, in ein Skript (ähnlich wie dieses).

#!/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_

Wird ausgegeben:

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

Alle korrekt in Anführungszeichen gesetzten Zeichenfolgen in einfachen Anführungszeichen.

Wenn Sie die Shell-Zeichenfolge in Python 2 oder Python 3 generieren, können die folgenden Argumente hilfreich sein:

#!/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()]))

Dies wird Folgendes ausgeben:

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

Hier sind meine zwei Cent - für den Fall, dass man shportabel und nicht nur spezifisch sein möchte bash(die Lösung ist jedoch nicht zu effizient, da sie ein externes Programm startet - sed):

• Setzen Sie dies in quote.sh(oder nur quote) irgendwo auf Ihre PATH:

# Dies funktioniert mit Standardeingabe (stdin)
quote () {
  echo -n "'";
  sed 's / \ ([' '' ''] ['' '' '] * \) /' '' '' \ 1 '' '' '/ g';
  echo -n "'"
}}

Fall "$ 1" in
 -) Zitat ;;
 *) echo "usage: cat ... | quote - # Eingabe in einfachen Anführungszeichen für die Bourne-Shell" 2> & 1 ;;
esac

Ein Beispiel:

$ echo -n "G'day, Kumpel!" | ./quote.sh -
'Guten Tag, Freund!'

Und das konvertiert natürlich zurück:

$ echo 'G' "'"' Tag, Kumpel! '
Guten Tag, Freund!

Erläuterung: Grundsätzlich müssen wir die Eingabe in Anführungszeichen setzen 'und dann auch jedes einzelne Anführungszeichen durch dieses Mikromonster ersetzen: '"'"'(Beenden Sie das erste Anführungszeichen mit einer Paarung ', umgehen Sie das gefundene einfache Anführungszeichen, indem Sie es mit doppelten Anführungszeichen umschließen - "'"und dann endlich eine neue Öffnung Apostroph ausgeben ', oder in pseudo-Notation: ' + "'" + ' == '"'"')

Eine Standardmethode hierfür ist die Verwendung seddes folgenden Substitutionsbefehls:

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

Ein kleines Problem ist jedoch, dass man, um das in der Shell zu verwenden, all diesen einfachen Anführungszeichen im sed-Ausdruck selbst entkommen muss - was zu so etwas führt

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

(und eine gute Möglichkeit, dieses Ergebnis zu erzielen, besteht darin, den ursprünglichen Ausdruck s/\(['][']*\)/'"\1"'/gden Skripten von Kyle Rose oder George V. Reilly zuzuführen).

Schließlich ist es irgendwie sinnvoll zu erwarten, dass die Eingabe von kommt stdin- da das Weiterleiten über Befehlszeilenargumente bereits zu viel Mühe bereiten kann.

(Oh, und vielleicht möchten wir eine kleine Hilfemeldung hinzufügen, damit das Skript nicht hängen bleibt, wenn jemand es nur ausführt und sich ./quote.sh --helpfragt, was es tut.)

Hier ist eine andere Lösung. Diese Funktion nimmt ein einzelnes Argument und zitiert es angemessen mit dem einfachen Anführungszeichen, genau wie in der obigen Antwort erklärt:

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'"
}

Sie können es also folgendermaßen verwenden:

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

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