kürzeste Möglichkeit, Zeichen in einer Variablen zu ersetzen

Es gibt viele Möglichkeiten, Zeichen in einer Variablen zu ersetzen.

Der kürzeste Weg, den ich herausgefunden habe, ist trbisher:

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

Gibt es einen schnelleren Weg? Und dann ist dies unter Angabe sicher für Angebote wie ', "und `selbst?

Wir werden sehen. Der kürzeste, den ich finden kann, ist eine Optimierung Ihrer trLösung:

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

Andere Alternativen umfassen die bereits erwähnte Variablensubstitution, die kürzer sein kann als bisher gezeigt:

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

Und sednatürlich ist dies in Bezug auf die Charaktere länger:

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

Ich bin mir nicht sicher, ob du die kürzeste Länge oder die kürzeste Zeit meinst. In Bezug auf die Länge sind diese beiden so kurz wie es geht (oder wie ich es sowieso bekommen kann), wenn es darum geht, diese bestimmten Zeichen zu entfernen. Welches ist das schnellste? Ich habe getestet, indem ich die OUTPUTVariable auf das gesetzt habe, was Sie in Ihrem Beispiel hatten, aber einige Dutzend Mal wiederholt habe:

$ 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

Wie Sie sehen, trist der eindeutig der Schnellste, dicht gefolgt von sed. Außerdem ist die Verwendung anscheinend echoetwas schneller als die Verwendung von <<<:

$ 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

Da der Unterschied winzig ist, habe ich die obigen Tests 10 Mal für jeden der beiden durchgeführt und es stellte sich heraus, dass der schnellste tatsächlich der ist, mit dem Sie beginnen mussten:

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

Dies ändert sich jedoch, wenn Sie den Aufwand für die Zuweisung einer Variablen berücksichtigen. Hier ist die Verwendung tretwas langsamer als die einfache Ersetzung:

$ 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

Wenn Sie also nur die Ergebnisse anzeigen möchten, verwenden trSie , aber wenn Sie eine Variable neu zuweisen möchten, ist die Verwendung der Zeichenfolgenmanipulationsfunktionen der Shell schneller, da sie den Aufwand für die Ausführung einer separaten Subshell vermeiden.

Sie können die Variablensubstitution verwenden :

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

Verwenden Sie diese Syntax: ${parameter//pattern/string}um alle Vorkommen des Musters durch die Zeichenfolge zu ersetzen.

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

In bash oder zsh ist es:

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

Beachten Sie, dass ${VAR//PATTERN/}alle Instanzen des Musters entfernt werden. Weitere Informationen finden Sie in der Bash-Parametererweiterung

Diese Lösung sollte für kurze Zeichenfolgen am schnellsten sein, da keine externen Programme ausgeführt werden müssen. Bei sehr langen Zeichenfolgen ist das Gegenteil der Fall - es ist besser, ein spezielles Tool für Textoperationen zu verwenden, z.

$ 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

Wenn Sie zufällig nur versuchen, Angebote für die Wiederverwendung der Shell zu verarbeiten, können Sie dies tun, ohne sie zu entfernen, und es ist auch denkbar einfach:

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

Diese Funktionsshell setzt ein beliebiges von Ihnen übergebenes arg-Array in Anführungszeichen und erhöht seine Ausgabe pro iterierbarem Argument.

Hier ist es mit ein paar Argumenten:

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

AUSGABE

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

Diese Ausgabe ist eine Ausgabe, dashdie in der Regel in sicheren Anführungszeichen steht '"'"'. bashwürde tun '\''.

Das Ersetzen einer Auswahl einzelner Bytes, die keine Leerzeichen oder Nullen enthalten, durch ein anderes Byte ist in einer POSIX-Shell mit $IFSund wahrscheinlich am schnellsten möglich $*.

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

AUSGABE

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

Dort habe ich es einfach printfso, dass man es sehen kann, aber natürlich, wenn ich es getan hätte:

var="$*"

... und nicht der Wert des printfBefehls $var, den Sie dort in der Ausgabe sehen.

Wenn ich set -fdie Shell anweise, nicht zu globieren - falls die Zeichenfolge Zeichen enthält, die als Glob-Muster ausgelegt werden könnten. Ich mache das, weil der Shells-Parser Glob-Muster erweitert, nachdem er die Feldaufteilung für Variablen durchgeführt hat. Globbing kann wie wieder aktiviert werden set +f. Im Allgemeinen - in Skripten - finde ich es nützlich, meinen Knall wie folgt zu setzen:

#!/usr/bin/sh -f

Und dann explizit das Globbing mit einer set +fbeliebigen Zeile aktivieren , die ich haben möchte.

Die Feldaufteilung erfolgt anhand der Zeichen in $IFS.

Es gibt zwei Arten von $IFSWerten - $IFSLeerzeichen und $IFSNicht-Leerzeichen. $IFSDurch Leerzeichen (Leerzeichen, Tabulatoren, Zeilenvorschübe) getrennte Felder werden so angegeben, dass sie nach der Reihenfolge in ein einzelnes Feld zerlegt werden (oder gar nicht, wenn sie keinem anderen Feld vorangehen) - also ...

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

Alle anderen sind jedoch so spezifiziert, dass sie pro Vorkommen zu einem einzigen Feld ausgewertet werden - sie werden nicht abgeschnitten.

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

Alle Variablenerweiterungen sind standardmäßig durch $IFSTrennzeichen getrennte Datenfelder $IFS. Sie werden in separate Felder aufgeteilt . Mit "-quote one überschreiben Sie diese Array-Eigenschaft und werten sie als einzelne Zeichenfolge aus.

Also, wenn ich es tue ...

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

Ich setze das Argumentarray der Shell auf die vielen $IFSbegrenzten Felder, die durch $vardie Erweiterung generiert werden . Wenn es seine konstituierenden Werte für die Zeichen erweitert enthalten in $IFSsind verloren - sie sind jetzt nur Feldtrenn - sie sind \0NUL.

"$*"- Wie bei anderen Variablenerweiterungen in doppelten Anführungszeichen - werden auch die feldaufteilenden Eigenschaften von überschrieben $IFS. Aber zusätzlich , ersetzt es das erste Byte in $IFS für jedes Feld begrenzt in "$@". Also da "wurde der erste Wert in $IFS allen nachfolgenden Begrenzern "in "$*". Und das "muss auch nicht sein, $IFSwenn Sie es teilen. Sie können $IFS after set -- $args vollständig auf einen anderen Wert ändern , und das neue erste Byte wird dann für die Feldbegrenzer in angezeigt "$*". Außerdem können Sie alle Spuren wie folgt entfernen:

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

AUSGABE

some crazy string here