Apprendre les commandes Linux : sed. Sed - Aye Yes Linux Wiki Apprendre les commandes Linux : sed

Et je ne trouve pas de tutoriels bien écrits.

Permettez-moi de dire que j'ai travaillé avec regex dans d'autres langages (Python, JavaScript, Java), donc ceci ne devrait pasêtre un problème.

Voici donc mes questions ("théoriques" et plus pratiques) :

les expressions régulières utilisées dans sed sont-elles exactement les mêmes que celles utilisées par Python / JS / Java ? J'ai lu des articles sur les BRE et les ERE, mais en quoi sont-ils différents ? ERE ne devrait-il pas être élargissement BRE ?

si je veux, disons, simplement extraire quelque chose du tube de sortie, quelle est la syntaxe sed ?

Détails sur la deuxième question : disons que j'ai une sortie de disponibilité avec sed :

Disponibilité | sed ...

Compte tenu de l'exemple de sortie de la disponibilité : 18:13 jusqu'à 5:12, 2 utilisateurs, charges moyennes : 0,45 0,37 0,40, je veux analyser le temps d'exécution unique en deux nombres séparés (heures et minutes), puis je veux afficher comme xxhyym (xx est des heures, yy minutes).

Et pour finir, voici ce que je ferais en Python :

Hh, mm = re.match (r "\ s + up \ s + (\ d (1,2)): (\ d (1,2))"). Groups () print "% sh% sm"% (hh, mm)

2 Solutions de collecte de formulaire Web pour les « commandes régulières et sed »

Les outils unix traditionnels prennent en charge BRE ou ERE (expressions régulières basiques ou étendues). POSIX encode les deux. Wikipédia les explique. La plupart des outils modernes étendent ERE, souvent avec des fonctionnalités supplémentaires introduites pour la première fois dans Perl (connu sous le nom de PCRE).

ERE étend les fonctionnalités de BRE, mais n'étend pas la syntaxe. Dans BRE, seuls les caractères \ [. * ^ $ ont une signification particulière, et certains opérateurs tels que le groupement \ (... \) utilisent une barre oblique inverse. Dans ERE, +? | () Sont également spéciaux, et une barre oblique inverse suivie d'un caractère non alphanumérique n'est jamais spéciale.

BRE n'a pas Python / PCRE \d et \s. Vous pouvez exprimer ces jeux de caractères à l'aide de jeux de caractères et de classes de caractères traditionnels : \ d est [[: digit:]] et \ s est [[: space:]]. Notez les doubles crochets : un pour le jeu de caractères et un pour la classe de caractères ; par exemple, "lettres, tirets ou traits de soulignement" peut être écrit [-_ [: alpha:]].

BRE n'a pas d'opérateur + (certaines implémentations de sed prennent en charge \ + comme extension de la syntaxe BRE) ; X + correspond à XX *. Une barre oblique inverse supplémentaire est requise pour les groupes et les matchs.

Donc l'équivalent BRE de Python \ s + up \ s + (\ d (1,2)): (\ d (1,2)) est [[: space:]] [[: space:]] * up [ [: espace:]] [[: espace:]] * \ ([[: chiffre:]] \ (1,2 \) \): \ ([[: chiffre:]] \ (1,2 \) \ ). Notez que vous exécutez trop : \ s + et un espace signifie au moins deux caractères d'espacement.

Vous devrez faire correspondre la ligne entière, car la commande sed réécrit la ligne. Il n'y a pas de commande séparée pour écrire une chaîne assemblée à partir de groupes stockés. Correction de l'espace blanc supplémentaire, un analogue de votre extrait Python :

Disponibilité | sed "s /^.* [[: espace:]] [[: espace:]] * up [[: espace:]] [[: espace:]] * \ ([[: chiffre:]] \ (1 , 2 \) \): \ ([[: digit:]] \ (1,2 \) \). * $ / \ 1h \ 2m / "

Contrairement à l'extrait de code Python, cela récupère la première correspondance, pas la dernière, mais cela n'a pas d'importance ici.

La sortie de disponibilité contient des espaces et des chiffres ASCII, vous pouvez donc simplifier l'expression régulière :

Disponibilité | sed "s /^.* up * \ (\ (1,2 \) \): \ (\ (1,2 \) \). * $ / \ 1h \ 2m /"

Cela ne correspondra à la disponibilité du week-end que si la voiture avait moins d'un jour. Je vais laisser le nombre de jours approprié comme exercice. (Indice : écrivez deux expressions : sed -es / AS CI-DESSUS / \ 1h \ 2m / -e "s / EXERCISE / \ 1d \ 2h \ 3m /")

Chaque outil utilise (principalement) sa propre bibliothèque RE. Même parmi les différentes versions de sed, vous trouverez des différences ici. Deux normes populaires sont standard régulières expressions POSIX, dont beaucoup les acceptent (avec au moins quelques options), un autre ensemble populaire est la bibliothèque Perl Compatible Regular Expression (PCRE). Mais ces dernières sont légèrement différentes des RE "vanille"...

Dans ton cas:

Disponibilité | sed -e "s / ^ \ (\): \ (\). * $ / \ 1h \ 2m /"

(Essayé sur Fedora 18, sed-4.2.1-10.fc18.x86_64, GNU sed).

Mettre à jour: quel est le problème avec beaucoup de documentation sur page d'accueil GNU sed ? Ou ce tuto ? Le livre blanc pour GNU sed est un peu long, mais complet.

L'éditeur de flux sed est un éditeur de texte non interactif qui effectue des opérations sur les données d'une entrée standard ou d'un fichier. Sed édite les informations ligne par ligne.

In a couvert les bases du travail avec l'éditeur sed. Ce guide couvre des techniques plus avancées.

Regrouper des équipes

Parfois, il devient nécessaire de passer plusieurs commandes à l'éditeur sed en même temps. Cela se fait de plusieurs manières.

Si vous n'avez pas encore de fichier de test sed, créez l'environnement suivant :

CD
cp / usr / share / licences communes / BSD.
cp / usr / share / common-licenses / GPL-3.
echo "c'est la chanson qui ne finit jamais

ne pas savoir ce que c'était

juste parce que ... "> ennuyeux.txt

Étant donné que sed fonctionne avec une entrée et une sortie standard, vous pouvez bien sûr simplement appeler les différentes commandes sed ensemble sur la même ligne :

sed "s / et / \ & /" annoying.txt | sed "s/personnes/chevaux/"

oui, ça continue encore et encore mon ami
des chevaux ont commencé à le chanter
ne pas savoir ce que c'était
& ils "continueront à le chanter pour toujours
juste parce que...

Cela fonctionnera, mais plusieurs appels à sed sont en surcharge, occupent plus d'espace et n'utilisent pas les capacités intégrées de sed.

Vous pouvez passer plusieurs commandes à sed en même temps en utilisant l'option -e, qui doit être insérée avant chaque commande :

sed -e "s / et / \ & /" -e "s / personnes / chevaux /" annoying.txt

Vous pouvez également concaténer des commandes dans une chaîne à l'aide du caractère point-virgule. Cette méthode fonctionne exactement de la même manière que la précédente.

sed "s / et / \ & /; s / personnes / chevaux /" annoying.txt

Veuillez noter que lors de l'utilisation de l'indicateur –e, il devient nécessaire de casser les guillemets simples, et lors de l'utilisation d'un point-virgule, toutes les commandes peuvent être répertoriées entre guillemets simples.

Ces deux méthodes d'appel de plusieurs commandes en même temps sont très pratiques, mais il y a des moments où vous devez utiliser une simple ligne de commande.

Vous devez également vous familiariser avec l'opérateur =. Cette instruction insère un numéro de ligne entre chaque ligne existante. Le résultat ressemble à ceci :

sed "=" ennuyeux.txt
1
c'est la chanson qui ne finit jamais
2
oui, ça continue encore et encore, mon ami
3
certaines personnes ont commencé à le chanter
4
ne pas savoir ce que c'était
5
et ils "continueront à le chanter pour toujours
6
juste parce que...

Essayez maintenant de modifier le texte pour voir comment le format de numérotation change.

La commande G ajoute une ligne vide entre les lignes existantes par défaut.

sed "G" ennuyeux.txt
_
c'est la chanson qui ne finit jamais
_
oui, ça continue encore et encore, mon ami
_
certaines personnes ont commencé à le chanter
_
ne pas savoir ce que c'était
_
et ils "continueront à le chanter pour toujours
_
juste parce que...

Essayez de combiner les deux. Au début, il peut sembler que la sortie de ces commandes contiendra une ligne vide entre la ligne de texte et la ligne numérotée. Cependant, la sortie ressemble à ceci :

sed "=; G" ennuyeux.txt
1
c'est la chanson qui ne finit jamais
_
2
oui, ça continue encore et encore, mon ami
_
3
certaines personnes ont commencé à le chanter
_
4
ne pas savoir ce que c'était
. . .
. . .

En effet, l'opérateur = modifie le flux de sortie (cela signifie que vous ne pouvez pas utiliser la sortie résultante pour une édition ultérieure).

Cela peut être contourné avec deux appels à sed, où le premier appel sera traité comme un simple flux de texte pour le second.

sed "=" ennuyeux.txt | sed "G"
1
_
c'est la chanson qui ne finit jamais
_
2
_
oui, ça continue encore et encore, mon ami
_
3
_
certaines personnes ont commencé à le chanter
. . .
. . .

Sachez que certaines commandes fonctionnent de la même manière, surtout si vous concaténez plusieurs commandes et que le résultat est différent de ce à quoi vous vous attendiez.

Adressage avancé

L'un des avantages des commandes adressables de sed est qu'elles peuvent utiliser des expressions régulières comme critères. Cela signifie que vous pouvez travailler avec des fichiers dont le contenu n'est pas exactement connu.

sed "1,3s /.*/ Bonjour /" annoying.txt
Bonjour
Bonjour
Bonjour
ne pas savoir ce que c'était
et ils "continueront à le chanter pour toujours
juste parce que...

Au lieu de cela, vous pouvez utiliser une expression régulière qui correspond uniquement aux chaînes contenant un modèle spécifique. Pour ce faire, vous devez placer le motif de recherche entre les deux barres obliques (/) avant la commande.

sed "/ chantant / s / it / & fort /" annoying.txt
c'est la chanson qui ne finit jamais
oui, ça continue encore et encore, mon ami
certaines personnes ont commencé à le chanter fort
ne pas savoir ce que c'était
et ils "continueront à le chanter fort pour toujours
juste parce que...

Dans cet exemple, le mot fort est placé avant le premier it dans chaque ligne qui contient le mot chant. Veuillez noter que les deuxième et quatrième lignes restent inchangées car elles ne correspondent pas au motif.

Les expressions d'adressage peuvent être compliquées. Cela rend les équipes plus flexibles.

L'exemple suivant montre comment utiliser des expressions régulières pour générer des adresses pour d'autres commandes. Cette commande trouve toutes les lignes vides et les supprime :

sed "/ ^ $ / d" GPL-3
LICENCE PUBLIQUE GÉNÉRALE GNU
Version 3, 29 juin 2007
Copyright (C) 2007 Free Software Foundation, Inc.
Tout le monde est autorisé à copier et distribuer des copies textuelles
de ce document de licence, mais sa modification n'est pas autorisée.
Préambule
La licence publique générale GNU est une licence libre, copyleft pour
. . .
. . .

Sachez que les expressions régulières peuvent être utilisées n'importe où dans la plage.

Par exemple, vous pouvez supprimer les lignes entre les lignes START et END :

sed "/ ^ START $ /, / ^ END $ / d" fichier d'entrée

Gardez à l'esprit : cette commande supprimera toutes les lignes du premier mot trouvé START au premier mot trouvé END, et si elle rencontre à nouveau le mot START, elle continuera à supprimer les données.

Pour inverser l'adressage (c'est-à-dire sélectionner des lignes qui ne correspondent pas au modèle), utilisez un point d'exclamation (!).

Par exemple, pour supprimer une ligne remplie, vous devez saisir :

sed "/ ^ $ /! d" GPL-3

L'adresse n'a pas besoin d'être une expression complexe pour être inversée. L'inversion fonctionne de la même manière avec la numérotation normale.

Utilisation d'un tampon supplémentaire

Le tampon supplémentaire (hold buffer) augmente la capacité de sed à effectuer des éditions multilignes.

Un tampon supplémentaire est une zone de stockage temporaire qui peut être modifiée par des commandes spécifiques.

Avoir ce tampon supplémentaire permet de stocker des chaînes tout en travaillant sur d'autres chaînes.

Commandes de tampon :

h : copie le tampon de traitement actuel (la dernière ligne correspondante sur laquelle vous travaillez) dans un tampon supplémentaire.
H : Ajoute le buffer de traitement courant à la fin du buffer courant traitement supplémentaire en les séparant par \ n.
g : copie le tampon supplémentaire actuel dans le tampon de traitement actuel. Le tampon de traitement précédent sera perdu.
G : ajoute le modèle actuel au tampon de traitement actuel, en les délimitant avec \ n.
x : échangez le modèle actuel et le tampon supplémentaire.

Le contenu du tampon supplémentaire ne peut pas être manipulé tant qu'il n'est pas déplacé vers le tampon de traitement.

Regardons un exemple complexe.

Essayez de concaténer les lignes adjacentes avec la commande suivante :

sed -n "1 ~ 2h; 2 ~ 2 (H; g; s / \ n / /; p)" ennuyeux.txt

Noter: En fait, sed fournit une commande N intégrée distincte pour cela ; mais pour la pratique, il est utile de considérer cet exemple.

L'option –n supprime la sortie automatique.

1 ~ 2h est une définition d'adresse qui remplace séquentiellement chaque deuxième ligne de texte, en commençant par la première (c'est-à-dire chaque ligne impaire). La commande h copie les lignes correspondantes dans un tampon supplémentaire.

Le reste de la commande est entouré d'accolades. Cela signifie que cette partie de la commande héritera de l'adresse qui vient d'être spécifiée. Sans ces crochets, seule la commande H héritera de l'adresse, et le reste des commandes sera exécuté pour chaque ligne.

Bien sûr, la commande N intégrée mentionnée précédemment est considérablement plus courte et plus simple et renvoie le même résultat :

sed -n "N; s / \ n / / p" ennuyeux.txt
c'est la chanson qui ne finit jamais oui, ça continue encore et encore, mon ami
certaines personnes ont commencé à le chanter sans savoir ce que c'était
et ils "continueront à le chanter pour toujours juste parce que ...

Scripts Sed

Les commandes peuvent être liées à des scripts. Cela vous permet d'exécuter tout un ensemble de commandes sur un seul modèle cible.

Par exemple, vous pouvez écrire un script pour créer des messages texte simples que vous devez formater au préalable.

De cette façon, vous n'avez pas à répéter les mêmes commandes pour chaque message. Fondamentalement, un script sed est une liste de commandes à appliquer à un objet donné.

Par exemple:

s / ceci / cela / g
s / neige / pluie / g
1.5s / pomme de pin / abricot / g

Ensuite, le fichier peut être appelé :

sed -f sedScriptName fileToEdit

Conclusion

Vous connaissez maintenant des techniques de sed plus avancées.

Les commandes Sed sont difficiles à comprendre au début et faciles à confondre. Par conséquent, il est recommandé de les expérimenter avant de les utiliser sur des données importantes.

Mots clés:,

Utilitaire sed est un puissant éditeur de texte en streaming avec prise en charge des expressions régulières. En utilisant sed vous pouvez remplacer des modèles de texte (et directement dans le fichier !), supprimer des lignes (éléments de tableau), afficher des lignes correspondant au masque (comme grep). Éditeur sed prend en charge plusieurs commandes et la syntaxe regex étendue (pas besoin d'échapper les caractères spéciaux).

Sed ne prend pas en charge les vérifications anticipées et rétrospectives chez les habitués ! Pour le remplacement à l'aide de la syntaxe regex étendue, utilisez :

Attention!

C'est plutôt problématique de travailler avec le caractère de saut de ligne ! La solution la plus pratique est :

N'importe quel caractère peut être utilisé comme séparateur (par exemple :,). Rencontre les parties (qui sont entre parenthèses) sont disponibles en tant que,.

Options utilitaires :

Drapeaux de ligne de commande (à préciser à la fin du masque) :

Exemples de

Filtrage des lignes

Lignes de sortie 1-5 :

Fichiers de sortie correspondant au masque :

Lignes de plus de 80 caractères :

Remplacement par motif

Imprimer les occurrences ( allumettes) via les onglets :

Remplacer les noms de fichiers ( compositeur au compositeur-dev):

Remplacer les caractères (regex) :

Remplacer l'URL dans le fichier (pièce dans les délimiteurs, et pour le remplacement dans le fichier) :

Remplacer le paramètre dans la configuration :

Supprimer les espaces de début (analogique ltrim):

Suppression de lignes

Supprimez une ligne correspondant au modèle du fichier :

Supprimer la première ligne de sortie :

Supprimer les lignes de la première à la correspondance expression régulière:

Remplacer la sous-chaîne :

Noter

Par défaut, toutes les spécifications doivent être échappées. caractères dans les expressions régulières, ce qui rend extrêmement difficile la lecture des masques. Afin d'échapper aux caractères spéciaux uniquement s'ils sont décrits dans le texte, activez le mode étendu expression régulière expressions à l'aide de l'option.

Supprimer les lignes vides :

Supprimer les derniers N = 2 caractères :

Extraire les sous-chaînes

Couper / mémoriser les derniers N = 4 caractères :

#sed, #regexp, #bash

Apprendre les commandes Linux : sed

Éditeur de flux SED

Sed est un outil de traitement de texte léger (le binaire ne pèse que 128 kilo-octets) et pratique.

Dans cet article, je vais donner quelques exemples simples utilisation sed et vous parler de ses principales caractéristiques.

Sed prend un flux d'entrée ou un fichier ligne par ligne, édite chaque ligne selon les règles définies dans le script sed, puis imprime le résultat. Sed est un langage de programmation complet de Turing.

Format de commande Sed

La commande sed a le format :

sed [-n] [-e script] [-f script fichier] [fichiers]

Drapeau -n supprime la sortie
-e- indique la liste des instructions données dans ligne de commande.
-F- indique l'emplacement du fichier de script.

Format des commandes d'édition

Le fichier de script se compose d'un ensemble de commandes :

[adresse [, adresse]] commande [arguments]

un sur chaque ligne.
Les adresses sont soit des numéros de ligne, soit des caractères spéciaux, soit une expression régulière :

$ - dernière ligne
début ~ N- Chaque N-ème ligne à partir du numéro Début
/expression régulière/- les chaînes qui correspondent à l'expression rationnelle
Exemples:

1~2 - Une ligne sur deux / REGEXP /- toutes les lignes qui contiennent / REGEXP / 10,20 - lignes 10 à 20 10,+10 - lignes 10 à 20 5, ~ N- lignes du 5ème au premier multiple N 5, / REGEXP /- lignes contenant / REGEXP /, après le 5 (sans compter le 5)

Si aucune adresse n'est spécifiée, toutes les lignes sont traitées.
Si une adresse est spécifiée, la ligne correspondante est traitée
Si deux adresses sont spécifiées, les lignes dans l'intervalle spécifié sont sélectionnées.
!commander- effectué commander, pour les lignes qui n'ont pas été sélectionnées par adresse.

Commandes de base

Considérons les commandes principales :

[adresse] un texte- ajouter une nouvelle ligne avec du texte après la ligne spécifiée

[adresse [, adresse]] c texte- Supprime les lignes sélectionnées et les remplace par texte

[adresse [, adresse]] d- Supprime les lignes spécifiées.

[adresse] j'envoie un texto- Insérer texteà la place de la ligne spécifiée.

[adresse [, adresse]] p(avec drapeau -n) affiche les lignes trouvées.

[adresse] q- sortie sed.

[adresse [, adresse]] r fichier- Est en train de lire déposer et délivre son contenu à la sortie.

[adresse [, adresse]] s / regex / replace / flags- Remplace expression régulière au remplacement-y en tenant compte des drapeaux :

g - dans toute la ligne
i - insensible à la casse
p - afficher le résultat du remplacement

[adresse [, adresse]] y / ligne1 / ligne2 /- Remplace toutes les occurrences de caractères dans ligne 1 caractères correspondants de chaînes2.

Les longueurs des lignes doivent être les mêmes.

[adresse [, adresse]] (commandes)- commandes de groupe de parenthèses
[adresse] =- Donne les numéros de ligne

Mots clés

: étiqueter- faire correspondre un groupe d'équipes étiqueter
étiquette b étiqueter, si étiqueter manquant, puis passez à la fin du fichier batch.

t étiquette- sauter à la commande indiquée par l'étiquette étiqueter seulement après un remplacement réussi à l'aide de la commande s ///

Cycle d'exécution

sed fonctionne sur deux tampons de données : principal et auxiliaire. Initialement, les deux tampons sont vides.
Le travail avec ces tampons s'effectue à l'aide des commandes : \\ `h', 'H', 'x', 'g', 'G' D ' h- Remplacer le contenu du buffer auxiliaire par le contenu du buffer principal
H- Ajouter une nouvelle ligne au tampon auxiliaire puis ajouter le contenu du tampon principal au contenu de l'auxiliaire
X- Échangez le contenu des deux tampons à certains endroits
g- Remplacer le contenu du buffer principal par le contenu de l'auxiliaire
g- Ajouter une nouvelle ligne au tampon principal puis ajouter le contenu du tampon auxiliaire au contenu du principal
ré- Supprimer le texte du tampon principal jusqu'au prochain caractère de saut de ligne
N- Ajouter une nouvelle ligne au tampon principal, puis y ajouter la prochaine ligne traitée
P- Affiche le contenu du tampon principal jusqu'au prochain caractère de saut de ligne.

Exemples plus complexes

Le script suivant permute les lignes du fichier (les premières lignes deviennent les dernières et vice versa)

On lit les lignes du fichier (afficher le numéro de la dernière ligne)

résultat

Inverser les cordes

Ce script déplace deux lettres à la fois.

Information additionnelle

Vous pouvez en savoir plus sur le format des scripts sed en lisant le manuel. homme sed ou documentation technique infos.

Retour à la table des matières

02.02.2013

Extensions de chaîne Bash dans les exemples (extensions de paramètres)

(Matériaux utilisés [1] [2] et [3])

Bash utilise des options de décomposition ( extensions de paramètres) Une description de ce principe peut être trouvée dans la clause.
La description est difficile à comprendre. Il est beaucoup plus facile de comprendre comment cela fonctionne avec des exemples.

1. Supprimer des caractères au début ou à la fin d'une ligne

Tout caractère unique est désigné par

Définissons la variable

$ STRING = aabbcc $ echo $ (STRING) aabbcc Pour supprimer des caractères en début de ligne, utilisez les commandes suivantes : $ echo $ (STRING #?) Abbcc $ echo $ (STRING # ???) bcc pour supprimer des caractères à la fin d'une ligne : $ echo $ (STRING%?) Aabbc $ echo $ (STRING% ???) aab Pour se rappeler quand utiliser le signe, et quand utiliser cette manière originale :
Les symboles sont situés sur le clavier de manière séquentielle et :
- à gauche de, signifie à partir du début de la ligne
- à droite de, signifie jusqu'à la fin de la ligne

2. Supprimer les expressions régulières au début ou à la fin d'une ligne

Les expressions régulières (expressions régulières ou RegExp, regex) sont une chaîne de modèle ou un "masque" qui définit une règle de recherche.

Redéfinissons la variable

$ STRING = GNULinux $ echo $ (STRING) GNULinux supprime la regex en début de ligne : $ echo $ (STRING # GNU) Linux supprime la regex en fin de ligne : $ echo $ (STRING% Linux) GNU Now la même chose, mais en utilisant " * " (Astérisque)
supprimer regex au début d'une ligne (): $ echo $ (STRING # * U) Linux supprimer regex à la fin d'une ligne (): $ echo $ (STRING% L *) GNU

Usage expressions régulières peut être combiné avec "?" (par n'importe quel symbole) ():

$ echo $ (STRING% ?? n *) GNU

3. Utilisation des doubles ## et %%

Si lors de la suppression d'une chaîne expressions régulières(* regex ou regex *), lors de l'utilisation de "#" et "%" avec "*" - la suppression va jusqu'à la première occurrence expression régulière, puis lors de l'utilisation du double "##" et "%%" - jusqu'au dernier :

Et encore une fois, définissons la variable

$ STRING = abcdcba $ echo $ (STRING) abcdcba STRING = abcdcba $ (STRING # * c) dcba$ (chaîne ## * c) ba$ (STRING% c *) a B c d$ (STRING %% c *) un B$ echo $ (STRING # * c) dcba $ echo $ (STRING ## * c) ba $ echo $ (STRING% c *) abcd $ echo $ (STRING %% c *) ab

4.
Aide-mémoire Sed

Trouver et remplacer

Remplacement de la première occurrence

Remplacement global

$ STRING = "abracadabra" $ echo "$ (STRING / a / O)" Obracadabra $ echo "$ (STRING // a / O)" ObrOcOdObrO $ echo "$ (STRING / # a / O)" Obracadabra $ echo " $ (STRING /% a / O) "abracadabrO $ echo" $ (STRING / a /) "bracadabra $ echo" $ (STRING // a /) "brcdbr

5. Extraire la sous-chaîne à l'aide de l'offset et de la longueur

Décalage du bord de la ligne

Longueur de la sous-chaîne

5.1 Offset pour les valeurs positives

Pour les valeurs de décalage positives, le premier caractère de la chaîne correspond à la valeur "".

Exemples avec des valeurs positives : $ STRING = "Debian Gentoo RedHat" $ echo $ (STRING : 0 : 6) Debian $ echo $ (STRING : 14) RedHat $ echo $ (STRING : 7 : 6) Gentoo
5.2 Offset pour les valeurs négatives

Pour les valeurs négatives, le comptage commence à partir de la fin de la ligne, et le dernier caractère de la ligne correspond à une valeur égale à "".

Pour écrire un décalage négatif entre les deux points et le signe moins, laissez un espace ou mettez une valeur négative entre parenthèses.

Si elle n'est pas spécifiée, la longueur de la sous-chaîne est automatiquement étendue jusqu'à la fin.

Exemples avec des valeurs négatives : $ STRING = "Debian Gentoo RedHat" $ echo $ (STRING : -6) RedHat $ echo $ (STRING : (- 6)) RedHat $ echo $ (STRING : (- 6) : 3) Red $ echo $ (STRING: (- 6): 10) # la longueur dépasse le décalage RedHat
5.3 Valeurs négatives.

S'il est négatif, il fonctionne comme un décalage par rapport à la fin de la ligne. Le résultat sera une sous-chaîne entre le premier et le deuxième décalage :

$ STRING = "Debian Gentoo RedHat" $ echo $ (STRING : 7 : -7) Gentoo $ echo $ (STRING : (- 14): - 7) Gentoo

Comment mettre tout cela en pratique :

Vous trouverez ci-dessous diverses options de code permettant de modifier l'extension de à lors du transcodage par lots de fichiers audio : for i in * .wav ; faire boiteux "$ i" "$ (i% ???) mp3" ; terminé; pour i dans * .wav; faire boiteux "$ i" "$ (i% wav) mp3" ; terminé; pour i dans * .wav; faire boiteux "$ i" "$ (i%. ). mp3"; terminé; pour i dans .wav; faire boiteux "$ i" "$ (i / wav / mp3)" ; terminé; pour i dans * .wav; faire boiteux "$ i" "$ (i: 0: -3) mp3"; terminé;

6. Compter le nombre de caractères dans une ligne

$ STRING = "Compter le nombre de caractères dans une chaîne" $ echo $ (# STRING) 36
Connaître le nombre de caractères du fichier : $ ARRAY = (`cat file.html`) $ echo $ (# ARRAY [@]) 1158

Il convient de noter ici que le fichier est lu non seulement dans une variable, mais dans un tableau, puisqu'il se compose de plusieurs lignes. Par conséquent, pour un calcul correct, il est nécessaire de parier. Si cela n'est pas fait, la commande ne lira que la première ligne du fichier :

$ ARRAY = (`cat file.html`) $ echo $ (# ARRAY) 7 En effet, la première ligne ne contient que la balise et le caractère de saut de ligne de Windows () - soit 7 caractères.

7. Changer la casse des caractères

Convertit le premier caractère en majuscule

Convertit tous les caractères en majuscules

Convertit le premier caractère en minuscule

Convertit tous les caractères en minuscules

Inverse la casse du premier caractère

Inverse la casse de tous les caractères

Tags : Linux, bash, shell, expressions régulières, extensions de paramètres, RegExp, regex, length, offset, for, in, do. lame, terminé, * .wav, mp3, CR + LF, regex, motif, recherche, variable, tableau, chaîne, caractères, majuscule, minuscule, casse

introduction

La commande sed est un éditeur de flux pour l'édition automatique de texte. Un "éditeur de flux" dans le sens où il peut éditer le flux de données entrant en continu, par exemple, dans le cadre d'un tube. Automatique - cela signifie que dès que vous définissez les règles d'édition, la suite se passe sans votre participation fastidieuse. En d'autres termes, sed n'est pas interactif.

Le programme sed est plus complexe que les commandes que nous avons couvertes dans les articles précédents de la série HuMan. Il dispose d'un arsenal de ses propres commandes, donc pour éviter tautologie et confusion, dans cet article la commande sed sera dorénavant appelée le « programme » ou « éditeur », et les commandes de l'éditeur sed sont simplement des commandes.

Le programme sed est capable de tâches complexes, et il faut du temps pour apprendre à formuler ces tâches.

Mais en plus des opérations complexes, sed possède des fonctionnalités simples mais très utiles qui ne sont pas plus difficiles à maîtriser que les autres commandes Unix. En raison de la complexité de maîtriser l'ensemble du programme, ne vous permettez pas d'abandonner ses aspects simples.

Nous allons commencer de facile à difficile afin que vous puissiez toujours savoir où vous arrêter.

Commande S - substitution

Le programme sed possède de nombreuses commandes qui lui sont propres. La plupart des utilisateurs ne connaissent que la commande s, et c'est suffisant pour démarrer avec sed. La commande s remplace SAMPLE par REPLACEMENT :

sed s / ÉCHANTILLON / REMPLACER /

$ écho jour | sed s / jour / nuit / (Entrée) nuit

Cela ne pourrait pas être plus facile. Et voici un exemple avec une entrée du fichier zar.txt :

Le matin, il faisait des exercices. La foudre est une charge électrique. $ sed s / charge / décharge / zar.txt Le matin, il a fait une décharge. La foudre est une décharge électrique.

Je n'ai pas cité l'expression s / SAMPLE / REPLACE / entre guillemets, car exemple donné n'a pas besoin de guillemets, mais si des métacaractères étaient présents, des guillemets seraient requis. Afin de ne pas se casser la tête à chaque fois, et de ne pas se tromper par inadvertance, mettez toujours des guillemets, mieux vaut célibataire "fort", c'est une bonne habitude. Vous ne pouvez pas gâcher la bouillie avec du beurre. Moi aussi, dans tous les exemples suivants, je ne lésinerai pas sur les citations.

Comme nous pouvons le voir, la commande s replacement a quatre composants :

La commande S elle-même /.../.../ delimiter PATTERN modèle pour rechercher puis remplacer l'expression REPLACEMENT qui remplacera PATTERN si elle est trouvée.

La barre oblique (/) est traditionnellement utilisée comme délimiteur, puisque l'ancêtre de sed, ed, les utilise (comme le fait vi). Dans certains cas, un tel séparateur est très gênant, par exemple, lorsque vous devez modifier les chemins vers des répertoires qui contiennent également une barre oblique (/usr/local/bin). Dans ce cas, vous devez séparer les barres obliques par les barres obliques inverses :

Sed " s / \ / usr \ / local \ / bin / \ / common \ / bin / "

C'est ce qu'on appelle la "palissade" et a l'air très moche, et surtout, incompréhensible.

Ce qui est unique avec sed, c'est qu'il permet d'utiliser n'importe quel délimiteur, tel que le trait de soulignement :

$ écho jour | sed s_day_night_ night

ou deux points :

$ écho jour | sed s : jour : nuit : nuit

Si, en cherchant un délimiteur que vous aimez, vous obtenez le message "commande incomplète"", alors ce caractère n'est pas un bon délimiteur, ou vous avez simplement oublié de mettre un ou deux délimiteurs.

Dans cet article, je suis obligé d'utiliser le séparateur traditionnel (/) pour ne pas embrouiller le lecteur, mais si nécessaire, j'utiliserai le tilde (~) comme séparateur.

Expressions régulières (RV)

(Expressions régulières, regexp, RE)

Le sujet des expressions régulières est si vaste que des livres entiers lui ont été consacrés (voir liens en fin d'article). Cependant, parler sérieusement de sed sans utiliser d'expressions régulières est tout aussi contre-productif que de parler de trigonométrie avec des bâtons de comptage. Par conséquent, il est nécessaire de parler au moins des expressions régulières qui sont souvent utilisées avec le programme sed.

avec Ou toute autre lettre. La plupart des lettres, chiffres et autres caractères non spéciaux sont considérés comme des expressions régulières.

* Un astérisque suivant un caractère ou une expression régulière signifie tout nombre (y compris zéro) de répétitions de ce caractère ou de cette expression régulière.

\+ Indique une ou plusieurs répétitions d'un caractère ou d'une expression régulière.

\? Signifie aucune ou une répétition.

\ (je \) Signifie exactement i répétitions.

\ (i, j \) Le nombre de répétitions est compris entre i et j inclus.

\ (je, \) Le nombre de répétitions est supérieur ou égal à i.

\ (, j \) Le nombre de répétitions est inférieur ou égal à j.

\ (RE \) Souvenez-vous de l'expression régulière ou d'une partie de celle-ci pour une utilisation future dans son ensemble. Par exemple, \ (a-z \) * recherchera n'importe quelle combinaison de n'importe quel nombre (y compris zéro) lettres minuscules.

. Désigne n'importe quel caractère, y compris un caractère de nouvelle ligne.

^ Indique une expression nulle au début d'une ligne. En d'autres termes, ce que ce caractère précède doit apparaître en début de ligne. Par exemple, ^ # include recherchera les lignes commençant par #include.

$ Le même que le précédent, ne s'applique qu'à la fin de la ligne.

[LISTE] Désigne n'importe quel caractère de la LISTE. Par exemple, recherchera n'importe quelle voyelle anglaise.

[^ LISTE] Désigne tout caractère autre que ceux de la liste. Par exemple, [^ aeiou] correspondra à n'importe quelle consonne. Remarque : LIST peut être un intervalle, par exemple [a-z], ce qui signifie n'importe quelle lettre minuscule. S'il est nécessaire de l'inclure dans la LISTE] (crochet), indiquez-le d'abord dans la liste ; si vous devez inclure dans la LISTE - (trait d'union), indiquez-le en premier ou en dernier dans la liste.

RE1 \ | RE2 Signifie PB1 ou PB2.

RE1RE2 Désigne l'union des expressions régulières PB1 et PB2.

\ n Indique un caractère de nouvelle ligne.

\$; \*; \.; \[; \\; \^ Moyenne, respectivement : $; *; .; [; \; ^

Attention: Les autres conventions C basées sur la barre oblique inverse (\) ne sont pas prises en charge par sed.

\1 \2 \3 \4 \5 \6 \7 \8 \9 Indique la partie correspondante de l'expression régulière, mémorisée à l'aide des caractères \ (et \).

Quelques exemples :

a B c d e F signifie abcdef

un B Signifie zéro ou un nombre quelconque de lettres a et une lettre b. Par exemple, aaaaab ; un B; ou b.

un B Signifie b ou ab

a \ + b \ + Signifie un ou plus de lettres a et une ou plusieurs lettres b. Par exemple : ab ; aaaab; abbbbb; ou aaaaaabbbbbbb.

.* Signifie tous les caractères sur une ligne, sur toutes les lignes, y compris les lignes vides.

.\+ Désigne tous les caractères d'une chaîne, mais uniquement les chaînes contenant au moins un caractère. Les lignes vides ne correspondent pas à l'expression régulière donnée.

^ principal. * (. *) Il recherchera les lignes commençant par le mot main, ainsi que celles contenant des crochets ouvrants et fermants, et un nombre quelconque de caractères (ou non) peut être trouvé avant et après la parenthèse ouvrante.

^# Cherchera les lignes commençant par un caractère # (par exemple des commentaires).

\\$ Recherche les lignes se terminant par une barre oblique inverse (\).

Des lettres ou des chiffres

[^ ]\+ (V crochet(outre le caractère ^, il y a aussi un espace et une tabulation) --Cela signifie un ou n'importe quel nombre de caractères autres qu'un espace et une tabulation. Habituellement, le mot est signifié.

^. * A. * $ Moyens lettre capitale Et exactement au milieu de la ligne.

A. \ (9 \) $ Indique une lettre majuscule A, exactement le dixième de la fin de la ligne.

^. \ (, 15 \) A Indique la lettre majuscule A, exactement le seizième à partir du début de la ligne.

Maintenant que nous connaissons quelques expressions régulières, revenons à la commande s de sed.

Utilisation du symbole & lorsque l'ÉCHANTILLON est inconnu « Comment est-ce inconnu ? » Vous demandez - « Vous ne savez pas ce que vous voulez remplacer ? » La réponse est : je veux mettre entre parenthèses tous les nombres trouvés dans le texte. Comment faire? La réponse est d'utiliser le symbole &.

Le symbole & (esperluette), lorsqu'il est placé dans une SUBSTITUTION, signifie tout ÉCHANTILLON trouvé dans le texte. Par exemple:

$ écho 1234 | sed "s / * / (&) /" (1234)

Un astérisque (astérisque) après l'intervalle est nécessaire pour remplacer tous les nombres trouvés dans l'échantillon. Sans cela, cela aurait donné :

$ écho 1234 | sed "s // (&) /" (1) 234

C'est-à-dire que le tout premier chiffre trouvé a été pris comme échantillon.

Voici un exemple avec une charge très significative : créons un fichier formula.txt :

A + 432-10 = n

et lui appliquer la commande :

$ sed "s / * - * / (&) /" formula.txt a + (432-10) = n

La formule mathématique a acquis un sens sans ambiguïté.

Un autre caractère esperluette peut être utilisé pour doubler l'ÉCHANTILLON :

$ echo 123 | sed "s / * / & & /" 123 123

Il y a ici une subtilité. Si on complique un peu l'exemple :

$ echo "123 abc" | sed "s / * / & & /" 123 123 abc

comme on peut s'y attendre, seuls les chiffres sont doublés car il n'y a pas de lettres dans l'ÉCHANTILLON. Mais si nous échangeons des parties du texte par endroits :

$ echo "abc 123" | sed "s / * / & & /" abc 123

alors aucun doublement des nombres ne fonctionnera. C'est une caractéristique de l'expression régulière * - elle ne correspond qu'au premier caractère de la chaîne. Si nous voulons doubler les chiffres où qu'ils soient, nous devons modifier l'expression régulière dans REPLACE :

$ echo "abc defg 123" | sed "s / * / & & /" abc defg 123 123

alors les nombres seront doublés, quel que soit le nombre de "mots" précédents.

Utilisation des caractères conditionnels \ (, \) et \ 1 pour traiter une partie d'un MOTIF Les caractères \ (et \) (parenthèses échappées) sont utilisés pour mémoriser une partie d'une expression régulière.

Le caractère conventionnel \ 1 signifie la première partie mémorisée, \ 2 - la seconde, et ainsi de suite, jusqu'à neuf parties mémorisées (le programme ne prend plus en charge). Regardons un exemple :

$ echo abcd123 | sed "s / \ (* \). * / \ 1 /" abcd

Ici \ (* \) signifie que le programme doit se souvenir de tous les caractères alphabétiques dans n'importe quelle quantité ; .* signifie n'importe quel nombre de caractères après la première partie mémorisée; a \ 1 signifie que nous voulons voir uniquement la première partie mémorisée. En effet, dans la sortie du programme on ne voit que des lettres et pas de chiffres.

Afin d'échanger des mots, vous devez mémoriser deux sous-ÉCHANTILLONS, puis les échanger :

$ echo pingouin stupide | sed "s / \ ([a-z] * \) \ ([a-z] * \) / \ 2 \ 1 /" pingouin stupide

Ici, \ 2 signifie le deuxième sous-MOTIF et \ 1 signifie le premier. Notez l'espacement entre la première expression \ ([a-z] * \) et la deuxième expression \ ([a-z] * \). Il faut trouver deux mots.

Le caractère \ 1 ne doit pas être uniquement en REMPLACEMENT, il peut également être présent dans l'ÉCHANTILLON, par exemple, lorsque l'on veut supprimer des mots en double :

$ echo pingouin pingouin | sed "s / \ ([a-z] * \) \ 1 / \ 1 /" pingouin

Modificateurs de remplacement de commande S

Les modificateurs de remplacement sont placés après le dernier délimiteur. Ces modificateurs déterminent les actions du programme si plus d'une correspondance avec SAMPLE est trouvée dans la chaîne, et comment effectuer le remplacement.

Modificateur / g

Remplacement global

Sed, comme la plupart des utilitaires Unix, lit une ligne à la fois lorsqu'il travaille avec des fichiers. Si nous ordonnons de remplacer un mot, le programme ne remplacera que le premier mot MATCH sur la ligne donnée. Si nous voulons changer chaque mot qui correspond au modèle, alors nous devons entrer le modificateur / g.

Sans le modificateur /g :

$ echo ce chat était un chat ordinaire | sed "s / cat / chaton /" ce chaton était le chat le plus ordinaire

L'éditeur n'a remplacé que le premier mot qui correspondait.

Et maintenant avec le modificateur de remplacement global :

$ echo ce chat était un chat ordinaire | sed "s / cat / chaton / g" ce chaton était le chaton le plus ordinaire

Toutes les correspondances de cette ligne ont été remplacées.

Et si vous avez besoin de changer tous les mots, disons, mettez-les entre parenthèses ? Ensuite, les expressions régulières viennent à nouveau à la rescousse. Pour sélectionner tous les caractères alphabétiques, à la fois majuscules et minuscules, vous pouvez utiliser la construction [A-Ya-z], mais elle n'inclura pas de mots tels que "quelque chose" ou "avec" lecteur ". La construction [ ^ ] *, qui correspond à tous les caractères à l'exception d'un espace. Donc :

$ echo pingouin stupide cache timidement | sed "s / [^] * / (&) / g" (stupide) (pingouin) (timidement) (se cache)

Comment choisir la bonne correspondance parmi plusieurs

Si aucun modificateur n'est utilisé, sed ne remplacera que le premier mot qui correspond au PATTERN. Si vous appliquez le modificateur / g, le programme remplacera chaque mot correspondant. Et comment sélectionner l'un des matchs s'il y en a plusieurs en ligne ? - À l'aide des symboles conventionnels \ (et \) que nous connaissons déjà, souvenez-vous des sous-ÉCHANTILLONS et sélectionnez celui dont vous avez besoin à l'aide des caractères \ 1 - \ 9.

$ echo pingouin stupide | sed "s / \ ([a-z] * \) \ ([a-z] * \) / \ 2 /" pingouin

Dans cet exemple, nous avons mémorisé les deux mots, et en mettant le deuxième (pingouin) à la première place, le premier (stupide) a été supprimé en mettant un espace dans la section REMPLACEMENT. Si nous mettons n'importe quel mot au lieu d'un espace, alors il remplacera le premier (stupide):

$ echo pingouin stupide | sed "s / \ ([a-z] * \) \ ([a-z] * \) / \ 2 intelligent /" pingouin intelligent

Modificateur numérique

Il s'agit d'un nombre à un / deux / trois chiffres qui est placé après le dernier séparateur et indique quelle correspondance doit être remplacée.

$ echo pingouin très stupide | sed "s / [a-z] * / bon / 2" très bon pingouin

Dans cet exemple, chaque mot correspond, et nous avons indiqué à l'éditeur quel mot nous voulons remplacer en plaçant le modificateur 2 après la section REPLACEMENT.

Vous pouvez combiner le modificateur numérique avec le modificateur / g. Si vous souhaitez laisser le premier mot inchangé et remplacer le deuxième et les suivants par le mot "(supprimé)", la commande ressemblera à ceci :

$ echo pingouin très stupide | sed "s / [a-z] * / (supprimé) / 2g" very (supprimé) (supprimé)

Si vous devez vraiment supprimer toutes les correspondances suivantes, à l'exception de la première, placez un espace dans la section REMPLACEMENT :

$ echo pingouin très stupide | sed "s / [a-z] * / / 2g" est très

Ou ne rien mettre du tout :

$ echo pingouin très stupide | sed "s / [^] * // 2g" est très

Le modificateur numérique peut être n'importe quel entier compris entre 1 et 512. Par exemple, si vous devez mettre un deux-points après 80 caractères de chaque ligne, la commande vous aidera :

$ sed "s /./&:/ 80" nom de fichier

Modificateur / p - imprimer vers la sortie standard (impression)

Sed imprime déjà la sortie sur une sortie standard (telle qu'un écran de moniteur) par défaut. Ce modificateur est utilisé uniquement avec l'option sed -n, qui bloque simplement la sortie du résultat à l'écran.

/ W modificateur

Permet d'écrire les résultats du traitement de texte dans le fichier spécifié :

$ sed "s / SAMPLE / REPLACE / w nom de fichier

/ Modificateur E (extension GNU)

Vous permet de spécifier une commande shell (pas un programme sed) en tant que REPLACE. Si une correspondance avec le PATTERN est trouvée, elle sera remplacée par la sortie de la commande spécifiée dans la section REPLACEMENT. Exemple:

$ écho nuit | sed "s / nuit / echo jour / e" jour

Modificateurs / I et / i (Extension GNU)

Rendez le processus de remplacement insensible à la casse.

$ echo Nuit | sed "s / nuit / jour / i" jour

Combinaisons de modificateurs

Les modificateurs peuvent être combinés lorsque cela a du sens. Dans ce cas, vous devez mettre le modificateur w en dernier.

Conventions (Extension GNU) Il n'y en a que cinq :

\ L convertit les caractères REPLACE en minuscules \ l convertit le caractère REPLACE suivant en minuscule \ U convertit les caractères REPLACE en majuscules \ vous convertit le caractère REPLACE suivant en majuscule \ E annule une traduction commencée par \ L ou \ U Pour des raisons évidentes, ces conventions sont utilisées seules. Par exemple:

$ echo pingouin stupide | sed "s / stupide / \ u & /" Pingouin stupide

$ echo petit chiot | sed "s / [a-z] * / \ u & / 2" petit Chiot

Nous avons couvert presque tous les aspects de la commande de sed. Il est maintenant temps d'examiner les options de ce programme.

Options de sédation

Le programme a étonnamment peu d'options. (Ce qui compense quelque peu l'excès de commandes, modificateurs et autres fonctions). En plus des options bien connues --help (-h) et --version (-V), que nous ne considérerons pas, il n'y en a que trois :

L'option -e--expression = jeu de commandes

Une façon d'exécuter plusieurs commandes consiste à utiliser l'option -e. Par exemple:

Sed -e "s / a / A /" -e "s / b / B /" nom de fichier

Tous les exemples précédents de cet article ne nécessitaient pas l'option -e simplement parce qu'ils contenaient une seule commande. On aurait pu mettre l'option -e dans les exemples, ça n'aurait rien changé.

L'option -f Si vous devez exécuter un grand nombre de commandes, il est plus pratique de les écrire dans un fichier et d'utiliser l'option -f :

Sed -f sedscript nom de fichier

Sedscript est ici le nom du fichier contenant les commandes. Ce fichier est appelé le script sed (ci-après simplement le script). Chaque commande de script doit figurer sur une ligne distincte. Par exemple:

#commentaire - Ce script changera toutes les voyelles minuscules en majuscules s / a / A / g s / e / E / g s / i / I / g s / o / O / g s / u / U / g

Vous pouvez nommer le script comme bon vous semble, il est important de ne pas confondre le fichier de script avec le fichier en cours de traitement.

Option -n Le programme sed -n n'imprime rien sur la sortie standard. Vous avez besoin d'une instruction spéciale pour obtenir la sortie. Nous avons déjà vu le modificateur /p, qui peut être utilisé pour spécifier cela. Rappelons le fichier zar.txt :

$ sed "s / 1-9 / & / p" zar.txt Il a fait des exercices le matin. La foudre est une charge électrique.

Comme aucune correspondance n'a été trouvée avec le MOTIF (il n'y a pas de nombres dans le fichier), la commande s avec le modificateur / p et le signe & comme REMPLACER (rappelez-vous que l'esperluette signifie le MOTIF lui-même) fonctionne comme la commande cat.

Si le PATTERN est trouvé dans le fichier, les lignes contenant le PATTERN seront doublées :

$ sed "s / exercice / & / p" zar.txt Il a fait des exercices le matin. Le matin, il faisait des exercices. La foudre est une charge électrique.

Ajoutons maintenant l'option -n :

$ sed -n "s / charge / & / p" zar.txt Il a fait des exercices le matin.

Maintenant, notre programme fonctionne comme une commande grep - il ne renvoie que les lignes contenant un PATTERN.

Sélection des éléments souhaités du texte modifiable

Avec une seule commande, nous avons vu la puissance extraordinaire de sed. Mais tout ce qu'il fait revient à trouver et à remplacer. Et dans le processus, sed édite chaque ligne une par une, sans prêter attention aux autres. Il serait pratique de limiter la plage de lignes à modifier, par exemple :

Sélectionnez les lignes par numéros
Sélectionnez des lignes dans une certaine plage de nombres
Sélectionnez uniquement les lignes contenant une expression
Sélectionnez uniquement les lignes entre certaines expressions
Sélectionnez uniquement les lignes du début du fichier à une expression
Sélectionnez uniquement les lignes d'une expression à la fin du fichier

Le programme sed peut faire tout cela et plus encore. Toute commande de l'éditeur sed peut être utilisée en adressage, dans une certaine plage d'adresses, ou avec les restrictions ci-dessus sur le cercle de lignes. L'adresse ou la restriction doit précéder immédiatement la commande :

Sed "commande adresse/restriction"

Sélection de lignes par numéros

C'est le cas le plus simple. On précise juste le numéro de la ligne requise avant la commande :

$ sed "4 s / [a-z] * // i" gumilev.txt Quelle étrange félicité Au petit crépuscule du matin, Dans la fonte des neiges de printemps, à tout ce qui meurt et sagement.

$ sed "3 s / B / (B) /" gumilev.txt Quelle étrange félicité Au petit crépuscule du matin, (B) la neige de printemps fond, Dans tout ce qui périt et est sage.

Sélection de lignes dans une plage de nombres

La plage est indiquée, sans surprise, séparée par des virgules :

$ sed "2,3 s / B / (B) /" gumilev.txt Quelle étrange félicité (B) au petit crépuscule du matin, (B) la fonte des neiges de printemps, Dans tout ce qui périt et est sage.

Si vous devez spécifier une plage jusqu'à la dernière ligne du fichier et que vous ne savez pas combien de lignes il y a, utilisez le signe $ :

$ sed "2, $ s / in / (in) / i" gumilev.txt Quel étrange bonheur (dans) le crépuscule matinal, (dans) la fonte des neiges de printemps, (dans) à propos de tout ce qui périt et judicieusement.

Sélection de lignes contenant une expression

L'expression requise est entourée de barres obliques (/) et est placée avant la commande :

$ sed "/ am / s / in / (in) / i" gumilev.txt Quelle étrange félicité (dans) le crépuscule matinal, Dans la fonte des neiges de printemps, Dans tout ce qui périt et est sage.

Sélection de lignes entre deux expressions

Comme pour les numéros de ligne, la plage est séparée par des virgules :

$ sed "/ am /, / wisely / s / in / (in) / i" gumilev.txt Quel étrange bonheur (dans) le crépuscule matinal, (dans) la fonte des neiges de printemps, (dans) environ tout ce qui périt et sagement...

Sélection des lignes du début du fichier à une expression

$ sed "1, / snow / s / in / (in) / i" gumilev.txt Quelle étrange félicité (dans) le crépuscule matinal, (dans) la fonte des neiges de printemps, Dans tout ce qui périt et est sage.

Sélection de lignes d'une expression à la fin du fichier

$ sed "/ snow /, $ s / in / (in) / i" gumilev.txt Quel étrange bonheur Au petit matin, (dans) la fonte des neiges de printemps, (dans) à propos de tout ce qui périt et est sage.

Autres commandes sed

Commande D (supprimer)

Supprime les lignes spécifiées de la sortie standard :

$ sed "2 d" gumilev.txt Quel étrange bonheur Dans la fonte des neiges de printemps, Dans tout ce qui périt et est sage.

Et le plus souvent, ils écrivent plus facilement (sans espace) :

Sed "2d" gumilev.txt

Tout ce qui a été dit dans la section précédente sur les lignes d'adressage est également vrai pour la commande d (comme avec presque toutes les commandes sed).

L'utilisation de la commande d est pratique pour supprimer l'en-tête inutile d'un message électronique :

$ sed "1, / ^ $ / d" nom de fichier

(Supprimez les lignes de la première à la première ligne vierge).

Débarrassez-vous des commentaires dans le fichier de configuration :

$ sed "/ ^ # / d" /boot/grub/menu.lst

Et vous ne savez jamais où vous devez supprimer des lignes supplémentaires !

Commande P (imprimer)

Le mot anglais « print » se traduit par « to print », qui en russe est associé à une imprimante, ou au moins à un clavier. En fait, le mot dans le contexte anglais signifie souvent simplement afficher sur l'écran du moniteur. Ainsi, la commande p n'affiche rien, elle imprime simplement les lignes spécifiées à l'écran.

Lorsqu'elle est appliquée seule, la commande p double les lignes dans la sortie (après tout, sed imprime la ligne à l'écran par défaut et la commande p imprime la même ligne une deuxième fois).

$ echo J'ai un chat | sed "p" j'ai un chat j'ai un chat

Il y a des utilisations pour cette propriété, par exemple, pour doubler les lignes vides pour améliorer l'apparence du texte :

$ sed "/ ^ $ / p nom de fichier

Mais la commande p révèle sa véritable identité en combinaison avec l'option -n, qui, comme vous vous en souvenez, interdit l'affichage des lignes à l'écran. En combinant l'option -n avec la commande p, vous ne pouvez obtenir que les lignes souhaitées dans la sortie.

Par exemple, affichez les lignes 1 à 10 :

$ sed -n "1,10 p" nom de fichier

Ou juste des commentaires :

$ sed -n "/ ^ # / p" /boot/grub/menu.lst # Fichier de configuration GRUB "/boot/grub/menu.lst". # généré par "grubconfig". Dim 23 mars 2008 21:45:41 # # Démarrer la section globale GRUB # Finir la section globale GRUB # La configuration de la partition amorçable Linux commence # La configuration de la partition amorçable Linux se termine # La configuration de la partition amorçable Linux commence # La configuration de la partition amorçable Linux se termine

Ceci est très similaire au programme grep que nous avons vu lorsque nous avons parlé de l'option -n avec le modificateur / p. Mais, contrairement à la commande grep, l'éditeur sed permet non seulement de retrouver ces lignes, mais aussi de les modifier, en remplaçant, par exemple, partout Linux par Unix :

$ sed -n "/ ^ # / p" /boot/grub/menu.lst | sed "s / Linux / Unix /" # Fichier de configuration GRUB "/boot/grub/menu.lst". # généré par "grubconfig". Dim 23 mars 2008 21:45:41 # # Démarrer la section globale GRUB # Finir la section globale GRUB # La configuration de la partition amorçable Unix commence # La configuration de la partition amorçable Unix se termine # La configuration de la partition amorçable Unix commence # La configuration de la partition amorçable Unix se termine

Commander!

Parfois, il est nécessaire d'éditer toutes les lignes, à l'exception de celles qui correspondent à l'ÉCHANTILLON ou à la sélection. symbole point d'exclamation(!) inverse la sélection. Par exemple, supprimons toutes les lignes sauf la seconde du quatrain de Gumilyov :

$ sed "2! d" gumilev.txt Au petit crépuscule du matin,

Ou sélectionnez toutes les lignes à l'exception des commentaires du fichier /boot/grub/menu.lst :

$ sed -n "/ ^ # /! p" /boot/grub/menu.lst par défaut 1 délai d'attente 20 gfxmenu (hd0,3) / boot / titre du message SuSe on (/ dev / hda3) root (hd0,2) kernel / boot / vmlinuz root = / dev / hda3 ro vga = 773 acpi = off title Linux on (/ dev / hda4) root (hd0,3) kernel / boot / vmlinuz root = / dev / hda4 ro vga = 0x317

Commande Q (quitter)

La commande q termine sed après la ligne spécifiée. C'est pratique si vous devez arrêter l'édition après avoir atteint un certain endroit dans le texte :

$ sed "11 q" nom de fichier

Cette commande se terminera lorsqu'elle atteindra la 11e ligne.

La commande q est l'une des rares commandes sed qui n'accepte pas les plages de lignes. La commande ne peut pas cesser de fonctionner 10 fois de suite si nous saisissons :

Sed "1,10 q" Absurde !

Commande W (écrire)

Comme le modificateur w de la commande s, cette commande permet d'écrire la sortie d'un programme dans un fichier :

$ sed -n "3, $ w gum.txt" gumilev.txt

Nous obtiendrons un fichier gum.txt contenant les deux dernières lignes du quatrain de Gumilev à partir du fichier gumilev.txt. De plus, si un tel fichier existe déjà, il sera écrasé. Si vous n'entrez pas l'option -n, le programme, en plus de créer le fichier gum.txt, affichera également tout le contenu du fichier gumilev.txt.

Pour le travail en ligne de commande, il est plus pratique d'utiliser la redirection de sortie normale (> ou >>), mais dans les scripts sed, la commande w est susceptible d'être utile.

Commande R (lecture)

Cette commande ne lit pas seulement le fichier spécifié, mais insère également son contenu à l'emplacement souhaité dans le fichier en cours d'édition. Pour sélectionner le "bon endroit", on utilise l'adressage déjà connu (par numéros de ligne, par expressions, etc.). Exemple:

$ echo D'un poème de Gumilyov : | sed "r gumilev.txt"

Extrait d'un poème de Goumiliov :

Quelle étrange félicité Au crépuscule du matin, Dans la fonte des neiges de printemps, Dans tout ce qui périt et est sage.

Commande =

Donnera le numéro de la ligne spécifiée :

$ sed "/ snow / =" gumilev.txt Quelle étrange félicité Au crépuscule matinal, 3 Dans la fonte des neiges de printemps, Dans tout ce qui périt et est sage.

$ sed -n "/ neige / =" gumilev.txt 3

La commande n'accepte qu'une seule adresse, n'accepte pas les intervalles.

Commande Y

Cette commande remplace les symboles de la section PATTERN par des symboles de la section REPLACE, fonctionnant comme un programme tr.

$ echo Voiture - un héritage du passé | sed "y / Auto / Paro /" Ferry - un héritage du passé

Commander oui ne fonctionne que si le nombre de caractères dans le PATTERN est égal au nombre de caractères dans REPLACE.

Scripts Sed

Pour utiliser sed comme un éditeur à part entière éditeur de texte, vous devez apprendre à écrire des scripts sed. Le programme sed possède son propre langage de programmation simple qui vous permet d'écrire des scripts qui peuvent faire des merveilles.

Cet article ne peut pas contenir de descriptions de scripts sed, tout comme son auteur ne se donne pas pour tâche de maîtriser le langage de programmation sed. Dans cet article, je me suis concentré sur l'utilisation de l'éditeur sed sur la ligne de commande, dans le but de l'utiliser comme filtre sur les tuyaux. Pour cette raison, j'ai omis de nombreuses commandes sed qui ne sont utilisées que dans les scripts sed.

Il y a de nombreux fans de l'éditeur sed, et de nombreux articles sur le sujet des scripts, y compris sur Internet russe. Alors pour ceux qui s'intéressent à ce merveilleux programme, il ne sera pas difficile de refaire leurs connaissances.

Programme Sed et caractères cyrilliques

Comme vous pouvez le voir dans les exemples de cet article, le programme sed sur un système correctement russifié parle couramment la langue "grande et puissante".

Résumé du programme sed

Sed est un éditeur de flux de données multifonctionnel, indispensable pour :

Modification de grands tableaux de texte
Édition de fichiers de toute taille lorsque la séquence d'actions d'édition est trop complexe
Modifier les données au fur et à mesure qu'elles deviennent disponibles, y compris en temps réel, c'est-à-dire dans les cas où il est difficile ou totalement impossible d'utiliser des éditeurs de texte interactifs.

Il faudra des semaines voire des mois de travail pour maîtriser le programme sed dans son intégralité, car il nécessite :

Apprendre les expressions régulières
Apprenez à écrire des scripts sed en maîtrisant le langage de programmation simple utilisé dans ces scripts

D'un autre côté, certaines des commandes sed les plus courantes ne sont pas plus difficiles à maîtriser que n'importe quelle commande Unix ; J'espère que cet article vous y aidera.

Épilogue

Jusqu'à présent, dans les articles du cycle HuMan, j'essayais de révéler au moins brièvement chaque option, chaque paramètre de la commande décrite, afin que l'article puisse remplacer le mana. À l'avenir, je continuerai à adhérer à ce principe.

Cet article est une exception, car il ne décrit pas toutes les fonctionnalités du programme. Pour les décrire complètement, il faudrait non pas un article, mais un livre. Cependant, cet article vous donnera une idée de l'éditeur sed et vous permettra de vous familiariser avec ce programme étonnant en utilisant ses commandes les plus courantes.