\input{../_preamble}
\input{../_preamble_bbl}
\usepackage{menukeys}
\title{grep et bash}
\usepackage{units}
\usepackage{cleveref}
\usepackage{booktabs}
\usepackage{xltabular}
\usepackage{dingbat}
\usepackage{mdframed}
\mdfsetup{
  backgroundcolor=Lavender,
  hidealllines=true}
\usepackage{minted}
\surroundwithmdframed{minted}
\setminted{
  breaklines,
  breaksymbolright=\small\carriagereturn}
\setmintedinline{bgcolor=Lavender}
\usepackage{soul}

\begin{document}
\maketitle
\renewcommand{\contentsname}{Sommaire}
\tableofcontents

\chapter{grep, les expressions régulières}
\label{cha:grep-les-expressions}
Les expressions régulières se rapprochent des \emph{wildcards} ou
\enquote{métacaractères} qui ont été présentés dans
\href{https://notabug.org/ralessi/courses/src/master/fichiers/01-ligne-de-commande.tex#L709}{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
\end{xltabular}

\paragraph{grep, egrep}
À 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{https://notabug.org/ralessi/courses/src/master/fichiers/01-ligne-de-commande.tex#L732}{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/}}.

\hfill\verb|../..| à suivre

\end{document}
