Commandes

Cheatsheet

https://hal.science/hal-04118265v1/file/2022-11-21_nojhan__UNIX-Shell_Cheatsheet__poster.pdf

Aide

whatis ls
man ls
ls --help

En vrac

`pwd` (print working directory)

affiche l’endroit où l’on se trouve.

Système de fichiers

Chemins et jokers

Ces chemins sont évalués à l’exécution
- ~ : home directory
- . : répertoire « courant »
- .. : répertoire « parent »
Les caractères jokers dans les chemins
- ? : remplace n’importe quel caractère (1 seul)
- * : remplace n’importe quelle séquence de caractères (une même la chaîne vide)
- [abcd] : soit a, b, c, ou d
- [!efg] : ni e, ni f, ni g

`ls` (list)

permet d’afficher la liste des fichiers

$ ls -l
total 26
-rw------- 1 rodriguf enseignants     0 18 sept. 13:32 cauie.txt
drwx------ 3 rodriguf enseignants     3 18 sept. 13:50 dossier
-rw------- 1 rodriguf enseignants     0 18 sept. 13:38 tata.txt
drwx------ 2 rodriguf enseignants     3 18 sept. 13:40 titi
-rw------- 1 rodriguf enseignants 39735 18 sept. 14:09 unix.html

-a Affiche tous les fichiers, même ceux cachés. Les fichiers cachés sous Linux sont ceux qui commencent par un « . ».

-i Affiche les numéros d’inode.

-l Affiche sous forme de liste verticale la liste des fichiers avec des informations supplémentaires formatées par colonnes.

`cd` (change directory)

permet de changer de répertoire courant

`mkdir` (make directory)

crée un répértoire

`touch`

crée un fichier vide

`cp` (copy)

copie un fichier

cp SOURCE DEST #copie un fichier « source » vers un fichier nommé « dest »
cp SOURCE DIRECTORY #copie le fichier « source » dans le répertoire « directory », la copie garde le nom

`mv` (move)

Déplace ou renomme un fichier ou un répértoire

mv SOURCE DEST #renomme, déplace le fichier « source » en « dest »
mv SOURCE DIRECTORY #déplace le fichier « source » dans le répertoire « directory »

`ln` (link)

créer un lien symbolique

ln -s TARGET LINKNAME

`rm` (remove)

supprime les fichiers (ou dossiers avec l’option -r) passés en paramètre

-f Ne demande pas de confirmation de la suppression.

-i Demande de confirmation de la suppression.

-r Supprime récursivement les sous-répertoires.

`rmdir`

supprime un répertoire, à condition qu’il soit vide (sinon utiliser rm -r)

`cat`

affiche le contenu d’un fichier

`more`

affiche le contenu d’un fichier (affichage paginé)

`less`

affiche le contenu d’un fichier (comme more mais avec plus de fonction, d’où son nom ;))

Droits et permissions

Lecture d’un `ls -l`

lrwxrwxrwx   1 root root     7 févr. 11  2021 bin -> usr/bin
drwxr-xr-x 156 root root 12288 janv. 20  09:26 etc
-rwxr-xr-x   2 root admin 4096 févr. 16  2021 choses.txt

1er caractère : type de fichier (- normal, d répertoire, l lien)
3 x 3 caractères suivants : droits du propriétaire (u), du groupe (g), des autres (o) — dans l’ordre lecture (r), écriture (w), exécution (x)
Puis : nombre de liens (durs), utilisateur / groupe propriétaires, taille en octets, date de dernière modification, nom du fichier

`chmod`

modifie les droits d’un fichier ou répertoire

chmod [OPTIONS] [ u g o a ] [ - + = ] [ r, w, x ] fichier

Qui ? u (user), g (group), o (other), a (all)
Action ? - enlever, + ajouter, = garder exactement ces droits
Droits ? r (read), w (write), x (execute)
Mode octal : r=4, w=2, x=1 (on additionne)
- Exemple : chmod 754 fichier → u=rwx (4+2+1), g=rx (4+0+1), o=r (4+0+0)

Redirections et tubes

Chaque processus dispose de 3 flux standards : entrée (stdin), sortie (stdout), erreur (stderr)
< : redirige l’entrée standard depuis un fichier
> (ou 1>) : redirige la sortie standard vers un fichier (écrase le fichier)
- >> : idem mais en ajoutant à la fin du fichier au lieu d’écraser
- Exemple : ls -l / > liste.txt
2> : redirige la sortie d’erreur vers un fichier
- Pour combiner les deux sorties dans le même fichier : ls 1>stdout_stderr.txt 2>&1
| (pipe/tube) : branche la sortie standard d’une commande vers l’entrée standard d’une autre
- Exemple : ls -1 / | wc -l (compte le nombre de fichiers non cachés du répertoire /)

Recherche

`find`

recherche récursive de fichiers

find <chemin(s)> <critère(s)> <action(s)>

Critères : -name '<motif>', -size <[+|-]taille>, -mtime <[+|-]date>, -user <nom|UID>, -newer <fichier référence>
Actions : -print (affiche le chemin), -ls (affiche comme ls -l), -exec <commande> {} \; (exécute sans confirmation), -ok <commande> {} \; (exécute avec confirmation)
Exemples :
- find /home /usr -name 'ab*' -print 2> /dev/null
- find . -name "*.o" -ok rm {} \;
- find . ! -user root -print

`grep`

recherche de motifs dans des fichiers texte

grep <regexp> [fichier ...]

Affiche les lignes correspondant à l’expression régulière regexp
Options : -v (inverse, lignes ne correspondant pas), -c (nombre de correspondances), -n (numéros de ligne), -l (noms des fichiers correspondants), -i (ignore la casse), -E (regex étendues)
Exemple : grep -ni "ab.." *
Métacaractères courants (mode étendu -E) : . (un caractère), * (0 ou plus), + (1 ou plus), ? (0 ou 1), ^ (début), $ (fin), () (groupe), [...] (plage), [^...] (plage interdite)
Référence : https://regex101.com/

Manipulation de texte

`cut`

sélection verticale (colonnes/champs)

cut -d<délimiteur> -f<champ(s)> [fichier]  # champs séparés par <délimiteur>
cut -c<colonne(s)> [fichier]               # colonnes de caractères

Exemple : cut -d":" -f3,6 liste.txt , cut -c1-10 liste.txt

`sed`

transformation de texte ligne par ligne

sed 's/droit/schtroumpf/g' droits-de-lhomme.txt

s/ = substituer, g à la fin = global (toutes les occurrences de la ligne)
Autres exemples :
- sed -n '3,7p' fichier → affiche les lignes 3 à 7
- sed '2,5d' fichier.txt → supprime les lignes 2 à 5
- sed '2i\Texte ajouté' fichier.txt → insère une ligne avant la ligne 2
- sed '/^$/d' fichier.txt → supprime les lignes vides
- sed '1,5s/foo/bar/g' fichier.txt → remplace seulement dans les lignes 1 à 5

`tr` (translate)

manipulation caractère par caractère

cat liste.txt | tr ',' ' '

`wc` (word count)

compte mots, lignes ou caractères

wc monFichier.txt

`sort`

trie les lignes d’un fichier

`uniq`

élimine les lignes en double (sur un fichier déjà trié)

Processus

`ps` / `pstree` / `htop`

lister les processus

ps : les processus du terminal courant
ps aux : tous les processus du système
pstree : hiérarchie des processus (arbre père/fils)
htop : suivi interactif des processus

Tâche de fond

& à la fin d’une commande : la lance en tâche de fond, ex. xeyes &
Ctrl+z (suspend le processus courant) puis bg (le reprend en tâche de fond)
Ces commandes renvoient le pid du processus

`kill`

envoie un signal à un processus

kill -NUM_SIGNAL PID

SIGTERM (15) : demande d’arrêt « propre »
SIGKILL (9) : arrêt « brutal »
Liste complète : man 7 signal

La gestion des utilisateurs et groupes

Consulter

Liste des utilisateurs : cat /etc/passwd ou getent passwd
Liste des groupes : cat /etc/group ou getent group
id : mes informations (uid, gid…) ; id USERNAME : celles d’un autre utilisateur
whoami : qui suis-je ?

`groupadd`

ajoute un groupe au système

`useradd`

ajoute un utilisateur au système

! adduser (et addgroup pour les groupes) sont des commandes de plus haut niveau, plus interactives, mais absentes par défaut sur certaines distributions !

Modification/suppression

Utilisateurs : usermod (modifie), deluser (supprime), passwd (change son propre mot de passe)
Groupes : addgroup (ajoute), groupmod (modifie), groupdel (supprime)

Devenir super-utilisateur

La gestion des utilisateurs/groupes nécessite d’être root
- su - : ouvre une session root
- sudo lacommande : exécute une seule commande en tant que root

Variables et environnement

Définir et lire

Affectation (sans espace autour du signe d’égalité) : maVariable=quelquechose
Lecture : $maVariable (ex. echo $maVariable)
Concaténation : echo "blabla${maVariable}blabla"
Visibilité : le shell courant seulement, sauf export maVariable (visible aussi par les processus fils)

Lister

Variables locales : set
Variables d’environnement (exportées) : printenv

Tableaux et calculs

Déclaration : montab=("un" "deux" "trois")
Accès à un élément : echo "${montab[2]}" ; tout le tableau : echo "${montab[@]}"
Longueur d’une variable : ${#variable}
Substitution de commande : $(date) (ou avec les anciens antiquotes) → remplacé par le résultat de la commande
Arithmétique (par défaut tout est chaîne de caractères !) : let a=3+4 ou A=$((3+4))
- Attention : a=3+4 (sans let=/=$(())) stocke la chaîne littérale 3+4, pas le résultat

Variables usuelles

$PATH : répertoires où le shell cherche les commandes (format chemin1:chemin2:...)
- Ajouter un chemin : export PATH=/mon/nouveau/rep:$PATH
$HOME : chemin du home directory
$SHELL : l’exécutable du shell
$_ : la dernière commande exécutée

Variables spéciales

$? : code de retour de la dernière commande (0 = succès)
$$ : pid du shell courant
$! : pid de la dernière commande lancée en tâche de fond
$0 : nom du script ; $1 à $9 : ses paramètres
$* et $@ : tous les paramètres (concaténés / en tableau) ; $# : leur nombre

Composition de commandes

Séquentiel : cp f1 f2 ; rm f1
Et conditionnel (si OK alors…) : cc coucou.c && mv a.out monProg
Ou conditionnel (si pas OK alors…) : cc coucou.c || echo "Il y a un pb de compilation !"

Écrire des scripts

Première ligne (shebang) : #!/bin/bash
Commentaire : # un joli commentaire
Fin d’exécution avec un code de retour : exit N
Affichage : echo bonjour (retour à la ligne), echo -n bonjour (sans retour à la ligne), echo -e "a\tb" (interprète \t, \n, etc.)
Lecture au clavier : read v1 v2 ... vn (lit les mots suivants et les affecte aux variables)

Paramètres du script

Passés sur la ligne de commande : ./monScript.bash truc chose bidule → $1, $2, …
shift : décale les paramètres ($1 devient l’ancien $2, etc.) — utile pour traiter plus de 9 paramètres ou les parcourir un par un

Structures de contrôle

`test` (ou `[ ]`)

évalue une condition

Sur les fichiers : test -r <path>, -w, -x, -f (fichier normal), -d (répertoire)
Sur les chaînes : test <ch1> = <ch2>, !, -z (vide), -n (non vide) — toujours mettre les variables entre guillemets (test "$a" = 1), sinon risque d’erreur si la variable est vide
Sur les nombres : test <nb1> -eq <nb2>, -lt, -gt, etc.
Composition : -a (et), -o (ou), ! (négation), ( expr )
Forme courante avec crochets (penser aux espaces après [ et avant ]) : [ $# -gt 1 ]

`if`

if <commande>
then
    <instruction>
elif <commande2>; then
    <instruction2>
else
    <instruction3>
fi

Se base sur le code de retour de <commande> : 0 → vrai, différent de 0 → faux

Boucles : `while`, `until`, `for`

while <commande>
do
    <instructions>
done

until <commande>
do
    <instructions>
done

for <var> in <liste>
do
    <instructions>
done

while : tant que <commande> réussit ; until : tant qu’elle échoue (inverse de while)
for f in *.c : parcourt les fichiers correspondant au motif ; for f (sans in) : parcourt les paramètres du script

Autres commandes utiles

date : affiche la date/heure
clear : efface le texte du terminal

Commandes

Cheatsheet

Aide

En vrac

pwd (print working directory)

Système de fichiers

Chemins et jokers

ls (list)

cd (change directory)

mkdir (make directory)

touch

cp (copy)

mv (move)

ln (link)

rm (remove)

rmdir

cat

more

less