Bash
Le shell Bash Linux
Bash, pour Bourne Again Shell a été créé par Brian Fox en 1989. Il s'est inspiré du Bourne Shell créé par Steve Bourne en 1977, d'où le jeu de mot avec Born Again. Il peut être aussi écrit dans un script shell avec l'extension .sh et lancé avec la commande bash.
Commencer
Prérequis avant de commencer
Dans ce chapitre, nous allons voir comment installer et lancer Linux sous Windows, tester notre première commande et utiliser l'aide bash.
Environnement
Mon environnement de développement
J'utilise WSL2 sous Windows 10 sur mon ordinateur personnel et l'émulateur MobaXterm pour me connecter au serveur Linux au travail.
Installation
Linux sous Windows 10
Installer d'abord le pilote GPU pour WSL selon votre processeur ou carte graphique pour prendre en charge les applications linux GUI puis installer WSL2.
Lien vers le tuto avec les pilotes GPU WSL
Lien vers la page d'installation WSL2
Lancement
Sous Windows 10 avec WSL
Dans un terminal powershell, taper la commande suivante en précisant vore distribution linux.
-
> wsl --distribution Ubuntu-20.04 $
Le terminal
L'interface utilisateur Linux est une interface en ligne de commande (CLI en anglais).
L'utilisateur interagit avec la machine en mode texte en écrivant les commandes directement dans le terminal.
La fonction echo
La fonction echo affiche du texte.
Elle s'écrit echo mon texte.
Testons notre première commande, le fameux, echo "hello world"
-
> echo "Hello world!" Hello world!
L'historique des commandes
La commande history liste toutes ses anciennes commandes
L'option -w sauve l'historique dans un fichier.
L'option -r ajoute les commandes écrites dans un fichier à l'historique.
L'option -c efface l'historique.
Ctrl + r permet de rechercher une commande dans l'historique. A ressaisir pour remonter dans l'historique.
Les flèches haut et bas permettent de rappeler d'anciennes commandes.
Le caractère ! suivi du début d'une commande permet de l'exécuter.
!?file? permet d'exécuter la dernière commande contenant file.
En rajoutant :p à la fin on ne fait que la rappeler.
!! exécute à nouveau la dernière commande.
-
$ history -w my_history.txt $ history -r my_history.txt $ !ls $ !?file?:p $ !! $ history -c $ clear
La commande clear
La commande clear permet de placer la ligne de commande en haut de l'écran.
Elle s'écrit simplement clear
-
$ clear
Les raccourcis clavier et souris
Ils permettent d'être plus rapide dans le terminal
Les touches flèche haut et flèche bas permettent de rappeler les anciennes commandes.
Le double click gauche souris fait un copier et le click droit fait un coller
La touche tabulation autocomplète le texte que vous rentrez.
Les caractères spéciaux
Ils sont indispensables pour utiliser certaines commandes efficacement.
Le caractère . désigne le répertoire courant.
Les 2 caractères .. désignent le répertoire parent.
Le caractère ~ représente le home utilisateur.
Le caractère * signifie tout.
Le caractère ? désigne n'importe quel caractère.
Les caractères [] désigne un des caractères listés. Le caractère - permet de donner un intervalle. Par exemple [a-d] désigne les caractères a à d. Le caractère ! au début signigie ne contient pas.
Le caractère | (pipe) permet d'écrire plusieurs commandes à la suite en tenant compte du résultat précédant.
Le caractère $ permet d'utliser la valeur d'une variable ou la sortie d'une commande.
Le caractère \ permet d'hiniber le caractère spécial.
Suite d'instructions
Le caractère ; permet de lancer plusieurs commandes sur une même ligne.
Les commandes seront lancées en série, i.e. l'une après l'autre.
Pour cela, on tape ma_commande1;ma_commande2.
-
$ pwd;whoami /home/nicot3m nicot3m
Les commentaires
Il y a deux moyens pour rajouter des commentaires.
Les commentaires sont principalement utilisés dans les scripts pour commenter une partie qu'on ne veut pas exécuter ou bien pour donner des indications sur son code.
Une ligne de commentaires
Le caractère #
Le caractère # permet de d'ajouter une ligne de commentaires
-
$ # Une ligne de commentaire
Commentaires sur plusieurs lignes
l'instruction com
L'instruction <<com permet d'ajouter plusieurs_lignes de commentaires.
-
$ <<com > Commentaire > sur plusieurs lignes > com $
L'aide
Aide d'une commande directement dans le terminal
Il y plusieurs façons d'obtenir des informations sur une commande.
L'option help
L'option help fournit l'aide sur une commande
Elle s'écrit ma_commande --help
-
$ ls --help
La commande man
La commande man affiche la documentation interne d'une commande.
Elle s'écrit man ma_commande.
-
$ man ls
L'outil apropos
L'outil apropos permet de trouver une commande.
Il s'écrit apropos ma_commande.
-
$ apropos zip
La commande type
La commande type affiche le type d'une commande. Une command builtin est une commande interne.
Elle s'écrit type ma_commande.
-
$ type echo echo is a shell builtin
L'arborescence du système Linux
Pour se déplacer dans l'arborescence, gérer les fichiers et répertoires
Les répertoires
Les principales commandes sur les répertoires
Nous allons voir les commandes pwd, cd, mkdir, rm, ls pour connaître le chemin courant, changer de répertoire, créer un répertoire, le supprimer et lister son contenu.
La commande pwd
La commande pwd permet d'afficher le chemin courant
Elle s'écrit simplement pwd
-
$ pwd /home/nicot3m
La commande cd
La commande cd permet de changer le répertoire courant
cd répertoire_enfant permet de descendre dans l'arborescence
-
$ cd my_subfolder $ pwd /home/nicot3m/my_folder/my_subfolder
cd .. permet de remonter dans l'arborescence
-
$ $ cd .. $ pwd /home/nicot3m/my_folder
cd ou cd ~ permet de revenir dans son home
-
$ cd $ pwd /home/nicot3m
La commande mkdir
La commande mkdir permet de créer un répertoire
Elle s'écrit mkdir nouveau_répertoire
-
$ mkdir my_new_folder $ cd my_new_folder $ pwd /home/nicot3m/my_folder/my_new_folder
La commande rm
La commande rm permet de supprimer un répertoire
Elle s'écrit rm répertoire_à_supprimer.
Les options -rf permettent de supprimer récursivement sans confirmation.
-
$ rm -rf my_old_folder
La commande ls
La commande ls permet de lister le contenu d'un répertoire
Elle s'écrit ls + des options
Les options -last permettent de trier par date avec les droits de tous les fichiers.
L'option -h permet d'afficher les tailles de fichiers lisibles facilement.
L'option -p permet de lister les répertoires.
Le caractère * permet de lister tous les fichiers
-
$ ls -last $ ls -h $ ls -p $ ls *.txt my_file1.txt my_file2.txt
Les fichiers
Les principales commandes sur les fichiers
Nous allons voir les commandes touch, cp, mv, rm pour créer, copier, renommer, déplacer et supprimer un fichier.
Nous allons aussi voir les commandes grep et find pour rechercher du texte dans un fichier et pour chercher un fichier.
La commande touch
La commande touch permet de créer un fichier
Elle s'écrit touch nouveau_fichier
-
$ touch my_new_file.txt
La commande cp
La commande cp permet de copier un fichier
Pour copier un fichier vers un autre fichier, on écrit cp mon_fichier mon_fichier_copié.
-
$ cp my_file.txt my_copied_file.txt
Pour copier un fichier vers un répertoire, on écrit cp mon_fichier répertoire
On utilise le caractère ~ pour le répertoire home
-
$ cp my_file.txt my_sub_folder $ cp my_file.txt ~
La commande mv
La commande mv de renommer ou déplacer un fichier
Pour renommer un fichier, on écrit cp mon_fichier mon_nouveau_nom_de_fichier
-
$ mv my_file.txt my_new_file_name.txt
Pour déplacer un fichier vers un répertoire, on écrit mv mon_fichier répertoire
-
$ mv my_file.txt my_subfolder
La commande rm
La commande rm permet de supprimer un fichier
Pour supprimer un fichier, on écrit rm mon_ancien_fichier
-
$ rm my_old_file.txt
La commande grep
La commande grep permet de chercher du texte sous forme d'expression régulière (regex) dans un fichier.
Elle s'écrit grep texte_cherché mon_fichier
-
$ grep ananas my_file.txt ananas
La commande find
La commande find permet de chercher des fichiers.
Elle est récursive par défaut.
Plusieurs options peuvent être utilisées:
| Option | Description |
|---|---|
| -name | nom du fichier avec casse |
| -iname | nom du fichier sans casse |
| -maxdepth | niveau de récursivité |
| -size | la taille du fichier |
| -empty | fichier vide |
| -ctime | date de création en jours |
| -mtime | dates de modification en jours |
| -atime | date d'accès en jours |
| -user | propriétaire |
| -group | groupe |
| -perm | droits d'accès |
| -type d | répertoire |
| -and, -or, -not | et, ou, négation |
| -exec | exécuter une commande |
Voyons quelques exemples d'utilisation.
La commande suivante permet de chercher les fichiers texte commançant par my_file d'une taille de 1ko et créés il y a 30 jours ou bien les fichiers de type jpg appartenant à nicot3m
-
$ find . -name "my_file*.txt" -size +1k -ctime -30 -o -name "*.jpg" -user nicot3m ./my_file1.txt ./my_image.jpg
La commande suivante permet de chercher les fichiers my_file.txt contenant le texte ananas
-
$ find . -name "my_file.txt" -exec grep ananas {} \; ananas:30
La commande suivante permet de chercher les fichiers de type texte et d'afficher leur contenu
-
$ find . -name "*.txt" -exec cat {} \; my file1 content my file2 content
La commande suivante permet de chercher tous les fichiers de type op2 dans le répertoire courant et de les lister dans le fichier liste_op2.txt.
-
$ find . -name "*.op2" -maxdepth 1 > liste_op2.txt my file1 content my file2 content
Mon compte
Pour voir les informations sur son compte, ses droits, ses variables d'environnement, sa config, son historique.
L'utilisateur
Les informations sur son compte
Nous allons voir les commandes whoami, id et su.
La commande whoami
La commande whoami permet d'afficher l'utilisateur actif.
Elle s'écrit simplement whoami
-
$ whoami nicot3m
La commande id
La commande id permet d'afficher des informations sur son compte.
Elle s'écrit simplement id
-
$ id uid=1000(nicot3m) gid=1000(nicot3m) groups=1000(nicot3m)
La commande su
La commande su permet de se connecter à un autre compte.
Elle s'écrit simplement id
-
$ su nicot3m Password:
Mes droits
Les droits d'accès aux documents
Nous allons voir le principe des droits d'accès, les commandes chmod, chown et chgrp.
Le principe des droits d'accès
Linux permet de gérer les droits de chaque fichier ou répertoire.
Pour chaque document, il y a 10 caractères. Le premier indique le type (- pour fichier et d pour répertoire). Les 9 caractères suivants indiquent les droits.
| - | rwx | rwx | rwx |
|---|---|---|---|
| type | utilisateur | groupe | univers |
La commande chmod
La commande chmod permet de changer les droits d'un fichier.
Elle s'écrit avec 3 digits, le 1er pour l'utilisateur, le 2e pour le groupe et le 3e pour l'univers, avec 0 pour aucun droit et 7 pour tous les droits.
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
|---|---|---|---|---|---|---|---|
| --- | --x | -w- | -wx | r-- | r-x | rw- | rwx |
| aucun droit | exécution seul | écriture seul | écriture + exécution | lecture | lecture + exécution | lecture + écriture | tous les droits |
Essayons de faire un chmod 777 sur le fichier my_file.txt.
-
$ chmod 777 my_file.txt $ ls -l my_file.txt -rwxrwxrwx 1 nicot3m nicot3m 0 Feb 27 19:35 my_file.txt
La commande chown
La commande chmown permet de changer le propriétaire d'un fichier.
Elle s'écrit chown utilisateur mon_fichier.
-
$ chown new_user my_file.txt
La commande chgrp
La commande chgrp permet de changer le groupe d'un fichier.
Elle s'écrit chgrp groupe mon_fichier.
-
$ chgrp new_group my_file.txt
Les variables d'environnement
Les variables d'environnement sont des variables spéciales du système accessibles à tous les programmes.
Nous allons voir les variables prédéfinies, les commandes printenv et export.
Les variables d'environnement prédéfinies
Elles sont créées lors de l'installation du système ou de la création du compte.
Il existe plusieurs variables d'environnement prédéfinies.
| Nom | définition |
|---|---|
| $HOME | Répertoire personnel utilisateur |
| $PWD | Répertoire courant |
| $PATH | Liste des répertoires de commandes |
| $LOGNAME | Nom utilisateur à la connexion |
| $SHELL | Chemin du fichier bash utilisé à la connexion |
| $PS1 | Description du contenu de l'invite de commande |
La commande printenv
La commande printenv permet de lister les variables d'environnement.
Elle s'écrit simplement printenv.
-
$ printenv SHELL=/bin/bash WSL2_GUI_APPS_ENABLED=1 WSL_DISTRO_NAME=Ubuntu-20.04 ...
La commande set
La commande set sans argument permet de lister les variables d'environnement + les variables créees par l'utilisateur.
Dans ce cas, elle s'écrit simplement set.
-
$ set
La commande export
La commande export permet de définir une variable comme une variable d'environnement et donc de l'utiliser dans un sous shell.
Elle s'écrit simplement set export ma_variable.
-
$ echo $HOME /home/nicot3m $ my_path=$HOME/TEST $ export my_path $ printenv | grep my_path my_path=/home/nicot3m/TEST $ bash $ echo $my_path /home/nicot3m/TEST $ cd $my_path $ pwd $ PS1="\u @ \w - \d \t \$ " nicot3m @ /mnt/c/Users/nicot - Sat Mar 11 12:28:30 $
Les fichiers de configuration du bash
Il est possible de configurer son bash grâce aux fichiers de configuration.
Nous allons voir les fichiers .bashrc, .bash_aliases, .bash_history.
Le fichier .bashrc
Le fichier .bashrc et contient les variables d'environnement.
Il ne faut pas oublier de faire un export pour qu'elles soient prises en compte par le système. La commande source .bashrc permet de rafraîchir les variables d'environnement contenues dans le .bashrc
Le fichier .bash_aliases
Le fichier .bash_aliases contient les alias.
Les alias servent de raccourcis utilisateur.
Le fichier .bash_history
Le fichier .bash_history liste l'historique de toutes les commandes.
Le système
Pour voir les informations sur le système, le root et l'installation de paquets.
Les informations du système
Les informations sur son compte
Nous allons voir les commandes uname et lsb_release.
La commande uname
La commande uname affiche le système.
Elle s'écrit simplement uname pour le nom du noyau ou uname -a pour la sortie complète.
-
$ uname Linux
La commande lsb_release
La commande uname affiche la version de sa distribution Linux.
Elle s'écrit lsb_release -a pour la sortie complète.
-
$ lsb_release -a Description: Ubuntu 20.04.4 LTS
Le root
Le compte administrateur
Le "root" designe le compte système, ie l'administrateur qui est un super-utilisateur. Il possède le niveau de privilège le plus élevé et permet d'effectuer des tâches telles que l'installation de logiciels, la modification de fichiers système et la gestion des comptes utilisateurs. Par sécurité, l'accès direct au root est désactivé.
La commande sudo
Pour effectuer les tâches administratives
La commande sudo permet d'exécuter des commandes nécessitant les droits admin, ie les privilèges d'administration temporaires, sans avoir à se connecter directement au compte root. Il faut pour cela avoir un compte autorisé grâce au fichier de configuration sudoers. Elle s'utilise ainsi, sudo ma_commande. L'option -i permet d'ouvrir une session interactive avec les droits admin et d'effectuer plusieurs commandes. La commande exit permet de sortir du mode admin et de revenir à l'utilisateur de base.
-
$ sudo cat root_application.sh
Installation d'un logiciel
Nous allons voir les paquets et les gestionnaires de paquets.
Les paquets
Un paquet ou package, en anglais, est un fichier compressé contenant les fichiers nécessaires à l'installation d'un logiciel.
Un paquet peut contenir des fichiers binaires exécutables, des fichiers de configuration, des fichiers de documentation et des dépendances qui sont d'autres paquets ou bibliothèques dont ce sert le logiciel. Le tableau suivant présente quelques exemples de paquets couramment utilisés sous Linux.
| Nom | Type |
|---|---|
| firefox | Navigateur web open-source |
| chromium-browser | Navigateur web open-source |
| libreoffice | Éditeur d'images puissant et open-source |
| gimp | Nom utilisateur à la connexion |
| vlc | Lecteur multimédia polyvalent et open-source |
| openssh-server | Serveur SSH pour permettre des connexions sécurisées à distance. |
| apache2 | Serveur web Apache, souvent utilisé pour héberger des sites web. |
| mysql-server | Serveur de base de données MySQL |
| python3 | Langage de programmation populaire et puissant. |
Les gestionnaires de paquets
Ils servent à installer, mettre à jour et supprimer les logiciels sur une distribution Linux.
Les paquets sont généralement distribués sur des dépôts distants. Les gestionnaires de paquets permettent d'y accéder et de gérer les paquets sur le système grâce à des commandes pour l'installation, la mise à jour et la suppression. On peut citer APT et apt-get comme gestionnaires de paquets pour les distributions Linux Debian Ubuntu.
Le gestionnaire de paquet APT
APT pour Advanced Package Tool
La commande install permet d'installer un logiciel. Elle s'écrit sudo apt install mon_paquet. Voici un exemple pour installer firefox.
-
$ sudo apt install firefox
Le texte
Pour voir l'affichage dans le terminal, les éditeurs, manipuler du texte et les expressions régulières.
L'affichage
Afficher du texte dans le terminal
Nous allons voir les commandes cat, head, tail, more and less.
La commande cat
La commande cat permet d'afficher l'intégralité du contenu d'un fichier dans le terminal.
Elle s'écrit cat mon_fichier.
-
$ cat my_file.txt my complete file
La commande head
La commande head permet d'afficher les premières lignes d'un fichier dans le terminal.
Elle s'écrit cat mon_fichier.
-
$ head my_file.txt first lines of my_file
La commande tail
La commande tail permet d'afficher les dernières lignes d'un fichier dans le terminal.
Elle s'écrit tail mon_fichier. Dans l'expemple, l'option -2 permet d'afficher les 2 dernières lignes du fichier my_file.txt.
-
$ tail -2 my_file.txt last 2 lines
La commande more
La commande more permet d'afficher le contenu d'un fichier dans le terminal, page par page.
La flèche entrée permet de descendre dans le document et q de quitter. Elle s'écrit more mon_fichier.
-
$ more my_file.txt first lines of my_file another line --More-- (40%) ↵ --More-- (60%) q $
La commande less
La commande les permet aussi d'afficher le contenu d'un fichier dans le terminal, page par page.
Les flèches haut et bas permettent de monter et descendre dans le document et q de quitter. Elle s'écrit less mon_fichier.↓
-
$ less my_file.txt first lines of my_file ↓ another line :↓ :q $
Les éditeurs de texte
Afficher et modifier du texte dans le terminal ou en mode graphique
Nous allons voir les éditeurs nano, nedit et gedit.
L'éditeur nano
Nano est un éditeur de texte en ligne de commande simple et convivial.
En fonction du serveur sur lequel vous travaillez, il peut-être plus rapide d'éditer un fichier dans le terminal plutôt qu'en mode graphique. Pour ouvrir un fichier on écrira nano mon_fichier. Les raccourcis claviers sont rappelés en bas de la fenêtre. L'appostrophe désigne la touche Ctrl et le M désigne la touche Alt.
| Touches | Action |
|---|---|
| Alt+Shift+tiret | Copier |
| Ctrl+U | Coller |
| Ctrl+W | Chercher |
| Alt+U | Annuler |
| Ctrl+O | Sauver |
| Ctrl+X | Quitter |
L'éditeur nedit
Nedit pour Nirvana editor est un éditeur de texte en mode graphique.
C'est peut-être plus lent d'ouvir un gros fichier avec nedit mais d'un autre côté, si vous êtes habitué à travailler sous Windows, il vous sera plus familier. Pour ouvrir un fichier on écrira nedit mon_fichier. Le tableau présente les principaux raccourcis
| Touches | Action |
|---|---|
| Ctrl+A | Tout sélectionner |
| Ctrl+C | Copier |
| Ctrl+V | Coller |
| Ctrl+F | Chercher (cocher la case Keep Dialog) |
| Ctrl+S | Sauver |
| Ctrl+S | Quitter |
L'éditeur gedit
L'éditeur gedit est un éditeur de texte en mode graphique fourni avec GNOME.
Il propose une meilleur expérience utilisateur que nedit car il est paraît plus fluide et plus esthétique. Les raccourcis claviers principaux sont les mêmes que nedit Il est plus adapté pour les scripts. Pour ouvrir un fichier on écrira gedit mon_fichier.
Manipulation de texte
Trier, compter, joindre du texte.
Nous allons voir les commandes sort, rev, count, cut ,unique, join, awk et tr.
La commande sort
La commande sort permet d'afficher le contenu d'un fichier avec les lignes triées.
Elle s'écrit sort -option mon_fichier.
Les options sont présentées dans le tableau suivant.
| Option | Action |
|---|---|
| -r | Trier dans le sens inverse |
| -k | Trier le énième champs |
| -t | Changer le séparateur de champs |
| -n | Trier numériquement |
Dans les exemples suivants, le 1er sort permet de trier le fichier my_file.txt par ordre alphabétique.
Le 2e sort permet de le trier numériquement par odre croissant en prenant en compte les 2 chiffres après le séparateur 2 poins.
-
$ cat my_file.txt banane:10 ananas:30 cerise:20 $ sort my_file.txt ananas:30 banane:10 cerise:20 $ sort my_file.txt -t ":" -k 2 -n banane:10 cerise:20 ananas:30
La commande rev
La commande rev permet d'inverser le contenu de chaque ligne d'un fichier.
Elle s'écrit rev mon_fichier.
Dans la 2e commande suivante, rev est intégré dans une commande plus complexe.
-
$ rev my_file.txt enanab sanana esirec $ /usr/bin/time rev my_file.txt > /dev/null 2>> log.txt ; echo "*****" >> log.txt
La commande wc
La commande wc permet de compter des éléments d'un fichier.
Elle s'écrit wc option mon_fichier.
Les options sont présentées dans le tableau suivant.
| Option | Action |
|---|---|
| -l | Compte les lignes |
| -w | Compte les mots |
| -m | Compte les caractères |
-
$ wc -l my_file.txt 3 my_file.txt
La commande cut
La commande cut permet de sélectionner et d'afficher une partie de chaque ligne d'un fichier.
Elle s'écrit cut option mon_fichier.
Les options sont présentées dans le tableau suivant.
| Option | Action |
|---|---|
| -f | Sélectionne les énièmes champs |
| -d | Définit le type de délimiteur |
| -c | Sélectionne les énièmes champs |
-
$ cat my_file.txt first line second line $ cut -f 1 -d " " my_file.txt first second $ cut -c 2-4 my_file.txt irs eco
La commande uniq
La commande uniq permet de filtrer les doublons et d'afficher les lignes uniques.
Elle s'écrit uniq option mon_fichier.
Les options sont présentées dans le tableau suivant.
| Option | Action |
|---|---|
| -c | Renvoie le nombre de lignes identiques |
-
$ cat my_file.txt ligne unique ligne en double ligne en double $ unique -c my_file.txt 1 ligne unique 2 ligne en double
La commande join
La commande join permet de joindre les lignes de 2 fichiers.
Elle s'écrit join mon_premier_fichier mon_deuxième_fichier.
-
$ cat my_file1.txt id1 pomme id2 poire id3 pêche $ cat my_file2.txt id1 10 id2 30 id3 20 $ join my_file.txt my_file2.txt id1 pomme 10 id2 poire 30 id3 pêche 20
La commande awk
La commande awk permet de manipuler du texte sous la forme de champs dans un fichier.
Elle s'écrit awk '{ action $champ }' mon_fichier.
Le n° de champ commence à 1.
-
$ cat my_file.txt 1 ananas marron gros 2 banane jaune moyen 3 cerise rouge petit $ awk '{ print $2, $4 }' ex_awk.txt ananas gros banane moyen cerise petit
La commande tr
La commande tr permet de remplacer des caractères dans un fichier ou dans un flux de données
Elle s'écrit tr ancien_caractère nouveau caractère.
Testons cette commande avec le flux de données toto.
-
$ echo toto | tr o i titi
L'expressions régulière
Une expression régulière (regex) est une chaine de caractères décrite selon un motif.
Elle est utilisée pour effectuer des opérations de recherche et de manipulation de texte avancées.
Nous allons voir les caractères spéciaux appostrophe, point, point d'interrogation, dollar et la commande sed.
L'appostrophe
Le caractère "^" signifie commence par.
Dans l'exemple suivant, grep ^b cherche les lignes commençant par b.
-
$ cat my_file.txt banane ananas cerise $ cat my_file.txt | grep ^b banane
Le dollar
Le caractère "$" signifie finit par.
Dans l'exemple suivant, grep e$ cherche les lignes finissant par e.
-
$ cat my_file.txt | grep e$ banane cerise
Le point
Le caractère . désigne n'importe quel caractère
Dans l'exemple suivant, grep b.n cherche les lignes avec le motif b suivi d'un caractère suivi d'un n.
-
$ cat my_file.txt | grep b.n banane
Le commande sed
La commande sed permet de remplacer du texte sans l'afficher à l'écran avec les expressions régulières.
Pour remplacer du texte dans un fichier on utilisera 's/ancien_texte/nouveau_texte/g' le g pour toutes les lignes. L'option -i permet de sauver le fichier modifié.
-
$ cat my_file.txt toto boto $ sed -i 's/to/ba/g' my_file.txt my_new_file.txt $ cat my_file.txt baba boba
Outils utils
Pour le temps, l'archivage, les transferts, la connexion distante, les calculs.
Le temps
Afficher l'heure et la date dans le terminal, faire une pause.
Nous allons voir les commandes date, cal, ncal, sleep, time.
La commande date
La commande date affiche la date et l'heure.
Elle s'écrit date -option +format.
Les options sont présentées dans le tableau suivant.
| Option | Action |
|---|---|
| -u | Affiche l'heure utc |
| -s | Change l'heure du système |
| -y | Affiche le calendrier de l'année en cours |
Les formats sont présentés dans le tableau suivant.
| Format | Affichage |
|---|---|
| %d | jour du mois comme 01 |
| %A | jour de la semaine en toutes lettres |
| %j | jour de l'année |
| %W | semaine de l'année |
| %w | jour de la semaine, 0 pour dimanche |
| %D | date comme 16/07/23 |
| %m | mois comme 12 |
| %B | mois en toute lettres |
| %y | année courte comme 23 |
| %Y | année longue comme 2023 |
| %H | heures format 24h |
| %M | minutes |
| %S | secondes |
| %s | secondes depuis 1970 |
Les 3 exemples suivants affichent la date avec des formats différents.
-
$ date Sun Jul 16 21:09:19 CEST 2023 $ date +"%d/%m/%y %H:%M:%S" 16/07/23 21:09:19 $ date +"%d/%m/%y %H:%M:%S.%3N" 17/07/23 21:11:25.874
La commande cal
La commande cal permet d'afficher un calendrier dans le terminal.
La semaine commence le dimanche.
Le jour actuel est sur fond négatif.
Elle s'écrit cal -option mois année.
Si les mois et année ne sont pas spécifiées, considère la période en cours.
Les options sont présentées dans le tableau suivant.
| Option | Détail |
|---|---|
| -j | Affiche les n° de jours |
| -m | Affiche le calendrier du mois demandé |
| -y | Affiche le calendrier de l'année demandée |
| -3 | Affiche le calendrier des mois précédant, en cours et suivant |
L'exemple suivant affiche le calendrier du mois en cours
-
$ cal July 2023 Su Mo Tu We Th Fr Sa 1 2 2 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
L'exemple suivant affiche le calendrier du mois de septembre 2009.
On peut aussi écrire simplement cal 9 2009.
-
$ cal -m -y 9 2009 September 2009 Su Mo Tu We Th Fr Sa 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
La commande ncal
La commande ncal permet aussi d'afficher un calendrier dans le terminal.
Elle est similaire à la commande cal mais est plus récente.
Elle permet d'afficher les semaines avec l'option -w.
L'exemple suivant affiche le calendrier de l'année avec les semaines.
-
$ ncal -y -w
La commande sleep
La commande sleep fait une pause.
Elle s'écrit sleep nb_secondes.
Il est aussi possible d'indiquer un temps en minutes (exemple 2m), en heures (exemple 2h), en jours (exemple 2d).
-
$ sleep 10
La commande time
La commande time devant une commande permet d'obtenir sa durée d'une commande dans la sortie erreur.
Elle s'écrit time ma_commande
-
$ time sleep 10 real 0m10.001s user 0m0.001s sys 0m0.000s
L'archivage
Compresser et archiver des documents
La compression consiste à réduire la taille d'un fichier.
L'archivage consiste à stocker une arborescence de fichiers et répertoires en un seul fichier.
Pour cela, nous allons voir les commandes zip, unzip, gzip, gunzip et tar.
La commande zip
La commande zip pour archiver et compresser des documents.
Elle s'écrit zip -option mon_archive.zip mes_documents
Les options sont présentées dans le tableau suivant.
| Option | Action |
|---|---|
| -r | Utilise la récursivité |
| -s | N'affichage pas les sorties |
| -u | Ajoute un fichier à l'archive |
| -d | Supprime un fichier de l'archive |
Dans l'exemple suivant, le répertoire my_folder est archivé et compressé en incluant tous les fichiers et sous-dossiers qu'il contient sans afficher les sorties.
-
$ zip -r -q my_archive.zip my_folder
La commande unzip
La commande unzip permet d'extraire les fichiers contenus dans une archive au format zip.
Elle s'écrit unzip -option mon_archive.zip -d mon_répertoire.
Le complément -d est un dossier optionnel où extraire.
Les options sont présentées dans le tableau suivant.
| Option | Action |
|---|---|
| -t | Teste l'archive |
| -l | Liste le contenu de l'archive sans extraire |
Dans l'exemple suivant, l'archive my_archive.zip est extraite dans le répertoire courant.
-
$ unzip my_archive.zip
La commande tar
La commande tar permet d'archiver un répertoire sans compression.
Elle s'écrit tar option mon_répertoire.
Dans l'exemple suivant, le répertoire my_folder est archivé dans le fichier my_archive.tar grâce aux options cvf.
-
$ tar cvf my_archive.tar my_folder
Dans l'exemple suivant, l'archive my_archive.tar est extraite grâce aux options xvf.
-
$ tar xvf my_archive.tar
Dans l'exemple suivant, l'archive my_archive.tar est listée sans extraction grâce aux options tvf.
-
$ tar tvf my_archive.tar my_subfolder
Il est aussi possible de lister seulement un sous répertoire particulier en le renseignant à la fin de la commande.
-
$ tar tvf my_archive.tar my_folder/my_subfolder
La commande tar permet aussi d'archiver et de compresser en une seule étape (comme la commande zip) grâce aux options czvf.
Dans ce cas, un fichier tgz est créé.
Dans l'exemple suivant, le répertoire my_folder est archivé et compressé dans le fichier my_archive.tgz.
-
$ tar czvf my_archive.tar my_folder
L'options xzvf permet d'extraire une archive au format tgz.
Dans l'exemple suivant, l'archive my_archive.tgz est extraite.
-
$ tar xzvf my_archive.tgz
La commande gzip
La commande gzip permet de compresser une archive tar.
Elle s'écrit gzip mon_archive.tar. Elle crée une archive compressée au format .tar.gz.
Dans l'exemple suivant, l'archive my_archive.tar est compressée en my_archive.tar.gz.
-
$ gzip my_archive.tar $ ls my_archive.tar.gz
La commande gunzip
La commande gunzip permet de décompresser une archive tar.gz.
Elle s'écrit gunzip mon_archive.targz.
Dans l'exemple suivant, l'archive my_archive.targz est décompressée en my_archive.tar.
-
$ gunzip my_archive.tar.gz $ ls my_archive.tar
Serveur distant
Se connecter et transférer des fichiers
Nous allons voir les commandes ssh, scp, sftp.
La commande ssh
La commande ssh permet de se connecter à un autre serveur à distance.
Ssh est un protocole sécurisé car ssh signigie Secure Shell.
La commande ssh s'écrit ssh utilisateur@serveur_distant.
Utilisateur est le nom de l'utilisateur sur le serveur distant.
Serveur_distant est l'adresse IP ou le nom d'hôte de l'ordinateur distant.
Dans l'exemple suivant, la commande permet de se connecter en tant que nicot3m au serveur d'adresse IP 172.16.126.0
-
$ ssh nicot3m@172.16.126.0
La commande scp
La commande scp permet de transférer des fichiers sur un serveur distant.
La commande scp pour Secure Copy utilise le protocole ssh pour établir une connexion sécurisée et transférer les fichiers.
La commande scp s'écrit scp mon_fichier utilisateur @serveur_distant : répertoire_destination.
-
$ scp nicot3m@172.16.126.0:/home/nicotm/my_folder
La commande sftp
La commande sftp permet de gérer des fichiers sur un serveur distant.
La commande sftp pour SSSH File Transfer Protocol propose plusieurs de fonctionalités que scp.
La commande sftp s'écrit sftp utilisateur @serveur_distant.
-
$ sftp nicot3m@172.16.126.0
Une fois connecté, il est par exemple possible de naviguer dans les répertoires distants, créer des dossiers, lister les fichiers et supprimer des fichiers.
Le tableau suivant présente les principales fonctions utiles.
| Fonction | Action |
|---|---|
| pwd | Affiche le répertoire courant du serveur distant. |
| ls | Liste le contenu du serveur distant. |
| cd | Change le répertoire distant. |
| get | Télécharge un fichier du répertoire distant vers le répertoire local. |
| get -r | Télécharge un répertoire distant vers le répertoire local courant. |
| put | Envoie un fichier du répertoire local vers le répertoire distant. |
| put -r | Envoie un répertoire vers le répertoire distant courant. |
| rm | Supprime un fichier distant. |
| rm | Supprime un fichier distant. |
| rename | Renomme un fichier distant. |
| chmod | Change les droits d'un fichier distant. |
| chmod | Change les droits d'un fichier distant. |
| chown | Change le propriétaire d'un fichier distant. |
| chgrp | Change le groupe d'un fichier distant. |
| df | Affiche l'occupation du disque. |
La commande suivante permet d'envoyer le fichier my_file.txt vers le répertoire distant courant.
-
$ put my_file.txt
La commande suivante permet de télécharger le fichier my_file.txt vers le répertoire local /home/local/my_folder.
-
$ get my_file.txt /home/local/my_folder/my_file.txt
Les Calculs
Effectuer des calculs arithmétiques avec des entiers puis des décimaux.
Nous allons voir les commandes expr, let, declare, bc, la substitution arithmétique et la variable $RANDOM.
Notez, qu'à la base, le bash permet seulement les calculs d'entiers.
La commande expr
La commande expr permet d'effectuer des calculs avec des entiers.
Elle s'écrit expr mon_opération.
Voyons les différentes opérations possibles:
L'addition
-
$ expr 2 + 3 5
La soustraction
-
$ expr 2 - 3 -1
La multiplication
-
$ expr 2 \* 3 6
La division
-
$ expr 3 / 2 1
Il faut précéder les parenthèses d'un antislash comme dans l'exemple suivant.
-
$ expr \( 2 + 3 \) \* 5 25
Pour sauver le résultat d'un calcul dans une variable, on écrira ma_variable=$(exp mon_opération).
-
$ sum=$(expr 2 + 3) $ echo $sum 5
La substitution arithmétique
La substitution arithmétique permet aussi d'effectuer des calculs avec des entiers.
Elle s'écrit $((mon_opération))
-
$ a=2 $ echo $((a*3)) 6
La commande let
La commande let permet aussi d'effectuer des calculs avec des entiers.
Elle s'écrit let "ma_variable=mon_opération".
-
$ a=2 $ let "sum=a+3" $ echo $sum 5
Elle peut aussi s'écrire sous la forme ((ma_variable=mon_opération)).
-
$ ((sum=a+3)) $ echo $sum 5
L'incrémentation peut s'écrire ++.
-
$ a=2 $ ((a++)) $ echo $a 3
La fonction declare -i
La fonction declare -i permet de déclarer une variable de type entier.
Elle s'écrit declare -i ma_variable=valeur.
-
$ declare -i a=2 $ declare -i prod $ prod=a*3 $ echo $prod 6
La commande bc
La commande bc permet d'effectuer des calculs avec des décimaux.
Elle peut s'utiliser en mode intéractif comme une calculatrice.
Pour rentrer dans le mode intéractif, on écrit simplement bc.
L'instruction scale permet de définir des décimales.
Dans l'exemple suivant, scale=2 permet de définir 2 décimales.
L'instruction quit permet de revenir dans le terminal.
-
$ bc scale=2 3/2 1.50 quit $
Elle peut aussi s'utiliser en mode commande.
Voici quelques exemples.
-
$ echo "scale=2; 3/2" | bc 1.50 $ div=$(echo "scale=2; 3/2" | bc) $ echo $div 1.50 $ echo $(cat number.txt) | sed 's/ /+/g' | bc 421
La variable $RANDOM
La variable $RANDOM permet de générer un nombre entre 0 et 32767 de façon aléatoire.
Elle s'écrit $((RANDOM % interval + min)) pour un nombre entre min et interval.
Dans l'exemple suivant on obtient un nombre aléatoire entre 1 et 10.
-
$ echo $((RANDOM%10+1)) 6
Les processus
Un processus est une instance de commande en cours d'exécution.
Informations sur les processus
Les statuts, les identifiants et la commande ps
Nous allons voir le statut et l'identifiant d'un processus et comment les afficher.
Les statuts
Le statut d'un processus désigne son état à un instant donné.
Les 2 principaux statuts sont présentées dans le tableau suivant.
| Statut | Description |
|---|---|
| R | En cours d'exécution (Running) |
| S | En attente (Sleeping) |
| T | Stoppé(Stopped) |
Les indentifiants
Le PID, le PPID et l'UID.
Les identifiants sont présentées dans le tableau suivant.
| Identifiant | Signification |
|---|---|
| PID | Identifiant du Processus |
| PPID | Identifiant du Processus Parent |
| UID | Identifiant de l'Utilisateur |
La commande ps
La commande ps permet d'afficher les processus en cours et leurs informations.
Elle s'écrit ps -option.
Pour juste lister les processus de l'utiliseur actif, la commande ps est utilisée sans option.
Les options principales sont présentées dans le tableau suivant.
| Option | Action |
|---|---|
| -e | Affiche les processus de tous les utilisateurs, root inclus. |
| -f | Affiche toutes les informations. |
La commande ps -f renvoie les champs présentés dans le tableau suivant.
| UID | PID | PPID | C | STIME | TTY | TIME | CMD |
|---|---|---|---|---|---|---|---|
| Propriétaire | Identifiant | Processus parent | Utilisation CPU | Heure de début | Terminal | Durée CPU | Commande |
Voici un exemple d'utilisation:
-
$ ps -f UID PID PPID C STIME TTY TIME CMD nicot3m 9 8 0 20:47 pts/0 00:00:00 -bash nicot3m 79 9 0 21:04 pts/0 00:00:00 ps -f
Les entrée/sorties
Définition et comment les récupérer et les rediriger
Nous allons voir leur définition, les redirections et la commande echo $?.
Définition
Les 3 canaux d'entrée/sorties standards
Un processus bash a 1 cannal d'entrée et 2 canaux de sorties par défaut.
Par défaut, le canal d'entrée est saisi au clavier et les canaux de sorties s'affichent dans le terminal
Ils sont présentés dans le tableau suivant.
| Nom | Définition |
|---|---|
| stdin n°0 | L'entrée standard |
| stdout n°1 | La sortie standard |
| stderr n°2 | La sortie d'erreurs |
Redirection
Il est possible de rediriger ces canaux d'entrée/sorties.
Ils peuvent aussi servir à commniquer avec le système d'exploitation ou un autre processus.
Pour cela il sont redirigés.
Nous allons utiliser les caractères >, >> et < .
Le caractère > redirige la sortie standard vers un nouveau fichier comme dans l'exemple suivant.
-
$ ls *.dat > dat_file_list.txt $ cat dat_file_list.txt file1.txt file2.txt
Les caractères >> redirigent la sortie standard à la suite d'un fichier.
-
$ echo "end of list" >> dat_file_list.txt $ cat dat_file_list.txt file1.txt file2.txt end of list
De même, Les caractères 2>> redirigent la sortie d'erreurs vers un nouveau fichier et 2>> à la suite d'un fichier.
-
$ ls no_file.txt 2> log.txt $ cat log.txt ls: cannot access 'no_file.txt': No such file or directory
La commande >/dev/null permet d'envoyer la sortie standard vers un trou noir.
Seule la sortie erreurs pourrait être renvoyée à l'admin.
-
$ cat dat_file_list.txt>/dev/null
Le caractère < redirige l'entrée standard.
Cela permet de fournir un fichier en données d'entrée d'une commande.
-
$ wc -w < log.txt 9
Le caractère pipe | redirige la sortie standard d'une commande vers l'entrée standard d'une autre commande.
On parle de branchement d'où le tube de pipe.
-
$ history | wc -l 598 $ man cat | wc -l >> my_file.txt
Les caractères >& redirigent un flux de données vers un autre.
Ainsi, >&2 redirige la sortie standard vers la sortie d'erreurs
et 2>&1 redirige la sortie d'erreurs vers la sortie standard.
La commande echo $?
Status d'un processus
La commande echo $? renvoie le status de la commande précédente:
0 si OK
un autre nombre si KO (par exemples 1, 2, 127, selon l'erreur)
Elle s'écrit simplement echo $?.
-
$ pwd /home/nicot3m $ echo $? 0 $ wrong_command $ echo $? 127
Arrière plan
Sous Linux, un processus se lance par défaut en premier plan plan mais il est aussi possible de le lancer en arrière plan.
Un processus en premier plan (foreground) occupe la fenêtre du terminal. La main est rendue à l'utilisateur lorsque le processus est terminé.
Il est aussi possible de lancer plusieurs processus en même temps tout en libérant le terminal grâce aux "tâches de fond" en arrière plan.
L'esperluette
Le caractère & permet de lancer une un processus en arrière-plan.
Pour lancer un processus en arrière plan on écrit ma_commande&.
L'utilisateur garde la main dans le terminal.
Dans l'exemple suivant la commande sleep est lancée en arrière plan.
-
$ sleep 120 & [1] 86
La commande jobs
La commande jobs permet de lister les processus en arrière plan.
Elle s'écrit simplement jobs.
Elle renvoie la liste des processus en arrière plan
Pour chaque processus, elle fournit un id entre crochets designant le n° de tâche interne au shell. Il est appelé avec %id.
-
$ jobs [1]+ Running sleep 120 &
La commande fg
La commande fg permet de remettre une tâche en premier plan.
Elle s'écrit fg %id.
-
$ fg %1 sleep 120
La commande bg
La commande bg lance un processus en arrière plan.
Voici comment elle s'utilise.
Tout d'abord, un processus est lancé en premier plan.
Ensuite, les touches Ctrl + Z permettent de suspendre le processus et de le placer en arrière plan.
Enfin bg relance le processus en arrière plan.
Elle s'écrit simplement bg.
-
$ sleep 120 Ctrl + z [1]+ Stopped sleep 120 $ bg [1]+ sleep 120 &
La commande kill
La commande kill permet d'envoyer un signal à un processus.
Par défaut, elle est utilisée pour tuer un processus avec le signal -9.
Le signal -15 permet de terminer un processsus.
Elle s'écrit kill -signal pid ou %id.
kill -l permet de lister les signaux.
-
$ sleep 120& [1] 71 $ kill 71
La commande killall
La commande killall permet de tuer plusieurs processus par leur nom.
Elle s'écrit killall nom_processus.
-
$ sleep 120& $ sleep 110& $ kill sleep
La commande bash
La commande bash seule permet de lancer un sous shell.
Dans ce cas d'utilisation, elle s'écrit simplement bash.
Les touches Ctrl + D permettent de quiter le bash.
Les scripts
Fichier sh, les variables, les boucles, les conditions
Fichier .sh
Un script shell bash est un fichier texte de type .sh contenant les commandes bash que l'on peut ensuite exécuter sous Linux.
Jusqu'à présent nous avons saisi les commandes dans le terminal.
Nous allons maintenant les regrouper dans un fichier, le script shell.
Cela permet d'automatiser les tâches et de créer des applications.
Les commandes sont exécutées de façon séquentielles, les unes après les autres.
Le script peut être édité dans un des éditeurs que nous avons vu comme nano ou nedit.
Nous allons maintenant voir sa structure et son exécution.
La structure
La première ligne contient le shebang bash.
Il s'écrit #!/bin/bash.
Les lignes suivantes contiennent les commandes bash.
Voici un premier script my_script.sh affichant Hello world.
-
#!/bin/bash echo "Hello world!"
Exécution
Nous allons voir comment exécuter le script depuis le terminal.
La première fois, il faut d'abord lui donner les droits d'exécution avec la commande chmod +x.
Ensuite, les commandes bash ou ./ permettent de l'exécuter.
Voici un exemple avec le script my_script.sh.
-
$ chmod +x my_script.sh $ bash my_script.sh Hello world!
Pour passer 2 arguments en entrée, on écrit bash mon_script.sh argument1 argument2.
Dans l'exemple suivant l'argument nico est passé en entrée de my_script.sh.
-
$ bash my_script.sh nico
Nous allons voir dans le chapitre suivant sur les variables comment récupérer les arguments dans le script et les utiliser.
Les variables
Nous allons voir d'abord l'affectation, la commande read, l'affichage, la substitution, la commande eval dans le terminal puis l'utilisation des variables dans les scripts.
Les variables se distinguent des variables d'environnement car elles sont définies par l'utilisateur utilisées dans une application.
L'affectation
Pour affecter une variable, on écrit ma_variable=valeur_variable.
On utilise le caractère $ suivi du nom de la variable pour l'utiliser.
-
$ my_var=10 $ echo $my_var 10
On peut aussi capturer la sortie d'une commande avec le caractère $.
Voici 3 exemples:
-
$ echo mon chemin:$(pwd) mon chemin:/home/nicot3m $ my_path = $(pwd) $ echo $(my_path) /home/nicot3m $ cat my_file.txt 10 20 30 $ echo $(cat my_file.txt) 10 20 30
La commande read
La commande read permet de lire la valeur d'une variable saisie par l'utilisateur dans le terminal.
Elle s'écrit read ma_variable.
-
$ echo "Quel est ton age?" $ read age 46
L'affichage
La commande echo avec les doubles ou simples quotes permettent d'afficher une variable dans du texte.
Si l'on veur laisser plusieurs espaces dans la ligne et afficher la valeur d'une variable, il faut utiliser les double quotes.
-
$ echo "Tu as $age ans." Tu as 46 ans.
Attention, les simples guillemets simples empêchent l'interprétation de tous les caractères spéciaux dans un texte.
-
$ echo 'Tu as $age ans.' Tu as $age ans.
Pour inhiber un caractère spécial, il faut le précéder du caractère \.
Ainsi l'antislash inhibe le dollar et le nom de la variable est affiché plutôt que sa valeur.
-
$ echo \$age $age
Dans l'exemple suivant, la valeur de la variable my_sentence est une phrase et l'antislash sert à inhiber les guillemets.
-
$ my_sentence="$(uname) says : \"hello $(whoami)\"." $ echo $my_sentence Linux says : "hello nicot3m"
La substitution
La substitution de variable et la substitution de commande
Les caractères ${} sont utilisés pour effectuer une substitution de variable de manière explicite.
Ainsi la variable se distingue clairement du reste du texte et d'autres caractères spéciaux.
Elle s'écrit ${ma_variable}.
-
$ echo "Ton age est ${age} ans." Tu as 46 ans.
Les caractères $() sont utilisés pour effectuer une substitution de commande.
Elle permet d'exécuter une commande à l'intérieur d'une affectation de valeur à une variable.
Nous l'avons déjà utilisé dans l'exemple avec my_sentence.
Elle s'écrit $(ma_variable).
-
$ my_username=$(whoami) $ echo $my_username nicot3m
La commande eval
La commande eval est utilisée pour exécutée une commande dynamiquement contenue dans la valeur d'une variable.
Elle s'écrit eval $ma_commande.
-
$ my_command="pwd" $ eval $my_command /home/nicot3m
Les arguments
Les arguments sont récupérés dans le script grâce aux variables spéciales $1, $2, $3.
Reprenons my_script.sh récupérant l'argument nico grâce à la variable spéciale $1 et affichant Hello world nico!.
-
#!/bin/bash echo "Hello world $1!" $ bash my_script.sh nico Hello world nico!
La variable spéciale $0 renvoie le nom du script.
-
#!/bin/bash echo "Mon script se nomme $0." $ bash my_script.sh Mon script se nomme my_script.sh.
La variable spéciale $# renvoie le nombre d'arguments.
-
#!/bin/bash echo "Mon script a $# arguments." $ bash my_script.sh arg1 arg1 Mon script a 2 arguments.
La variables spéciales $@ ou $*renvoie tous les arguments.
-
#!/bin/bash echo "Mon script a les arguments $*." $ bash my_script.sh arg1 arg1 Mon script a les arguments arg1 arg1.
${1:-Bob} permet de définir la valeur par défaut Bob du 1er argument.
-
#!/bin/bash arg1=${1:-Bob} echo "Hello world $arg1!" $ bash my_script.sh Hello world Bob! $ bash my_script.sh nico Hello world nico!
${1:?"arg1 manquant"} permet de renvoyer un message si l'argument 1 est manquant.
-
#!/bin/bash arg1=${1:?"arg1 manquant"} echo "Hello world $arg1!" $ bash my_script.sh my_script.sh: line 2: 1: arg1 manquant $ bash my_script.sh nico Hello world nico!
En exemple, voyons le script delat.sh permettant de calculer le déterminant d'une équation du second degré ax2+bx+c=0 avec la formule delta=b2-4a*c.
Les valeurs A, B, C pour a, b, c sont rentrées en arguments.
-
#!/bin/bash A=${1:?"A=?"} B=${2:?"B=?"} C=${3:?"C=?"} echo $((B*B-4*A*C)) $ bash delta.sh 3 2 -5 64
Les tests
Les tests conditionnels permettent de vérifier si une condition particulière est vraie ou fausse.
Ils servent principalement dans les structures conditionnelles que nous verrons dans le chapitre suivant.
Un test s'écrit entre crochets avec un espace au début et à la fin.
$? contient le retour avec la valeur 0 si vrai et 1 si faux.
Nous allons voir les tests sur les entiers, sur les chaines de caractères, sur les fichiers et les opérateurs logiques.
Tests sur les entiers
Des opérateurs de comparaison permettent de vérifier des conditions numériques.
Le tableau suivant présente les opérations de comparaison pour les entiers.
| Opérateur | Définition |
|---|---|
| -eq | = |
| -ne | ≠ |
| -gt | > |
| -ge | >= |
| -lt | < |
| -le | <= |
Le test suivant vérifie si 2 est inférieur 3 et renvoie 0 car c'est vrai.
-
$ [ 3 -lt 3 ]; echo $? 1
Tests sur le texte
Des opérateurs de comparaison permettent de vérifier des conditions basées sur des chaînes de caractères.
Le tableau suivant présente les options pour les chaines de caractères.
| Opérateur | Définition |
|---|---|
| = | = |
| != | ≠ |
| < | < |
| > | > |
| -z | vide |
| -n | non vide |
Le test suivant vérifie si var1 égale var2 et renvoie 1 car c'est faux.
-
$ var1=ananas $ var2=banane $ [ $var1 = $var2 ]; echo $? 1
Tests sur les fichiers
Des opérateurs spéficifiques permettent de vérifier des conditions basées sur les fichiers.
Le tableau suivant présente les options pour les fichiers.
| Opérateur | Définition |
|---|---|
| -e | existe |
| -s | non vide |
| -f | fichier existe |
| -d | répertoire existe |
| -r | accessible en lecture |
| -w | accessible en écriture |
| -x | exécutable |
Le test suivant vérifie si le fichier test.txt existe et renvoie 0 car c'est vrai.
-
$ [ -e test.txt ]; echo $? 0
Opérateurs logiques
Des opérateurs logiques permettent de combiner plusieurs conditions.
Le tableau suivant présente les opérateurs logiques.
| Opérateur | Définition |
|---|---|
| ! | négation |
| -a | et |
| -o | ou |
Le test suivant vérifie si le fichier test.txt n'existe pas et renvoie 1 car c'est faux.
-
$ [ ! -e test.txt ]; echo $? 1
L'exemple suivant contient plusieurs tests combinés.
-
$ [ -e test.txt -a ! -r test.txt -o ! -e test.txt ]; echo $? 0
Le script suivant permet suivant permet de vérifier les arguments.
S'il y a 2 arguments et si les 2 arguments sont différents et classés par ordre croissant ascii, alors renvoie 0 pour vrai.
-
#!/bin/bash [ "$#" = 2 -a "$1" != "$2" -a "$1" \< "$2" ]; echo $?
Tests étendus
Les tests étendus qui s'écrivent [[ expression ]] ont une syntaxe plus simple et plus flexible.
Les guillemets ne sont pas obligatoires autour des chaînes de caractères et autour des variables.
Les opérateurs traditionnels peuvent-êtres utilisés, en partie détaillés dans le tableau suivant.
| Opérateur | Définition |
|---|---|
| == | = |
| != | ≠ |
| < | < |
| > | > |
| ! | négation |
| && | et |
| || | ou |
Le test étendu suivant permet de vérifier la présence de 1 argument et vérifier qu'il contient au moins un A et un I en enchainant les tests.
-
#!/bin/bash [[ "$#" = 1 && "$1" == *"*A"* && "$1" == *"I"* ]]
Le test étendu suivant permet afficher my_file.txt s'il existe, sinon d'afficher un message d'erreur.
-
#!/bin/bash [ -f my_file.txt ] && cat my_file.txt || echo "No my_file.txt"
Les conditions
La condition permet de tester une variable et d'effectuer une action en fonction du résultat du test.
Nous allons voir la structure conditionnelle et les commandes exit et case.
La structure conditionnelle
Une structure conditionnelle s'écrit if then elif then else fi.
Dans le script suivant, si my_file.txt existe et s'il a les droits d'écriture alors OK est y ajouté, s'il n'existe pas il est créé et KO y est ajouté et s'il existe sans les droits en écriture, tous les droits lui sont donnés et KOK y est ajouté.
-
#!/bin/bash if [ -f my_file.txt -a -w my_file.txt ] then echo "OK" >> my_file.txt elif [ ! -e my_file.txt ] then echo "KO" > my_file.txt elif [ -f my_file.txt -a ! -w my_file.txt ] then chmod 777 my_file.txt echo "KOK" >> my_file.txt fi
La commande exit
La commande exit permet de définir un code retour de 0 à 255.
Elle s'écrit exit code_entier.
Le script suivant teste les arguments et renvoie un code de sortie en fonction du résultat du test.
-
#!/bin/bash [ "$#" = 0 ] && echo "Argument manquant" && exit 6 \ || [ "$#" -gt 1 ] && echo "Trop d'arguments" && exit 7 \ || [[ "$1" = "ok" || "$1" = "OK" ]] && echo "OK" && exit 0 \ || [[ "$1" = [sS][oO][sS] ]] && echo "Emergency" && exit 112 \ || [[ "$#" = 1 ]] && echo "Argument incorrect" && exit 1 $ bash test_exit.sh SoS ; echo $? coming 112
La commande case
La commande case permet d'effectuer des tests pour un plus grand nombre de choix.
Elle s'écrit case "ma_variable" in mon_intervalle).
Le script suivant teste les arguments et renvoie un code de sortie en fonction du résultat du test, cette fois en utilisant la commande case.
-
#!/bin/bash if [ "$#" -ne 1 ] then echo "KO" exit 1 elif [ "$#" = 1 ] then case "$1" in ??*) echo "This is too long" exit 66;; [a-z]) echo "This is lowercase" exit 3;; [A-Z]) echo "This is uppercase" exit 4;; [0-9]) echo "This is integer" exit 5;; *) echo "This is special character" exit 6;; esac fi
Les boucles
Les boucles permettent d'automatiser des tâches répétitives.
Nous allons voir la boucle while et la boucle for.
La boucle while
La commande while permet de répéter une suite de commandes tant que la condition est vraie.
Sa structure est: while test do commandes done.
Dans le script boucle_while.sh suivant, l'argument 1 est affiché tans que la variable i est inférieure à 3.
-
#!/bin/bash ARG1=${1:?"Argument manquant"} i=0 while [ $i -lt 3 ] ; do echo "$ARG1" ((i++)) done $ ./boucle_while.sh encore encore encore encore
La boucle while avec la commande read
La commande read associée à la boucle while permet de lire un fichier ligne par ligne.
Voici un exemple avec le script read_file.sh.
Une ligne est sautée entre chaque ligne sauf la première et la dernière.
La variable d'environnement IFS, pour Internal Field Separator, vaut par défaut, un espace, une tabulation ou le retour à la ligne.
La dernière ligne done < $file_name signifie que le contenu du fichier $file_name est utilisé comme entrée pour la boucle "while".
-
#!/bin/bash if [[ "$#" = 0 ]] then echo "Usage : $0 file.txt" exit 1 fi file_name=$1 first_line=true while IFS= read -r line; do if [[ $first_line = true ]] then echo "$line" first_line=false else echo ; echo "$line" fi done < $file_name $ cat my_file.txt ananas banane cerise $ read_file.sh my_file.txt ananas banane cerise
La boucle for
La commande for permet de boucler sur une liste
Sa structure est: for var in ma_liste do commandes done.
L'exemple suivant utilise une boucle sur les mots de la chaine de caractères My hello world.
-
#!/bin/bash for WORD in My hello world ; do echo $WORD done $ ./boucle_for.sh My hello world
Voici un 2e exemple pour afficher tous les arguments.
La variable spéciale $@ désigne tous les arguments passés.
-
#!/bin/bash ID=1 for arg in $@ ; do echo "$ID : $arg" ((ID++)) done $ ./boucle_for2.sh My hello world 1 : My 2 : hello 3 : world
Voici un 3e exemple pour afficher les arguments dans l'ordre inverse.
-
#!/bin/bash if [[ "$#" = 0 ]] ; then echo "Manque les arguments" exit 1 fi RESULT="" for arg in "$@" ; do RESULT="$arg $RESULT" done echo $RESULT exit 0 $ ./inverse.sh A B C "X Y Z" X Y Z C B A
La command seq
La commande seq, pour séquence, retourne une série d'entiers.
Elle s'écrit seq premier_entier pas dernier_entier.
Le pas,optionnel, vaut 1 par défaut.
Associée à la boucle for, la commande seq permet de répéter une suite de commandes n fois comme dans le script boucle_for3.sh.
-
#!/bin/bash ARG1=${1:?"Argument manquant"} for i in $( seq 1 3 ) ; do echo "$ARG1" done $ ./boucle_while.sh encore encore encore encore
Fonctions
Une fonction est un bloc de code pour une tâche spécifique.
Les fonctions permettent d'organiser et de réutiliser du code.
Elles apportent de la modularité et évitent les doublons.
Nous allons voir son utilisation et quelques exemples.
Utilisation
Déclaration et appel
Pour déclarer une fonction on écrit nom () {commandes}.
On peut aussi écrire function nom {commandes}.
Pour appeler une fonction, il suffit d'écrire le nom de la fonction suivi des arguments potentiels.
Dans l'exemple suivant la fonction show_name affiche le nom rentré en argument.
-
#!/bin/bash show_name() { echo "My name is $1" } show_name nico $ ./name.sh My name is nico
La commande return
La commande return permet de retourner un code de sortie entier entre 0 et 255.
Dans l'exemple suivant, le script max_value.sh renvoie le max de 2 valeurs entre 0 et 255.
-
#!/bin/bash max_value() { if [ $1 -gt $2 ]; then return $1 else return $2 fi } ARG1=${1:?"Argument 1 manquant"} ARG2=${2:?"Argument 2 manquant"} max_value $ARG1 $ARG2 echo $? $ ./max_value.sh 20 30 30 $ ./max_value.sh 200 300 44
Retour avec la fonction echo
La fonction echo permet de retourner une valeur depuis une fonction.
Dans l'exemple suivant, la fonction retour_statut renvoie le statut OK qui est récupéré dans la variable résultat.
-
retour_statut() { local statut="OK." echo "$statut" } resultat=$(retour_statut) echo "Statut : $resultat"
Voici un 2e exemple avec le script max_value2.sh
La fonction max_value renvoie le max de 2 entiers quelconques avec la commande echo et la substitution de commande.
-
#!/bin/bash max_value() { if [ $1 -gt $2 ]; then echo $1 else echo $2 fi } ARG1=${1:?"Argument 1 manquant"} ARG2=${2:?"Argument 2 manquant"} MAX=$(max_value $ARG1 $ARG2) echo $MAX $ ./max_value.sh 200 300 300
Voici un 3e exemple plus complexe avec le script lettres.sh.
Il permet de tirer au hasard des voyelles ou des consonnes.
-
#!/bin/bash voyelles="a e i o u y" consonnes="b c d f g h j k l m n p q r s t v w x z" function Aide { echo "Usage: $0 then enter one key c|v" >&2 exit 1 } function TirageRang { echo $((1 + $RANDOM % $#)) } function TirageLettre { rang=$1 # Sans remise shift $rang echo $1 } ligne="" i=1 while [ $i -le 10 ] do read -p "? " -e -n 1 choix case $choix in c) unelettre=$(TirageLettre $(TirageRang $consonnes) $consonnes) ;; v) unelettre=$(TirageLettre $(TirageRang $voyelles) $voyelles) ;; h) Aide ;; *) continue ;; esac ligne="$ligne $unelettre" echo $ligne ((i=i+1)) done exit 0
Les variables locales
Pour déclarer une variable locale à l'intérieur d'une fonction on écrit local .
Cela peut-être utile pour utiliser une variable limitée à portée de la fonction car autrement les variables sont globales par défaut
Dans l'exemple suivant, la variable compteur est locale, elle est donc effacée à la fin de la fonction.
-
ma_fonction() { local compteur=0 while [ $compteur -lt 10 ]; do echo "Tour : $compteur" compteur=$((compteur + 1)) done } ma_fonction