Czy istnieje sposób, aby uniemożliwić sedowi interpretację ciągu zastępującego? [Zamknięte]

Jeśli chcesz zastąpić słowo kluczowe ciągiem znaków za pomocą sed, sed próbuje zinterpretować ciąg zastępujący. Jeśli zastępujący ciąg znaków zawiera znaki, które sed uważa za specjalne, takie jak znak „/”, to zawiedzie, chyba że oczywiście miałeś na myśli, że zastępujący ciąg znaków ma znaki, które mówią sedowi, jak postępować.

Dawny:

VAR="hi/"

sed "s/KEYWORD/$VAR/g" somefile

Czy jest jakiś sposób, aby powiedzieć sedowi, aby nie próbował interpretować ciągu zastępującego znaki specjalne? Chcę tylko móc zastąpić słowo kluczowe w pliku zawartością zmiennej, bez względu na to, co to jest.

Możesz używać Perla zamiast sed z -p(zakładaj pętlę nad wejściem) i -e(podaj program w wierszu poleceń). Dzięki Perlowi możesz uzyskać dostęp do zmiennych środowiskowych bez interpolacji ich w powłoce. Pamiętaj, że zmienną należy wyeksportować :

export VAR='hi/'
perl -p -e 's/KEYWORD/$ENV{VAR}/g' somefile

Jeśli nie chcesz eksportować zmiennej wszędzie, podaj ją tylko dla tego procesu:

PATTERN="$VAR" perl -p -e 's/KEYWORD/$ENV{PATTERN}/g' somefile

Zauważ, że składnia wyrażeń regularnych Perla domyślnie nieco różni się od składni sed.

Są tylko 4 znaki specjalne części zamiennej: \, &, znak nowej linii i separator ( ref )

$ VAR='abc/def&ghi\foo
next line'

$ repl=$(sed -e 's/[&\\/]/\\&/g; s/$/\\/' -e '$s/\\$//' <<<"$VAR")

$ echo "$repl"
abc\/def\&ghi\\foo\
next line

$ echo ZYX | sed "s/Y/$repl/g"
Zabc/def&ghi\foo
next lineX

Najprostszym rozwiązaniem, które nadal poprawnie obsługiwałoby znaczną większość wartości zmiennych, byłoby użycie znaku niedrukowalnego jako separatora sedpolecenia zastępczego.

W vimożna uciec od dowolnego znaku kontrolnego, naciskając Ctrl-V (częściej zapisywany jako ^V). Więc jeśli użyjesz jakiegoś znaku kontrolnego (często używam ^Ajako ogranicznik w tych przypadkach), twoje sedpolecenie zostanie złamane tylko, jeśli ten niedrukowalny znak jest obecny w zmiennej, w której upuszczasz.

Więc wpisz "s^V^AKEYWORD^V^A$VAR^V^Ag"i co byś (w vi) wyglądałby:

sed "s^AKEYWORD^A$VAR^Ag" somefile

Działa to tak długo, jak długo $VARnie zawiera znaku niedrukowalnego ^A- co jest niezwykle mało prawdopodobne.

Oczywiście, jeśli przekazujesz wartość wejściową od użytkownika $VAR, wszystkie zakłady są wyłączone i lepiej oczyść swoje dane wejściowe, zamiast polegać na trudnych do wpisania znakach kontrolnych dla przeciętnego użytkownika.

Jednak w rzeczywistości należy uważać na więcej niż ciąg ogranicznika. Na przykład, &gdy występuje w ciągu zastępującym, oznacza „cały dopasowany tekst”. Np. s/stu../my&/Zamieniłbym „stuff” na „mystuff”, „stung” na „mystung” itp. Więc jeśli możesz mieć dowolny znak w zmiennej, którą upuszczasz jako ciąg zastępczy, ale chcesz użyć literału tylko wartość zmiennej, musisz wykonać pewne operacje dezynfekcji danych, zanim będziesz mógł użyć zmiennej jako łańcucha zastępczego w sed. (Jednak dezynfekcję danych można również wykonać sed.)

Możesz zamiast tego użyć a ,lub |a, to zajmie to jako separator i technicznie możesz użyć wszystkiego

ze strony podręcznika

\cregexpc
           Match lines matching the regular expression regexp.  The  c  may
      be any character.

Jak widać, powinieneś zacząć od \ przed separatorem na początku, możesz użyć go jako separatora.

z dokumentacji http://www.gnu.org/software/sed/manual/sed.html#The-_0022s_0022- Polecenie :

The / characters may be uniformly replaced by any other single character 
within any given s command.

The / character (or whatever other character is used in its stead) can appear in 
the regexp or replacement only if it is preceded by a \ character.

Przykład:

sed -e 'somevar|s|foo|bar|'
echo "Hello all" | sed "s_all_user_"
echo "Hello all" | sed "s,all,user,"

echo "Hello/ World" | sed "s,Hello/,Neo,"

Jeśli jest oparty na linii i tylko jeden wiersz do zastąpienia, zalecam wcześniejsze przygotowanie samego pliku za pomocą wiersza zastępującego printf, przechowywanie pierwszego wiersza w polu sedwstrzymania i upuszczanie go w razie potrzeby. W ten sposób nie musisz się martwić o znaki specjalne. (Jedynym założeniem tutaj jest to, że $VARzawiera jeden wiersz tekstu bez żadnych nowych linii, co już powiedziałeś w komentarzach.) Poza nowymi liniami, VAR może zawierać cokolwiek i to zadziała niezależnie.

VAR=whatever
{ printf '%s\n' "$VAR";cat somefile; } | sed '1{h;d;};/KEYWORD/g'

printf '%s\n'wypisze zawartość $VARjako ciąg dosłowny, niezależnie od jego zawartości, a następnie nowy wiersz. ( echow niektórych przypadkach zrobi inne rzeczy, na przykład jeśli treść $VARzaczyna się od myślnika - zostanie to zinterpretowane jako przekazanie flagi opcji echo).

Nawiasy klamrowe są używane do dodania wyjścia printfdo zawartości po somefilejej przekazaniu sed. Ważna jest tutaj biała spacja oddzielająca nawiasy klamrowe, podobnie jak średnik przed zamykającym nawias klamrowy.

1{h;d;};jako sedkomenda będzie przechowywać pierwszą linię tekstu w sed„s miejsca przechowywania , a następnie dsuĹ linię (zamiast drukowanie).

/KEYWORD/stosuje następujące działania do wszystkich wierszy, które zawierają KEYWORD. Akcja jest get, która pobiera zawartość przestrzeni wstrzymania i upuszcza ją w miejsce przestrzeni wzorca - innymi słowy, całą bieżącą linię. (To nie jest zamiana tylko części linii.) Nawiasem mówiąc, przestrzeń wstrzymania nie jest opróżniana, po prostu kopiowana do przestrzeni wzorów, zastępując wszystko, co tam jest.

Jeśli chcesz zakotwiczyć wyrażenie regularne, aby nie pasowało ono do linii, która zawiera tylko SŁOWO KLUCZOWE, ale tylko linię, w której nie ma nic innego oprócz KEYWORD, dodaj początek linii anchor ( ^) i koniec linii anchor ( $) do twoje wyrażenie regularne:

VAR=whatever
{ printf '%s\n' "$VAR";cat somefile; } | sed '1{h;d;};/^KEYWORD$/g'

Możesz użyć ukośnika odwrotnego do ukośników w zastępującym ciągu, używając rozszerzenia parametru podstawienia wzorca Basha. Jest to trochę bałagan, ponieważ ukośniki do przodu również muszą być poprzedzone przez Bash.

$ var='a/b/c';var="${var//\//\\/}";echo 'this is a test' | sed "s/i/$var/g"

wynik

tha/b/cs a/b/cs a test

Państwo mogli umieścić interpretacji parametrów bezpośrednio do komendy sed:

$ var='a/b/c';echo 'this is a test' | sed "s/i/${var//\//\\/}/g"

ale myślę, że pierwsza forma jest nieco bardziej czytelna. I oczywiście, jeśli zamierzasz ponownie użyć tego samego wzorca zastępowania w wielu poleceniach sed, sensowne jest, aby wykonać konwersję tylko raz.

Inną opcją byłoby użycie skryptu napisanego w awk, perl lub Python, lub program w C, do wykonania zamiany zamiast używania sed.

Oto prosty przykład w Pythonie, który działa, jeśli zastępowane słowo kluczowe jest pełną linią w pliku wejściowym (nie licząc nowej linii). Jak widać, jest to zasadniczo ten sam algorytm, co w przykładzie Bash, ale bardziej efektywnie odczytuje plik wejściowy.

import sys

#Get the keyword and replacement texts from the command line
keyword, replacement = sys.argv[1:]
for line in sys.stdin:
    #Strip any trailing whitespace
    line = line.rstrip()
    if line == keyword:
        line = replacement
    print(line)

Tak poszedłem:

#Replaces a keyword with a long string
#
#This is normally done with sed, but sed
#tries to interpret the string you are
#replacing the keyword with too hard
#
#stdin - contents to look through
#Arg 1 - keyword to replace
#Arg 2 - what to replace keyword with
replace() {
        KEYWORD="$1"
        REPLACEMENT_STRING="$2"

        while IFS= read -r LINE
        do
                if [[ "$LINE" == "$KEYWORD" ]]
                then
                        printf "%s\n" "$REPLACEMENT_STRING"
                else
                        printf "%s\n" "$LINE"
                fi
        done < /dev/stdin
}

w moim przypadku działa to świetnie, ponieważ moje słowo kluczowe samo w sobie znajduje się w wierszu. Gdyby słowo kluczowe było w linii z innym tekstem, to nie zadziałałoby.

Wciąż chciałbym wiedzieć, czy istnieje prosty sposób, który nie wymaga kodowania własnego rozwiązania.