¿Hay alguna manera de evitar que sed interprete la cadena de reemplazo? [cerrado]

Si desea reemplazar una palabra clave con una cadena usando sed, sed se esfuerza por interpretar su cadena de reemplazo. Si la cadena de reemplazo tiene caracteres que sed considera especiales, como un carácter '/', fallará, a menos que, por supuesto, haya querido decir que su cadena de reemplazo tiene caracteres que le dicen a sed cómo actuar.

Ex:

VAR="hi/"

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

¿Hay alguna forma de decirle a sed que no intente interpretar la cadena de reemplazo para caracteres especiales? Todo lo que quiero es poder reemplazar una palabra clave en un archivo con el contenido de una variable, sin importar cuál sea ese contenido.

Sólo hay 4 caracteres especiales en la pieza de repuesto: \, &, nueva línea y el delimitador ( 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

Puede usar Perl en lugar de sed con -p(asumir el bucle sobre la entrada) y -e(dar el programa en la línea de comandos). Con Perl puede acceder a las variables de entorno sin interpolarlas en el shell. Tenga en cuenta que la variable debe exportarse :

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

Si no desea exportar la variable a todas partes, solo debe proporcionarla para ese proceso únicamente:

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

Tenga en cuenta que la sintaxis de expresión regular de Perl es, por defecto, ligeramente diferente de la de sed.

La solución más simple que aún manejaría correctamente la gran mayoría de los valores de las variables sería utilizar un carácter que no se imprima como delimitador del sedcomando sustituto.

En vipuede escapar de cualquier carácter de control escribiendo Ctrl-V (más comúnmente escrito como ^V). Entonces, si usa algún carácter de control (a menudo lo uso ^Acomo delimitador en estos casos), su sedcomando solo se romperá si ese carácter no imprimible está presente en la variable que está colocando.

Entonces escribiría "s^V^AKEYWORD^V^A$VAR^V^Ag"y lo que obtendría (en vi) se vería así:

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

Esto funcionará siempre $VARque no contenga el carácter que no se imprime, lo ^Acual es extremadamente improbable.

Por supuesto, si pasa la entrada del usuario al valor de $VAR, entonces todas las apuestas están desactivadas y será mejor que desinfecte su entrada a fondo en lugar de confiar en que los caracteres de control son difíciles de escribir para el usuario promedio.

Sin embargo, en realidad hay más de qué tener cuidado que la cadena delimitador. Por ejemplo, &cuando está presente en una cadena de reemplazo, significa "todo el texto que coincidió". Por ejemplo, s/stu../my&/reemplazaría "cosas" con "mystuff", "picado" con "mystung", etc. Entonces, si tiene algún carácter en la variable que está colocando como una cadena de reemplazo, pero desea usar el literal solo el valor de la variable, entonces tiene que desinfectar algunos datos antes de poder usar la variable como una cadena de reemplazo sed. (Sin sedembargo, la desinfección de datos también se puede hacer ).

En su lugar, puede usar a ,o a |y lo tomará como un separador y técnicamente podría usar cualquier cosa

desde la página del manual

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

Como puede ver, debe comenzar con un \ antes de su separador al principio, luego puede usarlo como separador.

de la documentación 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.

Ejemplo:

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

Si se basa en una línea y solo se debe reemplazar una línea, recomiendo anteponer el archivo con la línea de reemplazo usando printf, almacenar esa primera línea en sedel espacio de espera y soltarla según sea necesario. De esta manera, no tiene que preocuparse por caracteres especiales en absoluto. (La única suposición aquí es que $VARcontiene una sola línea de texto sin líneas nuevas, que es lo que ya dijo en los comentarios). Además de las líneas nuevas, VAR podría contener cualquier cosa y esto funcionaría independientemente.

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

printf '%s\n'imprimirá el contenido de $VARcomo una cadena literal, independientemente de su contenido, seguido de una nueva línea. ( echoen algunos casos, hará otras cosas, por ejemplo, si el contenido de $VARcomienza con un guión, se interpretará como un indicador de opción al que se pasa echo).

Las llaves se usan para anteponer la salida de printflos contenidos de a somefilemedida que se pasan sed. El espacio en blanco que separa las llaves por sí mismos es importante aquí, al igual que el punto y coma antes de la llave de cierre.

1{h;d;};como sedcomando almacenará la primera línea de texto en sedel espacio de espera y luego delegirá la línea (en lugar de imprimirla).

/KEYWORD/aplica las siguientes acciones a todas las líneas que contienen KEYWORD. La acción es get, que obtiene el contenido del espacio de espera y lo coloca en lugar del espacio del patrón; en otras palabras, la línea actual completa. (Esto no es para reemplazar solo una parte de una línea.) El espacio de espera no se vacía, por cierto, solo se copia en el espacio del patrón, reemplazando lo que esté allí.

Si desea anclar su expresión regular para que no coincida con una línea que simplemente contiene KEYWORD, sino solo una línea donde no hay nada más en la línea que KEYWORD, agregue un ancla de inicio de línea ( ^) y un ancla de final de línea ( $) a tu expresión regular:

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

Puede hacer una barra diagonal inversa para escapar de las barras diagonales en su cadena de reemplazo, utilizando la expansión del parámetro de sustitución de patrones de Bash. Es un poco desordenado porque las barras diagonales también deben escaparse para Bash.

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

salida

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

Usted podría poner la expansión de parámetros directamente en su comando sed:

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

pero creo que la primera forma es un poco más legible. Y, por supuesto, si va a reutilizar el mismo patrón de reemplazo en múltiples comandos sed, tiene sentido hacer la conversión una vez.

Otra opción sería usar un script escrito en awk, perl o Python, o un programa en C, para hacer sus sustituciones en lugar de usar sed.

Aquí hay un ejemplo simple en Python que funciona si la palabra clave que se va a reemplazar es una línea completa en el archivo de entrada (sin contar la nueva línea). Como puede ver, es esencialmente el mismo algoritmo que su ejemplo de Bash, pero lee el archivo de entrada de manera más eficiente.

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)

Así es como fui:

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

esto funciona muy bien en mi caso porque mi palabra clave está en una línea por sí sola. Si la palabra clave estuviera en una línea con otro texto, esto no funcionaría.

Todavía me gustaría saber si hay una manera fácil de hacer esto que no implique codificar mi propia solución.