Modifier des fichiers texte sous Red Hat Enterprise Linux : Guide Complet

Introduction

Dans ce laboratoire, vous acquerrez des compétences essentielles pour la gestion des fichiers texte et la personnalisation de votre environnement shell sous Linux. Vous apprendrez à rediriger les flux de sortie standard et d'erreur vers des fichiers, à combiner différents flux et à construire des pipelines de commandes puissants pour automatiser des tâches.

De plus, vous explorerez les bases de l'édition de fichiers texte à l'aide de Vim, un éditeur de texte largement utilisé et puissant. Enfin, vous apprendrez à configurer et à utiliser des variables et des alias shell pour personnaliser votre expérience en ligne de commande et améliorer votre productivité.

Redirection de la sortie standard vers des fichiers

Dans cette étape, vous apprendrez à rediriger la sortie standard des commandes vers des fichiers. Il s'agit d'une compétence fondamentale en administration système Linux, qui vous permet de capturer les résultats des commandes pour une analyse ultérieure, la journalisation ou un traitement supplémentaire.

Le shell utilise des descripteurs de fichiers spéciaux pour gérer l'entrée et la sortie. Les plus courants sont :

0 : Entrée standard (stdin) - Généralement en provenance du clavier.
1 : Sortie standard (stdout) - Généralement vers l'écran du terminal.
2 : Erreur standard (stderr) - Généralement vers l'écran du terminal pour les messages d'erreur.

Nous nous concentrerons sur la redirection de stdout dans cette section.

Écrasement d'un fichier avec `>`

L'opérateur > redirige la sortie standard d'une commande vers un fichier spécifié. Si le fichier n'existe pas, il sera créé. Si le fichier existe déjà, son contenu sera écrasé.

Commençons par créer un simple fichier texte avec la date et l'heure actuelles.

Tout d'abord, assurez-vous d'être dans le dossier project de votre répertoire personnel.
```
cd ~/project
```
```
[labex@host project]$
```
Maintenant, utilisez la commande date et redirigez sa sortie vers un nouveau fichier nommé current_datetime.txt.
```
date > current_datetime.txt
```
Cette commande exécutera date, mais au lieu d'imprimer la date sur votre terminal, elle l'enregistrera dans current_datetime.txt.
Vérifiez le contenu du fichier à l'aide de la commande cat.
```
cat current_datetime.txt
```
```
Mon Day XX HH:MM:SS AM/PM TimeZone YYYY
```
La sortie affichera la date et l'heure actuelles, similaires à l'exemple ci-dessus.
Maintenant, essayons de rediriger la sortie de echo vers le même fichier. Cela écrasera le contenu précédent.
```
echo "This is a new line of text." > current_datetime.txt
```
Vérifiez à nouveau le contenu du fichier.
```
cat current_datetime.txt
```
```
This is a new line of text.
```
Comme vous pouvez le constater, la date et l'heure d'origine ont été remplacées par la nouvelle ligne de texte.

Ajout à un fichier avec `>>`

L'opérateur >> redirige la sortie standard d'une commande vers un fichier spécifié, en ajoutant le nouveau contenu à la fin du fichier. Si le fichier n'existe pas, il sera créé.

Ajoutons plus de contenu à notre fichier current_datetime.txt.

Ajoutez une autre ligne de texte à current_datetime.txt.
```
echo "This line is appended." >> current_datetime.txt
```
Affichez le contenu du fichier.
```
cat current_datetime.txt
```
```
This is a new line of text.
This line is appended.
```
Notez que la nouvelle ligne a été ajoutée après le contenu existant.
Ajoutons à nouveau la date et l'heure actuelles.
```
date >> current_datetime.txt
```

Vérifiez le contenu du fichier une fois de plus.

cat current_datetime.txt

This is a new line of text.
This line is appended.
Mon Day XX HH:MM:SS AM/PM TimeZone YYYY

La date et l'heure sont maintenant à la fin du fichier.

Redirection de la sortie d'autres commandes

Vous pouvez rediriger la sortie de presque n'importe quelle commande. Essayons de rediriger la sortie de ls et wc.

Redirigez la sortie de ls -l (format de liste longue) vers un fichier nommé file_list.txt.
```
ls -l > file_list.txt
```
Inspectez le contenu de file_list.txt.
```
cat file_list.txt
```
```
total 4
-rw-r--r-- 1 labex labex 80 Jun  4 07:04 current_datetime.txt
-rw-r--r-- 1 labex labex  0 Jun  4 07:04 file_list.txt
```
Ce fichier contient maintenant la liste détaillée des fichiers de votre répertoire actuel. Les tailles et horodatages exacts des fichiers varieront en fonction du moment où vous exécutez les commandes.
Maintenant, comptons le nombre de lignes dans file_list.txt en utilisant wc -l et redirigeons ce compte vers un autre fichier, line_count.txt.
```
wc -l file_list.txt > line_count.txt
```
Affichez le contenu de line_count.txt.
```
cat line_count.txt
```
```
3 file_list.txt
```
La sortie montre que file_list.txt contient 3 lignes (y compris la ligne total et les deux entrées de fichier).

Ceci conclut la première partie de la redirection de la sortie standard. Vous avez appris à créer et à écraser des fichiers en utilisant > et à les compléter en utilisant >>.

Redirection de l'erreur standard et combinaison des flux

Dans cette étape, vous apprendrez à rediriger l'erreur standard (stderr) et à combiner stdout et stderr en un seul flux. Ceci est crucial pour gérer les messages d'erreur générés par les commandes, vous permettant de les enregistrer ou de les ignorer selon vos besoins.

Rappelons que stderr est le descripteur de fichier 2. Nous utilisons 2> pour rediriger les messages d'erreur.

Redirection de l'erreur standard vers un fichier

Parfois, les commandes produisent des messages d'erreur que vous souhaitez capturer séparément de leur sortie standard.

Assurez-vous d'être dans votre répertoire ~/project.
```
cd ~/project
```
```
[labex@host project]$
```
Essayons de lister le contenu d'un répertoire inexistant. Cela générera un message d'erreur.
```
ls non_existent_directory
```
```
ls: cannot access 'non_existent_directory': No such file or directory
```
Vous pouvez voir le message d'erreur imprimé directement sur le terminal.
Maintenant, redirigeons ce message d'erreur vers un fichier nommé errors.log.
```
ls non_existent_directory 2> errors.log
```
Cette fois, vous ne verrez pas le message d'erreur sur votre terminal.
Vérifiez le contenu de errors.log.
```
cat errors.log
```
```
ls: cannot access 'non_existent_directory': No such file or directory
```
Le message d'erreur est maintenant stocké dans le fichier.

Ignorer l'erreur standard

Souvent, vous voudrez peut-être exécuter une commande qui produit des messages d'erreur bruyants dont vous ne vous souciez pas. Dans de tels cas, vous pouvez rediriger stderr vers /dev/null. /dev/null est un fichier de périphérique spécial qui ignore toutes les données qui y sont écrites.

Essayez à nouveau la commande ls avec le répertoire inexistant, mais cette fois, ignorez l'erreur.
```
ls non_existent_directory 2> /dev/null
```
Vous ne verrez aucune sortie sur le terminal, et aucun message d'erreur n'est enregistré dans un fichier.

Combinaison de la sortie standard et de l'erreur standard

Il existe des situations où vous souhaitez capturer à la fois stdout et stderr dans le même fichier. Cela peut être fait de plusieurs façons.

Méthode 1 : `> file 2>&1`

Cette méthode redirige stdout vers un fichier, puis redirige stderr vers le même emplacement que stdout. L'ordre 2>&1 est important : cela signifie "rediriger le descripteur de fichier 2 (stderr) vers le même endroit que le descripteur de fichier 1 (stdout)".

Créons une commande qui produit à la fois une sortie standard et une erreur standard. Nous utiliserons find pour rechercher un fichier dans un répertoire où nous avons des permissions et dans un répertoire où nous n'en avons pas.
```
find ~/project /root -name "current_datetime.txt" > combined_output.log 2>&1
```
Ici, find ~/project -name "current_datetime.txt" produira stdout (si trouvé), et find /root -name "current_datetime.txt" produira probablement stderr en raison de problèmes de permissions.
Examinez le fichier combined_output.log.
```
cat combined_output.log
```
```
/home/labex/project/current_datetime.txt
find: ‘/root’: Permission denied
```
Vous pouvez voir que la sortie réussie (le chemin d'accès au fichier) et le message d'erreur sont capturés dans le même fichier.

Méthode 2 : `&> file` (Spécifique à Bash)

Bash fournit une abréviation pour combiner stdout et stderr dans un fichier : &>. Ceci est équivalent à > file 2>&1.

Essayons la même commande find en utilisant l'abréviation &>.

find ~/project /root -name "file_list.txt" &> combined_output_shorthand.log

Vérifiez le contenu de combined_output_shorthand.log.
```
cat combined_output_shorthand.log
```
```
/home/labex/project/file_list.txt
find: ‘/root’: Permission denied
```
Le résultat est le même que la méthode précédente, démontrant la commodité de &>.

Ajout de flux combinés

Tout comme avec stdout, vous pouvez ajouter stdout et stderr combinés à un fichier en utilisant >> file 2>&1 ou &>> file.

Ajoutez plus de sortie et d'erreurs à combined_output.log.

find ~/project /root -name "line_count.txt" >> combined_output.log 2>&1

Affichez le combined_output.log mis à jour.

cat combined_output.log

/home/labex/project/current_datetime.txt
find: ‘/root’: Permission denied
/home/labex/project/line_count.txt
find: ‘/root’: Permission denied

La nouvelle sortie et les erreurs sont ajoutées au contenu existant.

Vous avez maintenant appris avec succès comment rediriger l'erreur standard et comment combiner la sortie standard et l'erreur standard dans un seul fichier. Cette connaissance est essentielle pour des tâches de script et d'administration système robustes.

Construire et comprendre les pipelines de commandes

Dans cette étape, vous découvrirez les pipelines de commandes, une fonctionnalité puissante du shell Linux qui vous permet d'enchaîner plusieurs commandes. La sortie d'une commande devient l'entrée de la suivante, ce qui permet un traitement et une manipulation complexes des données.

L'opérateur pipe | (barre verticale) est utilisé pour connecter les commandes dans un pipeline. Il redirige la sortie standard (stdout) de la commande à sa gauche vers l'entrée standard (stdin) de la commande à sa droite.

Pipelines de base

Commençons par un exemple simple pour comprendre le fonctionnement des pipelines.

Assurez-vous d'être dans votre répertoire ~/project.
```
cd ~/project
```
```
[labex@host project]$
```

Tout d'abord, listons les fichiers du répertoire courant.

ls

combined_output.log
combined_output_shorthand.log
current_datetime.txt
errors.log
file_list.txt
line_count.txt

Maintenant, canalisons la sortie de ls vers la commande wc -l, qui compte le nombre de lignes qu'elle reçoit.
```
ls | wc -l
```
```
6
```
La commande ls liste les fichiers, et sa sortie (chaque nom de fichier sur une nouvelle ligne) est fournie en entrée à wc -l, qui compte ensuite ces lignes, vous indiquant ainsi le nombre de fichiers/répertoires à l'emplacement actuel.
Essayons un autre cas d'utilisation courant : canaliser ls -l vers less pour une sortie paginée. Ceci est utile lorsqu'une commande produit trop de sortie pour tenir sur un seul écran.
```
ls -l /usr/bin | less
```
```
total 200000
-rwxr-xr-x 1 root root 12345 Jan XX HH:MM [filename]
... (press 'q' to quit less) ...
```
La commande ls -l /usr/bin liste tous les fichiers dans /usr/bin avec des informations détaillées. Cette sortie est ensuite envoyée à less, vous permettant de faire défiler la liste page par page. Appuyez sur q pour quitter less.

Filtrage de la sortie avec `grep`

La commande grep est souvent utilisée dans les pipelines pour filtrer les lignes qui correspondent à un motif spécifique.

Listons tous les processus en cours d'exécution sur le système à l'aide de ps aux, puis filtrons les processus liés à bash.
```
ps aux | grep bash
```
```
labex     1234  0.0  0.1  12345  6789 ?        Ss   HH:MM   0:00 /usr/bin/bash
labex     5678  0.0  0.0   9876  5432 pts/0    S+   HH:MM   0:00 grep bash
```
La commande ps aux liste tous les processus en cours d'exécution. Sa sortie est canalisée vers grep bash, qui affiche ensuite uniquement les lignes contenant le mot "bash". Vous pouvez voir deux lignes : une pour votre shell bash actuel et une pour la commande grep elle-même.
Pour exclure la commande grep de la sortie, vous pouvez utiliser grep -v (inverser la correspondance) ou affiner votre motif. Essayons grep -v grep.
```
ps aux | grep bash | grep -v grep
```
```
labex     1234  0.0  0.1  12345  6789 ?        Ss   HH:MM   0:00 /usr/bin/bash
```
Maintenant, seul le processus bash réel est affiché.

Utilisation de `sort` et `uniq`

sort est utilisé pour trier les lignes de texte, et uniq est utilisé pour signaler ou omettre les lignes répétées. Ils sont souvent utilisés ensemble.

Créons un fichier avec des mots non triés et répétés.

echo -e "apple\nbanana\napple\norange\nbanana" > fruits.txt

Affichez le contenu de fruits.txt.

cat fruits.txt

apple
banana
apple
orange
banana

Maintenant, trions les lignes dans fruits.txt.

cat fruits.txt | sort

apple
apple
banana
banana
orange

Pour obtenir uniquement les mots triés uniques, canalisez la sortie de sort vers uniq.
```
cat fruits.txt | sort | uniq
```
```
apple
banana
orange
```
Ce pipeline trie d'abord les lignes, puis uniq supprime les lignes adjacentes en double.

La commande `tee`

La commande tee est spéciale dans les pipelines. Elle lit l'entrée standard, l'écrit sur la sortie standard et l'écrit simultanément dans un ou plusieurs fichiers. C'est comme un raccord en "T" dans un tuyau, permettant aux données de circuler dans deux directions.

Listons les fichiers et enregistrons la sortie dans ls_output.txt tout en l'affichant également à l'écran.

ls -l | tee ls_output.txt

total 24
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM combined_output.log
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM combined_output_shorthand.log
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM current_datetime.txt
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM errors.log
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM file_list.txt
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM fruits.txt
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM line_count.txt
-rw-r--r-- 1 labex labex 0 Jan XX HH:MM ls_output.txt

Vous verrez la sortie de ls -l sur votre terminal, et un fichier nommé ls_output.txt sera créé avec le même contenu.

Vérifiez le contenu de ls_output.txt.

cat ls_output.txt

total 24
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM combined_output.log
... (same as above) ...

Vous pouvez également utiliser tee -a pour ajouter la sortie à un fichier.
```
echo "--- End of list ---" | tee -a ls_output.txt
```
```
--- End of list ---
```
La ligne "--- End of list ---" est imprimée sur le terminal et ajoutée à ls_output.txt.

Vérifiez le ls_output.txt mis à jour.

cat ls_output.txt

total 24
... (previous ls -l output) ...
--- End of list ---

Les pipelines sont incroyablement polyvalents et constituent l'épine dorsale de nombreux scripts shell et commandes en une seule ligne puissants. En combinant des commandes simples, vous pouvez effectuer des transformations de données complexes de manière efficace.

Modifier des fichiers texte avec les bases de Vim

Dans cette étape, vous apprendrez les opérations fondamentales de Vim, un éditeur de texte puissant et largement utilisé dans l'environnement Linux. Vim fonctionne en différents modes, ce qui peut être un peu difficile pour les débutants, mais maîtriser les bases augmentera considérablement votre productivité.

Vim est un éditeur modal, ce qui signifie qu'il possède différents modes pour différentes tâches :

Mode Normal (Mode Commande) : C'est le mode par défaut lorsque vous ouvrez Vim. Dans ce mode, les frappes sont interprétées comme des commandes (par exemple, déplacer le curseur, supprimer du texte, copier du texte).
Mode Insertion : Dans ce mode, tout ce que vous tapez est inséré dans le fichier. Vous entrez en mode Insertion depuis le mode Normal en appuyant sur i (insérer au curseur), a (ajouter après le curseur), o (ouvrir une nouvelle ligne en dessous), etc. Pour revenir au mode Normal, appuyez sur Esc.
Mode Visuel : Ce mode vous permet de sélectionner des blocs de texte pour des opérations telles que la copie, la coupe ou la suppression. Vous entrez en mode Visuel depuis le mode Normal en appuyant sur v (caractère par caractère), Maj+V (ligne par ligne) ou Ctrl+V (bloc par bloc). Appuyez sur Esc pour revenir au mode Normal.
Mode Ligne de commande (Mode Ex) : Ce mode est utilisé pour exécuter des commandes qui commencent généralement par un deux-points (:), telles que l'enregistrement (:w), la sortie (:q) ou la recherche (/). Vous entrez dans ce mode depuis le mode Normal en appuyant sur :.

Assurez-vous d'être dans votre répertoire ~/project.
```
cd ~/project
```
```
[labex@host project]$
```
Ouvrez un nouveau fichier nommé my_document.txt en utilisant vim.
```
vim my_document.txt
```
Votre terminal affichera maintenant l'interface Vim. Vous êtes en Mode Normal.
En mode Normal, vous pouvez naviguer en utilisant les touches fléchées ou h (gauche), j (bas), k (haut), l (droite). Puisque le fichier est vide, il n'y a pas grand-chose à naviguer pour le moment.

Mode Insertion : Ajout de texte

Pour commencer à taper, vous devez entrer en Mode Insertion. Appuyez sur i (pour insérer). Vous devriez voir -- INSERT -- en bas à gauche de votre terminal, indiquant que vous êtes en mode Insertion.

Tapez les lignes suivantes :

This is the first line.
This is the second line.
This is the third line.

Pour quitter le mode Insertion et revenir au mode Normal, appuyez sur la touche Esc. L'indicateur -- INSERT -- devrait disparaître.

Enregistrement et sortie

En mode Normal, pour enregistrer le fichier, tapez :w et appuyez sur Entrée.
```
:w
```
Vous devriez voir my_document.txt [New] 3L, 60B written en bas, confirmant l'enregistrement.
Pour quitter Vim, tapez :q et appuyez sur Entrée.
```
:q
```
Vous serez renvoyé à votre invite de commande shell.

Vérifiez le contenu de my_document.txt en utilisant cat.

cat my_document.txt

This is the first line.
This is the second line.
This is the third line.

Modification des fichiers existants

Ouvrez my_document.txt à nouveau.
```
vim my_document.txt
```
En mode Normal, déplacez votre curseur au début de la deuxième ligne (en utilisant j ou les touches fléchées).
Appuyez sur Maj+V pour entrer en Mode Visuel Ligne. L'intégralité de la deuxième ligne sera mise en surbrillance.
Appuyez sur y pour "yank" (copier) la ligne sélectionnée.
Déplacez votre curseur à la fin de la troisième ligne (en utilisant j ou les touches fléchées).
Appuyez sur p pour "put" (coller) la ligne yankée en dessous de la ligne actuelle. La deuxième ligne apparaîtra maintenant à nouveau comme la quatrième ligne.
Maintenant, supprimons une ligne. Déplacez votre curseur sur la quatrième ligne (celle que vous venez de coller).
Appuyez sur dd (double d) pour supprimer l'intégralité de la ligne.
Pour annuler votre dernière modification, appuyez sur u. La ligne supprimée réapparaîtra.
Pour enregistrer et quitter en une seule commande, tapez :wq et appuyez sur Entrée.
```
:wq
```
Vérifiez à nouveau le contenu de my_document.txt.
```
cat my_document.txt
```
```
This is the first line.
This is the second line.
This is the third line.
This is the second line.
```
Le fichier devrait maintenant avoir quatre lignes, avec la deuxième ligne dupliquée.

Rejet des modifications

Parfois, vous apportez des modifications et décidez que vous ne souhaitez pas les enregistrer.

Ouvrez my_document.txt à nouveau.
```
vim my_document.txt
```
Entrez en mode Insertion en appuyant sur i.
Ajoutez une nouvelle ligne à la fin :
```
This line should not be saved.
```
Appuyez sur Esc pour revenir au mode Normal.
Essayez de quitter en utilisant :q.
```
:q
```
Vim vous avertira : E37: No write since last change (add ! to override). Cela signifie que vous avez des modifications non enregistrées.
Pour quitter sans enregistrer, tapez :q! et appuyez sur Entrée.
```
:q!
```
Vous serez renvoyé à l'invite de commande shell, et vos modifications seront rejetées.

Vérifiez le contenu de my_document.txt.

cat my_document.txt

This is the first line.
This is the second line.
This is the third line.
This is the second line.

La dernière ligne que vous avez ajoutée ne devrait pas être présente.

Vous avez maintenant couvert les opérations de base de Vim : ouvrir des fichiers, insérer du texte, naviguer, enregistrer, quitter et rejeter les modifications. Ce sont les compétences essentielles pour commencer avec Vim.

Configurer et utiliser les variables et alias shell

Dans cette étape, vous apprendrez à configurer et à utiliser les variables et les alias shell. Ce sont des fonctionnalités puissantes qui vous permettent de personnaliser votre environnement shell, de stocker des données et de créer des raccourcis pour les commandes fréquemment utilisées, améliorant ainsi considérablement votre efficacité en ligne de commande.

Variables shell

Les variables shell sont des entités nommées qui stockent des données. Elles peuvent stocker des nombres, du texte ou d'autres données qui peuvent être utilisées par le shell ou par les programmes exécutés dans le shell.

Assurez-vous d'être dans votre répertoire ~/project.
```
cd ~/project
```
```
[labex@host project]$
```
Définition d'une variable locale : Créons une variable simple nommée MY_MESSAGE.
```
MY_MESSAGE="Hello, LabEx!"
```
Notez qu'il n'y a pas d'espaces autour du signe =.
Accès à une variable : Pour accéder à la valeur d'une variable, vous devez préfixer son nom avec un signe $.
```
echo $MY_MESSAGE
```
```
Hello, LabEx!
```
Expansion de variable avec des accolades : Parfois, vous devez délimiter clairement le nom de la variable, en particulier lorsqu'il est suivi d'autres caractères. Utilisez des accolades {} pour cela.
```
echo "The message is: ${MY_MESSAGE}."
```
```
The message is: Hello, LabEx!.
```
Si vous omettez les accolades, le shell pourrait interpréter MY_MESSAGE. comme le nom de la variable, qui n'existe pas.
Liste de toutes les variables définies : Vous pouvez utiliser la commande set pour lister toutes les variables et fonctions shell actuellement définies. Cette sortie peut être très longue, elle est donc souvent canalisée vers less.
```
set | less
```
```
BASH=/usr/bin/bash
BASHOPTS=checkwinsize:cmdhist:complete_fullquote:expand_aliases:extglob:extquote:force_fignore:histappend:interactive_comments:progcomp:promptvars:sourcepath
... (press 'q' to quit less) ...
```
Appuyez sur q pour quitter less.
Suppression d'une variable : Pour supprimer une variable, utilisez la commande unset.
```
unset MY_MESSAGE
```
Vérifiez que la variable n'est plus définie.
```
echo $MY_MESSAGE
```
Vous devriez voir une ligne vide, indiquant que la variable est supprimée.

Variables d'environnement

Les variables d'environnement sont un type spécial de variable shell qui sont héritées par les processus enfants. Cela signifie que tout programme ou script lancé à partir de votre shell actuel aura accès à ces variables. Elles sont généralement utilisées pour configurer l'environnement des applications.

Définition d'une variable d'environnement : Utilisez la commande export pour faire d'une variable une variable d'environnement.
```
export EDITOR=vim
```
Cela définit la variable d'environnement EDITOR, que de nombreux programmes utilisent pour déterminer votre éditeur de texte préféré.
Liste des variables d'environnement : Utilisez la commande env pour lister uniquement les variables d'environnement.
```
env | grep EDITOR
```
```
EDITOR=vim
```
Annulation de l'export d'une variable : Vous pouvez annuler l'export d'une variable sans la supprimer en utilisant export -n. Cela en fait à nouveau une variable locale.
```
export -n EDITOR
```
Vérifiez qu'elle n'est plus une variable d'environnement.
```
env | grep EDITOR
```
Vous ne devriez voir aucune sortie. Cependant, c'est toujours une variable locale :
```
echo $EDITOR
```
```
vim
```
Pour la supprimer complètement, utilisez unset.
```
unset EDITOR
```

Alias shell

Les alias sont des raccourcis pour les commandes. Ils vous permettent de définir une nouvelle commande qui se développe en une commande plus longue ou une séquence de commandes. Ceci est très utile pour les commandes fréquemment utilisées avec de nombreuses options.

Création d'un alias : Créons un alias pour ls -l pour le rendre plus court.
```
alias ll='ls -l'
```
Notez les guillemets simples autour de la commande pour vous assurer qu'elle est traitée comme une seule chaîne.

Utilisation d'un alias : Maintenant, vous pouvez simplement taper ll au lieu de ls -l.

ll

total 24
-rw-r--r-- 1 labex labex 123 Jan XX HH:MM combined_output.log
... (output of ls -l) ...

Liste des alias : Utilisez la commande alias sans aucun argument pour voir tous les alias définis.
```
alias
```
```
alias ll='ls -l'
```
Vous pourriez voir d'autres alias par défaut en fonction de la configuration de votre shell.
Création d'un alias plus complexe : Vous pouvez également créer des alias pour les commandes avec des arguments ou plusieurs commandes.
```
alias myip='ip a | grep "inet " | grep -v "127.0.0.1" | awk "{print \$2}" | cut -d/ -f1'
```
Ici, myip affichera votre adresse IP principale. Notez le \$2 pour échapper au signe $ afin qu'il soit transmis à awk et non interprété par le shell lors de la définition de l'alias.
Testez l'alias myip.
```
myip
```
```
172.17.0.2
```
(Votre adresse IP peut varier)
Suppression d'un alias : Pour supprimer un alias, utilisez la commande unalias.
```
unalias ll
```

Vérifiez que l'alias est supprimé.

alias

alias myip='ip a | grep "inet " | grep -v "127.0.0.1" | awk "{print \$2}" | cut -d/ -f1'

ll ne devrait plus être dans la liste.

Les variables et alias shell sont temporaires et seront perdus lorsque vous fermerez votre session de terminal. Pour les rendre permanents, vous devez les ajouter aux fichiers de configuration de votre shell (par exemple, ~/.bashrc ou ~/.profile), ce qui sera abordé dans des sujets plus avancés.

Résumé

Dans ce laboratoire, vous avez acquis des compétences fondamentales en ligne de commande Linux, essentielles pour la gestion des fichiers texte et de l'environnement shell. Vous avez commencé par maîtriser la redirection de sortie, en utilisant spécifiquement > pour écraser les fichiers et >> pour ajouter du contenu, ce qui vous permet de capturer les résultats des commandes pour la journalisation ou un traitement ultérieur. Vous avez également exploré la redirection de l'erreur standard (2>) et la combinaison de la sortie standard et de l'erreur (&>) pour gérer efficacement toutes les sorties de commandes.

De plus, vous avez acquis une maîtrise de la construction et de la compréhension des pipelines de commandes en utilisant l'opérateur |, ce qui vous permet d'enchaîner les commandes et de traiter les données de manière séquentielle. Vous avez été initié à l'édition de texte de base avec Vim, couvrant les commandes essentielles pour insérer, enregistrer et quitter des fichiers. Enfin, vous avez appris à configurer et à utiliser les variables shell pour stocker des données et à créer des alias pour simplifier les commandes fréquemment utilisées, améliorant ainsi votre efficacité et votre personnalisation en ligne de commande.

Modifier des fichiers texte sous Red Hat Enterprise Linux