1 files changed, 1226 insertions, 0 deletions

diff --git a/fichiers/04-grep-bash.tex b/fichiers/04-grep-bash.tex
new file mode 100644
index 0000000..48ea55f
--- /dev/null
+++ b/fichiers/04-grep-bash.tex
@@ -0,0 +1,1226 @@
+\input{../_preamble}
+\input{../_preamble_bbl}
+\usepackage{menukeys}
+\title{grep et bash}
+\usepackage{float}
+\usepackage{dingbat}
+\usepackage[newfloat]{minted}
+\SetupFloatingEnvironment{listing}{listname=Listings}
+\setminted{
+  bgcolor=Lavender,
+  breaklines,
+  breaksymbolright=\small\carriagereturn}
+\setmintedinline{bgcolor=Lavender}
+\usepackage{capt-of}
+\usepackage{soul}
+\makeindex[name=cmds, intoc, title={Liste des commandes et
+  instructions}, options={-s \jobname.ist}]
+
+\NewDocumentCommand{\commande}{s m O{}}{
+  \IfBooleanTF{#1}{\index[cmds]{#2@\texttt{#2}|#3textbf}}
+  {\index[cmds]{#2@\texttt{#2}#3}}
+}
+
+\NewDocumentCommand{\inputfile}{O{} m m O{application/x-sh}}{
+  \marginpar{\attachandlink{scripts/#3}[#4]{Fichier
+      attaché}{\textcolor{blue}{Ouvrir le fichier}}}
+  \inputminted[#1]{#2}{scripts/#3}
+}
+
+\begin{document}
+\maketitle
+\renewcommand{\contentsname}{Sommaire}
+\tableofcontents
+
+\listoflistings
+
+\needspace{3\baselineskip}
+\listoftables
+
+\chapter{grep, les expressions régulières}
+\label{cha:grep-les-expressions}\commande{grep}
+Les expressions régulières se rapprochent des \emph{wildcards} ou
+\enquote{métacaractères} qui ont été présentés dans
+\href{./01-ligne-de-commande.pdf#lnk_wildcards}{le cours sur la ligne
+  de commande}. C'est une technique commune à pour ainsi dire tous les
+langages de programmation qui permet de construire des
+\enquote{modèles}, en anglais \emph{patterns}, susceptibles de
+capturer des chaînes de caractères.
+
+Par exemple, soit le fichier suivant:
+\begin{minted}{text}
+/usr/share/dict/cracklib-small
+\end{minted}
+Ce fichier fait partie d'un programme dont le rôle est de vérifier la
+robustesse des mots de passe. Il contient un grand nombre d'entrées, à
+raison d'un mot par ligne. Vérifions cela:
+\begin{minted}{text}
+[robert@kiddo courses]$ wc -l /usr/share/dict/cracklib-small 
+54763 /usr/share/dict/cracklib-small
+\end{minted}
+L'expression régulière suivante retourne tous les mots de cinq lettres
+de ce fichier qui commencent par la lettre \verb|c| et se terminent
+par la lettre \verb|h|:
+\begin{minted}{text}
+[robert@kiddo courses]$ grep '\<c...h\>' /usr/share/dict/cracklib-small
+catch
+cinch
+clash
+cloth
+coach
+conch
+couch
+cough
+crash
+crush
+czech
+\end{minted}
+
+\begin{quoting}
+  \textsc{Rem.} \verb|grep| recherche les modèles ligne par
+  ligne et retourne donc un résultat positif dès lors qu'un modèle
+  donné a été trouvé au moins une fois dans une ligne.
+\end{quoting}
+
+\paragraph{Modèles}
+Pour construire les modèles (\emph{patterns}), on peut utiliser les
+symboles suivants\footnote{Cette liste n'est pas exhaustive.}:
+\begin{xltabular}{\linewidth}{lX}
+  \toprule
+  Symbole & Signification \\ \midrule\endhead
+  \verb|.| & tout caractère unique\\
+  \verb|?| & le caractère précédent est répété 0 ou une fois\\
+  \verb|*| & le caractère précédent est répété 0 fois ou autant
+             de fois que possible\\
+  \verb|+| & le caractère précédent est répété une fois \emph{au
+             moins}\\
+  \verb|{n}| & le caractère précédent est répété exactement \emph{n}
+               fois\\
+  \verb|{n,m}| & le caractère précédent est répété au moins \emph{n}
+                 fois et au plus \emph{m} fois\\
+  \verb|[abc]| & le caractère précédent est l'un de ceux qui se
+                 trouvent entre les crochets droits\\
+  \verb|[^abc]| & le caractère précédent n'est pas l'un de ceux qui se
+                  trouvent entre les crochets droits\\
+  \verb|[a-z]| & le caractère précédent est compris entre \emph{a} et
+                 \emph{z}, dans l'ordre de la table des
+                 caractères. C'est le sens du trait d'union entre les
+                 lettres \verb|a| et \verb|z|. On peut bien sûr
+                 combiner des chaînes avec et sans trait d'union. Par
+                 exemple, \verb|[A-Ea-e]| correspond aux cinq
+                 premières lettres de l'alphabet, en majuscule et en
+                 minuscule. \\
+  \verb|()| & ce qui est inclus entre les parenthèses est traité comme
+              un groupe \\
+  
+  \verb+|+ & opérateur logique signifiant \emph{ou} \\
+  \verb|^| & représente le début de la ligne\\
+  \verb|$| & représente la fin de la ligne\\ \\
+  \verb|\<| et \verb|\>| & représentent respectivement un début et une
+                           fin de mot\\
+  \bottomrule
+  \caption{grep \emph{patterns}}
+\end{xltabular}
+
+\paragraph{grep, egrep}
+\commande*{grep}
+\commande{egrep}[|see{\texttt{grep}}]
+À la place de \verb|grep|, on peut saisir à la ligne de commande
+\verb|egrep| ou \verb|grep -E| pour \emph{extended regular
+  expressions}. Quelle est la différence? Retenez ici simplement que
+sous \verb|grep| les metacaractères
+\begin{minted}{text}
+? + { } | ( )
+\end{minted}
+doivent être précédés de la \emph{séquence d'échappement} \verb|\|
+comme ceci:
+\begin{minted}{text}
+\? \+ \{ \} \| \( \)
+\end{minted}
+tandis que cela ne se fait pas avec \verb|egrep|.
+
+\paragraph{options}
+La commande \verb|(e)grep| peut recevoir un grand nombre
+d'options. Parmi ces options, retenons celles-ci:
+\begin{description}
+\item[-n] retourne les numéros des lignes dans lesquelles le modèle de
+  recherche a été trouvé.
+\item[-c] retourne le nombre d'occurrences trouvées.
+\item[-i] demande à \verb|grep| de ne pas faire de différence entre
+  les minuscules et les majuscules.
+\item[-H] retourne le nom du fichier dans lequel le modèle recherché
+  est trouvé.
+\item[-v] \emph{nie} le modèle recherché: \verb|grep| retournera donc
+  les lignes dans lesquelles le modèle \emph{n'a pas été trouvé}. 
+\end{description}
+
+\paragraph{Exemples}
+Les exemples ci-dessous utilisent
+\href{./01-ligne-de-commande.pdf#lnk_redirection}{la technique de la
+  redirection}.
+\begin{minted}{text}
+[robert@kiddo courses]$ cat /usr/share/dict/cracklib-small | grep '\<s.*m\>' | grep 'ea'
+scream
+seagram
+sealteam
+seam
+sidearm
+steam
+stream
+sunbeam
+sunbeam's
+\end{minted}
+  \begin{quoting}
+    \textbf{Commentaire:} La ligne de commande fait ici successivement
+  les opérations suivantes:
+    \begin{enumerate}
+    \item Concaténation de toutes les lignes du fichier
+      \verb|cracklib-small|
+    \item Sélection de tous les mots qui commencent par la lettre
+      \verb|s| et se terminent par la lettre \verb|m|.
+    \item Parmi ces mots, sélection de ceux qui contiennent la chaîne
+      \verb|ea|.
+    \end{enumerate}
+  \end{quoting}
+\begin{minted}{text}
+[robert@kiddo courses]$ cat /usr/share/dict/cracklib-small | grep '\<.....\>' | grep -E 'o{2}|e{2}' | grep 't' | column -c 70
+afoot   fleet   needn't skeet   steep   taboo   three   tweed
+beets   foote   roost   sleet   steer   taboo's three's
+boost   greet   roots   sooth   stood   teems   tools
+booth   hoots   scoot   steed   stool   teens   tooth
+boots   loots   sheet   steel   stoop   teeth   trees
+booty   meets   shoot   steen   sweet   tepee   troop
+\end{minted}
+\begin{quoting}
+  \textbf{Commentaire:} La ligne de commande fait ici successivement
+  les opérations suivantes:
+  \begin{enumerate}
+  \item Concaténation de toutes les lignes du fichier
+    \verb|cracklib-small|
+  \item Sélection des mots de cinq caractères.
+  \item Parmi ces mots, sélection de ceux qui contiennent \emph{soit}
+    la chaîne \verb|oo| \emph{soit} la chaîne \verb|ee|.
+  \item Enfin, sélection, parmi ces derniers mots, de ceux qui
+    contiennent la lettre \verb|t|
+  \item La dernière ligne, dont on n'a pas étudié la syntaxe, demande
+    l'affichage du résultat sous la forme de colonnes tabulées.
+  \end{enumerate}
+\end{quoting}
+
+\chapter{bash}
+\label{cha:bash}
+Comme on l'a vu, \verb|bash| est le \emph{shell} le plus répandu sur
+les systèmes Linux aujourd'hui. On peut écrire en \verb|bash| des
+\emph{scripts}, autrement dit de petits programmes informatiques, pour
+réaliser des suites d'opérations plus ou moins complexes.
+
+Voici un exemple très simple. Prenons les lignes suivantes:
+\begin{minted}[linenos]{text}
+mkdir sauvegarde
+cp *.tex sauvegarde
+zip -r sauvegarde.zip sauvegarde
+\end{minted}
+Ces trois lignes exécutent successivement les opérations suivantes:
+\begin{enumerate}
+\item Création d'un répertoire intitulé \verb|sauvegarde|
+\item Copie de tous les fichiers \TeX{} dans le répertoire
+  \verb|sauvegarde|
+\item Création d'une archive \verb|.zip| de tout le répertoire.
+\end{enumerate}
+
+Pour éviter de répéter ces trois lignes de commande et d'encourir le
+risque de se tromper dans la saisie, on peut décider de les écrire
+dans un fichier texte que l'on appellera par exemple \verb|backup.sh|
+de la façon suivante:
+\begin{minted}[linenos]{bash}
+#!/bin/bash
+mkdir sauvegarde
+cp *.tex sauvegarde
+zip -r sauvegarde.zip sauvegarde
+\end{minted}
+
+Il suffit alors de demander à \verb|bash| d'exécuter ce fichier pour
+que les trois opérations soient réalisées d'un coup. Comme les scripts
+écrits en \verb|bash| sont interprétés par le \textsl{shell}
+\verb|bash|, \emph{toute ligne de commande peut être exécutée dans un
+  script}. Réciproquement, \emph{tout ce qui peut entrer dans un
+  script peut aussi être exécuté à la ligne de commande}.
+
+\section{L'éditeur de texte}
+\label{sec:lediteur-de-texte}
+C'est dans un \emph{éditeur de texte} que l'on saisit tout code
+informatique. Certains éditeurs de texte sont très simples à
+utiliser. Nous allons prendre ici l'exemple de l'un des plus simples,
+\verb|nano|. Pour le lancer, il suffit de saisir à la ligne de
+commande: \mintinline{text}|nano|. Après avoir lancé \verb|nano| et
+saisi le script donné ci-dessus, voici ce que l'on obtient:
+\begin{minted}[linenos,fontsize=\footnotesize]{text}
+  GNU nano 2.8.2                     Nouvel espace                           
+
+#!/bin/bash
+mkdir sauvegarde
+cp *.tex sauvegarde
+zip -r sauvegarde.zip sauvegarde
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+^G Aide      ^O Écrire    ^W Chercher  ^K Couper    ^J Justifier ^C Pos. cur.
+^X Quitter   ^R Lire fich.^\ Remplacer ^U Coller    ^T Orthograp.^_ Aller lig.
+\end{minted}
+
+Les lignes 24 et 25 correspondent au menu de \verb|nano|. On n'y
+accède pas par la souris, mais à l'aide des \emph{raccourcis clavier}
+qui sont tous préfixés par le \emph{caret} (\verb|^|) qui représente
+la touche \keys{Ctrl} du clavier. Donc pour quitter le programme, on
+appuiera sur \keys{Ctrl-X}: voici ce que montre \verb|nano| au bas du
+terminal après avoir saisi \keys{Ctrl-X}:
+\begin{minted}[linenos,fontsize=\footnotesize]{text}
+Écrire l'espace modifié ? (Répondre « Non » ABANDONNE les modifications.)       
+ O Oui
+ N Non          ^C Annuler
+\end{minted}
+Les opérations suivantes sont donc possibles:
+\begin{enumerate}
+\item \keys{O}: sauvegarde le fichier.
+\item \keys{N}: quitte \verb|nano| sans sauvegarder.
+\item \keys{Ctrl-C}: annule l'opération et retourne à l'éditeur de texte.
+\end{enumerate}
+Appuyons sur la touche \keys{O}. \verb|nano| nous invite alors à
+entrer le nom du script:
+\begin{minted}[linenos,fontsize=\footnotesize]{text}
+Nom du fichier à écrire: backup.sh                                              
+^G Aide             M-D Format DOS      M-A Ajout (à la fin)M-B Copie de sécu.
+^C Annuler          M-M Format Mac      M-P Ajout (au début)^T Parcourir
+\end{minted}
+Après avoir entré le nom du fichier et appuyé sur la touche
+\keys{Enter} pour confirmer le choix, on retourne au terminal et à la
+ligne de commande.
+
+\section{Le \emph{shebang}}
+\label{sec:le-shebang}
+La première ligne du script \verb|backup.sh| donné en exemple
+ci-dessus appelle un commentaire particulier:
+\begin{minted}[linenos]{bash}
+#!/bin/bash
+\end{minted}
+
+Dans cette ligne, la séquence \mintinline{bash}|#!| s'appelle le
+\emph{shebang}. Par convention, le \emph{shebang} est un préfixe que
+l'on fait suivre du nom du programme qui doit interpréter le script,
+précédé de son chemin d'accès absolu.
+
+Le \emph{shebang} est important car il permet d'accéder aux
+interpréteurs auxquels on souhaite accéder depuis la ligne de
+commande. Par exemple, pour un script écrit en Python2, la première
+ligne sera:
+\begin{minted}[linenos]{python}
+#!/usr/bin/env python2
+"""
+ Mon premier script en Python
+"""
+print("bonjour le monde!")
+\end{minted}
+
+\section{Les commentaires}
+\label{sec:les-commentaires}
+En \verb|bash|, tout ce qui, sur une même ligne, suit le signe
+\mintinline{bash}|#| \emph{n'est ni interprété, ni exécuté}. On
+utilise donc ce signe pour introduire des \emph{commentaires} dans le
+code informatique.
+
+Les commentaires ne servent pas uniquement à introduire des remarques
+pour son usage personnel. Ils servent aussi, et surtout, à donner des
+indications sur le code lui-même pour permettre aux autres de mieux
+comprendre la programmation. Si le code est bien commenté, alors on
+doit pouvoir le lire comme on lit un livre. Cela est très important
+car les programmes longs et complexes dépassent souvent et parfois
+même survivent à leur auteur.
+
+Si le code est bien compris, il sera facilement mis à jour, corrigé et
+augmenté par d'autres programmeurs.
+
+L'art de commenter le code informatique tout en l'écrivant porte le
+nom de \emph{literate programming}. Il a été inventé par Donald
+E.~Knuth, le créateur de \TeX, qui a posé tous les principes de cet
+art dans le cadre de la programmation en
+\textsf{WEB}\footnote{\cite{Knuth1983}. Voir également en ligne
+  \url{http://www.literateprogramming.com/}}.
+
+Pour un exemple de code commenté, voir le \vref{lst:copyten}.
+
+\section{Exécution}
+\label{sec:execution}
+Il faut ici approfondir la notion de \emph{permissions} sur les
+fichiers qui a été présentée dans le cours sur la
+\href{./01-ligne-de-commande.pdf#lnk_permissions}{ligne
+  de commande}. Nous avons en effet étudié trois types de permissions
+sur les fichiers: en lecture, en écriture et en exécution. Revenons
+sur les permissions données par défaut au script \verb|backup.sh|:
+\begin{minted}{text}
+[robert@kiddo courses]$ ls -l backup.sh 
+-rw-r--r-- 1 robert robert 82 17 sept. 22:06 backup.sh
+\end{minted}
+Soit:
+\begin{itemize}
+\item lecture et écriture pour l'utilisateur \verb|robert| (\verb|rw|);
+\item lecture seule pour le groupe \verb|robert| (\verb|r|);
+\item lecture seule pour le reste du monde (\verb|r|)
+\end{itemize}
+
+\paragraph{chmod}
+\commande*{chmod}
+La commande qui permet de changer les droits s'appelle
+\verb|chmod|. Pour comprendre comment l'utiliser, il faut savoir que
+les permissions sont traduites par des valeurs numériques, à savoir:
+\begin{itemize}
+\item 4 pour le droit \emph{lecture};
+\item 2 pour le droit \emph{écriture};
+\item 1 pour le droit \emph{exécution}.
+\end{itemize}
+Ces valeurs peuvent être additionnées. On analyse donc ainsi les
+permissions sur le fichier \verb|backup.sh|:
+\begin{itemize}
+\item utilisateur \verb|robert|, lecture + écriture: $4+2=6$;
+\item groupe \verb|robert|, lecture: $4$;
+\item reste du monde, lecture: $4$.
+\end{itemize}
+Soit $644$. Pour ajouter à l'utilisateur \verb|robert| seulement la
+permission en exécution, il faudrait donc porter cette valeur à
+$744$. Nous allons ici donner ce droit à la fois à \verb|robert|, au
+groupe \verb|robert| et au reste du monde, soit une valeur de
+$755$. La syntaxe est la suivante:
+\begin{minted}{text}
+chmod xyz <fichier>
+\end{minted}
+où \verb|xyz| sont les trois chiffres qui représentent les permissions.
+\begin{minted}[escapeinside=||, linenos]{text}
+[robert@kiddo courses]$ chmod 755 backup.sh 
+[robert@kiddo courses]$ ls -l --color backup.sh 
+-rwxr-xr-x 1 robert robert 82 17 sept. 22:06 |\textcolor{green}{backup.sh}|
+\end{minted}
+\begin{quoting}
+  \textbf{Commentaire}:
+  \begin{enumerate}
+  \item La commande \verb|chmod| a été entrée à la ligne 1.
+  \item À la ligne 2, nous avons lancé la commande
+    \commande{ls}\mintinline{text}|ls -l --color| sur le fichier
+    \verb|backup.sh|: les droits listés à la ligne 3 montrent bien que
+    la valeur \verb|x| a été ajoutée aux trois endroits possibles. On
+    voit enfin que l'option \verb|--color| affiche en vert les
+    fichiers qui sont exécutables.
+  \end{enumerate}
+\end{quoting}
+
+Nous pouvons désormais exécuter notre script:
+\begin{minted}[linenos,escapeinside=||]{text}
+[robert@kiddo courses]$ ls -l --color
+total 36
+-rwxr-xr-x 1 robert robert   82 17 sept. 22:06 |\textcolor{green}{backup.sh}|
+-rw-r--r-- 1 robert robert  165 16 sept. 19:40 bibliography.bib
+drwxr-xr-x 5 robert robert 4096 17 sept. 22:30 |\textcolor{blue}{fichiers}|
+-rw-r--r-- 1 robert robert  680 16 sept. 18:34 makefile
+-rw-r--r-- 1 robert robert  898 16 sept. 19:39 _preamble_bbl.tex
+-rw-r--r-- 1 robert robert  699 14 sept. 15:02 _preamble-ed.tex
+-rw-r--r-- 1 robert robert  719 16 sept. 19:39 _preamble.tex
+-rw-r--r-- 1 robert robert 1407 17 sept. 00:15 README.md
+-rw-r--r-- 1 robert robert 1804 17 sept. 00:15 README.tex
+[robert@kiddo courses]$ ./backup.sh 
+  adding: sauvegarde/ (stored 0%)
+  adding: sauvegarde/README.tex (deflated 57%)
+  adding: sauvegarde/_preamble.tex (deflated 45%)
+  adding: sauvegarde/_preamble_bbl.tex (deflated 57%)
+  adding: sauvegarde/_preamble-ed.tex (deflated 44%)
+[robert@kiddo courses]$ ls -l --color
+total 44
+-rwxr-xr-x 1 robert robert   82 17 sept. 22:06 |\textcolor{green}{backup.sh}|
+-rw-r--r-- 1 robert robert  165 16 sept. 19:40 bibliography.bib
+drwxr-xr-x 5 robert robert 4096 17 sept. 22:31 |\textcolor{blue}{fichiers}|
+-rw-r--r-- 1 robert robert  680 16 sept. 18:34 makefile
+-rw-r--r-- 1 robert robert  898 16 sept. 19:39 _preamble_bbl.tex
+-rw-r--r-- 1 robert robert  699 14 sept. 15:02 _preamble-ed.tex
+-rw-r--r-- 1 robert robert  719 16 sept. 19:39 _preamble.tex
+-rw-r--r-- 1 robert robert 1407 17 sept. 00:15 README.md
+-rw-r--r-- 1 robert robert 1804 17 sept. 00:15 README.tex
+drwxr-xr-x 2 robert robert 4096 17 sept. 22:31 |\textcolor{blue}{sauvegarde}|
+-rw-r--r-- 1 robert robert 2828 17 sept. 22:31 sauvegarde.zip
+[robert@kiddo courses]$ ls sauvegarde
+_preamble_bbl.tex  _preamble-ed.tex  _preamble.tex  README.tex
+\end{minted}
+\begin{quoting}
+  \textbf{Commentaire:}
+  \begin{itemize}
+  \item lignes 1--11: la commande \commande{ls}\verb|ls -l --color|
+    donne l'état du dossier \emph{avant} l'exécution du script
+    \verb|backup.sh|;
+  \item lignes 12--17: exécution du script et messages du terminal;
+  \item lignes 18--30: la commande \verb|ls -l --color| donne l'état du
+    dossier \emph{après} l'exécution du script \verb|backup.sh|. On
+    voit qu'un nouveau répertoire \verb|sauvegarde| a été créé, de
+    même qu'un fichier archive \verb|sauvegarde.zip|;
+  \item lignes 31--32: la commande \verb|ls sauvegarde| liste le
+    contenu de ce répertoire. On y trouve tous les fichiers
+    \verb|.tex| qui y ont été copiés par le script.
+  \end{itemize}
+\end{quoting}
+
+\paragraph{PATH} Un dernier point reste à éclaircir: à la ligne 12,
+pourquoi a-t-on écrit \mintinline{bash}|./backup.sh| et non pas
+simplement \mintinline{bash}|backup.sh|? Tout simplement pour des
+raisons de sécurité. En effet, le principe est que les fichiers
+exécutables se trouvent dans certains répertoires-système spécialement
+conçus pour les accueillir. C'est pour cette raison que l'on peut
+lancer les commandes \verb|bash| sans avoir à les préfixer. Or notre
+répertoire de travail ne fait partie de ces répertoires spéciaux. Il
+faut donc préfixer tout script exécutable qui s'y trouve par son
+\emph{chemin d'accès}, soit relatif, soit absolu. On a choisi ici la
+première méthode: dans la séquence \mintinline{text}|./|, le point
+représente le répertoire courant tandis que le \emph{slash} précise
+qu'il s'agit d'un chemin d'accès. Sans le \emph{slash}, le
+\emph{shell} aurait compris le point comme un préfixe de fichier
+caché.
+
+\section{Les variables}
+\label{sec:les-variables}
+Les variables sont des informations temporaires qui peuvent être
+stockées et rappelées à tout moment. L'exemple qui suit va donner
+l'occasion d'étudier une nouvelle commande,
+\commande{echo}\verb|echo|, dont le rôle est justement de retourner
+au terminal la chaîne de caractères qu'on lui passe en argument:
+\begin{minted}[linenos]{text}
+[robert@kiddo courses]$ mysystem="Linux"
+[robert@kiddo courses]$ echo 'Mon système est $mysystem.'
+Mon système est $mysystem.
+[robert@kiddo courses]$ echo "Mon système est $mysystem."
+Mon système est Linux.
+\end{minted}
+
+\begin{quoting}
+  \textbf{Commentaire:}
+  \begin{description}
+  \item[Définition] Pour \emph{définir une variable}, on lui donne un
+    nom, suivi du signe $=$, suivi de sa définition entre guillemets
+    droits.
+  \item[Rappel] Pour \emph{rappeler} la valeur d'une variable, on
+    saisit le nom qu'on lui a donné, préfixé par le signe \verb|$|.
+  \end{description}
+  \begin{mdframed}[backgroundcolor=Cyan]
+    Observez la différence dans l'usage des guillemets!
+    \href{./01-ligne-de-commande.pdf#lnk_guillemets}{Comme
+      on le sait}, les guillemets servent à indiquer au \emph{shell}
+    que les espaces ne sont pas des caractères actifs. Il y a
+    cependant une grande différence entre les guillemets simples et
+    les guillemets doubles: les premiers renvoient une expression
+    littérale dans laquelle rien n'est interprété (lignes~2--3) tandis
+    que les seconds permettent l'interprétation des variables
+    (lignes~4--5).
+  \end{mdframed}
+\end{quoting}
+
+Certaines variables sont automatiquement définies par \emph{bash}. Par
+exemple:
+\begin{enumerate}
+\item \verb|$0|: renvoie le nom du script en cours d'exécution.
+\item \verb|$1 - $9|: désignent les arguments successifs passés au
+  script.
+\end{enumerate}
+
+Nous pouvons désormais perfectionner le script \verb|backup.sh|:
+\begin{minted}[linenos]{bash}
+#!/bin/bash
+echo "Veuillez choisir l'extension des fichiers à sauvegarder"
+echo "(sans le point):"
+read -p 'extension: ' ext
+echo "Veuillez choisir le nom du dossier de sauvegarde:"
+read -p 'dossier: ' backupdir
+mkdir "$backupdir"
+cp *.$ext "$backupdir"
+zip -r "$backupdir".zip "$backupdir"
+echo "Terminé. $0 a copié vos fichiers .$ext dans $backupdir"
+echo "et l'archive $backupdir.zip a été créée."
+\end{minted}
+
+\paragraph{read}
+\label{ref:read}
+\commande*{read} Cette nouvelle commande est expliquée dans
+le commentaire qui suit\footnote{Voir aussi plus loin
+  \vpageref{ref:read-plus}.}:
+\begin{quoting}
+  \textbf{Commentaire:}
+  \begin{enumerate}
+  \item Une nouvelle commande a été introduite ici: aux lignes~4 et 6,
+    \verb|read| attend que l'utilisateur saisisse quelque chose au
+    clavier. Ensuite, la valeur saisie au clavier est associée à une
+    variable qui peut être reprise dans le script. On a également
+    passé à \verb|read| l'option \verb|-p| qui permet d'ajouter un
+    \emph{prompt} spécifique.
+  \item Aux lignes 7, 8 et 9, on a pris la précaution de mettre entre
+    guillemets doubles le rappel de la variable:
+    \verb|"$backupdir"|. On sait en effet que beaucoup d'utilisateurs
+    utilisent les espaces dans les noms des fichiers. Ici, la variable
+    étant rappelée à l'intérieur de guillemets doubles, elle sera
+    toujours interprétée correctement par \emph{bash}.
+  \end{enumerate}
+\end{quoting}
+
+Exécution du script \verb|./backup.sh tex|:
+\begin{minted}[linenos]{text}
+[robert@kiddo courses]$ ./backup.sh 
+Veuillez choisir l'extension des fichiers à sauvegarder
+(sans le point):
+extension: tex
+Veuillez choisir le nom du dossier de sauvegarde:
+dossier: Houba
+  adding: Houba/ (stored 0%)
+  adding: Houba/README.tex (deflated 57%)
+  adding: Houba/_preamble.tex (deflated 45%)
+  adding: Houba/_preamble_bbl.tex (deflated 57%)
+  adding: Houba/_preamble-ed.tex (deflated 44%)
+Terminé. ./backup.sh a copié vos fichiers .tex dans Houba
+et l'archive Houba.zip a été créée.
+\end{minted}
+\begin{quoting}
+  \textbf{Commentaire:}
+  \begin{enumerate}
+  \item Les valeurs attendues ont été saisies par l'utilisateur aux
+    lignes~4 et 6.
+  \item À la ligne~12, le script a utilisé la variable \verb|$0| pour
+    retourner son propre nom.
+  \end{enumerate}
+\end{quoting}
+
+\section{Captures et substitutions}
+\label{sec:capt-et-subst}
+Cette technique simple permet de transformer en variable le résultat
+d'une commande. Il suffit de placer la commande entre parenthèses
+précédées du signe $=$. Exemple:
+\begin{minted}[linenos]{text}
+[robert@kiddo courses]$ nbre=$(ls | wc -l)
+[robert@kiddo courses]$ echo $nbre
+8
+\end{minted}
+
+\needspace{2\baselineskip}
+\begin{quoting}
+  \textbf{Commentaire:}
+  \begin{enumerate}
+  \item À la ligne~1, la commande \commande{ls}\verb|ls| liste les
+    fichiers, puis son résultat est interprété par
+    \commande{wc}\verb|wc -l| qui compte le nombre de fichiers
+    retournés.
+  \item La variable \verb|$nbre| contient donc ce dernier résultat.
+  \end{enumerate}
+\end{quoting}
+
+Utilisons cette technique pour perfectionner notre script
+\verb|backup.sh| (voir ci-dessous la ligne~9):
+\begin{minted}[linenos]{bash}
+#!/bin/bash
+echo "Veuillez choisir l'extension des fichiers à sauvegarder"
+echo "(sans le point):"
+read -p 'extension: ' ext
+echo "Veuillez choisir le nom du dossier de sauvegarde:"
+read -p 'dossier: ' backupdir
+mkdir "$backupdir"
+cp *.$ext "$backupdir"
+nbre=$(ls $backupdir/*.$ext | wc -l)
+zip -r "$backupdir".zip "$backupdir"
+echo "Terminé. $0 a copié $nbre fichiers .$ext dans $backupdir"
+echo "et l'archive $backupdir.zip a été créée."
+\end{minted}
+
+Exécution:
+\begin{minted}[linenos]{text}
+[robert@kiddo courses]$ ./backup.sh 
+Veuillez choisir l'extension des fichiers à sauvegarder
+(sans le point):
+extension: tex
+Veuillez choisir le nom du dossier de sauvegarde:
+dossier: Houba
+  adding: Houba/ (stored 0%)
+  adding: Houba/README.tex (deflated 57%)
+  adding: Houba/_preamble.tex (deflated 45%)
+  adding: Houba/_preamble_bbl.tex (deflated 57%)
+  adding: Houba/_preamble-ed.tex (deflated 44%)
+Terminé. ./backup.sh a copié 4 fichiers .tex dans Houba
+et l'archive Houba.zip a été créée.
+\end{minted}
+
+\section{Conditions}
+\label{sec:conditions}
+Il est souvent très utile de n'exécuter des lignes de code que si
+certaines conditions sont remplies. Reprenons ici l'exemple du script
+\verb|backup.sh|: au moment où le script crée le répertoire de
+sauvegarde, il ne contrôle pas si ce répertoire existe déjà, ce qui est
+un défaut. Voici comment on peut créer une condition adaptée à cette
+situation:
+\begin{minted}[linenos]{bash}
+if [ -d "$backupdir" ]
+then
+  echo "Le dossier $backupdir existe déjà. Veuillez relancer le"
+  echo "programme et saisir un autre nom."
+  exit 1
+else
+  mkdir "$backupdir"
+fi
+\end{minted}
+\begin{quoting}
+  \textbf{Commentaire:}
+  \begin{enumerate}
+  \item Observez la structure de la condition:
+    \begin{itemize}
+    \item ligne 1: \commande*{if}\mintinline{bash}|if|
+      $\rightarrow$ \emph{si <condition>} où la condition est posée
+      entre crochets. Dans l'expression entre les crochets, %
+      \verb|-d "$backupdir"|, \verb|-d| signifie: \verb|$backupdir|
+      existe \emph{et} est un répertoire;
+    \item ligne 2: \commande*{then}\mintinline{bash}|then|
+      $\rightarrow$ \emph{alors, passez à la ligne suivante};
+    \item ligne 6: \commande*{else}\mintinline{bash}|else|
+      $\rightarrow$ \emph{autrement, passez à la ligne suivante};
+    \item ligne 8: \commande*{fi}\mintinline{bash}|fi|
+      $\rightarrow$ \emph{fin de la condition} (en fait les deux
+      lettres de la conjonction \verb|if| écrite à l'envers).
+    \end{itemize}
+  \item À la ligne 5, la commande \commande{exit}\verb|exit 1|
+    ordonne au programme de se terminer immédiatement et de renvoyer
+    la valeur \verb|1| comme numéro d'état (\emph{status number}). Par
+    convention, \verb|0| est pour \emph{true} (le programme a bien été
+    exécuté) et \verb|1| est pour \emph{false} (il y a eu une erreur).
+  \end{enumerate}
+\end{quoting}
+
+Voici donc comment se présente le script \verb|backup.sh| une fois la
+condition insérée:
+\captionof{listing}{bash: exemple de condition \texttt{if-then-else}%
+\label{lst:if-then-else}}
+\inputfile[linenos,highlightlines={7-14}]{bash}{backup.sh}
+
+\subsection{Conditions en série}
+\label{sec:conditions-en-serie}
+Supposons que le répertoire de sauvegarde ait été supprimé mais que
+l'archive \verb|.zip| correspondante ne l'ait pas été. Dans ce cas, le
+script \verb|backup.sh| l'écraserait. Pour éviter cela, nous pouvons
+utiliser dans le script l'instruction
+\commande*{elif}\verb|elif| qui permet de construire des
+conditions en série. Littéralement, \verb|elif| est pour \emph{else
+  if}, \enquote{ou autrement, si\ldots}. Voici donc ce qu'il faut
+ajouter:
+\begin{minted}{bash}
+elif [ -e "$backupdir".zip ]
+  then
+  echo "L'archive $backupdir.zip existe déjà. Veuillez la supprimer"
+  echo "ou la déplacer en dehors de ce dossier, puis relancez le"
+  echo "programme."
+  exit 1
+\end{minted}
+
+Ce qui donne le script \verb|backup-mk2.sh| suivant:
+\captionof{listing}{bash: instruction \texttt{elif}\label{lst:elif}}
+\inputfile[linenos,highlightlines={12-17}]{bash}{backup-mk2.sh}
+
+\subsection{Tests}
+\label{sec:tests}
+Le tableau suivant donne la liste des tests les plus répandus que l'on
+peut associer aux conditions. Les tests sont placés entre crochets
+droits comme le montre la ligne~7 du \vref{lst:if-then-else}.
+\begin{xltabular}{.77\linewidth}{lX}
+  \toprule
+  Opérateur  & Description \\
+  \midrule\endhead
+  \verb|! expr| & \verb|expr| est faux \\
+  \verb|-n str| & la longueur de \verb|str| $>0$\footnote{Comprendre:
+                  \texttt{str} existe.} \\
+  \verb|-z str| & la longueur de \verb|str| $=0$\footnote{Comprendre:
+                  \texttt{str} n'existe pas.}\\
+  \verb|str1 = str2| & \verb|str1| est égal à \verb|str2|\\
+  \verb|str1 != str2| & \verb|str1| n'est pas égal à \verb|str2|\\
+  \verb|int1 -eq int2| & les nombres \verb|int1| et \verb|int2| sont
+                         égaux\\
+  \verb|int1 -gt int2| & \verb|int1| $>$ \verb|int2|\\
+  \verb|int1 -lt int2| & \verb|int1| $<$ \verb|int2|\\
+  \verb|-d fichier| & \verb|fichier| existe et est un répertoire\\
+  \verb|-e fichier| & \verb|fichier| existe \\
+  \verb|-s fichier| & \verb|fichier| existe et n'est pas vide (taille
+                      $>0$) \\
+  \verb|-r fichier| & \verb|fichier| existe et est accessible en
+                      lecture\\ 
+  \verb|-w fichier| & \verb|fichier| existe et est accessible en
+                      écriture \\
+  \verb|-x fichier| & \verb|fichier| existe et est accessible en
+                      exécution \\
+  \bottomrule
+  \caption{tests\label{tab:tests}}
+  \label{tab:tests}
+\end{xltabular}
+
+\paragraph{test}
+\commande*{test} À l'intérieur du script \verb|bash|, les
+crochets renvoient en fait à une commande par ailleurs disponible:
+\verb|test|. La commande \verb|test| renvoie en fait la sortie
+\verb|0| si le résultat est \emph{vrai} et \verb|1| si le résultat est
+\emph{faux}. Le terminal ne retourne pas le resultat, mais celui-ci
+est associé à une variable
+\verb|$?| que l'on peut afficher par la commande:
+\commande{echo}\mintinline{bash}|echo $?|. En voici quelques
+exemples:
+\begin{minted}[linenos]{text}
+[robert@kiddo courses]$ ls
+bibliography.bib  makefile           _preamble-ed.tex  _preamble.tex  README.tex
+fichiers          _preamble_bbl.tex  _preamble.log     README.md
+[robert@kiddo courses]$ test -d fichiers
+[robert@kiddo courses]$ echo $?
+0
+[robert@kiddo courses]$ test -x makefile
+[robert@kiddo courses]$ echo $?
+1
+[robert@kiddo courses]$ test -e makefile
+[robert@kiddo courses]$ echo $?
+0
+[robert@kiddo courses]$ test 0123 = 123
+[robert@kiddo courses]$ echo $?
+1
+[robert@kiddo courses]$ test 0123 -eq 123
+[robert@kiddo courses]$ echo $?
+0
+\end{minted}
+\begin{quoting}
+  \textbf{Commentaire ---} Cet exemple montre quelle est la différence
+  entre le test $=$ pour qui il faut une stricte équivalence dans les
+  chaînes de caractères, et le test \verb|-eq| qui est un test
+  arithmétique.
+\end{quoting}
+
+\subsection{Indentation}
+\label{sec:indentation}
+L'indentation est une technique qui consiste à donner aux lignes de
+code différentes profondeurs de marge à gauche de façon à distinguer
+clairement des blocs logiques. Les lignes 7--20 du
+\vref{lst:if-then-else} en donnent un exemple. L'indentation permet de
+faire apparaître clairement ce qui dépend de l'instruction
+\commande{if}\verb|if| (l.~7), puis \commande{elif}\verb|elif|
+(l.~12) et enfin \commande{else}\verb|else| (l.~18).
+
+Cette technique est commune à tous les langages informatiques et tous
+les programmeurs l'utilisent. En Python, que nous étudierons plus
+tard, l'indendation fait même partie du langage lui-même, puisque
+Python a recours à l'indentation pour structurer les blocs logiques, à
+la différence d'autres langages qui ont recours soit à des
+déclarations explicites telles que \verb|begin ...  end| ou encore à
+des opérateurs tels que \verb|{ ... }|
+
+Voici un exemple d'indentation d'une structure dans laquelle on a
+placé une condition à l'intérieur d'une autre condition:
+\captionof{listing}{bash: exemple d'indentation}
+\inputfile[linenos]{bash}{greaterthan.sh}
+
+\subsection{Opérateurs booléens}
+\label{sec:operateurs-booleens}
+Les opérateurs booléens, dont le nom est tiré du mathématicien anglais
+George Boole, sont des opérateurs logiques que l'on peut associer à
+des conditions. En voici deux ici:
+\begin{enumerate}
+\item \verb+||+ pour \emph{ou};
+\item \verb|&&| pour \emph{et}.
+\end{enumerate}
+
+Par exemple, dans le \vref{lst:elif} ci-dessus, on pourrait remplacer
+les lignes 7--20 par le code ci-dessous:
+\begin{minted}[linenos]{bash}
+if [ -d "$backupdir" ] || [ -e "$backupdir".zip ]
+  then
+  echo "Le dossier $backupdir et/ou l'archive $backupdir.zip"
+  echo "existent déjà. Veuillez relancer le programme et saisir"
+  echo "un autre nom."
+  exit 1
+else
+  mkdir "$backupdir"
+fi
+\end{minted}
+
+\subsection{case}
+\label{sec:case}\commande*{case}
+\verb|case| est une instruction qui permet d'exécuter différentes
+actions en fonction de la valeur d'une variable. Elle est intéressante
+à étudier ici car elle fait appel à la fois à la notion de variable et
+aux expressions régulières. La syntaxe est la suivante:
+\begin{minted}[linenos]{bash}
+case $var in
+  expr1)
+  <commandes ...>
+  ;;
+  expr2)
+  <commandes ...>
+  ;;
+esac
+\end{minted}
+\begin{quoting}
+  \textbf{Commentaire:}
+  \begin{enumerate}
+  \item L'instruction \verb|case| se termine par \verb|esac|, de même,
+    comme on l'a vu, que l'expression \verb|if| se termine par
+    \verb|fi|.
+  \item Les expressions régulières sont suivies d'une parenthèse
+    fermante.
+  \item Pour passer d'un jeu de commande au jeu suivant, on écrit, sur
+    une ligne \verb|;;|
+  \end{enumerate}
+\end{quoting}
+
+Le \vref{lst:case} montre un exemple facile à comprendre de cette
+technique.
+\captionof{listing}{bash: instruction \texttt{case}\label{lst:case}}
+\inputfile[linenos]{bash}{animal.sh}
+\begin{quoting}
+  \textbf{Commentaire:}
+  \begin{enumerate}
+  \item À la ligne 4, l'utilisateur est invité à entrer une
+    réponse. L'instruction \commande{read}\verb|read| associe la
+    réponse à la variable \verb|animal|.
+  \item À la ligne 6, l'instruction \verb|case| reprend la variable
+    qui est donc préfixée par le signe \verb|$|.
+  \item Aux lignes 7 et 10, on permet à l'utilisateur d'entrer soit le
+    mot \emph{chien}, soit le mot \emph{chat}. L'initiale peut être
+    une minuscule ou une majuscule.
+  \item À la ligne 13, comme le signe \verb|*| est en \emph{bash} le
+    \emph{wildcard} qui représente toute séquence de caractères, la
+    commande de la ligne~14 sera forcément exécutée si les tests des
+    lignes~7 et~10 ont échoué.
+  \end{enumerate}
+\end{quoting}
+
+\begin{quoting}
+  \textbf{Remarque:} à la place de l'instruction \verb|case|, on
+  recommande aujourd'hui d'utiliser une nouvelle instruction,
+  \commande{switch}\verb|switch|, dont la syntaxe, plus complexe,
+  n'est pas étudiée ici.
+\end{quoting}
+
+\section{Boucles}
+\label{sec:boucles}
+Les boucles (en anglais: \emph{loops}) servent à indiquer qu'une série
+d'instructions doit reprendre et continuer à s'exécuter aussi
+longtemps qu'une condition donnée est remplie ou n'est pas remplie.
+
+Prenons un exemple simple. Nous avons dans un répertoire plusieurs
+centaines d'images de différents formats et nous souhaitons convertir
+au format \verb|.png| toutes les images qui sont enregistrées au
+format \verb|.tiff|.
+
+Pour convertir une seule image, nous pouvons utiliser l'outil en ligne
+de commande \verb|convert| fourni par le programme
+\emph{imagemagick}\footnote{\url{http://www.imagemagick.org}}. Pour
+convertir une seule image, la syntaxe est la suivante:
+\begin{minted}{bash}
+convert image.tiff image.png
+\end{minted}
+
+Mais comment faire pour en convertir un grand nombre pris dans un
+répertoire qui en compte des centaines enregistrées dans des formats
+différents?
+
+\paragraph{basename}
+\commande*{basename}Avant de continuer, il faut dire un mot de la
+commande \verb|basename| que nous allons utiliser ici. Cette commande
+permet de dépouiller un nom de fichier de son chemin d'accès et de son
+extension. La syntaxe est la suivante:
+\begin{minted}[escapeinside=||]{text}
+basename -s .|\emph{ext}| |\emph{file}|
+\end{minted}
+où \emph{ext} est le nom de l'extension et \emph{file} le nom du
+fichier. Voici un exemple:
+\begin{minted}{text}
+[robert@kiddo fichiers]$ ls -l images/
+total 252
+-rw-r--r-- 1 robert robert 96404  2 juil. 18:32 02-ascii.png
+-rw-r--r-- 1 robert robert 33951 20 juin  19:59 02-donnees1.png
+-rw-r--r-- 1 robert robert 11503 20 juin  20:01 02-donnees2.png
+-rw-r--r-- 1 robert robert 17450  3 juil. 17:43 02-exercice_formats.png
+-rw-r--r-- 1 robert robert 87510 14 sept. 15:06 02-unicode.png
+[robert@kiddo fichiers]$ basename -s .png images/*
+02-ascii
+02-donnees1
+02-donnees2
+02-exercice_formats
+02-unicode
+\end{minted}
+
+\paragraph{for-do-done}
+\commande*{for}\commande*{do}\commande*{done}
+La boucle que nous allons utiliser fait appel à trois instructions:
+\begin{enumerate}
+\item \verb|for| prend comme argument un nom qui sera ensuite traité
+  comme une variable. Le nom de la variable est suivi de l'instruction
+  \commande{in}\verb|in| et d'un nom de fichier qui contient des
+  données séparées par des espaces ou bien d'une expression dans
+  laquelle on a placé des
+  \href{./01-ligne-de-commande.pdf#lnk_wildcards}{\emph{wildcards}}.
+\item \verb|do| est suivi des commandes qu'il faut exécuter sur chaque
+  élément retourné par l'instruction \verb|for| \ldots{} \verb|in|.
+\item \verb|done| marque la fin de la boucle.
+\end{enumerate}
+
+Voici maintenant le script qui assure la conversion du format
+\verb|.tiff| vers le format \verb|.png|:
+\captionof{listing}{bash: \texttt{for ... do ... done}}
+\inputfile[linenos]{bash}{tiff2png.sh}
+
+\begin{quoting}
+  \textbf{Commentaire:}
+  \begin{enumerate}
+  \item Comprendre ainsi le début de la ligne~2 %
+    (\mintinline{bash}|for file in|): \enquote{pour tout \texttt{file}
+      dans\ldots} où \verb|file| définit une variable dont la valeur
+    pourra ensuite être rappelée par \verb|$file|. Le reste de la
+    ligne est une \emph{double capture} (v.~\emph{supra},
+    \vref{sec:capt-et-subst}):
+    \begin{enumerate}
+    \item \verb|$(ls *.tiff)| liste et retourne tous les fichiers dont
+      l'extension est \verb|.tiff|
+    \item \verb|$(basename -s .tiff $(ls *.tiff))| demande à
+      \verb|basename| de dépouiller tous ces fichiers de leur
+      extension \verb|.tiff| et retourne la liste des noms seuls.
+    \end{enumerate}
+  \item La variable \verb|file| est donc une liste constituée des noms
+    de tous les fichiers \verb|.tiff| sans leur extension. La ligne~3
+    les convertit tous les uns après les autres vers le format
+    \verb|.png|.
+  \end{enumerate}
+\end{quoting}
+
+\paragraph{while}
+\commande*{while} L'expression \verb|while| exécute les
+lignes de code qui suivent aussi longtemps qu'un test donné retourne
+un résultat positif (\enquote{vrai}, en anglais \emph{true}). Le
+script \verb|countlines.sh|, donné dans le \cref{lst:countlines}
+ci-dessous, utilise cette expression pour compter les lignes des
+fichiers\footnote{Pour une autre façon plus simple d'écrire le même
+  programme, voir le \vref{lst:countlines-mk2}.}.
+\captionof{listing}{bash: \texttt{while}\label{lst:countlines}}
+\inputfile[linenos,highlightlines={13,16-17}]{bash}{countlines.sh}
+
+\paragraph{read}
+\label{ref:read-plus}\commande*{read}
+On a déjà présenté plus haut \vpageref{ref:read} cette
+instruction. Pour bien comprendre le \cref{lst:countlines}, il faut
+savoir que la fonction de \verb|read| est de \emph{lire une ligne},
+quelle que soit cette ligne, depuis l'entrée standard du \emph{shell}
+(en anglais: \emph{standard input}). Dans le \vref{lst:case}, la ligne
+en question était donc constituée d'une saisie au clavier dans
+laquelle la ligne était formée par une chaîne de caractères terminée
+par un \emph{retour charriot} (\emph{carriage return}).
+
+\begin{mdframed}[backgroundcolor=Cyan]
+  \verb|read| admet aussi une option \verb|-r| qui est importante:
+  quand cette option est activée, le caractère \verb|\|
+  (\emph{backslash}) est traité comme un caractère ordinaire, et non
+  comme un caractère actif. Pour simplement compter les lignes d'un
+  fichier, il faut ajouter cette option car en \emph{bash} le
+  \emph{backslash} est précisément un caractère actif: à la fin d'une
+  ligne, il sert à joindre cette ligne à la ligne suivante.
+\end{mdframed}
+
+Étudions de près les lignes~13--17 du \cref{lst:countlines}:
+l'instruction \verb|while| (l.~13) se termine à la ligne~17 par
+\verb|done|. Et aussitôt à ce moment,
+\href{./01-ligne-de-commande.pdf#lnk_redirection}{l'opérateur
+  de redirection} \mintinline{bash}|<| lit le contenu du fichier dont
+le nom correspond à la variable \verb|file| et le passe en argument à
+la boucle \verb|while ... done|.
+
+\paragraph{Commentaire du \cref{lst:countlines}}
+\begin{enumerate}
+\item À la ligne~6, on crée une variable \verb|numline| à laquelle
+  on attribue la valeur \verb|0|. Elle servira donc de compteur.
+\item L'instruction essentielle est à la ligne~13:
+  \mintinline{bash}|while read -r line|: comme ce qui suit
+  \verb|while| \emph{est un test}, ce test donnera un résultat positif
+  aussi longtemps que la variable \verb|line| existe, c'est-à-dire
+  aussi longtemps que l'opérateur de redirection \mintinline{bash}|<|
+  de la ligne~17 envoie des lignes terminées par un retour
+  charriot. Tant que cette condition est remplie, la commande de la
+  ligne~16 sera exécutée, et le compteur de lignes sera incrémenté
+  d'une unité à chaque fois.
+\item Les instructions des lignes~20--25 sont faciles à
+  suivre. Étudiez-les à l'aide du \vref{tab:tests}: vous pourrez
+  comprendre comment la programmation peut être adaptée pour suivre
+  les règles de l'orthographe française.
+\end{enumerate}
+
+Exécutons maintenant le script:
+\begin{minted}{text}
+[robert@kiddo courses]$ ./countlines.sh 
+Entrez le nom du fichier dont vous voulez compter les lignes:
+Fichier: whack
+Erreur: le fichier whack n'existe pas.
+[robert@kiddo courses]$ ./countlines.sh 
+Entrez le nom du fichier dont vous voulez compter les lignes:
+Fichier: makefile
+Votre fichier makefile compte 21 lignes.
+\end{minted}
+
+\paragraph{until}
+\commande*{until}À la différence de \verb|while|,
+\verb|until| exécute les instructions qui suivent jusqu'au moment où
+le résultat du test associé à \verb|until| devient \emph{positif}
+(\emph{true}). Pour prendre un exemple très simple, le script suivant,
+que l'on appellera \verb|rah.sh|, demande combien de fois on souhaite
+tirer la queue d'un lion:
+\captionof{listing}{bash: comment faire rugir le lion?}
+\inputfile[linenos]{bash}{rah.sh}
+
+\begin{quoting}
+  \textbf{Commentaire:}
+  \begin{enumerate}
+  \item La condition posée à la ligne~17 se comprend ainsi:
+    \enquote{faites ce qui suit jusqu'à ce que le compteur de
+      rugissements atteigne une valeur supérieure à celle définie par
+    l'utilisateur. Si la valeur est supérieure, sortez de la boucle.}
+\item À la ligne~20, on demande à \emph{bash} d'attendre une seconde.
+\item À la ligne~21, on incrémente de 1 la valeur du compteur de
+  rugissements (voir ci-dessus le \vref{lst:countlines}, l.~14), puis
+  on reprend la boucle à la ligne~17.
+  \end{enumerate}
+\end{quoting}
+
+Exécution du script \verb|rah.sh|:
+\begin{minted}{text}
+[robert@kiddo courses]$ ./rah.sh
+Combien de fois tirez-vous la queue du lion? 3
+Raaaaaaaaahhhhhhhhhhhh! (1)
+Raaaaaaaaahhhhhhhhhhhh! (2)
+Raaaaaaaaahhhhhhhhhhhh! (3)
+[robert@kiddo courses]$ 
+\end{minted}
+
+\paragraph{break}
+\commande*{break} \verb|break| est une instruction qui
+ordonne de quitter immédiatement la boucle dans laquelle on se
+trouve. Supposons par exemple que l'on écrive un programme dans lequel
+on souhaite limiter une action telle que la copie de
+fichiers. L'instruction \verb|break| sera exécutée dès que la limite
+est atteinte. Appelons ce script \verb|copyten.sh|:
+\captionof{listing}{bash: copie d'un nombre limité de
+ fichiers\label{lst:copyten}}
+\inputfile[linenos]{bash}{copyten.sh}
+
+Ce script donne un exemple de code commenté. Comme on le voit, les
+commentaires peuvent se trouver sur des lignes isolées aussi bien que
+sur des lignes qui contiennent des commandes\footnote{Voir ci-dessus,
+  \vref{sec:les-commentaires}.}.
+
+Exécution du script \verb|copyten.sh|:
+\begin{minted}{text}
+[robert@kiddo courses]$ ls *.txt
+01.txt  03.txt  05.txt  07.txt  09.txt  11.txt
+02.txt  04.txt  06.txt  08.txt  10.txt  12.txt
+[robert@kiddo courses]$ ./copyten.sh
+Attention: ce programme copie au maximum 10 fichiers.
+Que souhaitez-vous copier: *.txt
+Répertoire de destination: Houba
+Erreur: la destination doit être un répertoire.
+        Le cas échéant, utilisez "mkdir Houba"
+        pour créer le répertoire de destination.
+[robert@kiddo courses]$ mkdir Houba
+[robert@kiddo courses]$ ./copyten.sh
+Attention: ce programme copie au maximum 10 fichiers.
+Que souhaitez-vous copier: *.txt
+Répertoire de destination: Houba
+Terminé. 10 fichiers au maximum ont été copiés dans Houba.
+[robert@kiddo courses]$ ls Houba/
+01.txt  02.txt  03.txt  04.txt  05.txt 06.txt  07.txt
+08.txt  09.txt  10.txt
+\end{minted}
+
+\paragraph{continue}
+\commande*{continue} À l'inverse de \verb|break|,
+\verb|continue| demande à \emph{bash} d'interrompre l'itération
+courante mais sans quitter la boucle, puis de reprendre la boucle à
+partir de l'itération suivante. C'est une façon de prévoir des
+exceptions. Par exemple, nous pouvons modifier le script
+\ref{lst:copyten} comme suit:
+
+\captionof{listing}{bash: copie d'un nombre limité de
+ fichiers sans échec si le fichier source n'existe pas}
+\inputfile[linenos,highlightlines={26-31}]{bash}{copyten-mk2.sh}
+
+\begin{quoting}
+  \textbf{Commentaire:}
+  \begin{enumerate}
+  \item À la ligne~30, l'instruction \verb|continue| intervient dans
+    le cas où le fichier à copier n'existe pas (voir le test de la
+    ligne~26).
+  \item Dans ce cas, le fichier est créé par la ligne~28.
+  \item Puis \verb|continue| interrompt la boucle et la reprend depuis
+   la ligne~24.
+  \end{enumerate}
+\end{quoting}
+
+Voici ce que donne l'exécution de ce script:
+\begin{minted}{text}
+[robert@kiddo courses]$ ./copyten-mk2.sh 
+Attention: ce programme copie au maximum 10 fichiers.
+Que souhaitez-vous copier: tchic.txt
+Répertoire de destination: Houba
+création de tchic.txt qui n'existe pas...
+Terminé. 10 fichiers au maximum ont été copiés dans Houba.
+[robert@kiddo courses]$ ls Houba/
+tchic.txt
+\end{minted}
+
+\section{Les fonctions}
+\label{sec:les-fonctions}
+Comme leur nom l'indique, les fonctions permettent d'exécuter des
+instructions de façon autonome dans un script. Elles peuvent être
+ensuite utilisées aussi souvent que nécessaire et permettent donc de
+réduire la taille du script. Deux formats sont permis:
+\begin{minted}[linenos]{bash}
+# Format 1
+ma_fonction () {
+  <commandes>
+}
+
+# Format 2
+function ma_fonction {
+<commands>
+}
+\end{minted}
+
+Ces deux formats sont strictement équivalents. Le premier est le plus
+répandu car il rappelle ce qui se fait dans de nombreux autres
+langages où l'on utilise les parenthèses pour passer aux fonctions des
+variables, des chaînes de caractères, des paramètres optionnels ou
+même d'autres fonctions. Toutefois, en \emph{bash}, on ne met jamais
+rien entre les parenthèses qui sont purement décoratives.
+
+Le script suivant permet de parvenir au même résultat que le script
+qui a été présenté dans le \vref{lst:countlines}:
+\captionof{listing}{bash: exemple de
+  fonction\label{lst:countlines-mk2}}
+\inputfile[linenos]{bash}{countlines-mk2.sh}
+
+Pour terminer, exécutons cette nouvelle version de notre script
+ici appelée \verb|countlines-mk2.sh|:
+
+\begin{minted}{text}
+[robert@kiddo courses]$ ./countlines-mk2.sh 
+Entrez le nom du fichier dont vous voulez compter les lignes:
+Fichier: makefile
+Votre fichier makefile compte 21 lignes.
+\end{minted}
+
+\printindex[cmds]
+\end{document}