C'è un modo per impedire a sed di interpretare la stringa di sostituzione? [chiuso]

Se si desidera sostituire una parola chiave con una stringa utilizzando sed, sed si impegna a fondo per interpretare la stringa di sostituzione. Se la stringa sostitutiva sembra avere caratteri che sed considera speciali, come un carattere "/", fallirà, a meno che, naturalmente, tu abbia inteso che la stringa sostitutiva abbia caratteri che dicono a sed come agire.

Ex:

VAR="hi/"

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

C'è un modo per dire a sed di non provare a interpretare la stringa di sostituzione per caratteri speciali? Tutto quello che voglio è essere in grado di sostituire una parola chiave in un file con il contenuto di una variabile, indipendentemente dal contenuto.

Ci sono solo 4 caratteri speciali nel pezzo di ricambio: \, &, a capo e il delimitatore ( 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

Puoi usare Perl invece di sed con -p(assume loop over input) e -e(dai programma alla riga di comando). Con Perl è possibile accedere alle variabili di ambiente senza interpolarle nella shell. Nota che la variabile deve essere esportata :

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

Se non si desidera esportare la variabile ovunque, fornirla solo per quel processo:

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

Si noti che la sintassi delle espressioni regolari di Perl è di default leggermente diversa da quella di sed.

La soluzione più semplice che gestisca ancora correttamente la stragrande maggioranza dei valori delle variabili sarebbe quella di utilizzare un carattere non stampabile come delimitatore al sedcomando sostitutivo.

In vipuoi sfuggire a qualsiasi personaggio di controllo digitando Ctrl-V (più comunemente scritto come ^V). Quindi se usi un carattere di controllo ( ^Ain questi casi lo uso spesso come delimitatore), il tuo sedcomando si interromperà solo se quel carattere non stampabile è presente nella variabile in cui ti stai inserendo.

Quindi digitare "s^V^AKEYWORD^V^A$VAR^V^Ag"e vicome apparirà (in ):

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

Funzionerà finché $VARnon contiene il carattere non stampabile, il ^Ache è estremamente improbabile.

Ovviamente, se stai passando l'input dell'utente nel valore di $VAR, allora tutte le scommesse sono disattivate e faresti meglio a disinfettare completamente l'input piuttosto che affidarti a caratteri di controllo difficili da digitare per l'utente medio.

Tuttavia, in realtà c'è molto più da fare attenzione rispetto alla stringa del delimitatore. Ad esempio, &se presente in una stringa di sostituzione, significa "l'intero testo che è stato abbinato". Ad esempio, s/stu../my&/sostituirebbe "stuff" con "mystuff", "stung" con "mystung", ecc. Quindi, se si potrebbe avere un carattere nella variabile che si sta inserendo come stringa sostitutiva, ma si desidera utilizzare il valore letterale solo il valore della variabile, quindi è necessario eseguire alcune operazioni di disinfezione dei dati prima di poter utilizzare la variabile come stringa di sostituzione in sed. (Tuttavia, la disinfezione dei dati può essere eseguita sedanche con .)

Puoi usare a ,o a |invece e lo prenderai come un separatore e tecnicamente potresti usare qualsiasi cosa

dalla pagina man

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

Come puoi vedere, dovresti iniziare con un \ prima del tuo separatore all'inizio, quindi puoi usarlo come separatore.

dalla documentazione http://www.gnu.org/software/sed/manual/sed.html#The-_0022s_0022-Command :

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.

Esempio:

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,"

Se è basato su una riga e solo una riga da sostituire, ti consiglio di anteporre il file stesso alla riga di sostituzione utilizzando printf, memorizzando quella prima riga nello sedspazio di attesa e inserendola secondo necessità. In questo modo non devi preoccuparti di personaggi speciali. (L'unica ipotesi qui è che $VARcontenga una sola riga di testo senza nessuna nuova riga, che è già ciò che hai detto nei commenti.) Oltre alle nuove righe, VAR potrebbe contenere qualsiasi cosa e questo funzionerebbe a prescindere.

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

printf '%s\n'stamperà il contenuto $VARcome una stringa letterale, indipendentemente dal suo contenuto, seguito da una nuova riga. ( echofarà altre cose in alcuni casi, ad esempio se il contenuto di $VARinizia con un trattino, verrà interpretato come un flag di opzione a cui viene passato echo).

Le parentesi graffe vengono utilizzate per anteporre l'output printfal contenuto di somefilequando viene passato sed. Qui è importante lo spazio bianco che separa le parentesi graffe, così come il punto e virgola prima della parentesi graffa di chiusura.

1{h;d;};come un sedcomando memorizzare la prima riga di testo in sed's spazio attesa , quindi delete la linea (piuttosto che stamparlo).

/KEYWORD/applica le seguenti azioni a tutte le righe che contengono KEYWORD. L'azione è get, che ottiene il contenuto dello spazio di attesa e lo rilascia al posto dello spazio del modello, in altre parole, l'intera riga corrente. (Questo non è per sostituire solo una parte di una linea.) Lo spazio di mantenimento non viene svuotato, comunque, semplicemente copiato nello spazio del modello, sostituendo qualunque cosa ci sia.

Se vuoi ancorare il tuo regex in modo che non corrisponda a una linea che contiene semplicemente KEYWORD ma solo una linea dove non c'è nient'altro sulla linea tranne KEYWORD, aggiungi un inizio di ancoraggio di linea ( ^) e fine di ancoraggio di linea ( $) a la tua regex:

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

È possibile eseguire il backslash-escape delle barre in avanti nella stringa di sostituzione, utilizzando l'espansione del parametro di sostituzione del modello di Bash. È un po 'disordinato perché anche le barre in avanti devono essere sfuggite a Bash.

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

produzione

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

È possibile inserire l'espansione dei parametri direttamente nel comando sed:

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

ma penso che il primo modulo sia un po 'più leggibile. E ovviamente se riutilizzerai lo stesso schema di sostituzione in più comandi sed, è logico fare la conversione una sola volta.

Un'altra opzione sarebbe quella di usare uno script scritto in awk, perl o Python o un programma C, per fare le tue sostituzioni invece di usare sed.

Ecco un semplice esempio in Python che funziona se la parola chiave da sostituire è una riga completa nel file di input (senza contare la nuova riga). Come puoi vedere, è essenzialmente lo stesso algoritmo del tuo esempio di Bash, ma legge il file di input in modo più efficiente.

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)

È andata così:

#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
}

questo funziona alla grande nel mio caso perché la mia parola chiave è su una riga da sola. Se la parola chiave fosse in linea con altro testo, ciò non funzionerebbe.

Mi piacerebbe davvero sapere se esiste un modo semplice per farlo che non comporta la codifica della mia soluzione.