Escapar uma corda para um padrão de substituição sed

No meu script bash, tenho uma string externa (recebida do usuário), que devo usar no padrão sed.

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

Como posso escapar da $REPLACEstring para que ela seja aceita com segurança sedcomo uma substituição literal?

NOTA: A KEYWORDé uma substring mudo sem partidas etc. Não é fornecido pelo usuário.

Aviso : isso não considera novas linhas. Para uma resposta mais aprofundada, consulte esta pergunta SO . (Obrigado, Ed Morton e Niklas Peter)

Observe que escapar de tudo é uma má ideia. Sed precisa que muitos caracteres sejam escapados para obter seu significado especial. Por exemplo, se você escapar um dígito na sequência de substituição, ela retornará para uma referência anterior.

Como Ben Blank disse, existem apenas três caracteres que precisam ser escapados na sequência de substituição (escapam a si mesmos, barra invertida para final de instrução e & para substituir 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"

Se você precisar escapar da KEYWORDsequência, é o seguinte:

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

E pode ser usado 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"

Lembre-se, se você usar um caractere diferente de /delimitador, precisará substituir a barra nas expressões acima pelo caractere que está usando. Veja o comentário de PeterJCLaw para explicação.

Editado: devido a alguns casos de canto anteriormente não contabilizados, os comandos acima foram alterados várias vezes. Verifique o histórico de edições para obter detalhes.

O comando sed permite que você use outros caracteres em vez de /separador:

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

As aspas duplas não são um problema.

Os únicos três caracteres literais que são tratados especialmente na cláusula de substituição são /(para fechar a cláusula), \(para escapar dos caracteres, referência anterior, etc.) e &(para incluir a correspondência na substituição). Portanto, tudo que você precisa fazer é escapar desses três caracteres:

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

Exemplo:

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

Com base nas expressões regulares do Pianosaurus, criei uma função bash que escapa à palavra-chave e à substituição.

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

Veja como você o usa:

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

É um pouco tarde para responder ... mas há uma maneira muito mais simples de fazer isso. Basta alterar o delimitador (ou seja, o caractere que separa os campos). Então, em vez de s/foo/bar/você escrever s|bar|foo.

E, aqui está a maneira mais fácil de fazer isso:

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

A saída resultante é desprovida dessa desagradável cláusula DEFINER.

Acontece que você está fazendo a pergunta errada. Eu também fiz a pergunta errada. A razão pela qual está errado é o início da primeira frase: "No meu script bash ...".

Eu tive a mesma pergunta e cometi o mesmo erro. Se você estiver usando o bash, não precisará usar o sed para fazer substituições de strings (e é muito mais fácil usar o recurso de substituição incorporado ao bash).

Em vez de algo como, por exemplo:

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

você pode usar os recursos do bash exclusivamente:

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

Use awk - é mais limpo:

$ 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

Aqui está um exemplo de um AWK que usei há um tempo atrás. É um AWK que imprime novos AWKS. Sendo AWK e SED semelhantes, pode ser um bom modelo.

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

Parece excessivo, mas de alguma forma essa combinação de aspas funciona para manter o 'impresso como literal. Então, se bem me lembro, as variáveis ​​estão rodeadas de aspas como esta: "$ 1". Experimente, deixe-me saber como funciona com o SED.

Eu tenho uma melhoria sobre a função sedeasy, que quebrará com caracteres especiais como 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"
}

Então, o que é diferente? $1e $2entre aspas para evitar expansões de shell e preservar tabulações ou espaços duplos.

Tubulação adicional | sed -e 's:\t:\\t:g'(eu gosto :como token) que transforma uma guia \t.

Estes são os códigos de escape que eu encontrei:

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

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

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

não se esqueça de todo o prazer que ocorre com a limitação da concha "e '

então (em 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 você está apenas procurando substituir o valor Variável no comando sed, basta remover o Exemplo:

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

Se acontecer de você estar gerando uma senha aleatória para passar para sedsubstituir o padrão, escolha ser cuidadoso sobre qual conjunto de caracteres na sequência aleatória. Se você escolher uma senha criada codificando um valor como base64, haverá apenas um caractere possível na base64 e também um caractere especial no sedpadrão de substituição. Esse caractere é "/" e é facilmente removido da senha que você está gerando:

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

Uma maneira mais fácil de fazer isso é simplesmente construir a string antes da mão e usá-la como parâmetro para sed

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