Échapper à une chaîne pour un sed remplacer motif

Dans mon script bash que j'ai un externe (reçus de l'utilisateur) chaîne de caractères, qui je dois l'utilisation de sed modèle.

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

Comment puis-je échapper à la $REPLACE chaîne de sorte qu'il serait en sécurité acceptée par sed comme un littéral de remplacement?

REMARQUE: La KEYWORD est un muet sous-chaîne avec pas de matches etc. Il n'est pas fourni par l'utilisateur.

Êtes-vous en essayant d'éviter le "Petit Bobby Tables" problème si ils disent "/g -e 's/MOT de passe=.*/MOT de passe=abc/g'"?
Oui, celui-là aussi.
Si vous utilisez bash, vous n'avez pas besoin de sed. Utilisez simplement outputvar="${inputvar//"$txt2replace"/"$txt2replacewith"}".
Je pense que vous ne devriez pas mettre les deux variables en dehors de la cite. Bash peut lire des variables à l'intérieur des guillemets (dans votre exemple, les espaces pourraient vis les choses).
Voir aussi: stackoverflow.com/q/29613304/45375
voir mon commentaire sur ma propre réponse. Les guillemets à l'intérieur de l' ${} ne correspondent pas avec les guillemets à l'intérieur. Les deux variables ne sont pas à l'extérieur de la cite.
vous avez raison.
connexes: superuser.com/questions/422459/...

InformationsquelleAutor Alexander Gladysh | 2009-01-02

242

Avertissement: Ce n' pas envisager des retours à la ligne. Pour un plus en profondeur réponse, voir cette question à la place. (Merci, Ed Morton & Niklas Pierre)

Remarque qu'échapper à tout ce qui est une mauvaise idée. Sed a besoin de beaucoup de caractères à échapper à obtenir une signification particulière. Par exemple, si vous échappez un chiffre dans la chaîne de remplacement, il sera à son tour à une référence arrière.

Ben Vierge a dit, il y a seulement trois caractères doivent être échappés dans la chaîne de remplacement (échappe à eux-mêmes, barre oblique de fin d'instruction et & pour remplacer tous):
```
sed -e 's/[\/&]/\\&/g'
```
Si jamais vous avez besoin pour échapper à la KEYWORD chaîne, ce qui suit est celui dont vous avez besoin:
```
sed -e 's/[]\/$*.^[]/\\&/g'
```
Rappelez-vous, si vous utilisez un caractère autre que / comme délimiteur, vous avez besoin de remplacer la barre oblique dans les expressions ci-dessus avec le personnage que vous utilisez. Voir PeterJCLaw commentaire pour l'explication.

Édité: en Raison de certains cas de coin auparavant pas pris en compte, les commandes ci-dessus ont changé plusieurs fois. Cochez la case modifier l'histoire pour plus de détails.
- +1, je ne pense pas que backrefs et d'autres choses.
- Il est intéressant de noter que vous pouvez éviter d'avoir à échapper à l'obliques par ne pas les utiliser comme délimiteurs. La plupart (tous?) les versions de la sed de vous permettre d'utiliser n'importe quel caractère, tant qu'il correspond à la tendance: $ echo 'foo/bar" | sed s_/_:_ # foo:bar
- Bon point. Je crois que c'est vrai pour toutes les versions de la sed. Il y a seulement deux échappés des barres obliques ci-dessus, de sorte qu'il ne ferait pas beaucoup de différence, mais c'est important si vous utilisez un autre délimiteur dans le sed expression de cette sortie est inséré. J'ai ajouté quelques infos pour refléter cela.
- sed-e 's/(\/\|\\\|&)/\\&/g' n'a pas fonctionné pour moi sur OSX, mais ce n': sed 's/([\\\/&])/\\&/g,' et il est légèrement plus courte.
- Je n'ai aucune idée de pourquoi je n'ai pas utilisé les groupes de caractères lorsque j'ai d'abord écrit ce. J'ai mis à jour le post. GNU sed ne nécessite pas (ou de soutien) échapper les caractères à l'intérieur de groupes de caractères, donc j'ai dû le faire encore plus court. Ma version de travail pour vous? Si non, je vais ajouter un commentaire à propos de la non-gnu sed. Quel est votre --version?
- question: je viens d'essayer cette solution et si je le nourrir un "/boo" je suis de se changer en "&boo" au lieu de "\/boo". Mais si j'utilise 3 évasions Ben Vide suggéré - tout fonctionne. Peut comprendre pourquoi, 2 semble le bon choix
- Tout ce que vous êtes l'envoi de la commande se fait l'interprète de vos escapades. Par exemple, dans la plupart des coques, à l'aide de guillemets à la place des guillemets à ce.
- Pour la recherche de motif KEYWORD, dans GNU sed, voici 2 autres caractères ^,$ ne sont pas mentionnés ci-dessus: s/[]\/$*.^|[]/\\&/g
- Merci, Pierre.O. J'ai ajouté, et deux de plus. MAINTENANT nous devons avoir tous trouvés.
- Dans le cas où la chaîne de caractères à remplacer est juste le point de caractères, il doit également être "échappé". Comme: sed s/\[.]/_/g à l'opposé sed s/\.foo/_foo/g
- ( et ) ne doit pas être échappé. Ils n'ont pas de signification particulière par défaut, et d'échapper à leur donne eux une signification particulière. (GNU sed 4.2.2)
- qu'en est " que shell limitation, si elle est utilisée dans les sed modèle grâce à la substitution de variable ?
- Fixe. En fait, c'est l'erreur que j'ai en garde contre dans le premier paragraphe. Je suppose que je ne suis pas en pratique ce que je prêche.
- Je ne suis pas sûr que je sais ce que tu veux dire, mais " n'a pas de signification particulière dans les tuyaux ou les variables. Il est interprété par le shell avant d'exécuter le résultat, donc des guillemets à l'intérieur de variables sont en sécurité. Par exemple, essayez d'exécuter A='foo"bar' echo $A | sed s/$A/baz/ en bash. Les guillemets sont traités comme la " foo " et " bar " autour d'elle.
- vous avez raison, il suffit de faire le test dans plusieurs shell et en ksh, sh et bash, il passe même entouré d'une double cotation. J'étais (plus) de certains qui A='I am a fine"guy'; echo $A | sed -e "s/$A/Sorry I am dummy, learn first/" me faire plaisir mais ...
- Merci cela m'a vraiment aidé à sortir. Je l'ai fait en deux fonctions. Voir ll. 57-63 ici: github.com/gistya/expandr/blob/master/expandr.sh
- Ce que ce serait en pure bash de substitution? ${var//search/replace}
- Si vous voulez un littéral de 3 barres obliques inverses comme \\\, ce sed -e 's/[\/&]/\\&/g' semble être la seule à donner \\\\ comme sa sortie. Qui serait seulement de résoudre le 2 barres obliques inverses à droite? Je pense qu'il devrait en fait être de donner 6 barres obliques inverses. Ce qui peut être fait pour résoudre le sed de commande?
- Exemple d'utilisation de la CIBLE=$(echo $CIBLE | sed -e 's/[]\/$*.^|[]/\\&/g,')!
- À l'aide de l'écho comme ça, c'est dangereux, sauf si vous savez ce que le contenu de $CIBLE est, depuis écho accepte les commutateurs. Essayez, par exemple,TARGET="-e \foo"; echo $TARGET. Vous pouvez utiliser printf place: printf '%s\n' "$TARGET"
- Je pense que vous êtes soit à l'aide d'un sed version n'est pas compatible avec le mien, ou vous devez entrer les barres obliques dans le mauvais sens. Cela donne 6 antislash pour moi: printf '%s\n' '\\\' | sed -e 's/[\/&]/\\&/g'
- wrt there are only three characters that need to be escaped in the replacement string - non, vous avez aussi besoin de barres obliques inverses, quand ils sont remplacé par un chiffre, par exemple \1, ou ils seront traités comme une référence à un groupe correspondant. Voir stackoverflow.com/questions/29613304/... pour savoir comment faire ce travail de manière robuste.
- Vous n'avez pas envisager de caractères de saut de ligne.
- Cela a fonctionné pour moi jusqu'à ce que j'ai mis {} dans la chaîne. J'ai modifié pour être sed -e 's/[\/&}]/\\&/g' et qui semblait le fixer.
- Caractères d'échappement sont l'une des trois cités, donc je ne sais pas à quoi vous faites allusion. Essayez echo 'Foo\1bar' | sed -e 's/[\/&]/\\&/g' si vous êtes dans le doute. Votre lien est une vraiment bonne, dans la profondeur de réponse, donc j'ai ajouté un avertissement et votre lien vers la réponse. Merci.
- Vrai. Inclus dans l'avertissement maintenant, merci.
- Qu'est-ce que votre sed dialecte? Cela fonctionne très bien pour GNU: echo 'Foo' | sed -e 's/o/a{b}c/'
- Je travaillais avec Alpine Linux (dans le menu fixe). J'ai été en utilisant la version 3.3 à l'époque. Avant d'ajouter } j'ai eu cette erreur: sed: bad option in substitution expression
- Alpine utilise busybox, droit? J'ai testé mon foo-echo-dessus dans busybox v1.20.0, et il y travaille aussi. Avez-vous de la commande complète disponible?
- Pour ceux (comme moi) qui n'a pas compris ce que "& " dans la chaîne de remplacement signifiait, il signifie "le motif trouvé". Voir: grymoire.com/Unix/Sed.html#uh-3
- Voir aussi: stackoverflow.com/questions/12203963/...
- Veuillez supprimer | à partir de la clé de remplacement, trop. Exemple: sed 's/\|/x/g' <<< abc donne xaxbxcx, donc | ne doit pas être échappés ou utilisé comme délimiteur aussi. FYI: sed (GNU sed) 4.2.2
- Yep, | gains de signification particulière, en étant échappé de là. Fixe. Merci à vous, @Tino
- pourquoi avez-vous de remplacer les crochets [ ] deux fois dans la KEYWORD chaîne -- au début et à la fin? Ne faudrait-il pas paire sera suffisant?
- Je pense que c'est effectivement un gros [...] expression qui arrive à avoir ] en tant que premier et [ comme dernier élément dans la liste.
- Cette réponse n'a pas aider un novice comme moi.
InformationsquelleAutor Pianosaurus
81

La sed de commande vous permet d'utiliser d'autres caractères au lieu de / comme séparateur:
```
sed 's#"http://www\.fubar\.com"#URL_FUBAR#g'
```
Les guillemets ne sont pas un problème.
- Vous avez encore le besoin d'échapper à . qui, autrement, a une signification particulière. J'ai édité votre réponse.
- J'ai juste essayé de faire : sed '/CLIENTSCRIPT="foo"/a CLIENTSCRIPT2="hello"' file avec sed '|CLIENTSCRIPT="foo"|a CLIENTSCRIPT2="hello"' file et qui ne fait pas de même.
- Parce que cela s'applique uniquement à remplacer, ce qui devrait dire: Le s de commande (comme remplaçant) de sed permet d'utiliser d'autres caractères au lieu de / comme séparateur. Aussi, ce serait une réponse à comment utiliser sed sur les URL avec des caractères barre oblique. Il ne répond pas à l'OP question de savoir comment échapper à une chaîne entrée par l'utilisateur, qui peut contenir /, \, mais aussi # si vous décidez de l'utiliser. Et d'ailleurs, URI peut contenir # trop
InformationsquelleAutor scre_www
41

Les trois seuls caractères littéraux qui sont spécialement traités dans le remplacement de la clause sont / (pour fermer la clause), \ (pour échapper les caractères, la référence arrière, &c.), et & (notamment le match dans la zone de remplacement). Donc, tout ce que vous devez faire est de s'échapper de 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
```
- Aussi un retour à la ligne, je pense. Comment échapper à un retour à la ligne?
- Faire attention à ce que le comportement par défaut de l'écho à l'égard des barres obliques inverses. En bash, en écho par défaut, aucune interprétation de séquences d'échappement, qui sert le but ici. Dans le tableau de bord (sh), d'autre part, l'echo interprète des antislashes et n'a aucun moyen, autant que je sache, de la suppression de cette. Par conséquent, dans le tableau de bord (sh), à la place de echo $x, do printf "%s\n " $x.
- Aussi, toujours utiliser l'option-r lors d'une lecture à traiter les barres obliques inverses dans la saisie de l'utilisateur comme des littéraux.
- Pour la croix-compatibilité de plate-forme à d'autres shells, vous devriez consulter ce document concernant le remplacement de la sed caractères spéciaux: grymoire.com/Unix/Sed.html#toc-uh-62
- Si seulement ces trois personnages sont spécialement traités, pourquoi ne echo '[a](!)' | sed 's/[a](!)/[a]/' (avec GNU sed à l'intérieur de bash) résultat de la [a](!) au lieu de [a]?
- Les trois personnages sont les seuls particuliers dans le remplacer l'article. Beaucoup plus est spécial dans le modèle de la clause.
InformationsquelleAutor Ben Blank
31

Basé sur Pianosaurus est d'expressions régulières, j'ai fait une fonction bash, qui échappe à la fois de mots clés et de remplacement.
```
function sedeasy {
  sed -i "s/$(echo $1 | sed -e 's/$[[\/.*]\|\]$/\\&/g')/$(echo $2 | sed -e 's/[\/&]/\\&/g')/g" $3
}
```
Voici comment l'utiliser:
```
sedeasy "include /etc/nginx/conf.d/*" "include /apps/*/conf/nginx.conf" /etc/nginx/nginx.conf
```
- merci! si quelqu'un d'autre obtient une erreur de syntaxe lors de la tentative de l'utiliser, tout comme moi, n'oubliez pas de l'exécuter à l'aide de bash, pas de poisson
- Est-il une fonction juste pour échapper à une chaîne de sed au lieu de l'entourer sed?
- Hey, juste un avertissement d'ordre général au sujet de départ des tuyaux avec un écho comme ceci: Certains (la plupart?) les implémentations de l'écho de prendre des options (voir man echo), provoquant la conduite à se comporter de façon inattendue lorsque votre argument $1 commence par un tiret. Au lieu de cela, vous pouvez commencer votre tuyau avec printf '%s\n' "$1".
InformationsquelleAutor Gurpartap Singh
16

C'est un peu tard pour répondre... mais il y a un moyen beaucoup plus simple pour ce faire. Il suffit de changer le séparateur (c'est à dire, le caractère qui sépare les champs). Ainsi, au lieu de s/foo/bar/ vous écrire s|bar|foo.

Et, voici le moyen le plus facile pour ce faire:
```
sed 's|/\*!50017 DEFINER=`snafu`@`localhost`\*/||g'
```
La sortie qui en est dépourvu de ce méchant DÉFINISSEUR de la clause.
- Non, & et ` doit toujours être échappé, comme doit le délimiteur, selon ce qui est choisi.
- Qui a résolu mon problème, comme je l'avais "/" caractères dans une chaîne de caractères de remplacement. Merci, mec!
- fonctionne pour moi. Ce fais, c'est essayer de s'échapper $ dans la chaîne sur le point d'être changé, et de maintenir le sens de l' $ dans la chaîne de remplacement. dire que je veux changer $XXX à la valeur de la variable $YYY, sed -i "s|\$XXX|$YYY|g" file fonctionne très bien.
InformationsquelleAutor user2460464
11

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

J'ai eu la même question & fait la même erreur. Si vous utilisez bash, vous n'avez pas besoin d'utiliser sed pour faire de la chaîne de remplacement (et c'est beaucoup nettoyant à utiliser la fonction remplacer construit en 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 bash caractéristiques exclusivement:
```
INPUT='some long string with KEYWORD that need replacing KEYWORD.'
A='KEYWORD'
B='<funny characters here>'
OUTPUT="${INPUT//"$A"/"$B"}"
```
- BTW, la coloration syntaxique n'est pas bon. L'extérieur des guillemets correspondent & l'intérieur des guillemets correspondent. En d'autres termes, il ressemble à $A et $B sont non cotées, mais ils ne le sont pas. Les guillemets à l'intérieur de la ${} ne correspondent pas avec les guillemets à l'extérieur.
- Vous n'êtes pas obligé de citer le côté droit d'une affectation (sauf si vous voulez faire quelque chose comme var='has space') – OUTPUT=${INPUT//"$A"/"$B"} est sûr.
- Vous n'êtes pas obligé de citer le côté droit d'une affectation (sauf si vous voulez qu'il fonctionne dans le monde réel et pas seulement comme un jouet script pour afficher yur mad skilz). J'essaie toujours de citer toutes les variables d'extension que je ne veux pas le shell pour l'interpréter, à moins que j'ai une raison particulière de ne pas. De cette façon, les choses ont tendance à casser le moins souvent, surtout quand lorsqu'il est fourni avec de nouveaux ou inattendus d'entrée.
- Juste pour dire que un extension n'a pas à être cité: var1=$var2 ne peut se briser, peu importe ce que vous avez dans var2: glob caractères, espaces, retours à la ligne... Mais en citant il ne fait pas de mal, bien sûr.
- Voir manuel: "Toutes les valeurs subissent une expansion du tilde, paramètre et variable de l'expansion, de la substitution de commande, l'expansion arithmétique, et de citer la suppression (détaillé ci-dessous)." I. e., le même que dans les guillemets.
- Merci pour le lien. Je dois me rappeler que.
- Que faire si vous avez besoin d'utiliser sed sur un fichier?
InformationsquelleAutor destenson
1

Utiliser 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
```
- Le problème avec les awk est qu'il n'a rien de semblable à sed -i, qui vient très pratique, 99% du temps.
- C'est un pas dans la bonne direction, mais awk encore interprète certains caractères de remplacement dans votre substitution, il est donc toujours pas à l'abri de la saisie de l'utilisateur.
InformationsquelleAutor greggster
0

Voici un exemple d'un AWK j'ai utilisé il y a longtemps. C'est un AWK qui imprime de nouveaux AWKS. AWK et SED étant similaires, il peut être un bon modèle.
```
ls | awk '{ print "awk " "'"'"'"  " {print $1,$2,$3} " "'"'"'"  " " $1 ".old_ext > " $1 ".new_ext"  }' > for_the_birds
```
Il semble excessif, mais en quelque sorte que la combinaison de devis travaux à garder le ' imprimés comme des littéraux. Alors si je me souviens bien le vaiables sont juste entourés de guillemets comme ceci: "$1". Essayez-la, laissez-moi savoir comment cela fonctionne avec le SED.

InformationsquelleAutor Alex
0

J'ai une amélioration par rapport à la sedeasy fonction, qui VA rompre avec les caractères spéciaux comme onglet.
```
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, quoi de différent? $1 et $2 enveloppé dans des guillemets pour éviter shell expansions et de préserver les tabulations ou des espaces de double.

Supplémentaire de la tuyauterie | sed -e 's:\t:\\t:g' (j'aime : token) qui transforme un onglet dans \t.
- Mais voir mon commentaire sur le sedeasy réponse concernant l'utilisation de l'écho dans les tuyaux.
InformationsquelleAutor Francisco De Zuviria
-1

n'oubliez pas, tout le plaisir qui se produisent avec le shell limitation autour "et"

(dans 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"
```
- exactement de la direction, j'ai été nécessaires, pour échapper à des résultats de recherche, par le biais de google peut être utile pour quelqu'un - clos avec sed "s/[&\\\*\\"\'\"' )(]/\\&/g'
InformationsquelleAutor NeronLeVelu
-1

Si le cas se trouve être que vous générez un mot de passe aléatoire pour passer à sed remplacer le modèle, puis vous choisissez d'être prudent sur le jeu de caractères dans la chaîne de caractères aléatoires. Si vous choisissez un mot de passe composé par le codage d'une valeur en base64, il est est le seul personnage qui est à la fois possible en base64 et est également un caractère spécial dans sed remplacer le modèle. Ce caractère est "/", et s'enlève facilement le mot de passe de la production:
```
# password 32 characters log, minus any copies of the "/" character.
pass=`openssl rand -base64 32 | sed -e 's/\///g'`;
```
InformationsquelleAutor Mark Stosberg
-1

Si vous êtes simplement à la recherche pour remplacer la valeur de la Variable dans la commande sed puis il suffit de supprimer
Exemple:
```
sed -i 's/dev-/dev-$ENV/g' test to sed -i s/dev-/dev-$ENV/g test
```
InformationsquelleAutor shailender chauhan
-3

Un moyen plus facile de le faire est de simplement construire la chaîne avant de la main et de l'utiliser comme un paramètre pour sed
```
rpstring="s/KEYWORD/$REPLACE/g"
sed -i $rpstring  test.txt
```
- Échoue et extrêmement dangereux, comme de remplacement est fournie par l'utilisateur: REPLACE=/ donne sed: -e expression #1, char 12: unknown option to `s'
InformationsquelleAutor Javonne Martin

Vous devez vous connecter pour publier un commentaire.