Échapper une chaîne pour un motif de remplacement sed

Dans mon script bash, j'ai une chaîne externe (reçue de l'utilisateur) que je devrais utiliser dans le modèle sed.

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

Comment puis-je échapper à la $REPLACEchaîne afin qu'elle soit acceptée en toute sécurité par sedcomme remplacement littéral?

NOTE: Le KEYWORDest une sous - chaîne muet sans allumettes , etc. Il n'est pas fournie par l' utilisateur.

Avertissement : cela ne prend pas en compte les sauts de ligne. Pour une réponse plus approfondie, consultez plutôt cette question SO . (Merci, Ed Morton et Niklas Peter)

Notez que tout échapper est une mauvaise idée. Sed a besoin de beaucoup de personnages pour s'échapper pour obtenir leur signification particulière. Par exemple, si vous échappez un chiffre dans la chaîne de remplacement, il se transformera en une référence arrière.

Comme l'a dit Ben Blank, il n'y a que trois caractères à échapper dans la chaîne de remplacement (s'échappe eux-mêmes, barre oblique pour la fin de l'instruction et & pour tout remplacer):

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 jamais vous avez besoin de fuir KEYWORD chaîne, voici ce dont vous avez besoin:

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

Et peut être utilisé par:

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"

N'oubliez pas que si vous utilisez un caractère autre que /comme délimiteur, vous devez remplacer la barre oblique dans les expressions ci-dessus par le caractère que vous utilisez. Voir le commentaire de PeterJCLaw pour une explication.

Modifié: en raison de certains cas d'angle précédemment non pris en compte, les commandes ci-dessus ont changé plusieurs fois. Consultez l'historique des modifications pour plus de détails.

La commande sed vous permet d'utiliser d'autres caractères plutôt /que comme séparateur:

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

Les guillemets doubles ne sont pas un problème.

Les trois seuls caractères littéraux traités spécialement dans la clause replace sont / (pour fermer la clause), \(pour échapper les caractères, la référence arrière, etc.) et &(pour inclure la correspondance dans le remplacement). Par conséquent, tout ce que vous devez faire est d'échapper à ces trois personnages:

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

Exemple:

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

Sur la base des expressions régulières de Pianosaurus, j'ai créé une fonction bash qui échappe à la fois au mot-clé et au remplacement.

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

Voici comment vous l'utilisez:

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

Il est un peu tard pour répondre ... mais il existe un moyen beaucoup plus simple de le faire. Modifiez simplement le délimiteur (c'est-à-dire le caractère qui sépare les champs). Donc, au lieu d' s/foo/bar/écrire s|bar|foo.

Et voici la manière la plus simple de procéder:

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

La sortie résultante est dépourvue de cette clause DEFINER désagréable.

Il s'avère que vous posez la mauvaise question. J'ai également posé la mauvaise question. La raison pour laquelle c'est faux est le début de la première phrase: "Dans mon script bash ...".

J'avais la même question et j'ai fait la même erreur. Si vous utilisez bash, vous n'avez pas besoin d'utiliser sed pour effectuer des remplacements de chaîne (et c'est beaucoup plus propre d'utiliser la fonction de remplacement intégrée à bash).

Au lieu de quelque chose comme, par exemple:

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

vous pouvez utiliser exclusivement les fonctionnalités bash:

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

Utilisez awk - c'est plus propre:

$ 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

Voici un exemple d'un AWK que j'ai utilisé il y a quelque temps. Il s'agit d'un AWK qui imprime de nouveaux AWKS. AWK et SED étant similaires, cela peut être un bon modèle.

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

Cela semble excessif, mais d'une manière ou d'une autre cette combinaison de guillemets fonctionne pour garder le 'imprimé en tant que littéraux. Ensuite, si je me souviens bien, les variables sont simplement entourées de guillemets comme celui-ci: "$ 1". Essayez-le, faites-moi savoir comment cela fonctionne avec SED.

J'ai une amélioration par rapport à la fonction sedeasy, qui rompra avec les caractères spéciaux comme 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"
}

Alors, qu'est-ce qui est différent? $1et $2entouré de guillemets pour éviter les expansions du shell et préserver les tabulations ou les espaces doubles.

Tuyauterie supplémentaire | sed -e 's:\t:\\t:g'(j'aime :comme jeton) qui transforme un onglet en \t.

Voici les codes d'échappement que j'ai trouvés:

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

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

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

n'oubliez pas tout le plaisir qui se produit avec la limitation de la coque autour de "et"

donc (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 vous cherchez simplement à remplacer la valeur de variable dans la commande sed, supprimez simplement l'exemple:

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

Si le cas se trouve être que vous générez un mot de passe aléatoire à passer pour sedremplacer le modèle, alors vous choisissez de faire attention à quel ensemble de caractères dans la chaîne aléatoire. Si vous choisissez un mot de passe créé en encodant une valeur en base64, il n'y a qu'un seul caractère qui est à la fois possible en base64 et également un caractère spécial dans le sedmodèle de remplacement. Ce caractère est "/" et est facilement supprimé du mot de passe que vous générez:

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

Un moyen plus simple de le faire consiste simplement à créer la chaîne avant la main et à l'utiliser comme paramètre pour sed

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