Linux commandes de base grep sed flux cat pipes

 

Ce cours fait partie de l'ensemble Linux à voir ici, sur Linux les fondamentaux ici et linux les commandes des bases du shell ici , ensuite linux et les droits sur les fichiers , Linux les gestionnaires de paquets , Linux editeur nano , linux configurer dhcp server et client , linux configurer dns server et client , linux disque durs et partitions , linux disque durs et partitions avec LVM

 

 

Linux commandes de base grep sed flux pipes : grep

 

# Grep

Le logiciel grep est un outil indispensable tant pour l’administrateur système que pour le programmeur.

Il permet de parcourir des fichiers pour rechercher les lignes qui contiennent une expression rationnelle.

Voici sa syntaxe habituelle : ``grep [options] expression fichiers...``

## Les flags

* ``-E`` : les expressions régulières sont étendues ; par défaut, grep emploi des expressions rationnelles simples.
* ``-F`` : l’expression recherchée n’est pas une expression régulière mais une simple chaîne de caractères.
* ``-i`` : ignorer les différences entre majuscules et minuscules.
* ``-v`` : afficher les lignes qui ne contiennent pas l’expression rationnelle.
* `-o`: N'affiche que le résultat de l'expression régulière

```bash
$ grep root /etc/passwd
root:x:0:0:root:/root:/bin/bash
operator:x:11:0:operator:/root:/sbin/nologin
```

# Les expressions régulières

* Les expressions régulières se révèlent un support essentiel pour un bon nombre d’utilitaires Unix.
* Elles sont à la base de l’outil grep, que nous allons étudier dans ce chapitre, mais elles servent aussi de fondement pour les langages Sed et Awk
* Dans les expressions rationnelles simples, ces métacaractères sont : ``^ $ . [ ] * \ | ? { } +``

*animaux.txt*
```txt
chien
chat
cheveaux
koala
dauphin
balaine
escargot
```

Exemple de recherche sur ce fichier texte :

> ``^`` Début de ligne
```bash
$ grep ^ch animaux.txt
chien
chat
cheveaux
```

> ``$`` Fin de ligne
```bash
$ grep ot$ animaux.txt
escargot
```

> ``. (point)`` Un caractère quelconque de la chaine de caractère
```bash
$ grep ch..n animaux.txt
chien
```

> ``[liste_de_caractères]`` Un caractère cité dans la liste
```bash
$ grep [db]a animaux.txt
dauphin
balaine
```

> ``[^liste_de_caractères]`` Un caractère qui n'est pas cité dans la liste
```bash
$ grep ch[^i] animaux.txt
chat
cheveaux
```

> ``[a-z]`` Caractères minuscules de a à z.

> ``[0-9]`` Chiffres de 0 à 9.

> ``[a-e0-9]`` Lettres de « a » à « e » ou chiffres de 0 à 9.

> ``[^0-9]`` Chaîne ne contenant PAS de chiffres.
```bash
$ grep ch[a-e] animaux.txt
chat
cheveaux
```

> ``|`` Le caractère |, indique une alternative entre deux caractères.
```bash
$ grep 'chi\|cha' animaux.txt
chien
chat
```

> ``e+`` « e » doit apparaître au moins 1 fois.
```bash
$ grep 'e\+' animaux.txt
chien
cheveaux
balaine
escargot
```

> ``e{2}`` e doit appraître exactement 2 fois (ee)

> ``e{1,3}`` e doit appraître de 1 à 3 fois

> ``e{1,}`` e doit appraître au moins 1 fois

## Compter le nombre d'occurence avec grep

Vous pouvez ajoute `wc -l` à votre grep pour compter le nombre d'occurence :

```bash

grep 'e\+' animaux.txt | wc -l
4

```

 

 

 

 

 

 

 

  

Une question? Posez-la ici

Linux commandes de base grep sed flux pipes : sed

 

 

# Sed

Sed est un outil souvent mal connu des personnes récemment venues à l’informatique, et plus particulièrement au système Unix.

Cet utilitaire peut rendre de grands services au sein de scripts shell qui automatisent des tâches administratives, mais également pour manipuler des fichiers de texte, par exemple des pages HTML.

Le programme sed va agir sur les lignes d’un fichier de texte ou de son entrée standard, et fournir les résultats sur sa sortie standard. En conséquence, les instructions de manipulation doivent être fournies dans des fichiers de scripts indépendants, ou en ligne de commande. La syntaxe d’invocation est la suivante :

```bash
$ sed -e ’liste_d_instructions’ fichier_à_traiter
```
ou
```bash
$ sed -f fichier_script fichier_à_traiter
```

* Si aucun fichier à traiter n’est indiqué, sed attend les données sur son entrée standard.
* Lorsqu’on fournit directement les commandes sur la ligne, grâce à l’option -e, il est préférable de les inclure entre apostrophes simples, en raison de l’usage fréquent des caractères $, *, ?, etc., susceptibles d’être interprétés par le shell.
* Une option importante est également disponible : -n, avec laquelle sed fonctionne en mode silencieux, c’est-à-dire qu’il ne copie une ligne de texte de l’entrée standard vers la sortie standard que si on le lui demande explicitement, et non pas automatiquement comme c’est le cas par défaut. Nous détaillerons cela ultérieurement.

## Fonctionnement de Sed

* Lecture d’une ligne sur le flux d’entrée (jusqu’à ce qu’il rencontre un caractère de saut de ligne).
* Traitement de cette ligne en la soumettant à toutes les commandes rencontrées dans le fichier script.
* Affichage de la ligne résultante sur la sortie standard, sauf si sed est invoqué avec l’option –n.
* Passage à la ligne suivante, et ainsi de suite jusqu’à la fin du flux d’entrée standard.

## Utilisation de sed

Tous d'abord nous allons créer un fichier texte : `text.txt`

```txt
Bonjour,

Ceci est un fichier de test.
Ici la ligne numéro 4.

# ceci pourrait être un commentaire
Ici la ligne numéro 7.

Au revoir
```

Nous allons faire nos premiers tests en affichant les résultats de sed dans la console.

```bash
$ sed '' test.txt
Bonjour,

Ceci est un fichier de test.
Ici la ligne numéro 4.

# ceci pourrait être un commentaire
Ici la ligne numéro 7.

Au revoir
```
sed lancé avec un script vide renvoie simplement le contenu du fichier.

## Adressage
#### Adressage par ligne

Executez la commande `sed -e '4d; 7d' test.txt`

```bash
$ sed -e '4d; 7d' test.txt
Bonjour,

Ceci est un fichier de test.

# ceci pourrait être un commentaire

Au revoir
```

Ici, nous utilisons l'adressage par ligne. La commande `d (delete)` indique que l'on va supprimer la ligne.

**L'option `-e` permet de passer plusieurs commandes à la suite. Je pense que c'est une bonne habitude de l'ajouter de façon systématique.**

On peut aussi utiliser l'adressage par intervalle, comme ceci : `sed '4,7 d' test.txt`

```bash
$ sed '4,7 d' test.txt
Bonjour,

Ceci est un fichier de test.

Au revoir
```

Cette commande va effacer toutes les lignes comprises entre la ligne 4 et la ligne 7.

```bash
sed -re '/^$/d' test.txt
Bonjour,
Ceci est un fichier de test.
Ici la ligne numéro 4.
# ceci pourrait être un commentaire
Ici la ligne numéro 7.
Au revoir
```
Cette commande va effacer toutes les lignes vide.

#### Adressage par motif

On peut aussi utiliser des regex pour appliquer la commandes sur toutes les lignes ou le motif est trouvé.

```bash
$ sed '/^#/d' test.txt
Bonjour,

Ceci est un fichier de test.
Ici la ligne numéro 4.

Ici la ligne numéro 7.

Au revoir
```

`sed '/^#/ d' test.txt` supprimera toutes les lignes commençant par une dièse (le ^ est un métacaractère signifiant début de ligne).

On peut très bien aussi utiliser un adressage mixte, comme :

```bash
$ sed '/^#/,7 d' test.txt
Bonjour,

Ceci est un fichier de test.
Ici la ligne numéro 4.

Au revoir
```

## Mode silencieux

Il existe une autre façon d'utiliser sed, particulièrement intéressante. C'est l'utilisation en mode "silencieux", c'est-à-dire que sed ne doit afficher par défaut aucune ligne. Seules les lignes intéressantes seront affichées, avec la commande p (print). Pour passer en mode "silencieux", il faut utiliser l'option sed `-n`

```bash
$ sed -n '/Ici/p' test.txt
Ici la ligne numéro 4.
Ici la ligne numéro 7.
```

## Substitution, translittération

### Substitution

sed permet de remplacer du texte avec des regex. On peut utiliser la syntaxe habituelle, ou la syntaxe étendue avec `sed -r`

La substitution s'écrit comme ceci : `s/motif/substitut/`

Par défaut, elle s'effectue sur la première occurrence du motif, sauf si on lui ajoute l'option g comme ceci : `s/motif/substitut/g`

On peut aussi choisir l'occurrence voulue, avec par exemple `s/motif/substitut/2` pour la deuxième occurrence.

Exemple :

```bash
$ sed -re 's/^# *//' test1.txt
Bonjour,

Ceci est un fichier de test.
Ici la ligne numéro 4.

ceci pourrait être un commentaire
Ici la ligne numéro 7.

Au revoir
```
Cette commande décommente les lignes commentées (commençant par une dièse), et supprime les espaces en début de ligne (le * est un métacaractère signifiant 0 ou plus).

```bash
$ sed -re 's/o/i/g' test.txt
Binjiur,

Ceci est un fichier de test.
Ici la ligne numéri 4.

# ceci piurrait être un cimmentaire
Ici la ligne numéri 7.

Au reviir
```

Cette commande remplace tous les o par des i.

```bash
$ sed -re 's/ //g' test.txt
Bonjour,

Ceciestunfichierdetest.
Icilalignenuméro4.

#cecipourraitêtreuncommentaire
Icilalignenuméro7.

Aurevoir
```

Cette commande supprime tous les espaces

### Translittération

La translittération permet d'échanger certains caractères avec d'autres caractères.

On l'écrit comme ceci : `y/liste1/liste2/`

```bash
$ sed -re 'y/éèê/eee/' test.txt
Bonjour,

Ceci est un fichier de test.
Ici la ligne numero 4.

# ceci pourrait etre un commentaire
Ici la ligne numero 7.

Au revoir
```

Cette commande supprime les accents sur les e dans notre fichier test.txt.

## Commandes groupées

Sed permet de grouper les commandes avec des accolades. Cela permet de faire plus de choses dans une même commande.

```bash
$ sed -re 's/ //g;/^$/d' test.txt
Bonjour,
Ceciestunfichierdetest.
Icilalignenuméro4.
#cecipourraitêtreuncommentaire
Icilalignenuméro7.
Aurevoir
```

Cette commande supprime les espaces et les lignes blanches

Une question? Posez-la ici

Linux commandes de base grep sed flux pipes : flux

## Les flux

Chaque application lancée en Bash a les flux d'entrée/sortie :

* L'entrée standard, qui permet d'envoyer des données au programme : ``stdin``
* La sortie standard, qui est utilisée pour afficher les résultats d'un programme : ``stdout``
* La sortie standard des erreurs, qui permet d'afficher les messages correspondant aux erreurs survenues lors de l'exécution du programme : ``stderr```

**Par défaut les deux flux de sortie sont envoyés sur le terminal de l'utilisateur (écran) et l'entrée prend ses données depuis le clavier.**

Les trois flux standards peuvent être redirigés vers d'autres sources autres que le clavier ou l'écran. Par exemple, on peut ordonner à un processus de diriger sa sortie standard vers un fichier. Pour cela, les numéros des descripteurs de flux sont utilisés. Les outils pour réaliser ces redirections sont les suivants :

* ``>`` redirige le flux de sortie de la commande pour la placer dans un fichier. Par défaut, si rien n'est précisé, le flux redirigé est la sortie standard. *``>`` est équivalent à ``1>``. Pour rediriger la sortie d'erreur standard, on utilise ``2>``*.

*script.sh*
```bash
#!/bin/bash
echo "Salut"
```

```bash
$ ./script.sh > log
$ cat log
$ ./toto.sh
bash: ./toto.sh: Aucun fichier ou dossier de ce type
$ ./toto.sh 2> log
$ cat log
bash: ./toto.sh: Aucun fichier ou dossier de ce type
```

* ``<`` redirige le flux d'entrée de la commande pour la prendre dans un fichier

* ``>>`` redirige le flux de sortie de la commande pour l’ajouter à la fin d’un fichier existant.

*test.txt*
```txt
Bonjour à tous
```

```bash
$ echo "Au revoir" >> test.txt
$ cat test.txt
Bonjour à tous
Au revoir
```

Linux commandes de base grep sed flux pipes : cat

### Le cat tautologique

La commande cat recopie l'entrée standard sur la sortie standard. Pour quitter cette commande, utiliser la combinaison de touches CTRL D.
Par défaut, cat prend ses données en entrée ligne par ligne. Ce qui explique qu'à chaque fois que l'on tape entrée, les caractères inscrits sur l'entrée standard via le clavier sont recopiés sur la sortie standard. Cette commande peut prendre un fichier comme entrée standard.

On peut utiliser cat pour créer un fichier texte rapidement, en utilisant la redirection de la sortie standard vers un fichier :

```bash
$ cat > journal
> Bonjour axel
> Ça va ?
$ cat journal
Bonjour axel
Ça va ?
```

Souvent, dans les scripts bash, on utilise l'astuce suivante pour créer un fichier texte dynamiquement :

```bash
$ cat <<FIN > fichier
> Hey
> ça Va
> moi oui
> FIN
$ cat fichier
Hey
ça Va
moi oui
```

**Pour ajouter du contenu à un fichier, il suffit d'utiliser ``>>``.**

```bash
$ cat <<FIN >> fichier
> Au top
> FIN
$ cat fichier
Hey
ça Va
moi oui
Au top
```

## Concaténation dans un fichier

*fichier1.txt*
```txt
Bonjour à tous
```
*fichier2.txt*
```txt
Vous allez bien ?
```
```bash
$ cat fichier2.txt >> fichier1.txt
$ cat fichier1.txt
Bonjour à tous
Vous allez bien ?
```
*Avec une sortie d'erreur*
```bash
$ cat fichier_introuvable 2>> fichier1.txt
$ cat fichier1.txt
Bonjour à tous
Vous allez bien ?
cat: fichier_introuvable: No such file or directory

 

  

Une question? Posez-la ici

 

 

 

Linux commandes de base grep sed flux pipes : pipe

 

 

## Les pipes

Les pipes permettent de rediriger la sortie standard d'une commande vers l'entrée standard d'une autre commande.

```bash
commande1 | commande2
```

ou pour connecter en plus la sortie d'erreur de la commande1 sur l'entrée de la commande2:

```bash
commande1 |& commande2
```

Exemple :

```bash
$ ls | grep *.sh
```
*Cette commande liste tous les fichiers d'un répertoire et ne selectionne que les fichiers ayant comme extension .sh*

 

 

 

 

Ce transcript reflète exclusivement l'opinion de ses auteurs et n’engage en aucune façon Consultingit

 

Besoin d'aides avec Linux??