Esci da una stringa per un modello di sostituzione sed

Nel mio script bash ho una stringa esterna (ricevuta dall'utente), che dovrei usare nel modello sed.

REPLACE="<funny characters here>"
sed "s/KEYWORD/$REPLACE/g"

Come posso sfuggire al $REPLACE stringa in modo che possa essere tranquillamente accettata sedcome una sostituzione letterale?

NOTA: Il KEYWORDè una stringa muto con nessun risultato, ecc E non venga fornita dall'utente.

Avvertenza : questo non considera le nuove righe. Per una risposta più approfondita, vedere invece questa domanda SO . (Grazie, Ed Morton e Niklas Peter)

Nota che fuggire da tutto è una cattiva idea. Sed ha bisogno di sfuggire a molti personaggi per ottenere il loro significato speciale. Ad esempio, se si evita una cifra nella stringa di sostituzione, si trasformerà in un riferimento indietro.

Come ha detto Ben Blank, ci sono solo tre caratteri che devono essere sfuggiti nella stringa di sostituzione (sfugge a se stessi, barra in avanti per la fine dell'istruzione e & per sostituire tutto):

ESCAPED_REPLACE=$(printf '%s\n' "$REPLACE" | sed -e 's/[\/&]/\\&/g')
# Now you can use ESCAPED_REPLACE in the original sed statement
sed "s/KEYWORD/$ESCAPED_REPLACE/g"

Se mai dovessi sfuggire al KEYWORD stringa, quella che ti serve è la seguente:

sed -e 's/[]\/$*.^[]/\\&/g'

E può essere utilizzato da:

KEYWORD="The Keyword You Need";
ESCAPED_KEYWORD=$(printf '%s\n' "$KEYWORD" | sed -e 's/[]\/$*.^[]/\\&/g');

# Now you can use it inside the original sed statement to replace text
sed "s/$ESCAPED_KEYWORD/$ESCAPED_REPLACE/g"

Ricorda, se usi un carattere diverso da /come delimitatore, devi sostituire la barra nelle espressioni sopra con il carattere che stai usando. Vedi il commento di PeterJCLaw per una spiegazione.

Modificato: a causa di alcuni casi angolari precedentemente non considerati, i comandi sopra sono cambiati più volte. Controlla la cronologia delle modifiche per i dettagli.

Il comando sed consente di utilizzare altri caratteri anziché /come separatore:

sed 's#"http://www\.fubar\.com"#URL_FUBAR#g'

Le doppie virgolette non sono un problema.

Gli unici tre caratteri letterali trattati in modo speciale nella clausola di sostituzione sono /(per chiudere la clausola), \(per sfuggire a caratteri, backreference, ecc.) E &(per includere la corrispondenza nella sostituzione). Pertanto, tutto ciò che devi fare è scappare da questi tre personaggi:

sed "s/KEYWORD/$(echo $REPLACE | sed -e 's/\\/\\\\/g; s/\//\\\//g; s/&/\\\&/g')/g"

Esempio:

$ export REPLACE="'\"|\\/><&!"
$ echo fooKEYWORDbar | sed "s/KEYWORD/$(echo $REPLACE | sed -e 's/\\/\\\\/g; s/\//\\\//g; s/&/\\\&/g')/g"
foo'"|\/><&!bar

Basato sulle espressioni regolari di Pianosaurus, ho creato una funzione bash che sfugge sia alla parola chiave che alla sostituzione.

function sedeasy {
  sed -i "s/$(echo $1 | sed -e 's/\([[\/.*]\|\]\)/\\&/g')/$(echo $2 | sed -e 's/[\/&]/\\&/g')/g" $3
}

Ecco come lo usi:

sedeasy "include /etc/nginx/conf.d/*" "include /apps/*/conf/nginx.conf" /etc/nginx/nginx.conf

È un po 'tardi per rispondere ... ma c'è un modo molto più semplice per farlo. Basta cambiare il delimitatore (cioè il carattere che separa i campi). Quindi, invece di s/foo/bar/scrivere s|bar|foo.

Ed ecco il modo semplice per farlo:

sed 's|/\*!50017 DEFINER=`snafu`@`localhost`\*/||g'

L'output risultante è privo di quella brutta clausola DEFINER.

Si scopre che stai facendo la domanda sbagliata. Ho anche fatto la domanda sbagliata. Il motivo per cui è sbagliato è l'inizio della prima frase: "Nel mio script bash ...".

Ho avuto la stessa domanda e ho commesso lo stesso errore. Se stai usando bash, non è necessario usare sed per eseguire sostituzioni di stringhe (ed è molto più pulito usare la funzione di sostituzione integrata in bash).

Invece di qualcosa di simile, ad esempio:

function escape-all-funny-characters() { UNKNOWN_CODE_THAT_ANSWERS_THE_QUESTION_YOU_ASKED; }
INPUT='some long string with KEYWORD that need replacing KEYWORD.'
A="$(escape-all-funny-characters 'KEYWORD')"
B="$(escape-all-funny-characters '<funny characters here>')"
OUTPUT="$(sed "s/$A/$B/g" <<<"$INPUT")"

puoi usare esclusivamente le funzionalità bash:

INPUT='some long string with KEYWORD that need replacing KEYWORD.'
A='KEYWORD'
B='<funny characters here>'
OUTPUT="${INPUT//"$A"/"$B"}"

Usa awk - è più pulito:

$ awk -v R='//addr:\\file' '{ sub("THIS", R, $0); print $0 }' <<< "http://file:\_THIS_/path/to/a/file\\is\\\a\\ nightmare"
http://file:\_//addr:\file_/path/to/a/file\\is\\\a\\ nightmare

Ecco un esempio di un AWK che ho usato qualche tempo fa. È un AWK che stampa nuovi AWKS. Essendo AWK e SED simili potrebbe essere un buon modello.

ls | awk '{ print "awk " "'"'"'"  " {print $1,$2,$3} " "'"'"'"  " " $1 ".old_ext > " $1 ".new_ext"  }' > for_the_birds

Sembra eccessivo, ma in qualche modo quella combinazione di virgolette funziona per mantenere la stampa come letterale. Quindi, se ricordo bene, i vaiable sono racchiusi tra virgolette come questa: "$ 1". Provalo, fammi sapere come funziona con SED.

Ho un miglioramento rispetto alla funzione sedeasy, che si romperà con caratteri speciali come tab.

function sedeasy_improved {
    sed -i "s/$(
        echo "$1" | sed -e 's/\([[\/.*]\|\]\)/\\&/g' 
            | sed -e 's:\t:\\t:g'
    )/$(
        echo "$2" | sed -e 's/[\/&]/\\&/g' 
            | sed -e 's:\t:\\t:g'
    )/g" "$3"
}

Quindi, cosa c'è di diverso? $1e$2 racchiuso tra virgolette per evitare espansioni della shell e preservare schede o doppi spazi.

Piping aggiuntivo | sed -e 's:\t:\\t:g'(mi piace :come token) che trasforma una scheda in \t.

Questi sono i codici di escape che ho trovato:

* = \x2a
( = \x28
) = \x29

" = \x22
/ = \x2f
\ = \x5c

' = \x27
? = \x3f
% = \x25
^ = \x5e

non dimenticare tutto il piacere che si verifica con la limitazione della shell intorno "e"

quindi (in ksh)

Var=">New version of \"content' here <"
printf "%s" "${Var}" | sed "s/[&\/\\\\*\\"']/\\&/g' | read -r EscVar

echo "Here is your \"text\" to change" | sed "s/text/${EscVar}/g"

Se stai solo cercando di sostituire il valore della variabile nel comando sed, rimuovi semplicemente Esempio:

sed -i 's/dev-/dev-$ENV/g' test to sed -i s/dev-/dev-$ENV/g test

Se il caso è che stai generando una password casuale da passare per sedsostituire il modello, scegli di fare attenzione a quale set di caratteri nella stringa casuale. Se si sceglie una password creata codificando un valore come base64, allora c'è solo un carattere che è possibile sia in base64 sia un carattere speciale nel sedmodello di sostituzione. Quel carattere è "/" ed è facilmente rimosso dalla password che stai generando:

# password 32 characters log, minus any copies of the "/" character.
pass=`openssl rand -base64 32 | sed -e 's/\///g'`;

Un modo più semplice per farlo è semplicemente costruire la stringa in anticipo e usarla come parametro per sed

rpstring="s/KEYWORD/$REPLACE/g"
sed -i $rpstring  test.txt