Comment utiliser sed pour remplacer uniquement la première occurrence dans un fichier?

Écrire un script sed qui ne fera que remplacer la première occurrence de "Apple" en "Banane"

Exemple Entrée: Sortie:

     Apple       Banana
     Orange      Orange
     Apple       Apple

C'est la simple script: ^{note de l'Éditeur: fonctionne avec GNU sed seulement.}

sed '0,/Apple/{s/Apple/Banana/}' filename

Un aperçu de l'utile beaucoup les réponses existantes, complété par explications:

<sup>Le ici des exemples de l'utilisation d'une procédure simplifiée de cas d'utilisation: remplacer le mot " foo " par " bar " dans la première ligne seulement.

En raison de l'utilisation de C ANSI-chaînes entre guillemets ($'...') de fournir l'échantillon, les lignes d'entrée, bash, ksh, ou zsh est supposé que le shell.</sup>

---

GNU sed seulement:

Ben Hoffstein de anwswer nous montre que GNU fournit une extension à la Spécification POSIX pour sed qui permet à l'2-formulaire d'adresse: 0,/re/ (re représente un arbitraire expression régulière ici).

0,/re/ permet l'expression régulière regex pour match sur la première ligne également. En d'autres termes: cette adresse permettra de créer une gamme à partir de la 1ère ligne de jusqu'à et y compris la ligne qui correspond à re - si re se produit sur la 1ère ligne ou sur les éventuels ligne.

• Cela contraste avec la POSIX forme 1,/re/, ce qui crée une gamme qui correspond à compter de la 1ère ligne de jusqu'à et y compris la ligne qui correspond à re sur ultérieure lignes; en d'autres termes: ce ne détecte pas la première occurrence d'une re match si il arrive à se produire sur la 1er ligne et aussi empêche l'utilisation de la sténographie de // pour réutiliser le plus récemment utilisé les regex (voir point suivant).^[1]

Si vous combinez une 0,/re/ adresse avec un s/.../.../ (substitution) appel qui utilise le même expression régulière, votre commande sera efficacement que d'effectuer la substitution sur le première ligne qui correspond à re.

sed fournit un moyen pratique raccourci pour les réutiliser le plus récent expression régulière: un vide délimiteur paire, //.

$ sed '0,/foo/s//bar/' <<<$'1st foo\nUnrelated\n2nd foo\n3rd foo' 
1st bar         # only 1st match of 'foo' replaced
Unrelated
2nd foo
3rd foo

---

Une POSIX-caractéristiques-seulement sed comme BSD (macOS) sed (collaborera également avec GNU sed):

Depuis 0,/re/ ne peuvent pas être utilisés et la forme 1,/re/ ne détecte pas re si il arrive à se produire sur la première ligne (voir ci-dessus), un traitement spécial pour la 1ère ligne est nécessaire.

MikhailVS réponse mentionne la technique, de la mettre dans un exemple concret ici:

$ sed -e '1 s/foo/bar/; t' -e '1,//s//bar/' <<<$'1st foo\nUnrelated\n2nd foo\n3rd foo'
1st bar         # only 1st match of 'foo' replaced
Unrelated
2nd foo
3rd foo

Remarque:

• Le vide regex // raccourci est employé deux fois ici: une fois pour le point de terminaison de la gamme, et une fois dans la s appel; dans les deux cas, la regex foo est implicitement réutilisés, ce qui nous permet de ne pas avoir à dupliquer, ce qui le rend à la fois plus courtes et plus maintenable code.

• POSIX sed besoins réels des retours à la ligne après certaines fonctions, telles que, d'après le nom d'un label ou une omission, comme c'est le cas avec t ici; stratégiquement fendre le script en plusieurs -e options est une alternative à l'utilisation réelle des retours à la ligne: la fin de chaque -e script morceau où un retour à la ligne aurait normalement besoin d'aller.

1 s/foo/bar/ remplace foo sur la 1ère ligne seulement, si l'on y trouve.
Si oui, t branches à la fin du script (et ignore les autres commandes sur la ligne). (Le t fonction des branches d'un label si la plus récente s appel effectué une réelle substitution; en l'absence d'un label, comme c'est le cas ici, la fin du script est ramifiée à l').

Lorsque cela se produit, la gamme d'adresses 1,//, qui, normalement, trouve la première occurrence à partir de la ligne 2, sera pas match, et la plage de pas être traités, parce que l'adresse est évaluée lorsque la ligne en cours est déjà 2.

À l'inverse, si il n'y a pas de match sur la 1ère ligne, 1,// sera être entré, et trouver le vrai premier match.

L'effet net est le même qu'avec GNU sed's 0,/re/: seule la première occurrence est remplacé, si elle se produit sur la 1ère ligne ou de toute autre.

---

NON-gamme d'approches

potong réponse montre boucle techniques que de contourner la nécessité d'un; car il utilise GNU sed syntaxe, voici les conforme à POSIX équivalents de:

Boucle technique 1: Sur le premier match, effectuer la substitution, puis entrer dans une boucle qui imprime simplement les lignes restantes est-à -:

$ sed -e '/foo/{s//bar/; ' -e ':a' -e '$!{n;ba' -e '};}' <<<$'1st foo\nUnrelated\n2nd foo\n3rd foo'
1st bar
Unrelated
2nd foo
3rd foo

Boucle technique 2, pour de petits fichiers seulement: lire l'ensemble de l'entrée dans la mémoire, puis de réaliser une simple substitution sur elle.

$ sed -e ':a' -e '$!{N;ba' -e '}; s/foo/bar/' <<<$'1st foo\nUnrelated\n2nd foo\n3rd foo'
1st bar
Unrelated
2nd foo
3rd foo

---

<sup>[1] 1.61803 fournit des exemples de ce qui se passe avec 1,/re/, avec et sans s//:

- sed '1,/foo/s/foo/bar/' <<<$'1foo\n2foo' rendements $'1bar\n2bar'; c'est à dire, les deux lignes ont été mises à jour, parce que le numéro de ligne 1 correspond à la 1ère ligne, et regex /foo/ - la fin de la plage - est alors seulement regardé pour le démarrage sur le prochaine ligne. Par conséquent, les deux lignes sont sélectionnées dans ce cas, et le s/foo/bar/ de substitution est effectuée sur les deux.

- sed '1,/foo/s//bar/' <<<$'1foo\n2foo\n3foo' échoue: avec sed: first RE may not be empty (BSD/macOS) et sed: -e expression #1, char 0: no previous regular expression (GNU), parce que, au moment de la 1ère ligne est en cours de traitement (en raison de numéro de ligne 1 de départ de la gamme), pas de regex a encore été appliqué, de sorte // ne fait pas référence à quoi que ce soit.

À l'exception de GNU sedspécial 0,/re/ syntaxe, tout gamme qui commence avec une numéro de ligne efficacement s'oppose à l'utilisation de //.</sup>

Tout à fait une collection complète de réponses sur la linuxtopia sed FAQ. Il souligne aussi que certaines réponses fournies ne fonctionne pas avec les non-GNU version de sed, par exemple,

sed '0,/RE/s//to_that/' file

non-GNU version devra être

sed -e '1s/RE/to_that/;t' -e '1,/RE/s//to_that/'

Cependant, cette version ne fonctionne pas avec gnu sed.

Voici une version qui fonctionne avec:

-e '/RE/{s//to_that/;:a' -e '$!N;$!ba' -e '}'

ex:

sed -e '/Apple/{s//Banana/;:a' -e '$!N;$!ba' -e '}' filename

#!/bin/sed -f
1,/^#include/{
    /^#include/i\
#include "newfile.h"
}

Comment ce script fonctionne: Pour les lignes entre le 1 et le premier #include (après la ligne 1), si la ligne commence par #include, puis ajouter la ligne spécifiée.

Cependant, si la première #include est dans la ligne 1, puis la ligne 1 et la suivante #include aura la ligne précédée. Si vous utilisez GNU sed, il a une extension où 0,/^#include/ (au lieu de 1,) va faire la bonne chose.

Je sais que c'est un vieux post mais j'ai eu une solution que j'ai utilisé:

grep -E -m 1 -n 'old' file | sed 's/:.*$//' - | sed 's/$/s\/old\/new\//' - | sed -f - file

Utiliser grep pour trouver la première occurrence et de s'arrêter là. Également imprimer le numéro de ligne ie 5:ligne. Tuyau en sed et retirez le : et de rien, après si vous êtes juste à gauche avec un numéro de ligne. Tuyau en sed qui ajoute s/.*/remplacer à la fin qui donne la un 1 ligne de script qui est transmis dans le dernier sed pour exécuter un script sur le fichier.

donc si regex = #include et replace = bla et la première occurence grep trouve sur la ligne 5, puis les données joué à la dernière sed serait 5s/.*/bla/.

je voudrais le faire avec un script awk:

BEGIN {i=0}
(i==0) && /#include/{print "#include \"newfile.h\""; i=1}
{print $0}    
END {}

puis l'exécuter avec awk:

awk -f awkscript headerfile.h > headerfilenew.h

peut être bâclée, je suis nouveau sur ce.

J'ai finalement obtenu ce travail dans un script Bash est utilisé pour insérer un unique, d'horodatage, de chacun des éléments dans un flux RSS:

        sed "1,/====RSSpermalink====/s/====RSSpermalink====/${nowms}/" \
            production-feed2.xml.tmp2 > production-feed2.xml.tmp.$counter

Il remplace la première occurrence uniquement.

${nowms} est le temps en millisecondes définie par un script Perl, $counter est un compteur utilisé pour le contrôle en boucle dans le script, \ permet la commande doit être continue sur la ligne suivante.

Le fichier est lu et la sortie standard est redirigée vers un fichier de travail.

La façon dont je le comprends, 1,/====RSSpermalink====/ indique à sed quand arrêter par la définition d'une plage de limitation, puis s/====RSSpermalink====/${nowms}/ est le familier de commande sed pour remplacer la première chaîne avec le deuxième.

Dans mon cas, j'ai mis la commande dans des guillemets doubles becauase je suis de l'utiliser dans un script Bash avec des variables.

Cela pourrait fonctionner pour vous (GNU sed):

sed -si '/#include/{s//& "newfile.h\n&/;:a;$!{n;ba}}' file1 file2 file....

ou si la mémoire n'est pas un problème:

sed -si ':a;$!{N;ba};s/#include/& "newfile.h\n&/' file1 file2 file...

La commande suivante supprime la première occurrence d'une chaîne dans un fichier. Il supprime la ligne vide aussi. Il est présenté sur un fichier xml, mais il serait de travailler avec n'importe quel fichier.

Utile si vous travaillez avec des fichiers xml et que vous souhaitez supprimer une balise. Dans cet exemple, il supprime la première occurrence de la "isTag" tag.

Commande:

sed -e 0,/'<isTag>false<\/isTag>'/{s/'<isTag>false<\/isTag>'//}  -e 's/*$//' -e  '/^$/d'  source.txt > output.txt

Fichier Source (source.txt)

<xml>
    <testdata>
        <canUseUpdate>true</canUseUpdate>
        <isTag>false</isTag>
        <moduleLocations>
            <module>esa_jee6</module>
            <isTag>false</isTag>
        </moduleLocations>
        <node>
            <isTag>false</isTag>
        </node>
    </testdata>
</xml>

Fichier de résultat (output.txt)

<xml>
    <testdata>
        <canUseUpdate>true</canUseUpdate>
        <moduleLocations>
            <module>esa_jee6</module>
            <isTag>false</isTag>
        </moduleLocations>
        <node>
            <isTag>false</isTag>
        </node>
    </testdata>
</xml>

ps: ça n'a pas fonctionné pour moi sur Solaris, SunOS 5.10 (très vieux), mais il fonctionne sur Linux 2.6, sed version 4.1.5

POSIXly (également valable dans les sed), Seulement un regex utilisés, ont besoin de mémoire pour une seule ligne (comme d'habitude):

sed '/\(#include\).*/!b;//{h;s// "newfile.h"/;G};:1;n;b1'

Expliqué:

sed '
/\(#include\).*/!b          # Only one regex used. On lines not matching
                            # the text  `#include` **yet**,
                            # branch to end, cause the default print. Re-start.
//{                         # On first line matching previous regex.
    h                       # hold the line.
    s// "newfile.h"/     # append ` "newfile.h"` to the `#include` matched.
    G                       # append a newline.
  }                         # end of replacement.
:1                          # Once **one** replacement got done (the first match)
n                           # Loop continually reading a line each time
b1                          # and printing it by default.
'                           # end of sed script.