La ligne de commande et Bash

Quand on débute, le terminal intimide : un écran sombre, un curseur qui clignote, aucun bouton. Pourtant, c'est l'outil que tout·e développeur·euse utilise chaque jour, pour une raison simple : il est plus rapide, plus précis et plus puissant que les interfaces graphiques pour une foule de tâches. Là où tu cliquerais dix fois dans des fenêtres, une seule ligne de commande fait le travail, et peut même être répétée ou automatisée.

Autre atout décisif : le terminal est universel. Git, Node, Docker, le déploiement de sites, les serveurs distants : presque tous les outils du métier se pilotent en ligne de commande. Un serveur en production n'a d'ailleurs souvent pas d'interface graphique du tout : le terminal est le seul moyen d'y agir. Apprendre le terminal, ce n'est pas une option, c'est un passage obligé, et c'est bien plus accessible qu'il n'y paraît.

Terminal, shell, Bash : trois mots à distinguer

• Le terminal : la fenêtre, l'application dans laquelle tu tapes. C'est le contenant.
• Le shell : le programme qui lit tes commandes, les exécute et te répond. C'est le moteur.
• Bash : le shell le plus répandu (avec zsh, très proche). C'est une variété de moteur.

En clair : tu ouvres un terminal, qui fait tourner un shell comme Bash, auquel tu donnes des commandes. Ces distinctions sont un peu théoriques au début, mais elles t'évitent la confusion quand on parle de « ton shell » ou de « script Bash ». Sur macOS, le shell par défaut est aujourd'hui zsh, quasi identique à Bash pour tout ce que tu apprendras ici.

L'anatomie d'une commande

ls -l /Users/alice
# │  │   └── argument : sur quoi la commande agit
# │  └────── option (ou drapeau) : modifie le comportement
# └───────── la commande elle-même

Une commande suit presque toujours le même schéma : le nom de la commande, des options (précédées d'un tiret, comme -l) qui modifient son comportement, et des arguments qui indiquent sur quoi elle agit. Tu valides toujours avec la touche Entrée. Ce schéma se répète pour toutes les commandes : une fois qu'il est acquis, tu peux lire n'importe quelle commande.

Le système de fichiers est un arbre de dossiers imbriqués. Dans le terminal, tu es toujours « situé » quelque part dans cet arbre : c'est ton répertoire courant. Trois commandes fondamentales te permettent de te repérer et de te déplacer : pwd (où suis-je ?), ls (que contient ce dossier ?) et cd (aller ailleurs).

pwd                 # "print working directory" : affiche où tu es
# /Users/alice/projets

ls                  # liste le contenu du dossier courant
ls -l               # version détaillée (taille, date, permissions)
ls -la              # -a montre aussi les fichiers cachés (commençant par .)

cd mon-projet       # entre dans le dossier "mon-projet"
cd ..               # remonte au dossier parent
cd ~                # retourne à ton dossier personnel (home)
cd                  # sans argument : idem, retour au home

pwd affiche ton emplacement, ls liste ce qui s'y trouve, cd te déplace. L'option -a de ls révèle les fichiers cachés, ceux dont le nom commence par un point (comme .gitignore ou .env), invisibles par défaut. Tu les croiseras souvent en développement.

Chemins absolus et relatifs

Pour désigner un dossier ou un fichier, deux façons. Un chemin absolu part de la racine et décrit tout le trajet : /Users/alice/projets/site. Un chemin relatif part de ta position actuelle : si tu es dans projets, site ou ./site suffit. Quelques raccourcis universels à connaître :

• . : le dossier courant (là où tu es)
• .. : le dossier parent (un cran au-dessus)
• ~ : ton dossier personnel (home), par exemple /Users/alice
• / : la racine, tout en haut de l'arbre

Une fois que tu sais te déplacer, tu peux agir sur les fichiers et les dossiers. Ces commandes remplacent tes clics dans l'explorateur de fichiers, en plus rapide. Voici la boîte à outils essentielle.

mkdir mon-dossier          # crée un dossier ("make directory")
mkdir -p a/b/c             # -p crée toute l'arborescence d'un coup

touch fichier.txt          # crée un fichier vide (ou met à jour sa date)

cp source.txt copie.txt    # copie un fichier
cp -r dossier/ sauvegarde/ # -r pour copier un dossier et son contenu

mv ancien.txt nouveau.txt  # renomme (ou déplace) un fichier
mv fichier.txt ../         # déplace le fichier dans le dossier parent

mkdir crée des dossiers, touch crée un fichier vide, cp copie, mv déplace ou renomme (c'est la même opération : donner un nouveau chemin). Retiens l'option -r (récursif) pour agir sur un dossier et tout ce qu'il contient, et -p pour créer plusieurs niveaux de dossiers d'un coup.

Supprimer : la commande dangereuse

rm fichier.txt             # supprime un fichier (DÉFINITIVEMENT)
rm -r dossier/             # supprime un dossier et tout son contenu

# ⚠️ Il n'y a PAS de corbeille : la suppression est irréversible

Le terminal permet de lire des fichiers sans les ouvrir dans un éditeur, ce qui est précieux pour jeter un œil rapide ou inspecter un gros fichier de logs. Plusieurs commandes selon le besoin.

cat fichier.txt        # affiche tout le contenu d'un coup
less fichier.txt       # affiche page par page (q pour quitter)
head fichier.txt       # les 10 premières lignes
tail fichier.txt       # les 10 dernières lignes
tail -f journal.log    # -f suit le fichier en temps réel (logs)

cat déverse tout le contenu, pratique pour un petit fichier. Pour un fichier long, less l'affiche page par page (tu quittes avec q). head et tail montrent le début ou la fin, et tail -f est un incontournable : il suit un fichier en temps réel, idéal pour observer les logs d'un serveur qui tourne.

grep : chercher du texte

grep "erreur" journal.log        # affiche les lignes contenant "erreur"
grep -i "erreur" journal.log     # -i : insensible à la casse (Erreur, ERREUR)
grep -r "TODO" .                 # -r : cherche dans tous les fichiers du dossier
grep -n "fonction" script.js     # -n : affiche aussi le numéro de ligne

grep est l'un des outils les plus puissants du terminal : il cherche un texte dans un ou plusieurs fichiers et affiche les lignes correspondantes. Avec -r (récursif), il fouille tout un projet ; avec -i, il ignore les majuscules ; avec -n, il indique le numéro de ligne. Chercher « où est utilisée cette fonction ? » dans tout un projet devient instantané.

Voici l'idée qui fait toute la puissance du terminal, et la philosophie du système Unix : chaque commande fait une chose simple, mais on peut les combiner pour accomplir des tâches complexes. Deux mécanismes permettent ça : le tuyau (pipe) qui branche des commandes entre elles, et la redirection qui envoie le résultat vers un fichier.

Le tuyau : la sortie de l'un devient l'entrée de l'autre

# Le | envoie le résultat de gauche vers la commande de droite
ls -l | grep ".txt"        # liste les fichiers, puis garde ceux en .txt

cat journal.log | grep "erreur" | wc -l
# affiche le contenu -> garde les lignes "erreur" -> les compte (wc -l)

history | grep "git"       # cherche "git" dans l'historique des commandes

Le symbole | (la barre verticale, le pipe) prend la sortie de la commande de gauche et la donne comme entrée à celle de droite. On peut enchaîner autant de tuyaux qu'on veut, chacun affinant le résultat. Dans l'exemple, on affiche un fichier, on filtre les lignes contenant « erreur », puis on les compte avec wc -l (word count, option -l pour les lignes). Trois petites commandes, une réponse précise : « combien d'erreurs dans ce log ? »

Rediriger vers un fichier

ls -l > liste.txt          # > écrit le résultat dans un fichier (ÉCRASE)
echo "une ligne" >> notes.txt   # >> AJOUTE à la fin (sans écraser)

grep "erreur" app.log > erreurs.txt   # sauvegarde les erreurs trouvées

La redirection > envoie le résultat d'une commande dans un fichier au lieu de l'afficher. Attention à la nuance cruciale : > écrase le fichier existant, tandis que >> ajoute à la fin sans effacer. Confondre les deux et écraser un fichier par erreur est un grand classique : retiens que le double chevron >> préserve, le simple > remplace.

Sur les systèmes Unix (macOS, Linux), chaque fichier porte des permissions qui définissent qui a le droit de le lire, l'écrire (le modifier) ou l'exécuter (le lancer comme programme). Tu croiseras vite ce système, notamment quand un script refuse de se lancer avec un message « permission denied ».

ls -l script.sh
# -rwxr-xr--  1 alice  staff  128 script.sh
#  │└┬┘└┬┘└┬┘
#  │ │  │  └── autres : lecture seule (r--)
#  │ │  └───── groupe : lecture + exécution (r-x)
#  │ └──────── propriétaire : lecture + écriture + exécution (rwx)
#  └────────── type (- fichier, d dossier)

La sortie de ls -l montre les permissions sous forme de lettres : r (read, lire), w (write, écrire), x (execute, exécuter). Elles sont données pour trois catégories : le propriétaire du fichier, son groupe, et les autres. Ce trio permet un contrôle fin de qui peut faire quoi.

chmod : rendre un script exécutable

chmod +x script.sh     # ajoute le droit d'exécution (le cas le plus courant)
./script.sh            # on peut maintenant le lancer

# Notation numérique (fréquente) :
chmod 755 script.sh    # rwx pour le proprio, r-x pour groupe et autres
chmod 644 fichier.txt  # rw- pour le proprio, r-- pour les autres

La commande chmod (change mode) modifie les permissions. Le cas que tu rencontreras le plus souvent : chmod +x mon-script.sh pour rendre un script exécutable, sans quoi il refuse de se lancer. Tu verras aussi une notation numérique (755, 644) : chaque chiffre encode les droits d'une catégorie. Pas besoin de la maîtriser tout de suite ; retiens surtout chmod +x.

Dès que tu répètes la même série de commandes, il est temps d'en faire un script : un fichier texte qui contient des commandes, exécutées les unes après les autres quand tu le lances. C'est le premier pas vers l'automatisation, et un script Bash de dix lignes peut t'épargner des heures de manipulations répétitives.

#!/bin/bash
# La première ligne (le "shebang") indique quel shell exécute le script

echo "Début de la sauvegarde..."
mkdir -p sauvegardes
cp -r mon-projet/ sauvegardes/
echo "Sauvegarde terminée !"

La première ligne, #!/bin/bash, s'appelle le shebang : elle indique au système quel interpréteur doit exécuter le script. Les lignes commençant par # sont des commentaires, ignorés à l'exécution. Le reste, ce sont les commandes que tu connais déjà. Pour lancer le script : on le rend exécutable une fois (chmod +x sauvegarde.sh) puis on l'appelle avec ./sauvegarde.sh.

Variables, arguments et conditions

#!/bin/bash

nom="Alice"                 # une variable (pas d'espace autour du =)
echo "Bonjour $nom"         # on lit une variable avec $

# $1 est le premier argument passé au script : ./salut.sh Bob
echo "Premier argument : $1"

# Une condition : le dossier existe-t-il ?
if [ -d "mon-projet" ]; then
  echo "Le dossier existe"
else
  echo "Dossier introuvable"
fi

Un script peut stocker des valeurs dans des variables (attention : pas d'espace autour du =) et les relire avec un $ devant le nom. Les arguments passés au script sont accessibles via $1, $2, etc. On peut aussi tester des conditions avec if : ici [ -d "mon-projet" ] vérifie qu'un dossier existe. La syntaxe des conditions Bash est un peu particulière (les crochets, le then, le fi qui ferme), mais tu la reconnaîtras vite.

Répéter avec une boucle

#!/bin/bash
# Convertir : afficher chaque fichier .txt du dossier
for fichier in *.txt; do
  echo "Traitement de $fichier"
done

La boucle for répète des commandes pour chaque élément d'une liste, ici chaque fichier .txt du dossier (le * est un joker qui remplace n'importe quelle suite de caractères). Variables, conditions, boucles : tu retrouves les concepts de programmation vus dans les autres cours, avec une syntaxe propre à Bash. Un script combine tout ça pour automatiser des tâches réelles.

Un·e dev qui maîtrise son terminal ne tape presque rien : il s'appuie sur des raccourcis et des astuces qui accélèrent tout. Adopter ces réflexes dès le début te fait gagner un temps considérable et rend l'expérience bien plus confortable.

Les raccourcis à connaître

• Tab : complète automatiquement un nom de fichier ou de commande (déjà vu, le plus important).
• Flèches ↑ / ↓ : rappellent les commandes précédentes, pour les rejouer sans les retaper.
• Ctrl + C : interrompt une commande en cours (un serveur, un processus bloqué).
• Ctrl + L (ou clear) : nettoie l'écran.
• history : affiche l'historique de tes commandes, souvent combiné à grep.

Les alias : tes raccourcis personnels

# Un alias crée un raccourci pour une commande longue
alias gs="git status"
alias ll="ls -la"

# Pour les rendre permanents, on les ajoute au fichier de config
# du shell : ~/.bashrc (Bash) ou ~/.zshrc (zsh)

Un alias est un raccourci que tu définis pour une commande que tu tapes souvent. alias gs="git status" te permet ensuite de taper juste gs. Pour qu'ils survivent à la fermeture du terminal, on les inscrit dans le fichier de configuration de ton shell : ~/.bashrc pour Bash, ~/.zshrc pour zsh. Ce fichier est lu à chaque ouverture de terminal et c'est là qu'on personnalise son environnement.