Dans le monde GNU/Linux et plus généralement de la famille UNIX, les plus grandes difficultés éprouvées par les débutants sont de trouver les commandes adaptées à leurs besoins. Or, si toutes les fonctions standards sont bien documentées avec les pages man, il est difficile pour l’apprenti geeck de savoir quelles commandes existent et sont adaptées à son besoin du moment.

Ce mémo regroupe ${quelques} commandes élémentaires et astuces pour augmenter votre productivité en utilisant une console ; ${quelques} pouvant évidemment être calculé et affiché dans un terminal avec :

quelques = $(cat tips.md | grep '^[ ]*@\.' | wc -l)
echo ${quelques}

Toutes les commandes apparaissant dans ce document ont été empruntées à d’autres mais, par maladresse, je n’ai pas fait l’effort d’en retenir les auteur⋅e⋅s.

Guide de survie

Interpréteur de commandes (shell), terminal

L’interpréteur de commandes (ou shell) est le logiciel le plus important car il réalise l’interface entre l’utilisateur, le système d’exploitation et les logiciels. Ce programme tourne dans une fenêtre (émulateur de terminal) ou sur une console en mode texte (terminal). Son rôle est de lire une entrée (clavier, fichier, etc), de l’interpréter et, si besoin, de lancer une commande. La syntaxe du shell forme un langage de programmation de haut niveau (un langage de script directement interprété). Si cette syntaxe n’est pas respectée, le shell renvoie une erreur.

Il existe plusieurs interpréteurs de commandes UNIX. Les principaux sont :

sh Bourne shell : standard « universel » qui fait référence à un des premiers shell Unix écrit par Stephen Bourne et distribué avec la version 7 Unix aux environs de 1978 ;
bash GNU Bourne-Again SHell (norme POSIX) : shell Unix conçu pour le projet GNU en 1987. Son nom est l’acronyme de Bourne-again shell (« born again »). Bash est le shell par défaut de Debian et de bon nombre de distributions GNU/Linux ;
dash Debian Almquist SHell ;
Csh C-shell dont la syntaxe rappelle cette du C, shell de BSD ;
ksh Korn SHell (norme POSIX) ;
Tcsh Turbo Csh (nombreuse options en plus d’édition de la ligne) ;
zsh Zorn SHell.

Le shell est utilisé le plus souvent de manière interactive, pour passer des commandes au système. Il est associé au terminal sur lequel vous êtes connecté (ou à une fenêtre sur ce terminal). Pour signifier que le shell est prêt à recevoir ces commandes, il affiche un prompt. Ce prompt peut contenir un nombre variable d’informations selon la configuration, par exemple :

moi@monPC:~/répertoire/de/travail$

Ce processus prend comme données ce que vous tapez au clavier et génère comme sorties des affichages sur l’écran du terminal ou des actions sur des fichiers. De façon générique sous UNIX, le clavier est appelé entrée standard (stdin) et l’écran la sortie standard (stdout). En cas d’erreur, un message s’affiche sur l’écran, alors devenu erreur standard (stderr).

Dans la suite, on note :

<C-k> la frappe simultanée des touches du clavier <Ctrl> et <k> ;
<M-k> la frappe simultanée des touches du clavier <Alt> (META) et <k> ;
<CR> la frappe de la touche entrée (carriage return).

Exécuter une commande

Une commande est une liste de chaînes de caractères séparées par des espaces de la forme :

command [<chaine1>...<chaineP>]

Certaines commandes n’ont pas de paramètre, d’autres ne s’utilisent qu’avec un nombre précis de paramètres. On différencie deux types de paramètres :

les paramètres de la commande par exemple le nom du fichier à copier, le nom de l’utilisateur pour la commande de courrier ;
les options qui sont souvent des chaînes précédées du signe - qui indique que l’on veut un comportement spécial de la commande.

Pour exécuter une commande, il suffit de taper

command ... <CR>

où <CR> désigne l’appui sur la touche carriage return (entrée). L’interpréteur de commandes exécute alors la commande ou crée le ou les processus correspondant à la commande. Le code de sortie de la commande est stocké dans la variable ?

$ echo $?

s’il est égal à 0 la commande a réussie, 1+ sinon.

Raccourcis Bash

Voir le nom du shell utilisé
```
$ echo $SHELL
```
Effacer l’écran du terminal
```
$ clear
```
Rafraîchir l’affichage
```
<C-l>
```
Relancer/ré-initialiser le terminal
```
$ reset
```
Bloquer l’affichage du terminal
```
<C-s>
```
le débloquer avec
```
<C-q>
```
Interrompre la commande en cours
```
<C-c>
```
Ouvrir un éditeur de texte
```
$ <C+x><C-e>
```
Afficher les utilisateurs
```
$ ~<TAB><TAB>
```
Afficher les (nombreuses) variables systèmes
```
$ $<TAB><TAB>
```

On donne ci-après les principaux raccourcis en Bash.

`<tab>`	compéter le mot courant (complétion)
`<tab><tab>`	afficher les propositions de complétion du mot courant
`<C-p>`	afficher les commandes précédentes
`<C-n>`	afficher les commandes suivantes
	Déplacements
`<C-a>`	aller au début de la ligne
`<C-e>`	aller à la fin de la ligne
`<M-b>`	aller au début du mot
`<M-f>`	aller à la fin au mot suivant
	Coupes (yank)
`<C-k>`	couper la ligne après le curseur
`<C-u>`	couper la ligne avant le curseur
`<M-d>`	couper la fin du mot depuis le curseur
`<C-w>`	couper le début du mot jusqu’au curseur
`<C-d>`	couper le caractère sous le curseur
`<C-h>`	couper le caractère avant le curseur
	Collages
`<C-y>`	coller
`<C-y><M-y>`	coller en remontant l’historique du kill ring
	Édition
`<M-u>`	mettre en majuscule le mot depuis le curseur
`<M-L>`	mettre en minuscule le mot depuis le curseur
	Historique
`SHIFT+P.UP`	parcourir les pages précédentes
`SHIFT+P.DOWN`	parcourir les pages suivantes

Rechercher une commande, documentation

Les commandes usuelles qui permettent de survivre sur une console GNU/Linux sont répertoriées sur les pages Coreutils et commandes shell (debian). On donne un abrégé dans la section GNU coreutils.

Rechercher une commande ayant un rapport avec keyword
```
$ apropos keyword
$ man -k keyword
```
Afficher l’aide d’une commande
```
$ man command
```
taper q pour quitter.
Afficher l’aide de la commande man
```
$ man man
```
Afficher une ligne d’explication d’une commande
```
$ whatis command
```
Afficher un descriptif long d’une commande
```
$ info command
```
Afficher l’emplacement d’un fichier de commande
```
$ whereis command
```
ou
```
$ which command
```
ou
```
$ type -p command
```

Historique des commandes

L’historique des commandes passées est stocké dans le fichier défini dans $HISTFILE, pointant souvent vers ~/.bash_history. Sa longueur est définie dans la variable $HISTSIZE, généralement entre 500 et 1000 lignes.

Voir l’historique des commandes
```
$ history
```
En entrant !num , on relance la commande affichée ligne num.
Exécuter de nouveau la commande précédente
```
$ !!
```
à prononcer bang bang !
Exécuter une commande avec les arguments de la précédente
```
$ command !*
```
Ne pas ajouter une commande à l’historique
```
$  command
```
en la préfixant avec une espace.

Exécutions séquentielles ou conditionnelles

Exécuter de façon séquentielle deux commandes
```
$ command1 ; command2
```
Exécuter de façon parallèle deux commandes
```
$ command1 & command2
```
Exécuter la command2 que si la command1 a réussie
```
$ command1 && command2
```
Le résultat est un succès si les deux commandes ont réussies (&& est le ET logique).
Exécuter la command2 que si la command1 a échoué
```
$ command1 || command2
```
Le résultat est un succès si une des deux commandes a réussie (|| est le OU logique).

Redirections

Fichiers spéciaux

/dev/stdin: désigne l’entrée standard
/dev/stdout: désigne la sortie standard
/dev/stderr: désigne la sortie d’erreur standard

L’entrée (stdin), la sortie (stdout) et l’erreur standard (stderr) ont respectivement les descripteurs de fichiers 0, 1 et 2.

/dev/tty: désigne le terminal auquel vous êtes connecté
/dev/null: Ce fichier se comporte comme un « trou noir » en absorbant toute redirection sans être modifié.
/dev/zero: Ce fichier renvoie des octets nuls à l’infini.
/dev/urandom: Ce fichier renvoie des octets aléatoires à l’infini.

Plus de détails sur stackexchange.

Afficher le nom de son terminal
```
$ tty
```
Rediriger la sortie standard de command vers le fichier outfile
```
$ command > outfile
```
ou
```
$ command 1> outfile
```
Si le fichier outfile existe déjà, son contenu est écrasé.
Rediriger la sortie standard de command vers le fichier outfile seulement s’il n’existe pas
```
$ set -o noclobber
$ command > outfile
$ set +o noclobber
```
noclobber permet de protéger les fichiers existants.
Rediriger la sortie standard de la command vers le fichier outfile
```
$ command >> outfile
```
Si outfile existe déjà, le contenu est ajouté à la fin du fichier.
Rediriger l’entrée standard de la command vers le fichier infile
```
$ command < infile
```
La commande lit le contenu du fichier infile.
Rediriger l’entrée standard de command2 vers la sortie standard de la command1
```
$ command2 < (command1)
```
Rediriger la sortie d’erreur standard de command vers le fichier outfile (l’écraser)
```
$ command 2> outfile
```
Si on ne veut pas lire outfile, autant le remplacer par /dev/null.
Rediriger l’erreur standard de command au même endroit que la sortie standard
```
$ command 2>&1
```
Rediriger la sortie standard de command au même endroit que la l’erreur standard
```
$ command 1>&2
```

Tubes (pipeline)

Les shell des systèmes d’exploitation de type Unix disposent d’un mécanisme appelé tube (pipeline ou pipe). Ce mécanisme permet de chaîner des processus de sorte que la sortie d’un processus (stdout) alimente directement l’entrée (stdin) du suivant.

Exécuter la command2 avec le résultat de la command1
```
$ command1 | command2
```
L’exécution peut être simultanée. Cette commande est équivalente à
```
$ command2 < (command1)
```
Scinder les éléments provenant du tube en différentes lignes
```
... | xargs -n 1 echo
```
Concaténer les lignes provenant du tube en une ligne
```
... | xarg echo
```
Concaténer 3 lignes provenant du tube en une ligne en séparant les deux premières avec un tiret et les deux dernières avec un slash
```
... | paste -sd"-/" -
```
Extraire du tube les lignes contenant expression
```
... | grep expresion
```
ou celles ne la contenant pas
```
... | grep -v expresion
```
Lancer une commande de manière répétitive avec chaque élément provenant du pipe comme paramètre
```
... | xargs -n 1 command
```
Donner un fichier en argument d’une commande
```
$ command <<EOF
  ...
  EOF
```
avec le here document <<, EOF étant une chaîne permettant d’identifier la fin du fichier, <C-d> sinon.
Donner une chaîne de caractères en argument d’une commande
```
$ command <<< string
```
avec le here sting <<<. Il faut toujours préférer cette solution à
```
$ echo string | command
```
car elle utilise un processus de moins.
Écrire dans un fichier et en sortie standard stdout, par exemple pour continuer un long pipe
```
$ command | tee outfile | ...
```
Éditer le résultat d’une commande avec Vim
```
$ command | vim -
```

Expressions rationnelles

Une expression rationnelle est une manière compacte de représenter une chaîne de caractères.

Expression	Signification
`.`	Tout caractère (sauf `newline`)
`\`	Caractère d’échappement (interprétation littérale du caractère suivant)
`^`	Début de ligne
`$`	Fin de ligne
`\<`	Début de mot
`\>`	Fin de mot
`\n`	Fin de ligne
`\r`	Retour chariot
`\t`	Tabulation
	Classes de caractères
`\c`	Control
`\s`, `\S`	Espace, ou pas
`\d`, `\D`	Nombre, ou pas
`\w`, `\W`	Mot, ou pas
`\x`, `\O`	Nombre hexadécimal, octal
	POSIX
`[:upper:]`	Une lettre en majuscule
`[:lower:]`	Une lettre en minuscule
`[:alpha:]`	Une lettre
`[:alnum:]`	Une lettre ou un chiffre
`[:digit:]`	Un chiffre
`[:xdigit:]`	Un chiffre hexadécimal
`[:punct:]`	Un caractère de ponctuation
`[:blank:]`	Un espace ou tabulation
`[:cntrl:]`	Un caractère de contrôle
`[:word:]`	Une lettre, un chiffre ou underscore
	Groupes, ensembles
`(...)`	Groupe
`\n`	n-ième groupe
`[abc]`	Un des caractères spécifiés
`[a-dh]`	Une lettre de a à d ou h
`[0-57]`	0, 1, 2, 3, 4, 5 ou 7
`[a-d5-8-]`	a, b, c, d, 5, 6, 7, 8 ou -
`[012^]`	0, 1, 2 ou ^
`[^abc]`	Un caractère ne figurant pas dans la liste
`[^0-9]`	Tout sauf un chiffre
`[^a-zA-Z]`	Tout sauf une lettre
	Quantificateurs
`r*`	Aucune ou plusieurs instances de l’expression `r`
`r+`	Au moins une instance de l’expression `r`
`r?`	Aucune ou une instance de l’expression `r`
`{n}`	Exactement n fois l’élément précédent
`{n,m}`	Entre n et m fois l’élément précédent
`{n,}`	n fois ou plus l’élément précédent
`{,m}`	m fois au plus l’élément précédent
`r1\|r2`	Instance de l’expression `r1` ou `r2`
	Références
`&`, `\0`	tout le motif
`\n`	le n-ième groupe (n>=1)
`\r`	couper la ligne en 2 à ce point
`\u`	le caractère suivant en majuscule
`\l`	le caractère suivant en minuscule

Afficher la table des caractères ASCII
```
$ man ascii
```

Tout est fichier dans un système GNU/Linux ou UNIX. Un répertoire est un certain type de fichier. Chaque terminal (par exemple /dev/pts/4), chaque disque dur ou partition (par exemple /dev/sdb1) et tous les processus sont tous représentés comme des fichiers.

Répertoires

Afficher le nom du répertoire courant (print working directory)
```
$ pwd
```
ou
```
$ echo $PWD
```
ou
```
$ echo ~+
```
Voir les fichiers du répertoire
```
$ ls -1
```
y compris les fichiers cachés
```
$ ls -al
```
et ajouter l’option -h pour « humain ».
Voir tous les fichiers .tex du répertoire
```
$ ls -1 *.tex
```
* remplace toute chaîne de caractères et ? n’en remplace qu’un.
Changer de répertoire
```
$ cd directory/
```
pour aller dans le répertoire père
```
$ cd ..
```
Changer de répertoire pour le home directory
```
$ cd
```
ou
```
$ cd $HOME
```
Changer le répertoire courant pour le répertoire précédent
```
$ cd -
```
ou
```
$ cd $OLDPWD
```
Afficher le nom du répertoire précédent
```
$ echo $OLDPWD
```
ou
```
$ echo ~-
```
Créer un répertoire et y aller
```
$ mkdir directory && cd $_
```
Se balader dans l’arborescence des répertoires avec une pile, visible avec
```
$ dirs
```
ajouter un répertoire à la pile et y aller
```
$ pushd directory
```
supprimer le dernier répertoire de la pile et revenir au précédent
```
$ popd
```
Créer un répertoire et son arborescence
```
$ mkdir -p dir/subdir/directory
```
Copier un répertoire (et son contenu) vers un autre
```
$ cp -r directory destination/.
```
utiliser l’option -i pour éviter d’écraser involontairement un fichier de même nom s’il existe.
Supprimer un répertoire vide
```
$ rmdir directory
```
Supprimer un répertoire et tout ce qu’il contient
```
$ rm -rf directory
```
Afficher le contenu de l’arborescence des fichiers dans un répertoire
```
$ tree directory
```
Afficher la taille d’un répertoire
```
$ du -sh directory
```
si directory n’est pas spécifié, du répertoire courant.
Afficher la taille d’un répertoire et de ses sous-répertoires
```
$ du -h directory
```
ou en se limittant aux répertoires et trier la sortie par taille décroissante
```
$ du -hd 1 directory | sort -hr
```
Supprimer tous les sous-répertoires vide de dir
```
$ find dir -type d -empty -delete
```

Fichiers

Afficher le type d’un fichier
```
$ file infile
```
Obtenir les informations d’un fichier
```
$ stat infile
```
Actualiser la date de dernière modification d’un fichier
```
$ touch infile
```
Si infile n’existe pas, il est créé.
Copier un fichier
```
$ cp infile outfile
```
Renommer ou déplacer un fichier
```
$ mv infile outfile
```
Renommer des fichiers (Debian)
```
$ rename 's/exp1/exp2/' xxxexp1xx
```
Attention : cette commande n’existe pas sur toutes les plateformes et n’a pas toujours la même syntaxe (ici Debian). Ce qui fonctionne toujours est :
```
$ find . -maxdepth 1 -name "*exp1*" \
  -exec bash -c 'mv $0 ${0/exp1/exp2}' {}  \;
```
Renommer en fichier en *.old
```
$ mv filename{,.old}
```
Supprimer un fichier
```
$ rm infile
```
Supprimer un fichier au nom incluant des caractères spéciaux ou bizarres, à partir de son inode
```
$ ls -i
```
qui renvoie 2 colonnes, avec l’inode sur la première et le nom de fichier sur la seconde. Admettons que vous vouliez supprimer celui d’inode 12345
```
$ find . -inum 12345 -delete
```
ou
```
$ find . -inum -exec rm -i {} \;
```
Créer un lien symbolique
```
$ ln -s target_file linked_file
```
Créer un lien symbolique dans le dossier <dir>
```
$ ln -rst <dir> target_file 
```
Supprimer un lien symbolique
```
$ unlink linked_file
```
ou
```
$ rm linked_file
```
Voir le contenu (la cible) d’un lien symbolique
```
$ readlink linked_file
```
Effacer un grand nombre de fichier

$ mkdir empty && rsync -r –delete empty/ some-dir && rmdir some-dir

Recherches

Rechercher un fichier d’après son nom dans le répertoire dir
```
$ find dir -type f -name filename
```
Si votre système dispose d’une base de données /var/lib/mlocate/mlocate.db, il est plus rapide de faire la recherche avec
```
$ locate filename
```
Selon le système, il peut être nécessaire de créer et mettre à jour cette BDD avec
```
# updatedb
```
Rechercher des fichiers que l’on a le droit de lire et ainsi éviter les « Permission non accordée » en rafale en redirigeant la sortie standard d’erreur dans le « trou noir »
```
$ find dir -type f -name filename 2> /dev/null
```
Rechercher les fichiers modifiés il y a 30 jours
```
$ find dir -mtime +30 -type f
```
Rechercher un répertoire d’après son nom
```
$ find dir -type d dirname
```
Rechercher les répertoires dont les fichiers *.tex contiennent l’expression exp
```
$ grep -nre exp --include=*.tex | cut -d: -f 1 \
   | uniq | tr "\n" "\0" | xargs -0 dirname | uniq
```
la séquence tr "\n" "\0" | xargs -0 permet de tenir compte de noms de répertoire avec des espaces : en effet la commande tr "\n" "\0" remplace le caractère de fin de ligne par null et l’option -0 de xargs indique d’utiliser ce même caractère comme séparateur plutôt qu’une espace.

Rechercher et supprimer un répertoire

$ find . -type d -name 'dirname' -print0 | xargs -r0 -- rm -r

Rechercher les répertoires vers lesquels pointent les liens de $HOME/bin

$ find $HOME/bin -type l \
   | xargs readlink | xargs dirname | sort -u

$ find $HOME/bin -type l | xargs file | cut -d: -f2 \
   | sed 's/^[ ]*symbolic link to //g' | tr '\n' '\0' \
   | xargs -0 dirname | sort | uniq

Manipulation de fichiers texte

Édition de fichiers textes (avec `vim`)

vi est un éditeur de texte présent d’office sur la majorité des UNIX. vim (Vi IMproved) est son clone moderne libre GNU/Linux, avec une compatibilité descendante complète. Voir le mémo vim pour en savoir plus.

Ouvrir 2 fichiers cote à cote
```
$ vim -O file1 file2
```
ou dessus-dessous
```
$ vim -o file1 file2
```
Utiliser vim comme explorateur de fichier
```
$ vim .
```

Avec ces commandes, vous vous retrouvez évidemment dans vim. Si vous avez lancé ces commandes par erreur, tapez !qa pour quitter sans rien modifier.

Visualiser le contenu d’un fichier

Voir le fichier dans le terminal
```
$ cat infile
```
ou avec un pager ; au choix :
```
$ more infile
```
ou
```
$ less infile
```
Voir les lignes a à b d’un fichier
```
$ sed -n a,bp infile
```
Voir les a premières lignes d’un fichier
```
$ head -n a infile
```
Voir les b dernières lignes d’un fichier
```
$ tail -n b infile
```
Afficher le contenu d’un fichier en ASCII
```
$ od -c infile
```
ou en héxadécimal
```
$ od -t x1 infile
```

Encodage

Obtenir les informations d’encodage d’un fichier
```
$ file -bi infile
```

Vérifier si un fichier texte est bien encodé en UTF-8

$ iconv -f utf8 -t utf8 input.txt >/dev/null || echo "Non UTF-8"

Convertir l’encodage d’un fichier (ASCII vers UTF-8)
```
$ iconv -f ascii -t utf8 infile > newfile
```

Trouver la syntaxe hexadécimale d’un caractère char

$ printf char | hexdump -v -e '"x" 1/1 "%02X" " "';echo

puis le remplacer avec sed

$ sed -i 's/\x??\x??/new_char/g' infile

Afficher un caractère Unicode U+xxxx dans son shell
```
$ echo -ne '\uxxxx'       # u (petit) + 4 chiffres hexadécimaux
```
ou
```
$ echo -ne '\Uxxxxxxxx'   # U (grand) + 8 chiffres hexadécimaux
```
ou
```
$ python3 -c 'print(u"\uxxx")
```
évidemment, il faut que la variable LANG soit correctement paramétrée, du genre LANG=fr_FR.utf8 telle que
```
$ echo ${LANG##*.}
```
retourne utf8 ou UTF-8.
Changer les fins de lignes MS Windows (^M = <C-v><C-m>) en line feed Unix \n
```
$ sed -i 's/^M//g' infile
```
ou les fins de ligne Mac OS X \r
```
$ sed -i 's/\r/\n/g' infile
```
Enlever les BOM d’un fichier UTF-8, vu avec file, genre UTF-8 Unicode (with BOM) text:
```
$ tail --bytes=+4 infile > outfile
```

Pour tout débogger les problèmes d’encodage courant, voir le tableau là.

Comparaison

Voir les différences entre 2 fichiers textes
```
$ diff infile1 infile2
```
mais en couleur c’est toujours mieux
```
$ diff --color infile1 infile2
```
Sans tenir compte des espaces (option -w)
```
$ diff --color -w infile1 infile2
```
Pour s’affranchir des carriage return de MS windows
```
$ diff --color -w --strip-trailing-cr infile1 infile2
```
Comparer le contenu de 2 fichiers textes cote-à-cote
```
$ sdiff infile1 infile2
```
Éditer le contenu de 2 fichiers textes cote-à-cote avec coloration des différences
```
$ vimdiff infile1 infile2
```
ou, avec SSH
```
$ vimdiff infile scp://user@host/folder/infile2
```
Voir les différences entre 2 fichiers textes après tri
```
$ diff <(sort infile1) <(sort infile2)
```

Corriger un fichier avec un patch

$ patch infile1 < infile.patch

le patch étant généré avec

$ diff infile1 infile2 > infile.patch

Comparaison de 2 fichiers texte triés
```
$ comm infile1 infile2
```
renvoie 3 colonnes contenant respectivement les lignes n’appartenant qu’au fichier infile1, celles n’appartenant qu’au fichier infile2 et celles en commun. L’option -13 supprime les colonnes 1 et 3 de l’affichage.

Rechercher et remplacer

Trouver une expression dans un fichier
```
$ grep -n 'expression' infile
```
affiche la ligne de l’occurrence, avec l’option -i devient insensible à la casse.
Remplacer une expression par une autre dans un fichier
```
$ sed -i 's/expression1/expression2/g' infile
```
Supprimer les lignes vides
```
$ sed -i '/^$/d' infile
```

Découper, assembler

Afficher la 3ème colonne d’un fichier, celles-ci étant délimitées par ;
```
$ cut -d; -f3 infile
```
Découper un fichier texte par blocs de 100 lignes
```
$ split -l 100 -d infile
```
ici de noms x00, x01, etc.

Découper un fichier texte sur un motif

$ csplit infile '/\section/' '{*}' -f 'prefix_'

Assembler une collection de fichiers texte de noms x00, x01, etc
```
$ cat x* > outfile
```
Concaténer des fichiers (verticalement)
```
$ cat infile1 infile2 ...
```
Concaténer les colonnes de fichiers (horizontalement)
```
$ paste infile1 infile2
```

Remettre en forme

Limiter la longueur des lignes à 72 caractères

$ fold -sw 72 infile > outfile

$ fmt -s infile > outfile

Remettre en forme un fichier texte en joignant les lignes successives
```
$ fmt infile > outfile
```

Corrections orthographique et grammaticale

Vérifier l’orthographe d’un fichier écrit en français
```
$ aspell check --lang=fr infile
```
ou
```
$ aspell check -l fr infile
```
Vérifier la grammaire d’un fichier écrit en français avec Grammalecte
```
$ python3 chemin-vers/Grammalecte-fr/cli.py -f infile
```
ou alors créer un alias dans votre .bashrc
```
alias grammalecte="python3 chemin-vers/Grammalecte-fr/cli.py -off apos -f"
```
puis taper dans le shell
```
$ grammalecte infile
```
Heureusement, il existe un plugin pour une bonne intégration dans vim.

Traduction

Avec translate-shell

Traduire un mot, une phrase, une expression

$ trans fr:en "mot/phrase/expression"

ou de façon concise

$ trans -b fr:en "mot/phrase/expression"

Traduire une page web en français
```
$ trans :fr <URL>
```

Exporter le contenu, changer de format

Convertir un fichier texte en PDF

$ paps input.txt | ps2pdf - output.pdf

$ paps input.txt --font="Monospace Regular 10" \
   | ps2pdf -sPAPERSIZE=a4 -dOptimize=true -dEmbedAllFonts=true\
            - output.pdf

Exporter un fichier texte en PDF (HTML, DOCX…)
```
$ pandoc infile -o outfile.pdf
```
Voir un fichier Markdown en rich text dans le terminal
```
$ pandoc file.md | w3m -T text/html
```

Manipulation de PDF

Afficher les informations d’un PDF
```
$ pdfinfo file.pdf
```
Convertir un PDF en fichier texte
```
$ pdftotext infile.pdf outfile.txt
```

Comparaison

Voir les différences entre 2 fichiers PDF
```
$ diffpdf infile1.pdf infile2.pdf
```
Voir la page de diffPDF ou télécharger ses sources sur GitHub bien qu’il soit dans les dépots.

Recherches

Rechercher le numéro des lignes contenant une expression dans un fichier PDF
```
$ pdfgrep -n pattern file.pdf
```
Rechercher de façon récursive dans le répertoire courant les fichiers PDF dont le nom commence par foo et qui contiennent l’expression pattern
```
$ pdfgrep -r --include "foo*.pdf" pattern
```
Rechercher tous les fichiers PDF contenant l’expression pattern
```
$ find . -name "*.pdf" -print0 | xargs -0 pdfgrep pattern
```

Annotations

Je ne connais pas d’outil en ligne de commandes pour annoter un fichier PDF. J’utilise Okular avec clavier/souris ou Xournal avec une tablette graphique.

Composition

Composer un PDF à partir de plusieurs
```
$ pdftk A=file1.pdf B=file2.pdf cat A1-3 B2 A4 output outfile.pdf
```
ici les pages 1 à 3 du fichier file1.pdf (alias A), puis la page 2 du fichier file2.pdf (alias B), etc.
Supprimer des pages d’un PDF
```
$ pdftk infile.pdf  cat '~7~9~14'  output outfile.pdf
```
supprime les pages 7, 9 et 14

Inverser les pages d’un PDF

$ pdftk infile.pdf cat end-1 output outfile.pdf

Retourner les pages d’un PDF
```
$ pdftk infile.pdf  cat 1-endsouth output outfile.pdf
```
avec south pour 180°, west pour 270° et east pour 90°

Composer un PDF en deux pages sur une (en 2x1 comme avec lpr -o number-up=2)

$ pdfjam --nup 2x1 --paper a4paper --landscape --scale 1 \
    --outfile outfile.pdf infile.pdf

$ pdfnup infile.pdf

Composer un PDF livret en 2 pages par feuilles

$ pdfbook --short-edge --paper a4paper \
    --outfile outfile.pdf infile.pdf

Composer un PDF avec 4 pages par feuilles

$ pdfnup  --nup 2x2 --paper a4paper --landscape \
    --outfile outfile.pdf infile.pdf

Remettre en forme

Convertir un fichier PDF en version « vraiment portable »

$ gs -dSAFER -dBATCH -dNOPAUSE -sDEVICE=pdfwrite \
     -dCompatibilityLevel=1.4 \
     -dPDFSETTINGS=/printer \
     -sOutputFile=outile.pdf infile.pdf

Supprimer la transparence des images d’un PDF (l’aplatir en bitmap, option de gs)
```
$ gs ...
     -dCompatibilityLevel=1.3 \
  ...
```

Convertir les images d’un PDF en niveaux de gris (options de gs)

$ gs ...
  -sColorConversionStrategy=Gray -dProcessColorModel=/DeviceGray \
  ...

Re-dimensionner un PDF en A4 (options de gs)

$ gs ...
  -sPAPERSIZE=a4 -dFIXEDMEDIA -dPDFFitPage \
  ...

Comprimer les images d’un PDF (options de gs)

$ gs ...
  -dPDFSETTINGS=/printer \
  -dDownsampleColorImages=true -dColorImageResolution=200 \
  ...

ou, au choix

-dPDFSETTINGS=/screen (72 dpi)
-dPDFSETTINGS=/prepress

Sélectionner les pages a à b d’un PDF (options de gs)
```
$ gs ...
  -dFirstPage=a -dLastPage=b \
  ...
```

Incorporer les polices (options de gs)

$ gs ...
  -dNOPLATFONTS -dSubsetFonts=true -dEmbedAllFonts=true \
  ...

Édition des tags

$ gs ...
  -dDOPDFMARKS -sOutputFile=outile.pdf infile.pdf tagfile

ou tagfile est un fichier ASCII de la forme

[ /Author (you)
  /Title (title) 
  /Subject (subject)
  /Keywords (keword1, keword2)
  /CreationDate (D:20190209145643+01'00')
  /ModDate (D:20190209145643+01'00')
  /Producer (pdfTeX 1.40.17 + GPL Ghostscript 9.20)
  /Creator (LaTeX with teXstyles 0.0.1)
  /DOCINFO pdfmark

dont les champs doivent être encodés en UTF-16 BE s’ils comportent des accents. Il faudra par exemple remplacer le champ

(Ingénieur)

par

<FEFF0049006E006700E9006E0069006500750072>

chaîne qui peut être obtenue avec le one-liner

$ echo "Ingénieur" \
   | iconv -f utf-8 -t utf-16be \
   | echo "<FEFF"$(hexdump -v -e '1/1 "%02X" ') \
   | sed 's/.\{4\}$/>/'

ou avec la fonction python

import binascii
def pdfTag(c):
  # if not ascii, change encoding
  if False in [ord(k)<128 for k in c]:
    return(''.join(['<FEFF',
      str(binascii.hexlify(c.encode('UTF-16BE')))[2:-1].upper(),
      ">"]))
  else: # ascii
    return("("+c+")")

Protéger par mot de passe

Protéger un PDF avec un mot de passe
```
$ pdftk infile.pdf output outfile.pdf user_pw PROMPT
```
à saisir dans l’invite (PROMPT). Par défaut l’impression du fichier généré n’est pas autorisée. Pour que ce soit le cas :
```
$ pdftk infile.pdf output outfile.pdf user_pw PROMPT \
    allow printing
```

Manipulation d’images

Changer de format

Changer de format une image
```
$ convert image.jpg image.png
```

Supprimer la transparence et la remplacer par du blanc

$ convert image1.png -background white -alpha remove image2.png

Convertir une image bitmap (PNG, JPEG) en format vectoriel (SVG)
```
$ convert infile.png bmp:- | potrace -s - -o outfile.svg
```

Convertir une image bitmap (PNG, JPEG) en PDF

$ convert -background white -page a4 -compress Zip -quality 0 \
        infile.png outfile.pdf

Convertir un ensemble d’images en PDF

$ img2pdf -o oufile.pdf --pagesize a4 images/*.jpg

Redimensionner

Redimensionner une image

$ convert $image -resize "$largeur"x"$hauteur" $newimagename

Retourner une image

$ convert $image -rotate 90 $newimagename

GIF & Co.

Faire un GIF avec une collection d’images

$ convert -delay 20 -loop 0 img_*.gif output.gif

Extraire les images d’un GIF

$ convert -coalesce infile.gif img_%d.png

Faire un GIF avec les pages d’un PDF

$ convert -verbose -delay 50 -alpha off -background #FFFFFF \
   -loop 0 -density 300 infile.pdf outfile.gif

Vignettes

Convertir une page de PDF en PNG

$ convert -trim infile.pdf[0] -quality 100 \
          -flatten -resize x300 outfile.png

Visualisation des fonctions et données

Tracer avec gnuplot

Autres médias

Audio

Convertir un mp3 en wav
```
$ mpg123 -w outfile.wav infile.mp3
```
Écouter la radio, par exemple france culture
```
$ cvlc http://direct.franceculture.fr/live/franceculture-midfi.mp3
```
(voir ici pour quelques adresses de flux).

Vidéos

Convertir un avi en mp4, sans réencoder le son mais avec un flux vidéo réencodé à 100 kbps
```
$ ffmpeg -i input.avi -c:a copy -c:v vp9 -b:v 100K output.mp4
```

Convertir un avi en mov

$ ffmpeg -i input.avi -acodec libmp3lame -ab 192 output.mov

Découper une vidéo à 24’53 :

$ ffmpeg -i video.mp4 -acodec copy -vcodec copy \
    -ss 0 -t 00:24:53 video1.mp4
$ ffmpeg -i video.mp4 -acodec copy -vcodec copy \
    -ss 00:24:53 video2.mp4

Gestion de fichiers

Archiver, compresser

Archiver et compresser un répertoire

$ tar cz mydir -f mydir.tar.gz
$ tar cf - mydir | gzip -c mydir.tar.gz

avec bzip2

$ tar cj mydir -f mydir.tar.bz2
$ tar cf - mydir | bzip2 -c > mydir.tar.bz2

avec zip

$ tar cf - mydir | zip outfile.zip -

Décompresser et extraire un répertoire

$ tar xzf mydir.tar.gz
$ gzip -d -c mydir.tar.gz | tar xf -
$ gunzip -c mydir.tar.gz | tar xf -

avec bzip2

$ tar xjf mydir.tar.bz2
$ bzip2 -d -c mydir.tar.bz2 | tar xf -
$ bunzip2 -c mydir.tar.bz2 | tar xf -

avec zip

$ tar cf - mydir | gzip outfile.zip -

Archives zip

Attention à l’encodage !

Compresser un répertoire dans une archive zip
```
$ zip -r foo.zip foo
$ zip -r foo foo
```
Décompresser une archive zip
```
$ unzip foo.zip
```
Voir les fichiers contenus dans une archive zip
```
$ zip foo.zip -sf
```

Ajouter le fichier bar à une archive zip

$ zip foo.zip bar
$ zip foo.zip add bar
$ zip foo.zip -u bar

Mettre à jour le fichier bar d’une archive zip
```
$ zip foo.zip -u bar
```
Supprimer le fichier bar d’une archive zip
```
$ zip foo.zip -d bar
```

Gestion de versions

Voir la section « Comparaison » pour le contenu des fichiers textes.

Avec git & Co.

Synchronisation de répertoires

Synchroniser 2 répertoires (unidirectionnel)
```
$ rsync -a --stats --progress --delete $SRC $DST/
```
L’option -a précise le mode archive (récursif, liens, permissions) et --delete permet de supprimer les fichiers de la cible qui ne sont pas dans la source.
Synchroniser 2 répertoires par SSH
```
$ rsync -azv --delete -e ssh $SRC user@host:$DST/
```
L’option -z permet de compresser les fichiers pendant le transfert et -v active le mode verbeux.
Sauvegarde incrémentale
```
$ rsync -abz --stats --progress --delete --suffix="_old" \
    --backup-dir=$(basename $SRC)"_$(date +%Y-%m-%d)" $SRC $DST/
```
L’option -b ou --backup permet de garder une trace des fichiers de la cible modifiés, ici avec le suffixe _old dans le répertoire précisé par --backup-dir.

Voir ici pour d’autres options de rsync.

Synchronisation biderectionnelle en deux temps
```
$ rsync -Pcauv dir1/ dir2/
$ rsync -Pcauv dir2/ dir1/
```
où -P affiche la progression partielles, -c compare les sommes de contrôle (checksum) et non les dates ou la taille, -a actove le mode archive (récursif, liens, permissions), -u passe les fichiers plus récents de la cible et -v active le mode verbeux (vu là).
Synchroniser 2 répertoires
```
$ unison dir1/ dir2/
```
Nécessite l’installation de la même version d’unison sur les deux systèmes.

Vérifier que tous les fichiers d’une carte SD ${SDdir} sont dans sous-répertoire d’un répertoire ${homedir}

for file in $(ls ${SDdir}); do 
    filename=$(basename ${file})         
    if [ $(find ${homedir} -name "${filename}" | wc -l) -lt 1 ]
    then
        echo "${file} à sauver"
    fi
done

Sauvegardes

Pour gérer mes sauvegardes, j’utilise l’excellent BorgBackup (aide en ligne)

Initialiser un dépôt vide
```
$ mkdir -p /media/$whoami/... \
   && borg init --encryption=repokey $_
```
Le système vous demande une phrase de passe (deux fois).
Créer un backup
```
$ borg create --info --stats /path/to/repo::backup_name dir_to_backup/
```
Pour le nom du backup, pas besoin de faire original. Si la sauvegarde est quotidienne, un $(date +%F) suffit.
Voir les backup existants
```
$ borg list /path/to/repo
```

Supprimer un backup

$ borg delete /path/to/repo::backup_name

Voir les différences entre 2 backups

$ borg diff /path/to/repo::backup_name1 backup_name2

Restauration de sauvegarde
```
$ borg mount /path/to/repo::backup_name /mount/point
```
où /mount/point est un point de montage que vous avez créé avec les permissions adéquates (chown you:you /mount/point et chmod 700 /mount/point).
Explorez puis démonter
```
$ umount /mount/point
```
Suppression automatique des archives anciennes
```
$ borg prune -v /path/to/repo \
    --keep-daily=7 \
    --keep-weekly=4 \
    --keep-monthly=6
```
permet de garder :
- une archive par jour les 7 derniers jours,
- une archive par semaine pour les 4 dernières semaines,
- une archive par mois pour les 6 derniers mois (-1 pour tous les mois).

Pour « rester propre »

Comparer 2 fichiers bit à bit
```
$ cmp file1 file2
```
Trouver des fichiers en double dans un répertoire
```
$ fdupes -r directory > outfile
```

Trouver les fichiers en double dans un répertoire et les trier par taille décroissante

$ fdupes -rS directory | sed -e 's/^$/@@MAKE@@INLINE@@/g' | tr '\n' '\0' \
| sed -e 's/@@MAKE@@INLINE@@\x00/\n/g' | sort -rn | tr '\0' '\n' \
> outfile

Supprimer les fichiers en double dans un répertoire
```
$ fdupes -rd directory
```
ou de façon automatique (option N) en ne gardant que le premier (option f)
```
$ fdupes -rdfN directory
```

Supprimer les fichiers en double dans un répertoire ayant le motif pattern

$ fdupes -r directory -f | grep pattern \
    | tr "\n" "\0" | xargs -0 -n 1 rm -v

Éditer une liste de noms de fichiers puis les supprimer
```
$ fdupes -r directory > outfile.list
```
enfin supprimer les fichiers en omettant les lignes vides mais en tenant compte des espaces dans les noms de fichier)
```
$ cat outfile.list | sed -e '/^$/d' | tr '\n' '\0' | xargs -0 rm -v
```

Supprimer tous les fichiers en double contenus dans un sous-répertoire dir/sub/ de dir :

$ fdupes -r dir > outfile
$ for f in $(ls dir/sub/*.jpg);do \
  test $(grep -c $f outfile) -ge 1 && rm -v $f;\
  done

Trouver les répertoires en double

$ diff dir1 dir2 | grep "Commmon" | cut -d " " -f3 \
    | uniq | tr "\n" "\0" | xargs -0 basename -a

Communication, Internet

Liens

URL to link

import re
text = re.sub('(https?:\/\/[^\s<"]+)', r'<a href="\1">\1</a>', text)

Générer un code QR en PDF

$ qrencode "URL" -t eps -o - | epstopdf -f -o outfile.pdf

Téléchargement

Télécharger un fichier

$ wget http://path.to.the/file

$ curl http://path.to.the/file

Télécharger un fichier et le renommer

$ wget http://path.to.the/file -O newname

Reprendre un téléchargement avorté
```
$ wget -c http://path.to.the/file
```
Télécharger un fichier après authentification HTTP
```
$ curl -u username:password URL
```

Télécharger tous les PDF d’un site

$ wget -e robots=off -r -l1 --no-parent -A.pdf URL

Lister les formats disponibles sur un site de streaming
```
$ youtube-dl -F URL
```
Télécharger une vidéo sur un site de streaming en limitant la bande passante à 150 ko
```
$ youtube-dl -r 150K -f <format code> URL
```

Partage de fichiers (local et temporaire)

Un serveur web qui sert le dossier courant sur le port 8000
```
$ python3 -m http.server 8000
```

FTP

Lister le contenu d’un répertoire FTP

$ curl ftp://username:password@example.com

Envoyer un fichier par FTP

$ lftp -u $FTPuser,$FTPpwd ftp://@$FTPserver \
    -e "put outfile ; quit"

Créer un dossier miroir par FTP

$ lftp -u FTPuser,FTPpwd ftp://@FTPserver \
    -e "mirror -e -R localdir FTPdir ; quit"

Mails

Envoyer un email avec mutt

$ mutt -s "Subject" address@to.fr -a attached.pdf < body_text_file

Navigateurs

Afficher la météo à Paris dans son terminal
```
$ curl wttr.in/paris,france
```
ou à Lyon en français
```
$ curl fr.wttr.in/lyon,france
```

Faire une recherche sur le web en tapant directement dans le terminal

$ duckduckgo "ma recherche"

$ google "ma recherche"

après avoir inséré dans votre ~/.bashrc les lignes :

google() { w3m https://www.google.com/search\?q\="$1" ;}
duckduckgo() { w3m https://duckduckgo.com/\?q\="$1" ;}

SSH

Se connecter en SSH
```
$ ssh user@host
```
Envoyer un fichier par SSH
```
$ scp -O infile user@host:directory/.
```
ou en sens inverse
```
$ scp -O user@host:directory/infile .
```
où l’option -O est nécessaire depuis OpenSSH 8.8 (qui utilise le protocole SFTP par défaut).
Envoyer un dossier par SSH
```
$ scp -O -r dir user@host:directory/.
```

Monter un répertoire à travers une connexion SSH

$ sshfs user@shost:/path/to/folder /path/to/mount/point

avec le point de montage

$ sudo mkdir -p /path/to/mount/point
$ sudo chown you:you /path/to/mount/point
$ chmod 700 /path/to/mount/point

et, une fois fini

$ fusermount -u mountpoint

Assurez-vous d’avoir eu accès par SSH avant que l’hôte soit connue.

Workflow

Chronométrer une commande
```
$ time command
```
Faire une pause de 8 seconde
```
$ sleep 8
```

Calculatrice

Calculer (avec bc)

$ bc -l <<< "1+sqrt(5)"

où l’option -l charge la bibliothèque maths. Les fonctions élémentaires sont :

s(x)    sinus
c(x)    cosinus
a(x)    arctangente
l(x)    logarithme naturel
e(x)    exponentielle
sqrt(x) racine carrée
x^y     puissance
x%y     reste de la division euclidienne

Pour calculer $\pi$ :

$ pi=$(bc -l <<< "scale=10; 4*a(1)")

Calculer (avec octave)
```
$ octave -q <<< "[1:3:12]*pi"
```
avec une syntaxe à la matlab.

Vie de tous les jours

Afficher la date
```
$ date
```
ou juste année-mois-jour
```
$ date +%F
$ date +"%Y-%m-%d"
```
Afficher le calendrier du mois mm de l’année aaaa
```
$ cal mm aaaa
```
si pas d’argument, celui du mois en cours.
Lancer un chronomètre avec
```
$ time cat
```
puis taper
```
<C-d>
```
pour l’arrêter.

Impression

Lister les imprimantes
```
$ lpstat -p
```
ou en se limitant aux noms
```
$ lpstat -a | cut -f1 -d ' '
```
Soumettre un travail d’impression à l’imprimante printer
```
$ lpr -P printer filename
```
Limiter l’impression à certaines pages
```
$ lpr -o page-ranges=1-4,7,9-12 filename
```
Imprimer un document en format paysage ajusté à un A4
```
$ lpr -o landscape -o fit-to-page -o media=A4 filename
```

Imprimer 4 pages par feuille (2 pages/page et recto-verso)

$ lpr -o number-up=2 -o sides=two-sided-long-edge filename

Préciser le nombre de copies n à imprimer
```
$ lpr -#n filename
```
Voir la pile d’impression de l’imprimante printer
```
$ lpq -P printer
```
Supprimer le travail d’impression job-id
```
$ lprm job-id
```
Changer l’imprimante destinataire d’un travail job-id
```
$ /usr/sbin/lpmove job-id new-printer
```

Processus programmé

Exécuter une commande à une heure donnée
```
$ at HHMM <<< "cmd args"
```
Lister les PID des commandes programmées
```
$ atq
$ at -l
```
Voir le contenu d’une commande programmée
```
$ at -c PID
```

Multiplexeur de terminaux

Les multiplexeurs de terminaux permettent d’ouvrir plusieurs terminaux dans une même console, de passer de l’un à l’autre et de les mémoriser pour les récupérer plus tard. Dans le monde GNU/Linux, les deux principaux sont le « vieux » screen et tmux.

`screen`

Créer une session
```
$ screen -S name
```
Voir les sessions existantes
```
$ screen -ls
```
Se connecter à une session
```
$ screen -r name
```
ou, si elle n’est pas détachée
```
$ screen -x name
```
Détacher une session
```
<C-a> <C-d>
```
Fermer (tuer) une session (et toutes ses fenêtres)
```
<C-a> <C-\>
```
Créer une nouvelle fenêtre
```
<C-a> <C-c>
```
puis naviguer vers la précédente
```
<C-a> <C-p>
```
ou la suivante
```
<C-a> <C-n>
```
Lister les fenêtres disponibles
```
<C-a> "
```
Passer à la fenêtre n
```
<C-a> n
```
Renommer la fenêtre
```
<C-a> A
```
en changeant le nom pré-affecté en bas à gauche.
Supprimer la fenêtre courante
```
<C-a> K
```
Découper la fenêtre courante horizontalement
```
<C-a> S
```
ou verticalement
```
<C-a> |
```
en deux régions, puis y aller
```
<C-a> <tab>
```
et lancer un shell (fenêtre vide par défaut)
```
<C-a> c
```
Supprimer toutes les régions souf la courante
```
<C-a> Q
```

`tmux`

Tmux est assez performant sur la gestion de l’affichage avec notamment le découpage de fenêtres en panes.

Ouvrir une nouvelle session tmux
```
$ tmux new -s SessionName
```
Renommer la session
```
<C-b> $
```
Lister les sessions
```
$ tmux ls
```
ou directement dans une session
```
<C-b> s
```
puis sélectionner celle voulue.

Naviguer entre les sessions

<C-b> )     " session suivante
<C-b> (     " session précédente

Détacher une session
```
<C-b> d
```

Attacher une session

$ tmux a -t SessionName
$ tmux at -t SessionName
$ tmux attach -t SessionName

Tuer une session
```
$ tmux kill-session -t SessionName
```
ou toutes sauf la session courante
```
$ tmux kill-session -a
```
ou, depuis la session
```
<C-d>
```
Créer une nouvelle fenêtre
```
<C-b> c
```
Renommer la fenêtre
```
<C-b> ,
```
Afficher la liste des fenêtres disponibles
```
<C-b> w
```

Passer d’une fenêtre à une autre

<C-b> n        " fenêtre suivante
<C-b> p        " fenêtre précédente
<C-b> x        " fenêtre numéro x (numéros affichés en bas)

Fermer la fenêtre courante
```
<C-b> &
```
Scinder le pane verticalement
```
<C-b> %
```
ou horizontalement
```
<C-b> "
```
Changer l’affichage courant
```
<C-b> <space>
```

Se déplacer de pane en pane

<C-b> <up>
<C-b> <down>
<C-b> <left>
<C-b> <right>

Basculer d’un pane à l’autre
```
<C-b> o
```
ou au dernier pane utilisé
```
<C-b> ;
```
Afficher le numéro des panes
```
<C-b> q
```
Se rendre sur le pane x
```
<C-b> q x
```
Zoomer sur le pane courant
```
<C-b> z
```

Redimensionner le pane courant

<C-b-up>
<C-b-down>
<C-b-left>
<C-b-right>

Déplacer le pane courant à gauche
```
<C-b> {
```
ou à droite
```
<C-b> }
```
Écrire simultanément dans tous les panes
```
<C-b>:setw synchronize-panes on
```
puis pour le désactiver
```
<C-b>:setw synchronize-panes off
```
Convertir le pane courant en fenêtre
```
<C-b> !
```
Afficher l’heure dans le pane courant
```
<C-b> t
```
Supprimer le pane courant
```
<C-b> x
```
Activer le mode copie
```
<C-b> [
```
démarrer une selection
```
<space>
```
copier la sélection
```
<enter>
```
quitter le mode copie
```
q
```
Sélctionner le pane et coller
```
<C-b> ]
```

Outils de sécurité

Générer des mots de passes

Générer un mot de passe de 12 caractères
```
$ apg -a 1 -m 12 -n 1
```
ou 10 mots de passe de 20 caractères
```
$ apg -a 1 -m 20 -n 10
```
Générer un mot de passe avec une saisie clavier pour maximiser l’entropie
```
$ apg -a 1 -m 12 -n 1 -s
```

Chiffrer/déchiffrer un fichier

Chiffrer un fichier
```
$ gpg -c infile
$ gpg -c --cipher-algo AES256 infile
```
Algo de chiffrement symmétriques : AES256, TWOFISH et BLOWFISH
Déchiffrer un fichier
```
$ gpg infile.gpg
```

Éviter le prompt graphique de pinenty

$ echo "passwd" | gpg --pinentry-mode loopback \
    --passphrase-fd 0 -d infile.gpg

Archiver, compresser et chiffrer un répertoire

Archiver, compresser et chiffrer un répertoire
```
$ tar cz mydir | gpg -c > mydir.tar.gz.gpg
```
Déchiffrer, décompresser et extraire
```
$ gpg -d mydir.tar.gz.gpg | tar -xz
```

Chiffrer/déchiffrer avec une clé

Chiffrer un fichier

$ gpg -e -r user_id my_file

$ gpg -er user_email my_file

Déchiffrer un fichier
```
$ gpg my_file.gpg
```
ou de façon discrète
```
$ gpg -d my_file.gpg
```
de façon à pouvoir continuer dans un pipe.

Gestion des clés avec GnuPG

Lister les clés publiques

$ gpg --list-keys
$ gpg -k

et les clés privées

$ gpg --list-secret-keys
$ gpg -K

Exporter sa clé publique
```
$ gpg --armor --export KeyID > pubK.asc
```

Publier sa clé publique

$ gpg --send-keys --keyserver pgp.mit.edu keyID

Exporter sa clé privée

$ gpg --armor --export-secret-keys KeyID > privK.asc

Importer une clé
```
$ gpg --import keyfile.asc
```

Supprimer une clé publique

$ gpg --delete-keys pub_keyID

ou privée

$ gpg --delete-secret-keys priv_key_ID

ou les deux

$ gpg --delete-secret-and-public-key keyID

Changer la passphrase d’une clé
```
$ gpg --edit-key keyID
```
puis dans le shell de gpg
```
gpg> passwd
gpg> save
```
Révoquer une clé
```
$ gpg --gen-revoke keyID
```

Changer la date d’expiration d’une clé

$ gpg --edit-key keyID

puis dans le shell de gpg

gpg> list
gpg> key 0
gpg> expire
gpg> key 1
gpg> expire
gpg> save

enfin la publier

$ gpg --keyserver pgp.mit.edu --send-keys keyID

Relancer l’agent GnuPG
```
$ gpg-connect-agent reloadagent /bye
```

Signer, chiffrer ses emails

Chiffrer une pièce jointe envoyée à recipient@email.com

$ gpg --armor --encrypt --sign -r recipient@email.com filename

Signer un email
```
$ gpg --sign-key email@example.com
```

Éditer un fichier texte chiffré avec vim

L’idée est d’utiliser le mécanisme de clés publique et privée GnuPG avec vim. L’ouverture du fichier nécessite la clé privée, incluant sa passphrase puis l’enregistrement la clé publique. Par sécurité, aucun cache n’est généré. Voir la configuration du .vimrc. On tape ensuite simplement dans le terminal :

$ vim file.gpg

puis on entre sa passphrase dans le GPG pinentry.

Gestion des mots de passe

pass: gestionnaire de mots de passe à la UNIX basé sur GPG. https://www.passwordstore.org/

Outils de programmation

Scripts idempotents

On dira d’un script qu’il est idempotent si l’état du système reste le même après un ou plusieurs appels de celui-ci. En pratique, on veillera d’abord à ce qu’il ne lève pas d’erreur en cas d’exécutions multiples.

Créer un répertoire
```
$ mkdir -p directory
```
l’option -p permet de ne pas renvoyer d’erreur si directory existe ;
Supprimer un fichier
```
$ rm infile
```
l’option -f permet d’ignorer les fichiers inexistants ;
Créer un lien symbolique
```
$ ln -sf target_file linked_file
```
l’option -f permet de supprimer target_file avant de le recréer ;
Monter un disque
```
 $ mountpoint -q DataDir || mount Volume DataDir
```
en s’assurant qu’il ne soit monté avant ;
Créer et utiliser un répertoire temporaire qui sera supprimé quand le script termine
```
TMPDIR=$(mktemp -d) || exit 1
trap "cd / ; rm -rf '${TMPDIR}'" EXIT
```

Python

Retrouver une fonction dans un shell python

import inspect
print(inspect.getsource(fonction))

Parcourir deux listes simultanément avec un compteur

for i, x, y in izip(count(), a, b):

plus rapide que

for i, (x, y) in enumerate(zip(a, b)):

Définir des array avec les colonnes d’un fichier texte
```
col_k = np.readtxt("file")[:,k]
```
Modifier la taille de pile de récursivité
```
import sys
sys.setrecursionlimit(n)
```
avec $n=O(1000)$ par défaut.

Encoder et décoder du JSON

def JsonRead(infile):
    with open(infile,'r') as f:
        data = json.load(f)
    return(data)

où data est un dictionnaire.

def JsonWrite(data, oufile):
    with open(oufile,'w') as f:
        f.writelines(json.dumps(data, sort_keys=True, indent=4))

Administration système

Lancer une commande en administrateur
```
$ sudo command
```
ou
```
$ su -c command
```
Ajouter un utilisateur au groupe sudo
```
# adduser <user> sudo
```
Autoriser un utilisateur à utiliser le système de fenètres X
```
$ sudo xhost local:user
```
Arrêter le système (en root)
```
# shutdown -h now
```
ou
```
su -c poweroff
```
par sécurité sur debian poweroff pointe vers /sbin/poweroff.
Afficher depuis combien de temps vous êtes connecté et la charge de la machine
```
$ uptime
```
Afficher l’historique des redémarrages du système
```
$ last reboot
```

Plate-forme, distribution, etc.

Nom de machine
```
$ hostname
```
Changer le nom de la machine
```
# hostnamectl set-hostname <host-name>
```
puis éditer les fichiers /etc/hostname et /etc/hosts.

Vérifier avec
```
$ hostnamectl
```
Distribution
```
$ lsb_release -idrc
```
Afficher les informations de la distribution
```
$ lsb_release -a
```
Informations du système
```
$ uname -a
```
Noyau
```
$ uname -r
```
Afficher l’environnement de bureau utilisé
```
$ echo "$XDG_CURRENT_DESKTOP"
```
Afficher le gestionnaire X11
```
$ cat /etc/X11/default-display-manager
```

État du système

Version du noyau Linux utilisé, son nom, la version du compilateur utilisé :
```
$ cat /proc/version
```
Informations CPU
```
$ cat /proc/cpuinfo
```
Informations mémoire
```
$ cat /proc/meminfo
```
Utilisation de la mémoire
```
$ free -h
```
Partitions montées
```
$ cat /proc/partitions
```

Debian GNU/Linux

Date d’installation d’un paquet

# zgrep -h " installed " /var/log/dpkg.log* | sort | grep package

Trouver le paquet qui a installé une commande, avec une commande :

whatinstalled() { which "$@" | xargs -r readlink -f | xargs -r dpkg -S ;}

puis

$ whatinstalled <package>

Vider le cache

# sync && echo 3 | tee /proc/sys/vm/drop_caches

Analyser le démarrage

# systemd-analyze time
# systemd-analyze critical-chain
# systemd-analyze blame

Gérer les messages d’erreur
```
# dmesg
```
ou
```
# journalctl -p err
```

Utilisateurs, groupes, permissions

Nom d’utilisateur
```
$ whoami
```
Identifiants des groupes auxquels appartient un utilisateur
```
$ id user
```
si user n’est pas spécifié, de l’utilisateur courant (vous).
Identifier qui est connecté à la machine, comment (shells ouverts) et depuis combien de temps :
```
$ who
```
Afficher la liste de tous les utilisateurs connectés à la machine :
```
$ users
```
Identifier ce que chacun fait sur la machine
```
$ w
```
Afficher les utilisateurs qui se sont connectés au système
```
$ last
```
Se connecter au compte user
```
$ su - user
```
pour se déconnecter, taper
```
$ exit
```
ou
```
$ logout
```
Afficher les informations de l’utilisateur login
```
$ finger login
```
Modifier son mot de passe
```
$ passwd
```
Commande à réaliser avec le compte root ou en super user avec sudo en préfixe.

Créer un nouvel utilisateur

# adduser newuser

# useradd -m -d /home/newuser -c "Full name" newuser

Pour supprimer son compte, taper

# deluser --remove-home newuser

# userdel -r newuser

Modifier les informations d’un utilisateur

$ usermod -c "son nom" \
    -s /bin/bash user

Créer un nouveau groupe
```
$ addgroup newgroup
```
Ajouter un utilisateur à un groupe
```
$ adduser username groupname
```
Changer un utilisateur de groupe
```
$ chgrp vboxusers /dev/vboxdrv
```
Lister les connexions bloquées
```
# lastb
```
et pour lister toutes les connexions
```
$ last
```

Permissions des fichiers

On distingue trois types d’utilisateurs :

le propriétaire (user, aka u)
le groupe (group, aka g)
les autres (other, aka o)

Pour chaque type, les permissions sont notées :

0     ---      aucune permission
1     --x      exécution
2     -w-      écriture
3     -wx      écriture et exécution
4     r--      lecture
5     r-x      lecture et exécution
6     rw-      lecture et écriture
7     rwx      lecture, écriture et exécution

Créer un répertoire pour le seul utilisateur user1

$ mkdir newdir
$ chown user1:user1 newdir
$ chmod 700 newdir

Changer de propriétaire et de groupe un fichier
```
$ chown user:group filename
```
Pour changer seulement le propriétaire
```
$ chown user filename
```
ou seulement de groupe
```
$ chown :group filename
```
ou
```
$ chgrp group filename
```

Changer les permissions d’un fichier

 U   G   W
rw- --- ---     chmod 600 filename  (à préférer par défaut)
rw- r-- r--     chmod 644 filename
rw- rw- r--     chmod 664 filename
rwx r-x r-x     chmod 755 filename
rwx rwx r-x     chmod 775 filename
rwx rwx rwx     chmod 777 filename  (à proscrire)

Voir le masque de permissions appliqué par défaut
```
$ umask
```
en base octale, ou, pour la version symbolique, du genre u=rwx,g=rx,o=rx
```
$ umask -S
```

Les restrictions appliquées par un masque sont :

masque           droits laissés
7       ---      aucun
6       --x      exécution
5       -w-      écriture
4       -wx      écriture et exécution
3       r--      lecture
2       r-x      lecture et exécution
1       rw-      lecture et écriture
0       rwx      lecture, écriture et exécution

Changer le masque des permissions par défaut

 U   G   W
rw- --- ---     umask 177 (à préférer par défaut)
rw- r-- r--     umask 133
rw- rw- r--     umask 113
rwx r-x r-x     umask 022
rwx rwx r-x     umask 002
rwx rwx rwx     umask 000 (à proscrire)

Ajouter un droit d’exécution
```
$ chmod +x filename
```
Lister les attributs d’un fichier
```
# lsattr <file>
```
Bloquer un fichier (le rendre immuable)
```
# chattr +i <file>
```
le débloquer avec
```
# chattr -i <file>
```
Bloquer un répertoire
```
# chattr -R +i path
```

Locales

Afficher les paramètres régionaux du système
```
$ localectl status
```
Afficher les localisations disponibles
```
$ localectl list-locales
```

Passer en anglais

$ sudo localectl set-locale LANG=en_US.utf8

ou en français

$ sudo localectl set-locale LANG=fr_FR.utf8

Redéfinir la variable LANG pour se connecter en SSH
```
$ LANG=en_US.utf8 && ssh ...
```

Systèmes de fichiers, disques

Description de la hiérarchie du système de fichiers
```
$ man hier
```
Informations sur les périphériques bloc
```
$ lsblk
```
Avec les identifiants de partitions et les labels :
```
$ lsblk --output NAME,SIZE,TYPE,FSTYPE,MOUNTPOINT,PARTLABEL,UUID
```
Systèmes de fichiers montés
```
mount
```
Lister les disques
```
$ df -h
```
Monter un disque
```
$ mount volume DataDir
```
Monte le volume désigné par volume (comme /dev/sdb1) dans le point de montage DataDir (répertoire). L’option -t permet de définir le type de volume monté (vfat pour windows, iso9660 pour un CD-ROM par exemples). Pour le démonter :
```
$ umount
```

Formater un disque (clé USB) en FAT 32

# umount /dev/sdb1
# mkfs.vfat -F 32 /dev/sdb1

Copier une image ISO sur un disque (pas sur une partition) ; par exemple /dev/sdb et non pas /dev/sdb1:
```
# dd if=image.iso of=/dev/sdb bs=4M && sync
```
Attention la commande dd est très performante mais en cas d’erreur de syntaxe, il est possible d’effacer un disque dur.
Créer une image ISO à partir d’un répertoire
```
$ genisoimage -o image.iso directory
```

Processus

Afficher la liste des processus en cours d’exécution :
```
$ ps -ef
```
ou
```
$ ps aux
```
AFficher les processus sous forme d’arbre
```
$ pstree -p
```
Afficher la liste des processus en cours d’exécution ainsi que la consommation en ressources de chacun d’eux :
```
$ top
```
Mesurer la durée d’exécution d’une commande
```
$ time command
```
Afficher la liste des processus actifs de l’utilisateur
```
$ ps
```
Afficher les processus dans une arborescence
```
$ pstree
```
Tuer un processus en utilisant son pid
```
$ kill [signal] pid
```
Tuer un processus en utilisant le nom du programme
```
$ pkill [signal] progname
```

Les signaux utilisés par kill/pkill sont :

signal	mode	action
-1	(HUP)	recharger le fichier de configuration du processus
-2	(INT)	interrompre le processus
-3	(QUIT)	quitter le processus
-9	(KILL)	tuer le processus (à éviter, tenter -15 avant)
-15	(TERM)	terminer le processus proprement
-18	(STOP)	geler le processus
-20	(CONT)	reprendre l’exécution d’un processus gelé

Supprimer tous les processus associés à une commande
```
$ killall command
```
Lancer une commande avec une priorité faible
```
$ nice command
```
Trouver la liste des processus qui utilise un répertoire (en root)
```
$ lsof -x +D /repertoire
```
Trouver la liste des fichiers ouverts par un processus (en root)
```
$ lsof -p PID
```

Monitoring

Place au premier plan le processus pid
```
$ fg pid
```
Place en arrière plan le processus pid
```
$ bg pid
```
Redéfinir le niveau de priorité du processus pid
```
$ renice +1 pid
```
Afficher la liste des processus en arrière plan
```
$ jobs
```
Tuer le job [n]
```
$ kill %n
```

Terminal série

Créer un terminal série avec screen
```
$ screen -S name /dev/{tty,ACM}...
```

Réseau

Lister les interfaces avec leurs modes de connexion
```
$ nmcli
$ nmcli d
```

Lister les connexions actives

$ nmcli connection show --active
$ nmcli con show --active

Démarrer ou éteindre une connexion

$ nmcli connection down connection_name
$ nmcli connection up connection_name

Activer la Wi-Fi

$ nmcli radio wifi on

ou la désactiver

$ nmcli radio wifi off

Vérifier l’accès à Internet
```
$ nmcli network connexion
$ nmcli net con
```
doit renvoyer full pour un accès complet.
Afficher la liste de toutes les connexions réseaux
```
# lsof -i
```
Trouver le processus qui écoute sur le port 80
```
# lsof -nP -i tcp:80 | grep LISTEN
```

Configurer un proxy

$ export http_proxy="http://user:password@host:port"
$ export https_proxy="http://user:password@host:port"
$ export ftp_proxy="http://user:password@host:port"

visible avec

$ echo $http_proxy

Exemple, sans authentification

$ export http_proxy="http://172.20.1.4:3128/"

IP

Obtenir son IP locale

$ /sbin/ifconfig
$ ip addr show eth0
$ ip addr show eth0 | grep inet\  | cut -d' ' -f6 | cut -d/ -f1
$ ip addr show scope global | grep inet\  | cut -d' ' -f6 | cut -d/ -f1
$ hostname -I

Obtenir son IP publique

$ curl -s ipecho.net/plain;echo
$ curl -s https://ifconfig.me/ip;echo
$ curl -s http://whatismijnip.nl | cut -d " " -f 5

DNS

to get IP (DNS)
```
$ dig URL +short
```
to get URL (DNS Reverse)
```
$ dig -x IP +short
```
to use a Specific DNS server “dnsserver”
```
$ dig @dnsserver ...
```

Périphériques

Afficher la liste des périphériques USB connectés
```
$ lsusb
```
Afficher la liste des périphériques PCI connectés
```
$ lspci
```
Afficher les pilotes et les modules du noyau des périphériques matériels
```
$ lspci -nnk
```

Carte Wi-Fi

Régler la région « France » pour accéder canaux 11/12/13
```
# sed -i "s/^REGDOMAIN=.*$/REGDOMAIN=FR/" /etc/default/crda
```

Résidus

Interaction avec un Mac

Afficher un message à l’utilisateur (du clavier) depuis un terminal (ssh)
```
$ osascript -e 'display dialog "Hello!"'
```

Ressources

Lectures recommandées

GNU Bash (manuel)
Coreutils (GNU core utilities)
Linux man pages
TLDR pages, alternative raccourcie des manpages

Sur les commandes UNIX et GNU/Linux

page wikipedia sur les commandes unix
page des cahiers du débutant sur Debian
wiki Linux France
page de Patrick Hautrive

en anglais :

GNU/Linux tutorials from Debian Reference
FLOSS Manual
cheatography (Command-line cheat sheet)
Linux training academy

Idées & astuces

Guides des « bonnes pratiques » de l’ANSII

GNU coreutils

GNU file utilities

`chgrp`	Changes file group ownership.
`chown`	Changes file ownership.
`chmod`	Changes file permissions.
`cp`	Copies files.
`dd`	Copies and converts a file.
`df`	Shows disk free space on filesystems.
`dir`	Gives a brief directory listing.
`dircolors`	Setup program for the color output of GNU ls.
`du`	Shows disk usage on filesystems.
`install`	Copies file and sets its permissions.
`link`	Creates a single file hardlink
`ln`	Creates file links.
`ls`	Lists directory contents.
`mkdir`	Creates directories.
`mkfifo`	Creates FIFOs (named pipes).
`mknod`	Creates special files.
`mv`	Moves files.
`rm`	Removes (deletes) files.
`rmdir`	Removes empty directories.
`shred`	Destroy data in files.
`sync`	Synchronizes filesystem buffers and disk.
`touch`	Changes file timestamps.
`unlink`	Removes a single file or a hardlink
`vdir`	Long directory listing.

Shell utilities

`basename`	Removes the path prefix from a given pathname.
`chroot`	Changes the root directory.
`date`	Prints/sets the system date and time.
`dirname`	Removes the last level or filename from a given pathname.
`echo`	Prints a line of text.
`env`	Displays/modifies the environment.
`expr`	Evaluates expressions.
`factor`	Prints prime factors.
`false`	Returns an unsuccessful exit status.
`groups`	Print the groups that the user is a member of.
`hostid`	Print the numeric identifier for the current host
`hostname`	Print or set the machine name.
`id`	Print real/effective ?uid/?gid.
`logname`	Print current login name.
`nice`	Modify scheduling priority.
`nohup`	Allows a command to continue running after logging out.
`pathchk`	Check file name portability.
`pinky`	Lightweight finger
`printenv`	Prints environment variables.
`printf`	Formats and prints data.
`pwd`	Print the current working directory.
`seq`	Print numeric sequences.
`sleep`	Suspends execution for a specified time.
`stty`	Print/change terminal settings.
`su`	Allows you to adopt the id of another user or superuser.
`tee`	Sends output to multiple files.
`test`	Evaluates an expression.
`true`	Returns a successful exit status.
`tty`	Print terminal name.
`uname`	Print system information.
`users`	Print current user names.
`who`	Print a list of all users currently logged in.
`whoami`	Print effective user id.
`yes`	Print a string repeatedly.

Text utilities

`cat`	concatenate files and print to the standard output
`cksum`	checksum and count the bytes in a file
`comm`	compare two sorted files line by line
`csplit`	split a file into sections determined by context lines
`cut`	remove sections from each line of files
`expand`	convert tabs to spaces
`fmt`	simple optimal text formatter
`fold`	wrap each input line to fit in specified width
`head`	output the first part of files
`join`	join lines of two files on a common field
`md5sum`	compute and check MD5 message digest
`nl`	number lines of files
`od`	dump files in octal and other formats
`paste`	merge lines of files
`pr`	convert text files for printing
`ptx`	produce a permuted index of file contents
`sort`	sort lines of text files
`split`	split a file into pieces
`sum`	checksum and count the blocks in a file
`tac`	concatenate and print files in reverse
`tail`	output the last part of files
`tr`	translate or delete characters
`tsort`	perform topological sort
`unexpand`	convert spaces to tabs
`uniq`	remove duplicate lines from a sorted file
`wc`	print the number of bytes, words, and lines in files

About

Pour éditer ce document :

$ pandoc -o tips.pdf tips.md -s --highlight-style haddock

Pour éditer ce document en manpage :

$ pandoc tips.md -s -t man >tips.man

et le voir :

$ man ./tips.man

Guide de survie

Interpréteur de commandes (shell), terminal

Exécuter une commande

Raccourcis Bash

Rechercher une commande, documentation

Historique des commandes

Exécutions séquentielles ou conditionnelles

Redirections

Fichiers spéciaux

Tubes (pipeline)

Expressions rationnelles

Navigation

Répertoires

Fichiers

Recherches

Manipulation de fichiers texte

Édition de fichiers textes (avec vim)

Visualiser le contenu d’un fichier

Encodage

Comparaison

Rechercher et remplacer

Découper, assembler

Remettre en forme

Corrections orthographique et grammaticale

Traduction

Exporter le contenu, changer de format

Manipulation de PDF

Comparaison

Recherches

Annotations

Composition

Remettre en forme

Protéger par mot de passe

Manipulation d’images

Changer de format

Redimensionner

GIF & Co.

Vignettes

Visualisation des fonctions et données

Autres médias

Audio

Vidéos

Gestion de fichiers

Archiver, compresser

Archives zip

Gestion de versions

Synchronisation de répertoires

Sauvegardes

Pour « rester propre »

Communication, Internet

Liens

Téléchargement

Partage de fichiers (local et temporaire)

FTP

Mails

Navigateurs

SSH

Workflow

Calculatrice

Vie de tous les jours

Impression

Processus programmé

Multiplexeur de terminaux

screen

tmux

Outils de sécurité

Générer des mots de passes

Chiffrer/déchiffrer un fichier

Archiver, compresser et chiffrer un répertoire

Chiffrer/déchiffrer avec une clé

Gestion des clés avec GnuPG

Signer, chiffrer ses emails

Éditer un fichier texte chiffré avec vim

Gestion des mots de passe

Outils de programmation

Scripts idempotents

Python

Administration système

Plate-forme, distribution, etc.

État du système

Édition de fichiers textes (avec `vim`)

`screen`

`tmux`