Existe-t-il un moyen d'empêcher sed d'interpréter la chaîne de remplacement? [fermé]

Si vous souhaitez remplacer un mot clé par une chaîne à l'aide de sed, sed s'efforce d'interpréter votre chaîne de remplacement. Si la chaîne de remplacement contient des caractères que sed considère spéciaux, comme un caractère '/', cela échouera, à moins bien sûr que vous vouliez que votre chaîne de remplacement contienne des caractères qui indiquent à sed comment agir.

Ex:

VAR="hi/"

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

Existe-t-il un moyen de dire à sed de ne pas essayer d'interpréter la chaîne de remplacement pour les caractères spéciaux? Tout ce que je veux, c'est pouvoir remplacer un mot-clé dans un fichier par le contenu d'une variable, quel que soit ce contenu.

Il n'y a que 4 caractères spéciaux dans la pièce de rechange: \, &, et le retour à la ligne delimiter ( 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

Vous pouvez utiliser Perl au lieu de sed avec -p(supposer la boucle sur l'entrée) et -e(donner le programme sur la ligne de commande). Avec Perl, vous pouvez accéder aux variables d'environnement sans les interpoler dans le shell. Notez que la variable doit être exportée :

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

Si vous ne souhaitez pas exporter la variable partout, fournissez-la uniquement pour ce processus uniquement:

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

Notez que la syntaxe d'expression régulière de Perl est par défaut légèrement différente de celle de sed.

La solution la plus simple qui gèrerait toujours la grande majorité des valeurs de variables correctement serait d'utiliser un caractère non imprimable comme délimiteur de sedla commande de substitution.

Dans vivous pouvez échapper à n'importe quel caractère de contrôle en tapant Ctrl-V (plus communément écrit comme ^V). Donc, si vous utilisez un caractère de contrôle (j'utilise souvent ^Acomme délimiteur dans ces cas), alors votre sedcommande ne se cassera que si ce caractère non imprimable est présent dans la variable dans laquelle vous déposez.

Vous devez donc taper "s^V^AKEYWORD^V^A$VAR^V^Ag"et ce que vous obtiendrez (en vi) ressemblerait à:

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

Cela fonctionnera tant $VARqu'il ne contient pas le caractère non imprimable, ^Ace qui est extrêmement improbable.

Bien sûr, si vous transmettez une entrée utilisateur à la valeur de $VAR, tous les paris sont désactivés et vous feriez mieux de désinfecter soigneusement votre entrée plutôt que de compter sur des caractères de contrôle difficiles à taper pour l'utilisateur moyen.

Cependant, il y a plus à se méfier que la chaîne de délimitation. Par exemple, &lorsqu'il est présent dans une chaîne de remplacement, signifie «tout le texte qui a été mis en correspondance». Par exemple, s/stu../my&/remplacerait "stuff" par "mystuff", "piqué" par "mystung", etc. Donc, si vous pourriez avoir un caractère dans la variable que vous déposez en tant que chaîne de remplacement, mais vous voulez utiliser le littéral valeur de la variable uniquement, vous devez effectuer un nettoyage des données avant de pouvoir utiliser la variable comme chaîne de remplacement dans sed. (Le nettoyage des données peut également être effectué sed.)

Vous pouvez utiliser un ,ou un à la |place et il le prendra comme séparateur et techniquement, vous pourriez utiliser n'importe quoi

depuis la page de manuel

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

Comme vous pouvez le voir, vous devez commencer par un \ avant votre séparateur au début, puis vous pouvez l'utiliser comme séparateur.

à partir de la documentation 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.

Exemple:

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

S'il est basé sur une ligne et qu'une seule ligne doit être remplacée, je recommande d'ajouter le fichier lui-même avec la ligne de remplacement à l'aide de printf, de stocker cette première ligne dans sedl'espace de stockage de , et de la déposer si nécessaire. De cette façon, vous n'avez pas du tout à vous soucier des caractères spéciaux. (La seule hypothèse ici est que $VARcontient une seule ligne de texte sans aucun retour à la ligne, ce que vous avez déjà dit dans les commentaires.) À part les retours à la ligne, VAR peut contenir n'importe quoi et cela fonctionnerait malgré tout.

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

printf '%s\n'affichera le contenu de $VARsous forme de chaîne littérale, quel que soit son contenu, suivi d'une nouvelle ligne. ( echofera d'autres choses dans certains cas, par exemple si le contenu de $VARcommence par un trait d'union — il sera interprété comme un indicateur d'option transmis à echo.)

Les accolades sont utilisées pour ajouter la sortie de printfau contenu de somefilelors de sa transmission sed. Les espaces séparant les accolades par eux-mêmes sont importants ici, tout comme le point-virgule avant l'accolade fermante.

1{h;d;};en tant que sedcommande stockera la première ligne de texte dans sedl' espace d'attente de , puis dsupprimera la ligne (plutôt que de l'imprimer).

/KEYWORD/applique les actions suivantes à toutes les lignes qui contiennent KEYWORD. L'action est get, qui récupère le contenu de l'espace d'attente et le dépose à la place de l' espace de motif - en d'autres termes, la ligne actuelle entière. (Ce n'est pas pour remplacer seulement une partie d'une ligne.) L'espace de retenue n'est pas vidé, soit dit en passant, juste copié dans l'espace de motif, remplaçant tout ce qui s'y trouve.

Si vous souhaitez ancrer votre expression rationnelle afin qu'elle ne corresponde pas à une ligne qui contient simplement KEYWORD mais uniquement une ligne où il n'y a rien d'autre sur la ligne que KEYWORD, ajoutez un début d'ancre de ligne ( ^) et une ancre de fin de ligne ( $) à votre regex:

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

Vous pouvez utiliser une barre oblique inverse pour échapper aux barres obliques dans votre chaîne de remplacement, en utilisant l'expansion du paramètre de substitution de modèle de Bash. C'est un peu compliqué car les barres obliques doivent également être échappées pour Bash.

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

production

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

Vous pouvez mettre l'expansion des paramètres directement dans votre commande sed:

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

mais je pense que la première forme est un peu plus lisible. Et bien sûr, si vous allez réutiliser le même modèle de remplacement dans plusieurs commandes sed, il est logique de ne faire la conversion qu'une seule fois.

Une autre option serait d'utiliser un script écrit en awk, perl ou Python, ou un programme C, pour faire vos substitutions au lieu d'utiliser sed.

Voici un exemple simple en Python qui fonctionne si le mot-clé à remplacer est une ligne complète dans le fichier d'entrée (sans compter la nouvelle ligne). Comme vous pouvez le voir, il s'agit essentiellement du même algorithme que votre exemple Bash, mais il lit le fichier d'entrée plus efficacement.

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)

Voici comment je suis allé:

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

cela fonctionne très bien dans mon cas, car mon mot clé est sur une ligne à lui tout seul. Si le mot clé était aligné avec un autre texte, cela ne fonctionnerait pas.

J'aimerais toujours vraiment savoir s'il existe un moyen facile de le faire qui n'implique pas de coder ma propre solution.