Skip to content
GitLab
Explore
Sign in
Primary navigation
Search or go to…
Project
Linux
Manage
Activity
Members
Labels
Plan
Issues
Issue boards
Milestones
Wiki
Code
Merge requests
Repository
Branches
Commits
Tags
Repository graph
Compare revisions
Snippets
Build
Pipelines
Jobs
Pipeline schedules
Artifacts
Deploy
Releases
Container Registry
Model registry
Operate
Environments
Monitor
Incidents
Analyze
Value stream analytics
Contributor analytics
CI/CD analytics
Repository analytics
Model experiments
Help
Help
Support
GitLab documentation
Compare GitLab plans
Community forum
Contribute to GitLab
Provide feedback
Keyboard shortcuts
?
Snippets
Groups
Projects
Show more breadcrumbs
Picasoft
APIs
Init
Linux
Merge requests
!6
Semi adv
Code
Review changes
Check out branch
Download
Patches
Plain diff
Merged
Semi adv
semi-adv
into
master
Overview
0
Commits
9
Pipelines
1
Changes
1
Merged
Stephane Bonnet
requested to merge
semi-adv
into
master
6 years ago
Overview
0
Commits
9
Pipelines
1
Changes
1
Expand
0
0
Merge request reports
Compare
master
master (base)
and
latest version
latest version
8ba8c890
9 commits,
6 years ago
1 file
+
1098
−
22
Inline
Compare changes
Side-by-side
Inline
Show whitespace changes
Show one file at a time
src/cli/semi-adv.tex
+
1098
−
22
Options
\subsection
{
Wildcards et glob
s
}
\subsection
{
Globbing patterns et wildcard
s
}
\begin{frame}
[fragile]
{
Faire référence à plusieurs fichiers
}
%% globs
%% Attention aux fichiers cachés
C'est fastidieux d'être obligé d'écrire le nom de tous les fichiers dans
les commandes. On peut se simplifier la vie grâce aux globbing patterns.
\begin{block}
{
globbing pattern (
\emph
{
motif d'englobement
}
)
}
Un motif de nom de fichier qui en englobe plusieurs.
\end{block}
\begin{block}
{
wildcard (
\emph
{
joker
}
)
}
Lettre spéciale qui représente un caractère ou une suite de caractères
quelconques dans un
\emph
{
globbing pattern
}
.
\end{block}
\end{frame}
\begin{frame}
[fragile]
{
Le joker ``*''
}
Joker le plus utilisé.
Remplace toute suite de caractères dans un motif. S'il est utilisé seul, remplace tout mot.
\begin{exampleblock}
{
Créons des fichiers
}
\cmd
{
cd ; mkdir api ; cd api
}
\cmd
{
touch here that there this
}
\end{exampleblock}
\begin{alertblock}
{
Le point-virgule
}
Le point virgule sépare des commandes successives sur la ligne de commande.
\end{alertblock}
\begin{alertblock}
{
\cmd
{
touch
}}
Crée les fichiers passés en arguments. Si un fichier existe déjà,
met à jour sa date de dernière modification.
\end{alertblock}
\end{frame}
\begin{frame}
[fragile]
{
Le joker ``*''
}
\begin{exampleblock}
{
Supprimons des fichiers
}
On pourrait écrire:
\cmd
{
rm here that there this
}
\cmd
{
rm *
}
fait la même chose car le joker ``*'' correspond à tous les noms de fichiers.
\end{exampleblock}
\begin{beamercolorbox}
[rounded=true,shadow=true]
{
terminal
}
\begin{Verbatim}
$
ls
here that there this
$
\textcolor
{
yellow
}{
rm *
}
$
ls
$
\end{Verbatim}
\end{beamercolorbox}
\end{frame}
\begin{frame}
[fragile]
{
Le joker ``*''
}
\begin{exampleblock}
{
Re-créeons des fichiers
}
\cmd
{
touch here that there this
}
\end{exampleblock}
On peut restreindre le motif en donnant une partie du nom.
\begin{beamercolorbox}
[rounded=true,shadow=true]
{
terminal
}
\begin{Verbatim}
$
ls
*
here that there this
$
ls t*
that there this
$
ls
*
h
*
here that there this
$
ls th*e
there
$
ls that
*
that
$
ls thi*s
this
\end{Verbatim}
\end{beamercolorbox}
\begin{alertblock}
{
Attention
}
``*'' correspond aussi aux séquences vides!
\end{alertblock}
\end{frame}
\begin{frame}
[fragile]
{
Le joker ``?''
}
\begin{block}
{}
Il représente un caractère unique quelconque dans un motif.
\end{block}
\begin{beamercolorbox}
[rounded=true,shadow=true]
{
terminal
}
\begin{Verbatim}
$
ls th?t
that
$
ls th??
that this
$
ls th???
there
$
ls ?here
there
$
ls
*
here
\textcolor
{
red
}{
<
----
Attention ici le joker correspond aussi à une séquence vide
}
here there
\end
{
Verbatim
}
\end
{
beamercolorbox
}
\end
{
frame
}
\begin
{
frame
}
[
fragile
]
{
Le joker ``
[]
''
}
\begin
{
block
}{}
Permet de définir un ensemble de caractères pouvant apparaître dans le nom.
\end
{
block
}
\begin
{
exampleblock
}{
Créons plus de fichiers
}
\cmd
{
touch file
\_
1
file
\_
2
file
\_
3
file
\_
4
file
\_
a file
\_
b file
\_
c file
\_
d
}
\end
{
exampleblock
}
\begin
{
beamercolorbox
}
[
rounded
=
true,shadow
=
true
]
{
terminal
}
\begin
{
Verbatim
}
$
ls file
_
[12ab]
file
_
1 file
_
2 file
_
a file
_
b
\end{Verbatim}
\end{beamercolorbox}
\end{frame}
\begin{frame}
[fragile]
{
Le joker ``[]''
}
On peut spécifier des intervalles plutôt que de donner tous les caractères.
\begin{beamercolorbox}
[rounded=true,shadow=true]
{
terminal
}
\begin{Verbatim}
$
ls file
_
[
1
-
3
b
-
d
]
file
_
1
file
_
2
file
_
3
file
_
b file
_
c file
_
d
\end
{
Verbatim
}
\end
{
beamercolorbox
}
\vspace
{
10
pt
}
On peut aussi prendre le complément de la liste en la préfixant par un ``
\verb
+
^
+
''.
\begin
{
beamercolorbox
}
[
rounded
=
true,shadow
=
true
]
{
terminal
}
\begin
{
Verbatim
}
$
ls file
_
[
^
1-3b-d]
file
_
4 file
_
a
\end{Verbatim}
\end{beamercolorbox}
\end{frame}
\begin{frame}
[fragile]
{
Échappement de caractères
}
Et si il y a un fichier dont le nom contient le caractère ``-''?
\begin{exampleblock}
{
Un fichier de plus
}
\cmd
{
touch file
\_
-
}
\end{exampleblock}
\begin{beamercolorbox}
[rounded=true,shadow=true]
{
terminal
}
\begin{Verbatim}
$
ls file
_
[
1
-
3
b
-
d
]
file
_
1
file
_
2
file
_
3
file
_
b file
_
c file
_
d
$
ls file
_
[1-3b-d
\textcolor
{
yellow
}{
\textbackslash
{}
-
}
]
file
_
- file
_
1 file
_
2 file
_
3 file
_
b file
_
c file
_
d
\end{Verbatim}
\end{beamercolorbox}
\vspace
{
10pt
}
\begin{block}
{
Caractère d'échappement
}
Le caractère ``
\textbackslash
'' supprime l'interprétation par le shell du caractère qui le suit.
On peut même échapper l'espace.
\end{block}
\begin{beamercolorbox}
[rounded=true,shadow=true]
{
terminal
}
\begin{Verbatim}
$
touch my
\textbackslash
file
$
ls
'my file'
\textcolor
{
cyan
}{
<----- Les simple quotes indiquent qu'il s'agit d'un seul fichier
}
\end{Verbatim}
\end{beamercolorbox}
\end{frame}
\begin{frame}
[fragile]
{
Expansion d'accolades
}
\begin{block}
{
Expansion d'accolades
}
\cmd
{
bash
}
supporte l'expansion d'accolades: générer toutes les chaînes dans un intervalle ou à partir
d'une liste.
\end{block}
\begin{beamercolorbox}
[rounded=true,shadow=true]
{
terminal
}
\begin{Verbatim}
$
echo
\{
1
..
20
\}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
$
echo a
\{
c,d,e
\}
f
acf adf aef
\end{Verbatim}
\end{beamercolorbox}
\vspace
{
10pt
}
Cette expansion peut être utilisée dans des motifs.
\begin{beamercolorbox}
[rounded=true,shadow=true]
{
terminal
}
\begin{Verbatim}
$
touch file
_
\{
1
..
20
\}
$
ls
file
_
1 file
_
12 file
_
15 file
_
18 file
_
20 file
_
5 file
_
8
file
_
10 file
_
13 file
_
16 file
_
19 file
_
3 file
_
6 file
_
9
file
_
11 file
_
14 file
_
17 file
_
2 file
_
4 file
_
7
$
rm file
_
\{
12
..
14
\}
$
ls
file
_
1 file
_
15 file
_
18 file
_
20 file
_
5 file
_
8
file
_
10 file
_
16 file
_
19 file
_
3 file
_
6 file
_
9
file
_
11 file
_
17 file
_
2 file
_
4 file
_
7
\end{Verbatim}
\end{beamercolorbox}
\end{frame}
\begin{frame}
[fragile]
{
Expansion d'accolades
}
\begin{block}
{
Extensions multiples
}
L'expansion d'accolade est très utilisée pour sélectionner des fichiers avec des extensions multiples.
\cmd
ls *.
\{
jpg,png,bmp
\}
listera tous les fichiers correspondants à ces extensions.
\end{block}
\begin{alertblock}
{
Extensions
}
\begin{itemize}
\item
Les extensions n'ont pas de sens particulier sous UNIX.
\item
Spécificité de Windows et de ses prédécesseurs.
\item
Pratique pour indiquer le type des fichiers...
\end{itemize}
\end{alertblock}
\end{frame}
\begin{frame}
[fragile]
{
Remarques
}
\begin{block}
{
Jokers dans les chemins
}
Le chemin fait partie du nom des fichiers, on peut mettre des jokers dans ceux-ci.
\cmd
{
ls /var/*/*.log
}
liste tous les fichiers de logs dans tous les sous-répertoires directs de
\cmd
{
/var
}
\cmd
{
ls /var/*/*/*.log
}
liste tous les fichiers de logs dans tous les sous-répertoires des sous-répertoires de
\cmd
{
/var
}
\end{block}
\begin{block}
{
Si le motif ne correspond à aucun fichier?
}
Dans ce cas, le motif est transmis tel quel à la commande.
\end{block}
\begin{beamercolorbox}
[rounded=true,shadow=true]
{
terminal
}
\begin{Verbatim}
$
rm file?
rm: impossible de supprimer 'file?': Aucun fichier ou dossier de ce type
\end
{
Verbatim
}
\end
{
beamercolorbox
}
\end
{
frame
}
\begin
{
frame
}
[
fragile
]
{
Remarques
}
\begin
{
alertblock
}{
Attention aux noms pris comme des options
}
On suppose qu'il existe un fichier ``
-
R''.
Si on exécute ``
\cmd
{
rm
*
}
'', l'englobement va passer le nom
\cmd
{
-
R
}
à ``
\cmd
{
rm
}
'' qui l'interprétera comme une option.
La commande réellement exécutée sera ``
\cmd
{
rm
-
R
*
}
''. Oups
!
\end
{
alertblock
}
\begin
{
block
}{
Séparer les options des arguments
}
\begin
{
itemize
}
\item
``
\cmd
{
-
{}
-
}
'' est utilisé dans les commandes pour séparer explicitement les options des arguments.
\item
Tout ce qui suit ``
\cmd
{
-
{}
-
}
'' est interprété comme un argument.
\end
{
itemize
}
``
\cmd
{
rm
-
{}
-
*
}
'' est donc plus sûr, puisque c'est bien la commande ``
\cmd
{
rm
-
{}
-
-
R
*
}
'' qui sera exécutée.
\end
{
block
}
\end
{
frame
}
\begin
{
frame
}
[
fragile
]
{
Et les fichiers cachés?
}
%% globs
%% Attention aux fichiers cachés
\begin
{
block
}{
Des fichiers cachés? Où ça?
}
Tous les fichiers dont le nom commence par un point sont cachés.
\begin
{
itemize
}
\item
Ils ne sont pas affichés par ``
\cmd
{
ls
}
''.
\item
Ils ne sont pas considérés pour l'englobement.
\end
{
itemize
}
\end
{
block
}
\begin
{
beamercolorbox
}
[
rounded
=
true,shadow
=
true
]
{
terminal
}
\begin
{
Verbatim
}
$
touch .hidden
$
ls
$
ls -a
\textcolor
{
blue
}{
.
}
\textcolor
{
blue
}{
..
}
.hidden
$
rm
*
$
ls -a
\textcolor
{
blue
}{
.
}
\textcolor
{
blue
}{
..
}
.hidden
\end{Verbatim}
\end{beamercolorbox}
\end{frame}
\begin{frame}
[fragile]
{
Et les fichiers cachés?
}
\begin{alertblock}
{
\cmd
{
shopt
}}
\cmd
{
shopt
}
permet de changer certaines options du shell.
\begin{itemize}
\item
\cmd
{
shopt -s <option>
}
active l'option
\cmd
{
<option>
}
\item
\cmd
{
shopt -u <option>
}
active l'option
\cmd
{
<option>
}
\end{itemize}
\end{alertblock}
\begin{block}
{
L'option
\cmd
{
dotglob
}}
Si elle est active, les fichiers commençant par un point sont candidats à l'englobement. Par défaut désactivée.
\end{block}
\begin{beamercolorbox}
[rounded=true,shadow=true]
{
terminal
}
\begin{Verbatim}
$
ls
-
a
\textcolor
{
blue
}{
.
}
\textcolor
{
blue
}{
..
}
.hidden
$
\textcolor
{
yellow
}{
shopt -s dotglob
}
$
rm
*
$
ls -a
\textcolor
{
blue
}{
.
}
\textcolor
{
blue
}{
..
}
\end{Verbatim}
\end{beamercolorbox}
\end{frame}
\subsection
{
Chercher des fichiers
}
\begin{frame}
{
Trouver des fichiers
}
Des centaines de milliers de fichiers sur une distribution classique.
Difficile de s'y retrouver sans outils...
\begin{block}
{
\cmd
{
locate
}}
Recherche des fichiers dans une base de données préremplie
\end{block}
\begin{block}
{
\cmd
{
find
}}
Recherche des fichiers dans l'arborescence, éventuellement avec des filtres
précis.
\end{block}
\end{frame}
\begin{frame}
[fragile]
{
\cmd
{
locate
}}
%% find
%% Exécution de commandes
\begin{block}
{}
\begin{description}
\item
[\cmd{locate <motif>}]
recherche
\cmd
{
<motif>
}
dans la base de données
\cmd
{
/var/lib/mlocate/mlocate.db
}
\end{description}
\end{block}
\begin{beamercolorbox}
[rounded=true,shadow=true]
{
terminal
}
\begin{Verbatim}
$
locate issue
/
etc
/
issue
/
etc
/
issue.net
[
...
]
\end
{
Verbatim
}
\end
{
beamercolorbox
}
\begin
{
alertblock
}{
Si
\cmd
{
locate
}
ne renvoie rien
}
\begin
{
itemize
}
\item
Rien n'a été trouvé
\item
La base de donnée est vide
\end
{
itemize
}
\end
{
alertblock
}
\end
{
frame
}
\begin
{
frame
}
[
fragile
]
{
\cmd
{
updatedb
}}
\begin
{
block
}{}
\begin
{
description
}
\item
[
\cmd
{
updatedb
}
]
met à jour la base de données
\cmd
{
/
var
/
lib
/
mlocate
/
mlocate.db
}
\end
{
description
}
\end
{
block
}
\begin
{
alertblock
}{
\cmd
{
sudo
}
obligatoire
!
}
Cette commande modifie un fichier que seul le superutilisateur peut modifier.
Il faut exécuter
\cmd
{
sudo updatedb
}
.
\end
{
alertblock
}
\begin
{
alertblock
}{
\cmd
{
sudo
}
(
\emph
{
SuperUserDO
}
)
}
\begin
{
itemize
}
\item
Cette commande exécute une autre commande avec les droits du superutilisateur.
\item
Seuls certains utilisateurs ont le droit de l'invoquer.
\item
Elle demande le mot de passe de l'utilisateur qui l'invoque avant de s'exécuter.
\end
{
itemize
}
\end
{
alertblock
}
\end
{
frame
}
\begin
{
frame
}
[
fragile
]
{
\cmd
{
find
}}
\begin
{
block
}{}
\begin
{
description
}
\item
[
\cmd
{
find
}
]
recherche un fichier dans le système de fichiers.
\end
{
description
}
\end
{
block
}
Il suffit de spécifier le point de départ et ce qu'on cherche.
\begin
{
beamercolorbox
}
[
rounded
=
true,shadow
=
true
]
{
terminal
}
\begin
{
Verbatim
}
$
find . -name file
_
1
./api/file
_
1
\end{Verbatim}
\end{beamercolorbox}
On peut utiliser des jokers dans le nom
\begin{beamercolorbox}
[rounded=true,shadow=true]
{
terminal
}
\begin{Verbatim}
$
find .
-
name 'file
_
1
*
'
-
print
.
/
api
/
file
_
11
.
/
api
/
file
_
18
.
/
api
/
file
_
1
[
...
]
\end
{
Verbatim
}
\end
{
beamercolorbox
}
\begin
{
alertblock
}{
Attention aux quotes
}
Le motif doit être entre quotes, sinon il sera interprété par le
shell.
\end
{
alertblock
}
\end
{
frame
}
\begin
{
frame
}
[
fragile
]
{
Filtrer avec
\cmd
{
find
}}
\begin
{
block
}{}
\cmd
{
find
}
est capable de filtrer la recherche
\begin
{
itemize
}
\item
{
Par type de fichier
}
\item
{
Par taille
}
\item
{
Par date de modification
}
\item
...
\end
{
itemize
}
\end
{
block
}
\begin
{
exampleblock
}{
Cherchons les fichiers de plus de
10
Mo
}
\cmd
{
find
/
-
size
+
10
M
-
print
}
\end
{
exampleblock
}
\begin
{
alertblock
}{
Il y a plein d'erreurs
!
}
Elles sont dûes au permissions d'accès à certains fichiers.
On peut les supprimer en redirigeant la sortie d'erreur vers
le périphérique 'poubelle'
\cmd
{
/
dev
/
null
}
:
\cmd
{
find
/
-
size
+
10
M
-
print
2
>
/
dev
/
null
}
\end
{
alertblock
}
\end
{
frame
}
\begin
{
frame
}
[
fragile
]
{
Exécuter des commandes avec
\cmd
{
find
}}
\cmd
{
find
}
peut exécuter une commande sur chaque fichier trouvé
avec l'option
\cmd
{
-
exec
}
.
\begin
{
exampleblock
}{
Créer un backup de chaque fichier
}
\cmd
{
find api
-
name 'file
*
'
-
exec cp
\{\}
\{\}
.bak
\textbackslash
;
}
\end
{
exampleblock
}
\begin
{
block
}{
Explication
}
\begin
{
itemize
}
\item
\cmd
{
cp
}
]
est exécutée pour chaque fichier trouvé
\item
\cmd
{
\{\}
}
est remplacé par le nom du fichier trouvé
\item
\cmd
{
\textbackslash
;
}
indique la fin de la commande.
\end
{
itemize
}
\end
{
block
}
\begin
{
alertblock
}{}
\begin
{
itemize
}
\item
\cmd
{
-
exec
}
n'autorise qu'une seule commande.
\item
On peut avoir plusieurs
\cmd
{
-
exec
}
.
\end
{
itemize
}
\end
{
alertblock
}
\end
{
frame
}
\subsection
{
Chercher à l'intérieur des fichiers
}
\begin
{
frame
}
[
fragile
]
{
\cmd
{
grep
}}
\begin
{
block
}{}
\begin
{
description
}
\item
[
\cmd
{
grep
}
]
recherche un motif dans des fichiers
\end
{
description
}
\end
{
block
}
\begin
{
exampleblock
}{
Chercher tous les mots qui contiennent ``aard''
}
\cmd
{
grep 'aard'
/
usr
/
share
/
dict
/
words
}
\end
{
exampleblock
}
\begin
{
beamercolorbox
}
[
rounded
=
true,shadow
=
true
]
{
terminal
}
\begin
{
Verbatim
}
$
grep 'aard' /usr/share/dict/words
Kierkeg
\textcolor
{
red
}{
aard
}
Kierkeg
\textcolor
{
red
}{
aard
}
's
\textcolor
{
red
}{
aard
}
vark
\textcolor
{
red
}{
aard
}
vark's
\textcolor
{
red
}{
aard
}
varks
\end{Verbatim}
\end{beamercolorbox}
\begin{block}
{
Remarques
}
\begin{itemize}
\item
{
\cmd
{
grep
}
peut être utilisée récursivement:
option
\cmd
{
-R
}}
\item
{
\cmd
{
grep
}
sans argument, cherche le motif sur l'entrée
standard
}
\end{itemize}
\end{block}
\end{frame}
\begin{frame}
[fragile]
{
Expressions régulières
}
\begin{frame}
[fragile]
{
Expressions régulières (
\emph
{
regex
}
)
}
\begin{block}
{}
\begin{itemize}
\item
Chaîne de caractères qui décrit précisément un ensemble
de chaînes de caractères possibles.
\item
Dans les commandes qui utilisent un motif (comme
\cmd
{
grep
}
), le motif est presque toujours une expression régulière.
\end{itemize}
\end{block}
\end{frame}
\begin{frame}
[fragile]
{
Expressions régulières (
\emph
{
regex
}
)
}
\framesubtitle
{
Bases
}
\begin{itemize}
\item
Décrit la suite de caractères qui doivent correspondre dans une chaîne.
\item
Les alternatives sont séparées par une barre verticale:
\cmd
{
a|b
}
reconnaît tout
mot contenant 'a' ou 'b'.
\item
Les parenthèses regroupent les expressions:
\begin{itemize}
\item
\cmd
{
ab|cd
}
reconnaît tout mot contenant 'ab' ou 'cd'
\item
\cmd
{
a(b|c)d
}
reconnaît tout mot contenant 'abd' ou 'acd'.
\end{itemize}
\end{itemize}
\begin{alertblock}
{
Attention aux caractères interprétés par le shell
}
Les parenthèses et les barres verticales sont interprétées par le shell.
Il faut les échapper pour les utiliser dans des regex. Pour exploiter le motif
\cmd
{
a(b|c)d
}
avec grep, il faudra écrire:
\begin{center}
\cmd
{
grep 'a
\textbackslash
(b
\textbackslash
|c
\textbackslash
)d'
}
\end{center}
\end{alertblock}
\end{frame}
\begin{frame}
[fragile]
{
Expressions régulières (
\emph
{
regex
}
)
}
\framesubtitle
{
Caractères
}
Chaque caractère de la chaîne à reconnaître doit être spécifié, soit en donnant sa valeur
directement ou en donnant sa classe.
\begin{itemize}
\item
\cmd
{
abcd
}
: la suite 'abcd'.
\item
\cmd
{
[ab]bcd
}
: soit a, soit b suivi de bcd. Les crochets définissent une
classe de caractères acceptables pour un caractère donné.
\item
\cmd
{
[a-z]bcd
}
: on peut utiliser des intervalles dans les classes.
\item
\cmd
{
a.b
}
: trois caractères commençant par a et finissant par b.
Le point correspond à n'importe quel caractère.
\item
\cmd
{
[:alnum:]
}
: tout caractère alphanumérique
\item
\cmd
{
[:digit:]
}
: tout chiffre
\item
\cmd
{
[:space:]
}
: tout espace
\end{itemize}
\end{frame}
\begin{frame}
[fragile]
{
Expressions régulières (
\emph
{
regex
}
)
}
\framesubtitle
{
Quantificateurs et prédicats
}
Il représentent le nombre de répétitions d'une expression et ajoutent des contraintes sur
sa position dans la chaîne.
\begin{itemize}
\item
\cmd
{
expr*
}
: le motif
\cmd
{
expr
}
répété 0 ou plusieurs fois.
\item
\cmd
{
expr+
}
: le motif
\cmd
{
expr
}
répété 1 ou plusieurs fois.
\item
\cmd
{
expr?
}
: le motif
\cmd
{
expr
}
répété 0 ou une fois.
\item
\verb
+
^expr
+
: le motif
\cmd
{
expr
}
en début de ligne.
\item
\cmd
{
expr
\$
}
: le motif
\cmd
{
expr
}
en fin de ligne.
\end{itemize}
\end{frame}
\begin{frame}
[fragile]
{
\cmd
{
grep
}
et expressions régulières
}
\begin{exampleblock}
{
Trouver tous les mots commençant par ab
}
\verb
+
grep '^ab' /usr/share/dict/words
+
\end{exampleblock}
\begin{exampleblock}
{
Trouver tous les mots de quatre lettres commençant par g et finissant par t
}
\verb
+
grep '^g..t$' /usr/share/dict/words
+
\end{exampleblock}
\begin{exampleblock}
{
Trouver tous les mots commençant par g et finissant par t
}
\verb
,
grep '^g.\+t$' /usr/share/dict/words
,
\end{exampleblock}
\begin{alertblock}
{
C'est très pratique...
}
...pour les mots croisés!
\end{alertblock}
\end{frame}
\subsection
{
Identifier des fichiers
}
\begin{frame}
[fragile]
{
\cmd
{
file
}}
\begin{block}
{}
\begin{description}
\item
[\cmd{file}]
identifie la nature des données d'un fichier.
\end{description}
\end{block}
\begin{beamercolorbox}
[rounded=true,shadow=true]
{
terminal
}
\begin{Verbatim}
$
file
/
usr
/
lib
/
libreoffice
/
program
/
intro.png
/
usr
/
lib
/
libreoffice
/
program
/
intro.png: PNG image data,
661
x
169
,
8
-
bit
/
color RGBA, interlaced
$
file /bin/bash
/bin/bash: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked,
interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0,
BuildID[sha1]=b636f50d85c3cca7cf2518030446660c1d90d660, stripped
\end{Verbatim}
\end{beamercolorbox}
\begin{block}
{
Remarque
}
\cmd
{
file
}
fonctionne en analysant réellement le contenu du fichier, il ne se sert pas de
l'extension.
\end{block}
\end{frame}
\subsection
{
Manipuler des fichiers
}
\begin{frame}
[fragile]
{
Un peu de manipulation de fichiers
}
%% cut
%% sort
%% wc
%% diff
Il existe de nombreuses commandes de manipulation de fichiers utiles:
\begin{description}
\item
[\cmd{wc}]
Compte les lignes, mots, etc. d'un fichier
\item
[\cmd{sort}]
Trie les lignes d'un fichier
\item
[\cmd{uniq}]
Supprime les doublons adjacents d'un fichier
\item
[\cmd{tr}]
Transforme les caractères d'un fichier
\item
[\cmd{diff}]
Compare deux fichiers et affiche les différences
\item
[\cmd{cut}]
Découpe un fichier en champs
\item
[\cmd{sed}]
Édite un fichier à la volée
\end{description}
\end{frame}
\begin{frame}
[fragile]
{
\cmd
{
tr
}}
\begin{block}
{}
\begin{description}
\item
[\cmd{tr}]
Transforme des caractères entre deux ensembles
\end{description}
\end{block}
\begin{beamercolorbox}
[rounded=true,shadow=true]
{
terminal
}
\begin{Verbatim}
$
cd ~
/
api ; echo 'The quick brown fox jumps over the lazy dog' > file.txt
\end
{
Verbatim
}
\end
{
beamercolorbox
}
\begin
{
columns
}
\begin
{
column
}{
.
45
\textwidth
}
Un peu de cryptographie...
\begin
{
beamercolorbox
}
[
rounded
=
true,shadow
=
true
]
{
terminal
}
\begin
{
Verbatim
}
$
\textcolor
{
yellow
}{
tr 'a-z' 'b-za' < file.txt
}
Tif rvjdl cspxo gpy kvnqt pwfs uif mbaz eph
\end{Verbatim}
\end{beamercolorbox}
Passage en capitales...
\begin{beamercolorbox}
[rounded=true,shadow=true]
{
terminal
}
\begin{Verbatim}
$
\textcolor
{
yellow
}{
tr
[
:lower:
]
[
:upper:
]
< file.txt
}
THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG
\end
{
Verbatim
}
\end
{
beamercolorbox
}
\end
{
column
}
\begin
{
column
}{
.
45
\textwidth
}
Séparons les mots...
\begin
{
beamercolorbox
}
[
rounded
=
true,shadow
=
true
]
{
terminal
}
\begin
{
Verbatim
}
$
\textcolor
{
yellow
}{
tr [:blank:] '
\textbackslash
{}
n' < file.txt
}
The
quick
brown
fox
jumps
over
the
lazy
dog
\end{Verbatim}
\end{beamercolorbox}
\end{column}
\end{columns}
\begin{alertblock}
{
Séquences d'échappement
}
Interprétées par le shell comme des caractères spéciaux:
\cmd
{
\textbackslash
{}
n
}
est un retour à la ligne,
\cmd
{
\textbackslash
{}
t
}
une
tabulation...
\end{alertblock}
\end{frame}
\begin{frame}
[fragile]
{
\cmd
{
cut
}}
\begin{block}
{}
\begin{description}
\item
[\cmd{cut}]
Supprime des sections de chaque ligne d'un fichier.
\end{description}
\end{block}
\begin{columns}
\begin{column}
{
.45
\textwidth
}
On garde les caractères 5 à 9...
\begin{beamercolorbox}
[rounded=true,shadow=true]
{
terminal
}
\begin{Verbatim}
$
\textcolor
{
yellow
}{
cut
-
c
5
-
9
file.txt
}
quick
\end
{
Verbatim
}
\end
{
beamercolorbox
}
\end
{
column
}
\begin
{
column
}{
.
45
\textwidth
}
On garde les champs
3
et
5
...
\begin
{
beamercolorbox
}
[
rounded
=
true,shadow
=
true
]
{
terminal
}
\begin
{
Verbatim
}
$
\textcolor
{
yellow
}{
cut -f 3,5 -d' ' file.txt
}
brown jumps
\end{Verbatim}
\end{beamercolorbox}
\end{column}
\end{columns}
\begin{alertblock}
{
Délimiteur
}
Le délimiteur de champs est par défaut la tabulation. L'option
\cmd
{
-d
}
permet de le changer.
\end{alertblock}
\end{frame}
\begin{frame}
[fragile]
{
\cmd
{
sed
}}
\begin{block}
{}
\begin{description}
\item
[\cmd{sed}]
(
\emph
{
Stream EDitor
}
) Édite le fichier ligne par ligne à la volée.
\end{description}
\end{block}
Remplaçons
\emph
{
brown
}
par
\emph
{
yellow
}
...
\begin{beamercolorbox}
[rounded=true,shadow=true]
{
terminal
}
\begin{Verbatim}
$
\textcolor
{
yellow
}{
sed 's
/
brown
/
yellow
/
g' file.txt
}
The quick yellow fox jumps over the lazy dog
\end
{
Verbatim
}
\end
{
beamercolorbox
}
\begin
{
itemize
}
\item
\cmd
{
s
}
est la commande de remplacement. Elle prend deux paramètres:
\begin
{
itemize
}
\item
le motif à rechercher
(
c'est une regex
)
\item
le texte à substituer aux correspondances
\end
{
itemize
}
\item
\cmd
{
g
}
indique que le remplacement affecte toutes les occurrences.
\item
Le séparateur est le caractère qui suit directement la commande
\cmd
{
s
}
.
On aurait pu utiliser un autre caractère que ``
/
''.
\end
{
itemize
}
\begin
{
alertblock
}{
RTFM
}
\cmd
{
sed
}
est une commande très puissante mais très complexe. Lisez le man.
\end
{
alertblock
}
\end
{
frame
}
\subsection
{
Combiner les commandes: les pipes
}
\begin{frame}
[fragile]
{
Pipes
}
\begin
{
frame
}
[
fragile
]
{
Les Pipes
}
\framesubtitle
{
Généralités
}
\begin
{
alertblock
}{
KISS
(
Keep It Simple, Stupid
)
}
Les commandes, aussi complexes qu'elles soient, sont chacune spécialisées dans une
fonction spécifique. C'est la philosophie générale des commandes Unix: ne faire qu'une
chose, mais la faire bien.
\end
{
alertblock
}
\begin
{
block
}{
Les pipes
(
ou tubes
)
}
\begin
{
itemize
}
\item
Connectent la sortie standard d'une commande à l'entrée standard d'une autre.
\item
Permettent de chaîner des commandes pour construire des traitements complexes.
\end
{
itemize
}
\end
{
block
}
\end
{
frame
}
\begin
{
frame
}
[
fragile
]
{
Les Pipes
}
\framesubtitle
{
Comment ça marche?
}
Supposons qu'on veuille voir le listing complet des fichiers du système. On peut
exécuter ``
\cmd
{
ls
-
lR
/
}
'' mais la sortie est trop grande et on ne pourra pas tout voir...
On peut utiliser les services de
\cmd
{
less
}
pour paginer la sortie.
Il suffit de taper:
\begin
{
exampleblock
}{}
\cmd
{
ls
-
lR
/
| less
}
\end
{
exampleblock
}
Le symbole ``|'' représente le pipe entre les deux commandes.
\end
{
frame
}
\begin
{
frame
}
[
fragile
]
{
Les Pipes
}
\framesubtitle
{
Remarques
}
\begin
{
itemize
}
\item
Les pipes ne sont pas de taille infinie. Les commandes qui produisent
les données
(
ici
\cmd
{
ls
}
)
attendent lorsqu'ils sont pleins.
\textbf
{
On ne peut pas perdre
de données dans un pipe.
}
\item
Si on arrête le consommateur
(
ici
\cmd
{
less
}
)
, le producteur se termine également
par fermeture de son fichier de sortie standard.
\item
De même, la fin du producteur entraine la fermeture de l'entrée standard du
consommateur et donc son arrêt.
\end
{
itemize
}
\end
{
frame
}
\begin{frame}
[fragile]
{
\cmd
{
tee
}}
\begin
{
frame
}
[
fragile
]
{
Les Pipes
}
\framesubtitle
{
La commande
\cmd
{
tee
}}
On peut vouloir enregistrer la sortie d'une commande dans un fichier en même temps
qu'on la transmet à une autre commande par un pipe.
\begin
{
block
}{
\cmd
{
tee
}}
\begin
{
description
}
\item
[
\cmd
{
tee
}
]
lit son entrée standard, l'enregistre dans un fichier et
la recopie sur sa sortie standard.
\end
{
description
}
\end
{
block
}
\begin
{
exampleblock
}{
Enregistrer la sortie de
\cmd
{
ls
-
lR
}
pendant qu'on compte les fichiers
}
\verb
+
ls
-
lR ~ | tee listing.txt | wc
-
l
+
\end
{
exampleblock
}
\end
{
frame
}
\begin
{
frame
}
[
fragile
]
{
Les Pipes
}
\framesubtitle
{
A vous de jouer
!
}
\begin
{
itemize
}
\item
Téléchargez ``Vingt mille lieues sous les mers'' de Jules VERNE depuis le site du
projet Gutemberg:
\end
{
itemize
}
\begin
{
exampleblock
}{}
\cmd
{
wget http:
//
www.gutenberg.org
/
files
/
54873
/
54873
-
0
.txt
}
\end
{
exampleblock
}
\begin
{
exampleblock
}{
Combien de mots différents sont utilisés par l'auteur?
}
Il faut: lire le fichier, le transformer pour qu'il ait un mot par ligne, trier les mots,
éliminer les mots en double ou plus, compter le nombre de lignes.
\end
{
exampleblock
}
\begin
{
exampleblock
}{
Combien de fois le Capitaine Nemo est
-
il nommé?
}
L'approche est similaire, mais il faut aussi ne garder que le mot ``Nemo''.
\end
{
exampleblock
}
\end
{
frame
}
\subsection
{
Processus et jobs
}
\begin
{
frame
}
[
fragile
]
{
Les processus
}
\framesubtitle
{
Définition
}
\begin
{
block
}{
Qu'est
-
ce que c'est?
}
\begin
{
itemize
}
\item
Un processus est un programme en cours d'exécution.
\item
Un programme est un exécutable binaire stocké sur le disque dans un fichier
\item
A son exécution, le programme est copié en mémoire par le système et
devient un processus.
\item
De nombreux processus s'exécutent en même temps: c'est une des fonctions
principales du système de partager le processeur et la mémoire entre ceux
-
ci.
\end
{
itemize
}
\end
{
block
}
\end
{
frame
}
\begin{frame}
[fragile]
{
Mettre fin à des processus
}
\begin
{
frame
}
[
fragile
]
{
Les processus
}
\framesubtitle
{
Hierarchie des processus
}
\begin
{
block
}{
PID
}
Les processus sont identifiés par in nombre: l'identifiant du processus,
ou
\emph
{
Process ID
(
PID
)
}
.
\end
{
block
}
\begin
{
block
}{
Arborescence des processus
}
Un processus a un père unique: c'est le processus qui l'a créé. L'ID du
processus père est le
\emph
{
Parent Process ID
(
PPID
)
}
.
\end
{
block
}
\begin
{
block
}{
Processus initial
}
Le premier processus est exécuté directement par le noyau au démarrage. Il s'agit du
processus
\cmd
{
init
}
(
\cmd
{
systemd
}
sur Ubuntu
)
. Son PID est
0
et il est l'ancêtre de
tous les processus.
\end
{
block
}
\end
{
frame
}
\begin
{
frame
}
[
fragile
]
{
Les processus
}
\framesubtitle
{
État des processus
}
A tout instant, un processus est dans l'un des états suivants:
\begin
{
itemize
}
\item
R
(
Running
)
: Processus éligible au processeur
\item
S
(
Sleeping
)
: Processus en attente d'un événement
\item
D
(
Uninterruptible Sleep
)
: Processus en attente d'une entrée
/
sortie
\item
T
(
Stopped
)
: Processus interrompu par un signal de contrôle
\item
Z
(
Zombie
)
: Terminé, en attente du processus père
\end
{
itemize
}
% \begin{center}
% \begin{tabular}{|m{1cm}|m{3cm}|m{5.5cm}|}
% \hline
% \textbf{Lettre} & \textbf{Signification} & \textbf{Description} \\
% \hline\hline
% R & Running & Processus éligible au processeur \\
% \hline
% S & Sleeping & Processus en attente d'un événement \\
% \hline
% D & Uninterruptible Sleep & Processus en attente d'une entrée / sortie \\
% \hline
% T & Stopped & Processus interrompu par un signal de contrôle \\
% \hline
% Z & Zombie & Terminé, en attente du processus père \\
% \hline
% \end{tabular}
% \end{center}
\end
{
frame
}
\begin
{
frame
}
[
fragile
]
{
Les processus
}
\framesubtitle
{
Voir les processus
}
\begin
{
block
}{
\cmd
{
ps
}}
\begin
{
description
}
\item
[
\cmd
{
ps
}
]
affiche les processus en cours d'exécution et les informations associées
\end
{
description
}
\end
{
block
}
\cmd
{
ps
}
seul affiche tous les processus de l'utilisateur associé au terminal:
\begin
{
beamercolorbox
}
[
rounded
=
true,shadow
=
true
]
{
terminal
}
\begin
{
Verbatim
}
$
ps
PID TTY TIME CMD
10923 pts/2 00:00:01 bash
12472 pts/2 00:00:00 cat
12622 pts/2 00:00:00 ps
\end{Verbatim}
\end{beamercolorbox}
Il y a ici trois processus. Les champs s'interprètent comme suit:
\begin{description}
\item
[PID]
Le PID
\item
[TTY]
Le terminal de contrôle
\item
[TIME]
Le temps réellement passé à utiliser le processeur
\item
[CMD]
La commande exécutée
\end{description}
\end{frame}
\begin{frame}
[fragile]
{
Les processus
}
\framesubtitle
{
Voir les processus
}
La commande ``
\cmd
{
ps a
}
'' affiche tous les processus de l'utilisateur.
\begin{beamercolorbox}
[rounded=true,shadow=true]
{
terminal
}
\begin{Verbatim}
$
ps a
PID TTY STAT TIME COMMAND
986
tty
1
Ssl
+
0
:
00
/
usr
/
lib
/
gdm
3
/
gdm
-
x
-
session
--
run
-
script env GNOME
_
S
988
tty
1
Sl
+
21
:
46
/
usr
/
lib
/
xorg
/
Xorg vt
1
-
displayfd
3
-
auth
/
run
/
user
/
999
tty
1
Sl
+
0
:
00
/
usr
/
lib
/
gnome
-
session
/
gnome
-
session
-
binary
--
sessio
1163
tty
1
Sl
+
41
:
15
/
usr
/
bin
/
gnome
-
shell
1208
tty
1
Sl
14
:
18
ibus
-
daemon
--
xim
--
panel disable
1212
tty
1
Sl
0
:
00
/
usr
/
lib
/
ibus
/
ibus
-
dconf
[
...
]
\end
{
Verbatim
}
\end
{
beamercolorbox
}
\medskip
La commande ``
\cmd
{
ps aux
}
'' affiche tous les processus de tous les utilisateurs.
\end
{
frame
}
\begin
{
frame
}
[
fragile
]
{
Les processus
}
\framesubtitle
{
Voir les processus
}
\begin
{
block
}{
\cmd
{
pstree
}}
La commande
\cmd
{
pstree
}
affiche l'arbre des processus en cours d'exécution
/
\end
{
block
}
\begin
{
beamercolorbox
}
[
rounded
=
true,shadow
=
true
]
{
terminal
}
\begin
{
Verbatim
}
$
pstree -A
systemd-+-ModemManager---2*[
{
ModemManager
}
]
|-NetworkManager-+-dhclient
| `-2*[
{
NetworkManager
}
]
|-2*[VBoxClient---VBoxClient]
|-2*[VBoxClient---VBoxClient---
{
VBoxClient
}
]
|-VBoxClient---VBoxClient---2*[
{
VBoxClient
}
]
|-VBoxService---7*[
{
VBoxService
}
]
|-accounts-daemon---2*[
{
accounts-daemon
}
]
|-acpid
|-avahi-daemon---avahi-daemon
|-boltd---2*[
{
boltd
}
]
|-colord---2*[
{
colord
}
]
|-cron
[...]
\end{Verbatim}
\end{beamercolorbox}
\begin{alertblock}
{}
\cmd
{
systemd
}
est bien l'ancêtre de tout les processus...
\end{alertblock}
\end{frame}
\begin{frame}
[fragile]
{
Les processus
}
\framesubtitle
{
Suivre les processus en temps réel
}
\begin{block}
{
\cmd
{
top
}
,
\cmd
{
htop
}}
\begin{itemize}
\item
\cmd
{
top
}
affiche l'évolution des processus en temps réel. Quitter avec ``q''.
\item
\cmd
{
htop
}
fait la même chose avec une interface plus moderne.
\end{itemize}
Ces deux commandes montrent aussi en temps réel l'utilisation des processeurs et
l'occupation de la mémoire. Elles permettent de suivre les performances du système.
\end{block}
\end{frame}
\begin{frame}
[fragile]
{
Les processus
}
\framesubtitle
{
Les signaux
}
\begin{block}
{
Signal
}
Le noyau peut transmettre des signaux aux processus pour des raisons diverses.
Les processus peuvent intercepter certains de ces signaux. S'il ne le font pas, alors
les signaux ont des effets par défaut sur le processus.
\end{block}
\begin{block}
{
Transmission de signaux par le clavier
}
Quand un processus est exécuté au premier plan, certaines combinaisons de touches
provoquent la transmission de signaux vers celui-ci.
\begin{itemize}
\item
\cmd
{
CTRL+C
}
envoie SIGINT. Met fin au processus avec potentielle perte de données.
\item
\cmd
{
CTRL+Z
}
envoie SIGTSTP. Stoppe le processus et rend la main au shell.
\item
\cmd
{
CTRL+]
}
envoie SIGQUIT. Met fin au processus plus brutalement que
\cmd
{
CTRL+C
}
.
\end{itemize}
\end{block}
\end{frame}
\begin{frame}
[fragile]
{
Terminaux
}
\begin{frame}
[fragile]
{
Les processus
}
\framesubtitle
{
Effet des signaux
}
\begin{exampleblock}
{
CTRL+C vs. CTRL+]
}
\begin{itemize}
\item
Installez
\cmd
{
sl
}
:
\cmd
{
sudo apt install sl
}
\item
Lancer sl. Le train passe.
\item
Observez la différence entre CTRL+C et CTRL+] pendant le passage du train.
\end{itemize}
\end{exampleblock}
\end{frame}
\begin{frame}
[fragile]
{
Exécution en arrière plan
}
Une commande exécutée en arrière plan est dite
\emph
{
détachée
}
du terminal.
\begin{block}
{
Exécution en arrière plan
}
Faire suivre la commande de ``
\&
''. La commande se lance et rend la main au shell.
``
\cmd
{
gedit
\&
}
'' lance l'éditeur de texte gedit et rend la main.
\end{block}
\begin{block}
{
Arrière plan et signaux
}
\cmd
{
CTRL+Z
}
suspend le processus attaché au terminal.
``
\cmd
{
bg
}
'' le relance en arrière plan, comme si on l'avait exécuté avec ``
\&
''.
\end{block}
\begin{beamercolorbox}
[rounded=true,shadow=true]
{
terminal
}
\begin{Verbatim}
$
xeyes
^
Z
[
1
]+
Arrêté xeyes
$
\textcolor
{
yellow
}{
bg
}
[1]+ xeyes
&
$
\end
{
Verbatim
}
\end
{
beamercolorbox
}
\end
{
frame
}
\begin
{
frame
}
[
fragile
]
{
Mettre fin à des processus
}
\begin
{
block
}{
\cmd
{
kill
}}
Pour mettre fin à un processus, la commande à utiliser est
\cmd
{
kill
}
suivie du PID du processus à tuer.
\end
{
block
}
\begin
{
beamercolorbox
}
[
rounded
=
true,shadow
=
true
]
{
terminal
}
\begin
{
Verbatim
}
$
ps
PID TTY TIME CMD
13154 pts/5 00:00:00 bash
\textcolor
{
yellow
}{
13162
}
pts/5 00:00:01 xeyes
13178 pts/5 00:00:00 ps
$
kill
\textcolor
{
yellow
}{
13162
}
$
[1]+ Complété xeyes
$
\end
{
Verbatim
}
\end
{
beamercolorbox
}
\begin
{
alertblock
}{
Processus récalcitrants
}
Par défaut,
\cmd
{
kill
}
envoie
\cmd
{
SIGTERM
}
au processus. Si le processus ne se termine pas avec
ce signal,
``
\cmd
{
kill
-
KILL
}
''
(
ou ``
\cmd
{
kill
-
9
}
''
)
suivie du PID y mettra fin systématiquement mais avec plus de
risques de perte de données.
\end
{
alertblock
}
\end
{
frame
}
\begin
{
frame
}
[
fragile
]
{
Gestion des jobs
}
\begin
{
itemize
}
\item
\cmd
{
jobs
}
affiche la liste des processus en arrière plan
\item
\cmd
{
fg
}
ramène le processus indiquer en avant plan
\item
\cmd
{
bg
}
passe le dernier processus arrêté en arrière plan
\item
\cmd
{
kill
}
peut aussi s'utiliser avec un numéro de job.
\end
{
itemize
}
\begin
{
beamercolorbox
}
[
rounded
=
true,shadow
=
true
]
{
terminal
}
\begin
{
Verbatim
}
$
xeyes
&
[1] 13507
$
jobs
[
\textcolor
{
yellow
}{
1
}
]+
En cours d'exécution xeyes
&
$
kill
\textcolor
{
yellow
}{
%1}
$
[
1
]+
Complété xeyes
$
\end{Verbatim}
\end{beamercolorbox}
\end{frame}
\subsection
{
Substitution de commandes
}
\begin{frame}
[fragile]
{
Substitution de commandes
}
Consiste à récupérer la sortie d'une commande pour remplacer le texte de la commande.
\begin{block}
{
Syntaxe de la substitution de commande
}
Deux syntaxes sont possibles:
\begin{itemize}
\item
\cmd
{
\$
( commande )
}
\item
\cmd
{
` commande `
}
\end{itemize}
\end{block}
\begin{beamercolorbox}
[rounded=true,shadow=true]
{
terminal
}
\begin{Verbatim}
$
echo Nous sommes le
\textcolor
{
yellow
}{$
(date +'
%A %d %B %Y').}
Nous sommes le mardi 22 janvier 2019.
\end{Verbatim}
\end{beamercolorbox}
\end{frame}
\subsection
{
L'historique
}
\begin{frame}
[fragile]
{
Rappeler des commandes
}
%% Historique + manipulation
%% Où est l'historique (bases)
\cmd
{
bash
}
maintient un historique des commandes et permet de les rappeler pour ne pas avoir à les retaper.
L'historique est stocké
dans le fichier
\verb
+
~/.bash\_history
+
.
\begin{itemize}
\item
La commande ``
\cmd
{
history
}
'' affiche l'historique.
\item
Les touches haut et bas permettent de naviguer dans l'historique.
\item
Le point d'exclamation suivi d'une chaîne rappelle la dernière commande commençant par cette chaîne.
\item
La combinaison
\cmd
{
CTRL+R
}
entre en mode recherche dans l'historique.
\cmd
{
CTRL+R
}
recherche à nouveau.
\end{itemize}
\begin{block}
{
Astuce
}
La commande
\cmd
{
!!
}
relance la dernière commande. On peut l'utiliser avec
\cmd
{
sudo
}
pour relancer une commande
en superutilisateur:
\begin{center}
\cmd
{
sudo !!
}
\end{center}
\end{block}
\end{frame}
\begin{frame}
[fragile]
{
Rechercher dans l'historique
}
\end{frame}
Loading