Escapar de una cadena para un patrón de reemplazo de sed

En mi script bash tengo una cadena externa (recibida del usuario), que debería usar en el patrón sed.

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

¿Cómo puedo escapar de la $REPLACEcadena para que sea aceptada de forma segura sedcomo un reemplazo literal?

NOTA: El KEYWORDes una subcadena mudo de coincidencias, etc. No es suministrada por el usuario.

Advertencia : Esto no considera nuevas líneas. Para una respuesta más profunda, vea esta pregunta SO en su lugar. (Gracias, Ed Morton y Niklas Peter)

Tenga en cuenta que escapar de todo es una mala idea. Sed necesita escapar de muchos personajes para obtener su significado especial. Por ejemplo, si escapa un dígito en la cadena de reemplazo, se convertirá en una referencia inversa.

Como dijo Ben Blank, solo hay tres caracteres que deben escaparse en la cadena de reemplazo (se escapa, barra diagonal para el final de la declaración y & para reemplazar todos):

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"

Si alguna vez necesita escapar de la KEYWORDcadena, la siguiente es la que necesita:

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

Y puede ser utilizado por:

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"

Recuerde, si usa un carácter que no sea /delimitador, debe reemplazar la barra diagonal en las expresiones anteriores con el carácter que está usando. Vea el comentario de PeterJCLaw para una explicación.

Editado: debido a algunos casos de esquina que anteriormente no se tenían en cuenta, los comandos anteriores han cambiado varias veces. Verifique el historial de edición para más detalles.

El comando sed le permite usar otros caracteres en lugar de /como separador:

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

Las comillas dobles no son un problema.

Los únicos tres caracteres literales que se tratan especialmente en la cláusula de reemplazo son /(para cerrar la cláusula), \(para escapar de caracteres, referencia, etc.) y &(para incluir la coincidencia en el reemplazo). Por lo tanto, todo lo que necesitas hacer es escapar de esos tres personajes:

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

Ejemplo:

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

Basado en las expresiones regulares de Pianosaurus, hice una función bash que escapa tanto a la palabra clave como al reemplazo.

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

Así es como lo usa:

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

Es un poco tarde para responder ... pero hay una manera mucho más simple de hacer esto. Simplemente cambie el delimitador (es decir, el carácter que separa los campos). Entonces, en lugar de s/foo/bar/escribir s|bar|foo.

Y, aquí está la manera fácil de hacer esto:

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

El resultado resultante carece de esa desagradable cláusula DEFINER.

Resulta que estás haciendo la pregunta equivocada. También hice la pregunta equivocada. La razón por la que está mal es el comienzo de la primera oración: "En mi script bash ...".

Tuve la misma pregunta y cometí el mismo error. Si usa bash, no necesita usar sed para hacer reemplazos de cadenas (y es mucho más limpio usar la función de reemplazo incorporada en bash).

En lugar de algo como, por ejemplo:

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

puedes usar las funciones de bash exclusivamente:

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

Use awk, es más limpio:

$ 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

Aquí hay un ejemplo de un AWK que usé hace un tiempo. Es un AWK que imprime nuevos AWKS. AWK y SED son similares, puede ser una buena plantilla.

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

Parece excesivo, pero de alguna manera esa combinación de citas funciona para mantener el 'impreso como literales. Entonces, si recuerdo correctamente, las variables están rodeadas de comillas como esta: "$ 1". Pruébalo, avísame cómo funciona con SED.

Tengo una mejora sobre la función sedentaria, que romperá con caracteres especiales como tabulación.

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

Entonces, ¿qué es diferente? $1y $2entre comillas para evitar expansiones de shell y preservar pestañas o espacios dobles.

Tubería adicional | sed -e 's:\t:\\t:g'(me gusta :como token) que transforma una pestaña en \t.

Estos son los códigos de escape que he encontrado:

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

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

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

no olvides todo el placer que se produce con la limitación de shell "y"

entonces (en 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"

Si solo está buscando reemplazar el valor de la Variable en el comando sed, simplemente elimine el Ejemplo:

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

Si el caso es que está generando una contraseña aleatoria para pasar para sedreemplazar el patrón, entonces elige tener cuidado con qué conjunto de caracteres en la cadena aleatoria. Si elige una contraseña creada al codificar un valor como base64, entonces solo hay un carácter que es posible en base64 y también es un carácter especial en el sedpatrón de reemplazo. Ese carácter es "/", y se elimina fácilmente de la contraseña que está generando:

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

Una manera más fácil de hacer esto es simplemente construir la cadena de antemano y usarla como parámetro para sed

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