najkrótszy sposób zamiany znaków w zmiennej

Istnieje wiele sposobów zamiany znaków w zmiennej.

Najkrótsza droga, jaką się dowiedziałem, to tr:

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

Czy jest szybszy sposób? I jest to bezpieczne dla cytowanie cytatów jak ', "i `sama?

Zobaczmy. Najkrótsze, jakie mogę wymyślić, to ulepszenie twojego trrozwiązania:

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

Inne alternatywy obejmują wspomniane już podstawienie zmiennych, które może być krótsze niż dotychczas pokazane:

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

I sedoczywiście jest to dłuższe pod względem postaci:

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

Nie jestem pewien, czy masz na myśli najkrótszą długość lub czas. Jeśli chodzi o długość, te dwa są tak krótkie, jak to możliwe (lub tak czy inaczej mogę je zdobyć), jeśli chodzi o usuwanie tych konkretnych postaci. Który jest najszybszy? Przetestowałem, ustawiając OUTPUTzmienną na wartość z przykładu, ale powtórzyłem kilkadziesiąt razy:

$ 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

Jak widać, trjest zdecydowanie najszybszy, a tuż za nim sed. Wygląda na to, że używanie echojest nieco szybsze niż używanie <<<:

$ 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

Ponieważ różnica jest niewielka, powyższe testy przeprowadziłem 10 razy dla każdego z nich i okazuje się, że najszybszy jest rzeczywiście ten, od którego musiałeś zacząć:

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

Zmienia się to jednak, gdy weźmie się pod uwagę narzut związany z przypisywaniem zmiennej, tutaj użycie trjest nieco wolniejsze niż zwykła zamiana:

$ 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

Podsumowując, gdy chcesz po prostu wyświetlić wyniki, użyj, trale jeśli chcesz ponownie przypisać do zmiennej, korzystanie z funkcji manipulacji ciągiem powłoki jest szybsze, ponieważ pozwalają uniknąć nakładania się na osobną podpowłokę.

Możesz użyć podstawienia zmiennej :

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

Użyj tej składni: ${parameter//pattern/string}aby zastąpić wszystkie wystąpienia wzorca łańcuchem.

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

W bash lub zsh jest to:

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

Zauważ, że ${VAR//PATTERN/} usuwa wszystkie wystąpienia wzorca. Aby uzyskać więcej informacji , rozszerzenie parametru bash

To rozwiązanie powinno być najszybsze w przypadku krótkich ciągów, ponieważ nie wymaga uruchamiania żadnych programów zewnętrznych. Jednak w przypadku bardzo długich ciągów jest odwrotnie - lepiej jest używać dedykowanego narzędzia do operacji tekstowych, na przykład:

$ 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

Jeśli przypadkowo próbujesz poradzić sobie z cytatami dotyczącymi ponownego użycia powłoki, możesz to zrobić bez usuwania ich, a to również jest bardzo proste:

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

Ta funkcja powłoki cytuje każdą tablicę arg, którą jej podajesz, i zwiększa jej wynik na iterowalny argument.

Oto kilka argumentów:

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

WYNIK

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

To wyjście, z dashktórego typowo bezpieczne cytaty zawierają pojedyncze cytaty '"'"'.bashzrobiłby '\''.

Zastąpienie wyboru pojedynczych bajtów niepustych białych znakami o wartości innej niż null innym pojedynczym bajtem można prawdopodobnie zrobić najszybciej w dowolnej powłoce POSIX za pomocą $IFSi $*.

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

WYNIK

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

Tam właśnie printfto widzę, ale oczywiście, gdybym to zrobił:

var="$*"

... zamiast printfpolecenia$var „s wartość byłaby co widać w tam wyjście.

Kiedy set -finstruuję powłokę, aby nie globowała - w przypadku gdy łańcuch zawiera znaki, które można by interpretować jako wzorce globu. Robię to, ponieważ parser powłok rozszerza wzorce globu po dokonaniu podziału pól na zmienne. globbing może być ponownie włączony jak set +f. Ogólnie rzecz biorąc - w skryptach - przydatne jest ustawienie huku w następujący sposób:

#!/usr/bin/sh -f

A następnie, aby jawnie włączyć globowanie z set +fdowolną linią, której bym tego chciał.

Podział pola następuje na podstawie znaków w $IFS.

Istnieją dwa rodzaje $IFSwartości - $IFSbiałe znaki i $IFSinne znaki. $IFSspacje (spacja, tabulator, nowa linia) pola rozdzielane są określane tak, aby następowały po nich sekwencje do pojedynczego pola (lub wcale, jeśli nie poprzedzają czegoś innego) - więc ...

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

Ale wszystkie inne są określone, aby oceniać do jednego pola na wystąpienie - nie są obcinane.

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

Wszystkie rozszerzenia zmiennych są domyślnie $IFSograniczonymi tablicami danych - są one podzielone na osobne pola zgodnie z $IFS. Kiedy ty" cytujesz jedną, zastępujesz tę właściwość tablicy i oceniasz ją jako pojedynczy ciąg.

Więc kiedy to zrobię ...

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

Ustawiam tablicę argumentów powłoki na wiele $IFSrozdzielanych pól generowanych przez $varrozszerzenie. Po rozwinięciu jego wartości składowe dla zawartych w nim znaków $IFSsą tracone - są one teraz tylko separatorami pól - są\0NUL .

"$*"- podobnie jak inne podwójnie cytowane rozwinięcia zmiennych - również zastępuje właściwości podziału pola na $IFS. Ale dodatkowo zastępuje pierwszy bajt w $IFS każdym rozdzielanym polu w "$@". Tak, ponieważ "był pierwszy wartość $IFS wszystkich kolejnych ograniczniki stać "w "$*". I "nie trzeba też być $IFSprzy podziale. Można zmieniać $IFS po set -- $args innej wartości w całości i jego nowy pierwszy bajt by następnie pokazać się na ograniczniki polowych w "$*". Co więcej, możesz całkowicie usunąć wszystkie ich ślady:

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

WYNIK

some crazy string here