Traitement du texte

Objectifs de certification

Linux Essentials

RHCSA EX200

  • 1.Comprendre et utiliser les outils essentiels
    • 1.2. Utiliser la redirection des entrées/sorties
    • 1.3. Utiliser des expressions grep et régulières pour analyser du texte
    • 1.7. Créer et éditer des fichiers texte

LPIC 1

1. Redirections et tubes

1.1. Redirections >, >>, <, |

  • Les processus UNIX ouvrent trois descripteurs de fichiers standards (correspondant aux flux standards) qui permettent de traiter les entrées et sorties. Ces descripteurs standards peuvent être redéfinis pour chaque processus. Dans la plupart des cas, le descripteur stdin (entrée standard) est le clavier, et les deux descripteurs de sortie, stdout (sortie standard) et stderr (l'erreur standard), sont l'écran.
  • Un processus et ses 3 descripteurs de fichiers STDIN (0), STDOUT (1) et STERR (2)
STDIN < ------ PROCESSUS ---- >
                   |     ---- >> STDOUT
                   |     ---- |
                   |
                   2>
                 STDERR

1.2. Redirection de l'entrée standard

programme < fichier
  • Dans ce cas, les données vont de droite à gauche. L'opérateur "<" ne peut être utilisé qu'avec stdin : on ne peut pas l'utiliser avec les flux de sortie.
  • Si le fichier contient les instructions l et q (une instruction par ligne), alors dans l'exemple suivant fdisk affichera la table des partitions de /dev/sda, puis affichera l'aide puis quittera :
$ cat > fdisk.txt
l
q
[CRTL-D]
$ su
# fdisk /dev/?da < fdisk.txt
# exit
  • Redirection de l'entrée standard :

PROCESSUS ---- < ---- FICHIER / PÉRIPHÉRIQUE
         ---- 0< ----

1.3. Etiquettes

Une étiquette permet de limiter la redirection. C'est utile par exemple pour donner des arguments à une commande sur plusieurs lignes. Un autre usage est la création de fichiers à partir d'un script. Dans l'exemple suivant, on envoie un email sur plusieurs ligne avec la commande mail.

$ mail mon@adresse <<FIN
> ceci
> est
> un
> test
> FIN

Exercice : Créer des fichiers avec un script bash.

Par exemple un script qui crée un fichier personnalisé :

#!/bin/bash
n=1
touch fichier-$n.txt
cat << EOF > fichier-$n.txt
Ceci est le fichier n°$n
Ligne 2
Ligne 3
Ligne 4
EOF
echo "fichier-$n créé"

1.4. Redirection de la sortie standard

  • Les données vont de gauche à droite.
programme > fichier

Par exemple, avec les droits de root :

fdisk -l /dev/?da > partitions.txt
  • Ceci lance fdisk et redirige la sortie vers le fichier partitions.txt. La sortie n'est pas visible a l'écran. Notez que le shell lit cette commande à partir de la droite : le fichier partitions.txt est d'abord créé s'il n'existait pas auparavant, écrasé dans le cas contraire car l'opérateur ">" est utilisé.
  • L'opérateur ">>" ajoute la sortie standard à un fichier sans l'écraser.
  • Redirection de la sortie standard :
          ---- > ----
PROCESSUS ---- >> ---- FICHIER / PÉRIPHÉRIQUE
          ---- 1> ----

1.5. Exemples de redirection de la sortie standard

  • > crée un nouveau fichier avec la sortie standard
  • >> ajoute la sortie au fichier

Par exemple :

$ date > date.txt
$ cat date.txt
dim fév 21 04:52:01 CET 2016
$ date >> date.txt
$ cat date.txt
dim fév 21 04:52:01 CET 2016
dim fév 21 04:53:09 CET 2016
$ date > date.txt
$ cat date.txt
dim fév 21 04:53:32 CET 2016

1.6. Redirection de la sortie erreur standard

programme 2> fichier_erreur
  • stdin, stdout et stderr sont représentés respectivement par 0, 1 et 2. Cela nous permet de choisir le flux d'erreur standard. Par exemple, vers une corbeille :
ls /fake / 2> /dev/null
  • Par exemple, vers un fichier :
ls /fake 2> err.txt
  • Redirection de l'erreur standard :
PROCESSUS ---- 2> ---- FICHIER / PÉRIPHÉRIQUE

1.7. Travailler avec les redirections

  • La commande suivante donne des erreurs et une sortie standard :
$ find /etc/ -name "*.crt"
/etc/ssl/certs/ca-certificates.crt
find: /etc/ssl/private: Permission denied
...

1.8. Isoler et diviser des sorties

  • Isoler la sortie erreur :
$ find /etc/ -name "*.crt" > /dev/null
find: /etc/ssl/private: Permission denied
  • Isoler la sortie standard :
$ find /etc/ -name "*.crt" 2> /dev/null
/etc/ssl/certs/ca-certificates.crt
  • Diviser les sorties :
$ find /etc/ -name "*.crt" 2> /dev/null
/etc/ssl/certs/ca-certificates.crt
$ find /etc/ -name "*.crt" > crt.txt 2> crt.err
$ cat crt.txt
/etc/ssl/certs/ca-certificates.crt
$ cat crt.err
find: /etc/ssl/private: Permission denied
  • Exemple récapitulatif à méditer

Avec le fichier fdisk.txt.

fdisk /dev/?da < fdisk.txt 2> /dev/null > resultat.txt

Le fichier fdisk.txt envoie des commandes en entrée à l'exécutable fdisk, le résultat sans les erreurs est écrit dans le fichier resultat.txt.

1.9. Tubes

programme1 | programme2
  • Les tubes sont représentés par l'opérateur "|". Les données vont de gauche à droite. La figure suivante indique comment la sortie standard du premier processus est redirigée vers l'entrée standard du second processus.
  • Redirection à partir d'un tube :
PROCESSUS1 (stdout) ---- | ---- (stdin) PROCESSUS2
  • Exemple :
$ ps aux | grep login

Note : L'utilitaire pgrep fournit le même résultat.

2. Outils de traitement du texte

2.1. cat : éditeur rudimentaire

La commande cat peut être utilisée comme un éditeur de texte rudimentaire.

$ cat > texte.txt
ligne 1
ligne 2
ligne 3
Crtl+D
  • Vous noterez l'utilisation de Ctrl+D. Cette commande est utilisée pour clore la saisie.

2.2. cat lecteur de texte

On utilise plus couramment cat pour envoyer du texte vers la sortie standard.

Les options les plus courantes sont :

  • -n numéroter chaque ligne de la sortie
  • -b numéroter uniquement les lignes non vides
  • -A afficher le retour charriot

Exemples :

$ cat texte.txt
ligne 1
ligne 2
ligne 3
$ cat -n /etc/resolv.conf

2.3. tac lecteur inverse

tac fait la même chose que cat à l'exception qu'elle lit de la dernière ligne à la première.

$ tac texte.txt
ligne 3
ligne 2
ligne 1

2.4. head et tail

On utilise souvent les commandes head et tail pour analyser les fichiers de journaux. Par défaut, ces commandes affichent 10 lignes. En voici les utilisations les plus courantes :

  • afficher les 20 premières lignes de /var/log/messages :
$ head -n 20 /var/log/messages
$ head -20 /var/log/messages
  • afficher les 20 dernières lignes de /etc/aliases:
tail -20 /etc/aliases

tail a une option supplémentaire qui nous permet d'afficher la fin d'un texte en commençant par une ligne donnée.

  • afficher le texte en partant de la ligne 25 de /var/log/messages
tail -n +25 /var/log/messages

tail peut afficher un fichier en continu avec l'option -f. C'est très pratique pour suivre les modifications d'un fichier en temps réel.

2.5. Commande tee

La commande tee permet à la fois de lire un flux et de le rediriger.

Par exemple, tee donne la sortie et l’écrit dans le fichier ls1.txt :

$ ls | tee ls1.txt

La sortie de la liste de fichiers dont on compte les lignes est redirigée vers la sortie standard et dans le fichier count.txt

ls -l *.txt | wc -l | tee count.txt

3. Manipulation de texte

  • Compter des lignes, des mots, des octets
  • Remplacer des tabulations par des espaces
  • Afficher les fichiers binaires
  • Découper les fichiers
  • Sélectionner les champs et les caractères avec cut
  • Trouver des doublons
  • Trier la sortie
  • Couper des fichiers
  • Jointure de texte
  • Mise en forme de la sortie avec fmt et pr
  • Convertir les caractères

3.1. Compter lignes, mots et octets avec la commande wc

La commande wc compte le nombre d'octets, de mots et de lignes dans les fichiers.

Les options suivantes vous permettent de sélectionner ce qui nous intéresse :

  • -l compte le nombre de lignes
  • -w compte le nombre de mots (words)
  • -c compte le nombre d'octets
  • -m compte le nombre de caractères
  • sans argument, wc compte ce qui est saisi dans stdin.

Par exemple :

$ wc -l /etc/passwd
$ cat /etc/passwd | wc -l

3.2. Remplacer les tabulations par des espaces

  • On utilise la commande expand pour remplacer les tabulations par des espaces.
  • unexpand est utilisé pour l'opération inverse.

3.3. Afficher les fichiers binaires

  • Il y a nombre d'outils pour ça. Les plus courants sont od (octal dump) et hexdump.

3.4. Découper les fichiers avec la commande split

La commande split peut découper un fichier en plusieurs fichiers plus petits à partir de critères comme la taille ou le nombre de lignes. Par exemple, nous pouvons découper /etc/passwd en fichiers de 5 lignes chacuns :

$ split -l 5 /etc/passwd
  • Cette commande va créer des fichiers appelés xaa, xab, xac, xad, etc., chaque fichier contenant au plus 5 lignes. Tentez et vérifiez :
$ split -dl 5 /etc/passwd passwd
  • Il est possible de donner un préfixe plus significatif que "x", comme "pass-5" :
$ split -l 5 /etc/passwd passwd-5
  • Cette commande crée des fichiers identiques à la commande précédente, mais ils sont désormais nommés passwd-5aa, passwd-5ab, passwd-5ac, passwd-5ad, ...

3.5. Sélectionner les champs et les caractères avec cut

La commande cut peut extraire une plage de caractères ou de champs de chaque ligne d'un texte.

  • L'option -c est utilisée pour manipuler les caractères.
  • Syntaxe : cut –c {plage1,plage2}

Exemple :

cut -c5-10,15- /etc/passwd
  • Cette commande extrait les caractères 5 à 10 puis 15 jusqu'à la fin pour chaque ligne de /etc/passwd.

  • On peut spécifier le séparateur de champ (espace, virgule, etc.) d'un fichier ainsi que les champs à extraire. Ces options sont définies respectivement par les options -d (delimiter) et -f (field).

Syntaxe :

  • cut -d {séparateur} -f {champs}

  • Exemple :

cut -d: -f 1,7 --output-delimiter=" " /etc/passwd
  • Cette commande extrait les 1er et 7e champs de /etc/passwd séparés par un espace. Le délimiteur de sortie est le même que le délimiteur d'entrée d'origine (par défaut, la tabulation). L'option --output-delimiter vous permet de le changer.

3.6. Trouver des doublons avec la commande uniq

  • Éliminer les lignes successives en doublon
  • La commande uniq n'envoie à STDOUT qu'une version des lignes successives identiques. Par exemple :
$ uniq > /tmp/list1
ligne 1
ligne 2
ligne 2
ligne 3
ligne 3
ligne 3
ligne 1
^D
$ cat /tmp/UNIQUE
sort | uniq > /tmp/UNIQUE

3.7. Trier la sortie avec la commande sort

Par défaut, sort trie le texte par ordre alphabétique. Pour effectuer un tri numérique, utilisez l'option -n.

$ cat > /tmp/list2
ligne 1
ligne 2
ligne 2
ligne 1
ligne 3
ligne 2
ligne 3
ligne 1
$ sort /tmp/list2
$ sort /tmp/list2 | uniq > /tmp/list3

3.8. Jointure de texte avec paste

La commande la plus facile est paste qui "concatène" deux fichiers l'un à la suite de l'autre.

  • Syntaxe :
paste texte1 texte2
  • Exemples avec deux fichiers :

texte1 :

01 Paris
02 Luxembourg
03 Berlin
04 Bruxelles
05 Londres

texte2 :

01 France
02 Grand-Duché de Luxembourg
03 Allemagne
04 Belgique
05 Royaume-Uni
$ paste texte1 texte2
01 Paris    01 France
02 Luxembourg    02 Grand-Duché de Luxembourg
03 Berlin    03 Allemagne
04 Bruxelles    04 Belgique
05 Londres    05 Royaume-Uni
$ paste -s texte1 texte2
01 Paris    02 Luxembourg    03 Berlin    04 Bruxelles    05 Londres
01 France    02 Grand-Duché de Luxembourg    03 Allemagne    04 Belgique    05 Royaume-Uni
$ paste -s -d: texte1 texte2
01 Paris:02 Luxembourg:03 Berlin:04 Bruxelles:05 Londres
01 France:02 Grand-Duché de Luxembourg:03 Allemagne:04 Belgique:05 Royaume-Uni
$ paste -d: texte1 texte2
01 Paris:01 France
02 Luxembourg:02 Grand-Duché de Luxembourg
03 Berlin:03 Allemagne
04 Bruxelles:04 Belgique
05 Londres:05 Royaume-Uni

3.9. Jointure de texte avec join

Avec join vous pouvez en plus préciser quels champs vous souhaitez à condition que les fichiers disposent d'un début de ligne commun.

Syntaxe :

join -j1 {champ_no} -j2{champ_no} texte1 texte2

ou

join -1 {champ_no} -2{champ_no} texte1 texte2
  • Le texte n'est envoyé à la sortie que si les champs sélectionnés correspondent.
  • Les comparaisons se font ligne par ligne et le processus s'arrête dès qu'il n'y a pas de correspondance, même s'il y a d'autres correspondances à la fin du fichier.

Par exemple avec les fichiers précédents :

$ join texte1 texte2
01 Paris France
02 Luxembourg Grand-Duché de Luxembourg
03 Berlin Allemagne
04 Bruxelles Belgique
05 Londres Royaume-Uni
  • Exercice optionnel : Regroupez les fichiers séparés précédemment.

3.10. Mise en forme de la sortie avec fmt et pr

Vous pouvez modifier le nombre de caractères par ligne avec fmt. Par défaut fmt joint les ligne et génère des lignes de 75 caractères.

Options de fmt :

  • -w (width) nombre de caractères par ligne
  • -s découpe les lignes longues mais sans les remplir
  • -u sépare chaque mot par une espace et chaque phrase par deux espaces
  • On peut paginer les longs fichiers pour qu'ils correspondent à une taille donnée avec la commande pr. On peut contrôler la longueur des pages (66 lignes par défaut), la largeur (par défaut 72 caractères) ainsi que le nombre de colonnes.
  • Lorsqu'on produit un texte sur plusieurs colonnes, chaque colonne est tronquée uniformément en fonction de la largeur de page spécifiée. Cela veut dire que des caractères sont supprimés à moins d'avoir édité le texte de façon à éviter cela.

3.11. Convertir les caractères avec la commande tr

La commande tr convertit un ensemble de caractères en un autre.

  • convertir les majuscules en minuscules
tr 'A-B' 'a-b' < fichier.txt
  • changer de délimiteur dans /etc/passwd
tr ':' ' ' < /etc/passwd
$ join texte1 texte2 | tr ' ' ':'
01:Paris:France
02:Luxembourg:Grand-Duché:de:Luxembourg
03:Berlin:Allemagne
04:Bruxelles:Belgique
05:Londres:Royaume-Uni

Remarque : tr a seulement deux arguments ! Le fichier n'est pas un argument.

4. Recherche de texte

4.1. Commande grep

Historiquement, le nom provient de l'une des commandes de l'éditeur de texte ed disponible sur UNIX, dont la syntaxe est :

:g/re/p

Cette commande signifie : "rechercher globalement les correspondances avec l'expression rationnelle (en anglais, regular expression), et imprimer (print) les lignes dans lesquelles elle correspond". Par défaut, grep se comporte très exactement comme cette commande. Toutefois, de nombreuses options en ligne de commande permettent de changer son comportement.

D'après d'autres sources, le nom grep serait en fait l'acronyme de "General Regular Expression Processor", ce qui signifie "« "Processeur d'Expressions Rationnelles Générique".

grep, egrep, fgrep - Afficher les lignes correspondant à un motif donné.

On ira lire utilement man grep et info grep.

4.2. SYNOPSIS

grep [ -[[AB] ]num ] [ -[CEFGVBchilnsvwx] ] [ -e ] motif | -ffichier ] [ fichiers... ]

grep recherche dans les fichiers d'entrée indiqués les lignes correspondant à un certain motif.

Si aucun fichier n'est fourni, ou si le nom "-" est mentionné, la lecture se fait depuis l'entrée standard.

Par défaut, grep affiche les lignes correspondant au motif.

Il existe trois variantes principales de grep, contrôlées par les options suivantes.

  • -G : Interprète le motif comme une expression rationnelle simple (voir plus bas). C'est le comportement par défaut.

  • -E : Interprète le motif comme une expression rationnelle étendue (voir plus bas).

  • -F : Interprète le motif comme une liste de chaînes figées, séparées par des Sauts de Lignes (NewLine). La correspondance est faite avec n'importe laquelle de ces chaînes.

De plus, il existe deux variantes du programme : egrep et fgrep. Egrep est similaire (sans être identique) à grep -E, et est compatible avec les versions UNIX historiques de egrep. Fgrep est identique à grep -F.

Toutes les variantes de grep acceptent les options suivantes :

  • -num : Les correspondances seront affichées avec num lignes supplémentaires avant et après. Néanmoins, grep n'affichera jamais une ligne plus d'une fois.

  • -A num : Afficher num lignes supplémentaires après la ligne correspondante.

  • -B num : Afficher num lignes supplémentaires avant la ligne correspondante.

  • -C : est équivalent à -2.

  • -V : Afficher le numéro de version de grep sur la sortie d'erreur standard. Ce numéro de version devra être inclus dans tous les rapports de bogues (voir plus bas).

  • -b : Avant chaque ligne, afficher son décalage (en octet) au sein du fichier d'entrée.

  • -c : Ne pas afficher les résultats normaux. À la place, afficher un compte des lignes correspondantes pour chaque fichier d'entrée. Avec l'option -v (voir plus bas), afficher les nombres de lignes ne correspondant pas au motif.

  • -e motif : Utiliser le motif indiqué. Ceci permet de protéger les motifs commençant par -.

  • -f fichier : Lire le motif dans le fichier indiqué.

  • -h : Ne pas afficher le nom des fichiers dans les résultats lorsque plusieurs fichiers sont parcourus.

  • -i : Ignorer les différences majuscules/minuscules aussi bien dans le motif que dans les fichiers d'entrée.

  • -L : Ne pas afficher les résultats normaux. À la place, indiquer le nom des fichiers pour lesquels aucun résultat n'aurait été affiché.

  • -l : Ne pas afficher les résultats normaux. À la place, indiquer le nom des fichiers pour lesquels des résultats auraient été affiches.

  • -n : Ajouter à chaque ligne de sortie un préfixe contenant son numéro dans le fichier d'entrée.

  • -q : Silence. Ne pas afficher les résultats normaux.

  • -s : Ne pas afficher les messages d'erreurs concernant les fichiers inexistants ou illisibles.

  • -v : Inverser la mise en correspondance, pour sélectionner les lignes ne correspondant pas au motif.

  • -w : Ne sélectionner que les lignes contenant une correspondance formant un mot complet. La sous-chaîne correspondante doit donc être soit au début de la ligne, soit précédée d'un caractère n'appartenant pas à un mot. De même elle doit se trouver soit à la fin de la ligne, soit être suivie par un caractère n'appartenant pas à un mot. Les caractères composants les mots sont les lettres, les chiffres et le souligné ('_'). ([NDT] Bien entendu les minuscules accentuées ne sont pas des lettres ! Elles servent donc à séparer les mots...)

  • -x : Ne sélectionner que les correspondances qui occupent une ligne entière.

5. Expressions rationnelles

5.1. Définition

Une expression rationnelle est une description d’une chaîne de caractères. Par exemple :

^[[:digit:]]+ -[[:blank:]]+.*$

5.2. Scripts regexp.sh

Les scripts regexp.sh sera utile pour éprouver les expressions rationnelles.

Il compare une exepression rationnelle à des chaines de caractères et donne le résultat.

#! /bin/sh
# Christophe Blaess, Scripts Shell Linux et Unix, p. 180.
# regexp.sh
EXPRESSION="$1"
# Eliminons l'expression des arguments de ligne de commande :
shift
# Puis comparons-la avec les chaines :
for chaine in "$@"
do
echo "$chaine" | grep "$EXPRESSION" > /dev/null
if [ $? -eq 0 ]
then
echo "$chaine : OUI"
else
echo "$chaine : NON"
fi
done

Par exemple :

./regexp.sh ou Bonjour ou bonsoir
Bonjour : OUI
ou : OUI
bonsoir : NON
./regexp.sh ou Bonjour oU bonsoir
Bonjour : OUI
oU : NON
bonsoir : NON
./regexp.sh o. Bonjour oU bonsoir
Bonjour : OUI
oU : OUI
bonsoir : OUI

5.3. Le symbole générique .

./regexp.sh o.r Bonjour oU bonsoir
Bonjour : OUI
oU : NON
bonsoir : OUI
./regexp.sh o.r Bonjour oU bonsoiiiiiir
Bonjour : OUI
oU : NON
bonsoiiiiiir : NON
./regexp.sh o.r Bonjour oU bonsoor
Bonjour : OUI
oU : NON
bonsoor : OUI

5.4. Début et fin de chaînes

./regexp.sh '^B' Bonjour oU bonsoor
Bonjour : OUI
oU : NON
bonsoor : NON
./regexp.sh 'r$' Bonjour oU bonsoor
Bonjour : OUI
oU : NON
bonsoor : OUI
./regexp.sh '^oU$' Bonjour oU bonsoor
Bonjour : NON
oU : OUI
bonsoor : NON
./regexp.sh '^ou$' Bonjour oU bonsoor
Bonjour : NON
oU : NON
bonsoor : NON
./regexp.sh 'ou.$' Bonjour oU bonsoor
Bonjour : OUI
oU : NON
bonsoor : NON

5.5. Alternatives

./regexp.sh 'ou\|oi' Bonjour ou bonsoir
Bonjour : OUI
ou : OUI
bonsoir : OUI
./regexp.sh 'ou\|oi' Bonjour ou bonsoor
Bonjour : OUI
ou : OUI
bonsoor : NON
./regexp.sh 'ou\|oi\|oo' Bonjour ou bonsoor
Bonjour : OUI
ou : OUI
bonsoor : OUI

5.6. Listes

./regexp.sh '[ji]' Bonjour ou bonsoir
Bonjour : OUI
ou : NON
bonsoir : OUI
./regexp.sh 'n[ji]' Bonjour ou bonsoir
Bonjour : OUI
ou : NON
bonsoir : NON
./regexp.sh 'n[js]' Bonjour ou bonsoir
Bonjour : OUI
ou : NON
bonsoir : OUI

5.7. Intervalles

$ ./regexp.sh 'o[a-z]' Bonjour o5 bonsoir
Bonjour : OUI
o5 : NON
bonsoir : OUI
./regexp.sh '[A-Z]o' Bonjour o5 bonsoir
Bonjour : OUI
o5 : NON
bonsoir : NON
./regexp.sh 'o[0-9]' Bonjour o5 bonsoir
Bonjour : NON
o5 : OUI
bonsoir : NON

5.8. Classes

Les classes sont plus commodes à utiliser à utiliser que les intervalles. Voici les douze classes standards.

Les classes se notent dans le format [[:classe:]]

Nom Signification Ascii Iso-8859-15
alpha Lettres alphabétiques dans la locali- sation en cours. [A-Za-z] [A-Za-zÀÁÂÃÄ... ùúûü ́y]
digit Chiffres décimaux. [0-9] idem Ascii
xdigit Chiffres hexadécimaux. [0-9A-Fa-f] idem Ascii
alnum Chiffres ou lettres alphabétiques. [[:alpha:][:digit:]] [[:alpha:][:digit:]]
lower Lettres minuscules dans la localisation en cours. [a-z] [a-zàáâãä...ùúûü ́y]
upper Lettres majuscules dans la localisation en cours. [A-Z] [A-ZÀÁÂÃÄ...ÙÚÛÜY ́]
blank Caractères blancs. espace et tabulation idem Ascii
space Caractères d’espacement. espace, tabulation, sauts de ligne et de page, retour chariot idem Ascii
punct Signes de ponctuation. ``[]!"#$%&'()*+,-./:;<=>?@\ ^_{ }~[]``` idem Ascii
graph Symboles ayant une représentation graphique. [[:alnum:][:punct:]] [[:alnum:][:punct:]]
print Caractères imprimables (graph et l’espace). [[:graph:]] [[:graph:]]
cntrl Caractères de contrôle. Codes Ascii inférieurs à 31, et caractère de code 127 idem Ascii

Exemple :

./regexp.sh "[[:punct:]]" bonjour bonjour,
bonjour : NON
bonjour, : OUI

5.9. Opérateurs de répétitions

Opérateurs :

  • * : toute occurence de l'élément précédent même l'absence
  • \+ : une ou plusieurs occurence de l'élément précédent
  • \? : zéro ou une occurrence de l’élément précédent
  • \{n,m\} : au moins n et au plus m occurrences de l’élément précédent

Exemples :

  • Tout caractère :
./regexp.sh "b.*" b bo bon bonjour Bonjour
b : OUI
bo : OUI
bon : OUI
bonjour : OUI
Bonjour : NON
./regexp.sh "bo*n" bn bon boooooon
bn : OUI
bon : OUI
boooooon : OUI
  • Trouver une chaîne composée de mots séparés d'espaces et de tabulations :
^[[:blank:]]*[[:alpha:]][[:alpha:]]*[[:blank:]]*
  • Une ou plusieurs occurences :
./regexp.sh "bo\+n" bn bon boooooon
bn : NON
bon : OUI
boooooon : OUI
  • Aucune ou une occurence :
./regexp.sh "bo\?n" bn bon boooooon
bn : OUI
bon : OUI
boooooon : NON
  • Un minimum d'occurences :
./regexp.sh "bo\{2,\}n" bn bon boooooon
bn : NON
bon : NON
boooooon : OUI
  • Un maximum d'occurences :
./regexp.sh "bo\{0,2\}n" bn bon boooooon
bn : OUI
bon : OUI
boooooon : NON
  • Exactement un nombre d'occurences :
./regexp.sh "bo\{2\}n" bn bon boooooon
bn : NON
bon : NON
boooooon : NON

5.10. Groupements

\(\)

Un groupement permet de rechercher une chaine précise, et sa répétition, ici au minimum deux fois à la suite :

./regexp.sh "\(bon\)\{2\}" bon bonbon
bon : NON
bonbon : OUI

5.11. Expressions rationnelles étendues

Signification Symbole pour expression régulière simple Symbole pour expression regulière étendue
Caractère générique . .
Début de ligne ^ ^
Fin de ligne $ $
Alternative `\ ` ` `
Liste de caractères [] []
Classe de caractères (dans une liste) [:classe:] [:classe:]
Juxtaposition de caractères (dans une liste) [.séquence.] [.séquence.]
Classe d’équivalence (dans une liste) [=classe=] [=classe=]
Zéro, une ou plusieurs occurrences de l’élément précédent * *
Une ou plusieurs occurrences de l’élément précédent \+ +
Zéro ou une occurrence de l’élément précédent \? ?
Au moins n et au plus m occurrences de l’élément précédent \{n,m\} {n,m}
Au moins n occurrences de l’élément précédent \{n,\} {n,}
Au plus m occurrences de l’élément précédent \{0,m\} {0,m}
Exactement n occurrences de l’élément précédent \{n\} {n}
Regroupement de caractères \( \) ()
Référence arrière au n-ième regroupement \n \n
Préfixe d’un caractère spécial pour reprendre sa valeur littérale \ \

Pour tester les expressions rationnelles étendues, on modifiera le script regexp.sh en ajoutant l'option -E à la commande grep

5.12. Exercices grep

Pour extraire l'adresse IPv4 de l'interface eth0 :

ip -4 addr show eth0 | grep inet | awk '{ print $2; }' | sed 's/\/.*$//'

Pour retirer les lignes de commentaires :

grep -v "^#" /etc/ssh/sshd_config

Pour retirer en plus les lignes vides :

grep -v "^#" /etc/ssh/sshd_config | grep -v "^$"

Retirer les lignes vides et les commentaires :

grep -v '^$\|^\s*\#' /etc/ssh/sshd_config

On visitera utilement http://stackoverflow.com/search?q=grep .

4.13. Recherche récursive avec find

find . –type f | xargs grep 'motifachercher'

La recherche de fichier est développée dans le partie Recherche de fichiers

6. Sed

sed (abréviation de Stream EDitor, « éditeur de flux ») est un programme informatique permettant d'appliquer différentes transformations prédéfinies à un flux séquentiel de données textuelles. sed lit des données d'entrée ligne par ligne, modifie chaque ligne selon des règles spécifiées dans un langage propre (appelé « script sed »), puis retourne le contenu du fichier (par défaut). Bien qu'originellement écrit pour Unix, par Lee E. McMahon en 1973/1974 (Bell Labs), sed est maintenant disponible sur pratiquement tous les systèmes d'exploitation disposant d'une interface en ligne de commande.

sed est souvent décrit comme un éditeur de texte non-interactif. Il diffère d'un éditeur conventionnel en ceci que la séquence de traitement des deux flux d'informations nécessaires (les données et les instructions) est inversée. Au lieu de prendre une par une les commandes d'édition pour les appliquer à l'intégralité du texte (qui doit alors être intégralement en mémoire), sed ne parcourt qu'une seule fois le fichier de texte, en appliquant l'ensemble des commandes d'édition à chaque ligne. Comme une seule ligne à la fois est présente en mémoire, sed peut traiter des fichiers de taille complètement arbitraire.

(source : https://fr.wikipedia.org/wiki/Stream_Editor)

sed accepte un certain nombre de commandes représentées par une lettre unique. Ce jeu de commandes est basé sur celui de l'éditeur ed. Les commandes les plus utilisées sont d, p et s.

L'option -e sort le résultat sur la sortie standard et l'option -i applique directement les changements sur le fichier.

6.1. Impression et suppression

Les commandes p et d permettent d'imprimer ou d'effacer des lignes sur base d'un motif. Ces fonctions peuvent être assurées par d'autres programmes comme tail, head, grep, etc.

La commande p permet d'imprimer la sélection

$ sed -e 'p' /etc/hosts.allow
#
#
# hosts.allow    This file contains access rules which are used to
# hosts.allow    This file contains access rules which are used to
#        allow or deny connections to network services that
#        allow or deny connections to network services that
#        either use the tcp_wrappers library or that have been
#        either use the tcp_wrappers library or that have been
#        started through a tcp_wrappers-enabled xinetd.
#        started through a tcp_wrappers-enabled xinetd.
#
#
#        See 'man 5 hosts_options' and 'man 5 hosts_access'
#        See 'man 5 hosts_options' and 'man 5 hosts_access'
#        for information on rule syntax.
#        for information on rule syntax.
#        See 'man tcpd' for information on tcp_wrappers
#        See 'man tcpd' for information on tcp_wrappers
#
#

Sans l'option -n la ligne traitée est dupliquée.

$ sed -n -e 'p' /etc/hosts.allow
#
# hosts.allow    This file contains access rules which are used to
#        allow or deny connections to network services that
#        either use the tcp_wrappers library or that have been
#        started through a tcp_wrappers-enabled xinetd.
#
#        See 'man 5 hosts_options' and 'man 5 hosts_access'
#        for information on rule syntax.
#        See 'man tcpd' for information on tcp_wrappers
#

Sélectionner une ligne, ici la numéro 4 :

$ sed -n -e '4p' /etc/hosts.allow
#        either use the tcp_wrappers library or that have been

Sélectionner un intervalle de lignes, ici de 4 à 6 :

$ sed -n -e '4,6p' /etc/hosts.allow
#        either use the tcp_wrappers library or that have been
#        started through a tcp_wrappers-enabled xinetd.
#

Imprimer les lignes contenant un motif :

$ sed -n -e '/hosts/p' /etc/hosts.allow
# hosts.allow    This file contains access rules which are used to
#        See 'man 5 hosts_options' and 'man 5 hosts_access'

Imprimer les lignes qui ne contiennent pas un motif :

$ sed -n -e '/hosts/!p' /etc/hosts.allow
#
#        allow or deny connections to network services that
#        either use the tcp_wrappers library or that have been
#        started through a tcp_wrappers-enabled xinetd.
#
#        for information on rule syntax.
#        See 'man tcpd' for information on tcp_wrappers
#

La commande d permet de supprimer des lignes ici de 1 à 6:

sed -e '1,6d' /etc/hosts.allow
#        See 'man 5 hosts_options' and 'man 5 hosts_access'
#        for information on rule syntax.
#        See 'man tcpd' for information on tcp_wrappers
#

Supprimer des lignes de commentaire vide :

sed -e '/^#$/d' /etc/hosts.allow
# hosts.allow    This file contains access rules which are used to
#        allow or deny connections to network services that
#        either use the tcp_wrappers library or that have been
#        started through a tcp_wrappers-enabled xinetd.
#        See 'man 5 hosts_options' and 'man 5 hosts_access'
#        for information on rule syntax.
#        See 'man tcpd' for information on tcp_wrappers

6.1. Substitution

C'est la commande s qui permet la subistition. Utilisée sans autre commande, elle transforme le premier motif rencontré sur chaque ligne :

$ sed -e 's/man/!!!!!/' /etc/hosts.allow
#
# hosts.allow    This file contains access rules which are used to
#        allow or deny connections to network services that
#        either use the tcp_wrappers library or that have been
#        started through a tcp_wrappers-enabled xinetd.
#
#        See '!!!!! 5 hosts_options' and 'man 5 hosts_access'
#        for information on rule syntax.
#        See '!!!!! tcpd' for information on tcp_wrappers
#

Ici, on remplace la seconde occurence trouvée sur chaque ligne :

$ sed -e 's/man/!!!!!/2' /etc/hosts.allow
#
# hosts.allow    This file contains access rules which are used to
#        allow or deny connections to network services that
#        either use the tcp_wrappers library or that have been
#        started through a tcp_wrappers-enabled xinetd.
#
#        See 'man 5 hosts_options' and '!!!!! 5 hosts_access'
#        for information on rule syntax.
#        See 'man tcpd' for information on tcp_wrappers
#

On ajoute l'option g pour que chaque occurence soit remplacée :

$ sed -e 's/man/!!!!!/g' /etc/hosts.allow
#
# hosts.allow    This file contains access rules which are used to
#        allow or deny connections to network services that
#        either use the tcp_wrappers library or that have been
#        started through a tcp_wrappers-enabled xinetd.
#
#        See '!!!!! 5 hosts_options' and '!!!!! 5 hosts_access'
#        for information on rule syntax.
#        See '!!!!! tcpd' for information on tcp_wrappers
#

On ira visiter utilement http://stackoverflow.com/search?q=sed

7. AWK

Source : https://fr.wikipedia.org/wiki/Awk

awk — dont le nom vient des trois créateurs, Alfred Aho, Peter Weinberger et Brian Kernighan — est un langage de traitement de lignes, disponible sur la plupart des systèmes Unix et sous Windows avec Cygwin ou Gawk. Il est principalement utilisé pour la manipulation de fichiers textuels pour des opérations de recherches, de remplacement et de transformations complexes.

7.1. Présentation

Awk est le plus souvent utilisé pour la production de fichiers plats aux spécifications particulières (échanges entre différents systèmes d'informations hétérogènes). Il est aussi utilisé comme analyseur (parser) de fichiers XML ou de fichiers textes pour générer des commandes SQL à partir des données extraites. Il peut être utilisé aussi pour des opérations de calculs complexes et mise en forme de données brutes pour faire des tableaux statistiques.

On distingue awk, la commande originale, du new awk (nawk), arrivée un peu plus tard sur le marché. Les implémentations GNU de awk, sont en fait des new awk. On trouve en général la commande awk dans /usr/bin sous Unix. Certains systèmes GNU/Linux le mettent dans /bin. En général, elle est dans la variable d'environnement PATH. Cependant, on peut faire des scripts en awk et le shebang (#!/usr/bin/awk -f) devient faux. Le script est donc inutilisable si le binaire n’est pas là où on l’attend.

Il agit comme un filtre programmable prenant une série de lignes en entrée (sous forme de fichiers ou directement via l'entrée standard) et écrivant sur la sortie standard, qui peut être redirigée vers un autre fichier ou programme. Un programme Awk est composé de trois blocs distincts utilisables ou non pour le traitement d'un fichier (pré-traitement, traitement, post-traitement). Awk lit sur l'entrée ligne par ligne, puis sélectionne (ou non) les lignes à traiter par des expressions rationnelles (et éventuellement des numéros de lignes). Une fois la ligne sélectionnée, elle est découpée en champs selon un séparateur d'entrée indiqué dans le programme awk par le symbole FS (qui par défaut correspond au caractère espace ou tabulation). Puis les différents champs sont disponibles dans des variables : $1 (premier champ), $2 (deuxième champ), $3 (troisième champ), …, $NF (dernier champ).

« awk » est aussi l'extension de nom de fichier utilisée pour les scripts écrits dans ce langage (rarement utilisée).

La syntaxe est inspirée du C :

awk [options] [programme] [fichier]

où la structure du programme est :

'motif1 { action1 } motif2 { action2 } …'

Chaque ligne du fichier est comparée successivement aux différents motifs (le plus souvent des expressions rationnelles, et globalement une expression booléenne) et l'action du premier motif renvoyant la valeur vraie est exécutée. Dans ce cas, ou si aucun motif n'est accepté, le programme lit la ligne suivante du fichier et la compare aux motifs en partant du premier.

Quelques options :

  • -F séparateur : permet de modifier le séparateur de champs ;
  • -f fichier : lit le programme à partir d'un fichier.
  • -v awkVar=$shellVar : Permet de facilement intégrer des variables du shell dans le code awk.

7.2. Description technique

Un fichier est divisé en lignes (records en anglais) elles-mêmes divisées en champs (fields en anglais)

  • lignes : séparateur ; compteur NR.
  • champs : séparateur espace ou tabulation ; compteur NF.

Les séparateurs d'entrée-sortie sont stockés dans des variables et peuvent être modifiés :

  • lignes : variables RS et ORS
  • champs : variables FS et OFS

Pour retourner le ne champ :

  • $n où n est un entier strictement positif ;
  • $0 retourne la ligne entière.

Deux masques spéciaux :

  • BEGIN : définit un programme avant de commencer l'analyse du fichier ;
  • END : définit un programme après l'analyse.

Pour définir un intervalle, on utilise la virgule comme ceci :

  • NR == 1, NR == 10 : l'action associée sera appliquée aux lignes 1 à 10.

Plusieurs fonctions sont déjà implémentées :

  • print, printf : fonctions d'affichage ;
  • cos(expr), sin(expr), exp(expr), `log(expr)`` ;
  • getline() : lit l'entrée suivante d'une ligne, retourne 0 si fin de fichier (EOF : end of file), 1 sinon ;
  • index(s1, s2) : retourne la position de la chaîne s2 dans s1, retourne 0 si s2 ne figure pas dans s1 ;
  • int(expr) : partie entière d'une expression ;
  • length(s) : longueur de la chaîne s ;
  • substr(s,n,l) : retourne une partie de la chaine de caractères s commençant à la position n, et d'une longueur l.

Structures de contrôles : la syntaxe provient directement du C :

  • if (test) {actions} else {actions}
  • while (test) {actions}
  • do {actions} while (test)
  • for (expr1;expr2;expr3) {actions}
  • continue : passe à l'élément suivant dans une boucle
  • break : sort d'une boucle

Par rapport au C il y a quelques extensions :

  • continue : hors d'une boucle, passe au motif suivant.
  • next : passe à la ligne suivante
  • tableau[texte]=valeur : tableaux assocatifs
  • for (var in tableau) {actions}

7.3. Quelques exemples

  • Affiche toutes les lignes de fichier (idem que cat fichier).
awk '{print $0}' fichier
  • Affiche toutes les lignes où le caractère 2 est présent (idem que grep '2' ref.txt).
awk '/2/ {print $0}' ref.txt
  • Affiche toutes les lignes où le caractère 2 est présent dans le premier champ.
awk '$1~/2/ {print $0}' ref.txt
  • Affiche le contenu de fichier, mais chaque ligne est précédée de son numéro.
awk '{print NR ":", $0}' fichier
  • Renvoie la liste des utilisateurs (idem cut -d : -f 1 /etc/passwd).
awk -F: '{print $1}' /etc/passwd
awk 'BEGIN {FS = ":"}{print $1}' /etc/passwd
  • Ecrit la somme de tous les nombres de la première colonne de fichier.
awk '{s=s+$1} END {print s}' fichier
  • Ecrit toutes les lignes contenues dans le fichier entre le Motif1 et le Motif2.
awk '/Motif1/ , /Motif2/' fichier

8. L'Editeur VI

8.1. Le programme vi

vi est un éditeur de texte en mode texte plein écran écrit par Bill Joy en 1976 sur une des premières versions de la distribution Unix BSD.

vi ou l'un de ses clones peut être trouvé dans presque toutes les installations de Unix. La Single UNIX Specification (plus particulièrement l'« IEEE standard 1003.2, Part 2: Shell and utilities ») inclut vi. Ainsi, tout système se conformant à cette spécification intègre vi.

Les utilisateurs, débutant avec vi, sont souvent confrontés à des difficultés, d'une part à cause des raccourcis utilisés pour chacune des commandes, ensuite parce que l'effet de ces raccourcis change selon le mode dans lequel se trouve vi.

On installe vi Improved (vim) :

# yum install vim || apt-get install vim

On pourra changer l'éditeur par défaut sous Debian/Ubuntu avec la commande :

$ sudo update-alternatives --config editor

8.2. Commandes vi

La plupart des commandes de vi sont choisies de façon à :

  • limiter la frappe nécessaire. Les modificateurs tels que Ctrl, Maj ou Alt sont utilisés avec la plus grande parcimonie ;
  • limiter les mouvements des doigts et des mains sur le clavier. Par exemple, en mode commande, les touches h, j, k et l permettent de déplacer le curseur. Comme il s'agit d'une des fonctions les plus importantes, les touches qui lui sont affectées sont celles que l'utilisateur a immédiatement sous les doigts ;
  • faciliter les moyens mnémotechniques pour retenir leur(s) effet(s). Il faut toutefois garder à l'esprit que vi a été écrit par des programmeurs anglophones. Par exemple, en mode commande, d permet d'effacer (delete), i passe en mode insertion, w avance le curseur d'un mot (word). En combinant une commande d'édition (par exemple effacer : d) et une commande de mouvement (par exemple avancer d'un mot : w), on obtient la séquence dw, qui permet d'effacer un mot. D'une manière similaire, la commande d3w efface trois mots.

8.3. Lancer vi

vi nomdefichier

vi --help

8.4. Modes vi

On trouve plusieurs modes :

  • mode normal commande :
    • Mouvements (déplacement) et quantificateurs
    • effacement, copier/couper/coller,
    • rechercher
  • mode insertion
    • qui permet d'ajouter/insérer des caractères
  • mode ligne de commande :
    • quitter, enregistrer, Fermer
    • Remplacer
    • Exécuter une commande externe

8.5. Guide vi

Avant toutes choses

  • :10 : Se déplacer à la ligne 10.

  • :set nu : Afficher les numéro de ligne.

  • :set nonu : Désactiver l'affichage des numéro de ligne.

  • ESC pour revenir au mode commande

Mouvements

On appelle les déplacements du curseur dans le fichier des "mouvements".

  • 0 : Revenir au début de la ligne

  • $ : Aller à la fin de la ligne

  • w : Aller au début du mot suivant

  • e : Aller à la fin du mot courant

  • gg : Aller au début du document.

  • G : Aller au début de la dernière ligne du document.

  • G$ : Aller au début de la dernière ligne du document.

Quantificateur

  • 2w :

Effacer/Couper

  • x : Efface le caractère sous le curseur.

Avec mouvement :

  • dw : Efface le mot sous le curseur.

  • d$ : Efface juqsu'à la fin de la ligne à partir du curseur.

  • de : Efface juqsu'à la fin du mot à partir du curseur.

  • dd : Efface la ligne du curseur.

Avec quantificateur :

  • d2w : Efface les deux mots à partir du curseur.

  • 2dd : Efface les deux lignes à partir du curseur.

Annuler

  • u : Annuler la dernière commande.

  • U : Annuler tous les changements sur une ligne.

  • CTRL-R : Annuler l'annulation.

Copier/Coller

  • y

  • Y

  • p : Coller à l'endroit du curseur.

  • r

  • v0$y : Copier la ligne en mode visuel

Rechercher

  • / : Rechercher une occurrence

  • %

Mode insertion

Ce mode est invoqué par une des commandes :

  • i : insère des caractères après le curseur.

  • A : ajoute des caractères à la fin d'une ligne où que soit positionné le curseur.

  • o

  • a

Fichier

  • :q! : Quitter sans enregistrer.

  • :x : Quitter en enregistrant.

  • :w : Enregistrer.

  • :w nomdefichier : Enregistrer sous un nom.

Remplacer

  • :s/aa/bb : Remplacer sur une ligne.

  • :s/aa/bb/g : Tout remplacer sur une ligne.

  • :#25,#30s/aa/bb/g : Remplacer du texte de la ligne 25 à 30.

  • :%s/aa/bb/g : Remplacer toutes les occurrences dans le fichier.

  • :%s/aa/bb/gc : Remplacer toutes les occurrences dans le fichier avec confirmation.

8.6. vi par la pratique

vimtutor (à télécharger) vous permet d’apprendre vi par la pratique en 7 leçons :

  1. Déplacer le curseur, sortir de vim, effacer, insérer et ajouter du texte, éditer un fichier.
  2. Commandes d’effacement, opérateur et mouvement, quantificateur et effacement, opération sur les lignes, annulation.
  3. Collage, remplacement, opérateur de changement.
  4. Position du curseur et état du fichier, recherche, substitution
  5. Enregistrement de fichiers, d’extraits de fichiers, récupération et fusion de fichiers.
  6. Ouverture, ajout, remplacement, copier/coller
  7. Aide, script de démarrage et complétion

results matching ""

    No results matching ""