02 - Fichiers et répertoires

Ce que tu vas apprendre

• Les commandes essentielles pour manipuler des fichiers
• Utiliser find pour chercher n'importe quoi sur le système
• La différence entre liens hard et soft (symlinks)
• Les wildcards et pourquoi rm -rf merite le respect

Prerequisites

Savoir naviguer dans le terminal. Voir l'article sur le terminal si ce n'est pas le cas.

Tout est fichier

Sous Linux, tout est fichier. Un dossier ? C'est un fichier. Un disque dur ? Un fichier dans /dev/. Une connexion réseau ? Aussi un fichier. Ce concept peut paraitre bizarre au début, mais il simplifie énormément les choses. Les memes outils fonctionnent partout.

ls : lister, mais bien

Tu connais ls. Mais tu n'utilises probablement pas ses options les plus utiles :

bash# Basique
ls                     # Liste simple
ls -l                  # Liste detaillee (permissions, taille, date)
ls -a                  # Inclut les fichiers caches (commencent par .)
ls -la                 # Les deux combines (mon defaut)

# Les options qui changent la vie
ls -lh                 # Tailles lisibles (1.5K au lieu de 1536)
ls -lt                 # Trie par date de modification (plus recent en premier)
ls -lS                 # Trie par taille (plus gros en premier)
ls -lR                 # Recursif (liste les sous-dossiers aussi)

# Exemple concret
$ ls -lah
total 48K
drwxr-xr-x  5 nicolas dev  4.0K Mar 29 10:30 .
drwxr-xr-x  3 nicolas dev  4.0K Mar 28 14:00 ..
-rw-r--r--  1 nicolas dev   245 Mar 29 10:30 .env
-rw-r--r--  1 nicolas dev  1.2K Mar 29 09:15 package.json
drwxr-xr-x  8 nicolas dev  4.0K Mar 29 10:00 src
-rw-r--r--  1 nicolas dev   15K Mar 28 16:20 yarn.lock

Copier, deplacer, supprimer

Les opérations de base, avec les options que tu vas utiliser tous les jours :

bash# Copier
cp fichier.txt copie.txt              # Copie simple
cp -r dossier/ backup/                # Copie recursive (obligatoire pour les dossiers)
cp -i fichier.txt destination/        # Demande confirmation si ecrasement
cp -v *.json backup/                  # Verbose : affiche ce qui est copie

# Deplacer / Renommer
mv ancien.txt nouveau.txt             # Renommer
mv fichier.txt /tmp/                  # Deplacer
mv *.log /var/log/archive/            # Deplacer plusieurs fichiers

# Supprimer
rm fichier.txt                        # Supprimer un fichier
rm -r dossier/                        # Supprimer un dossier et son contenu
rm -i *.tmp                           # Demande confirmation pour chaque fichier
rm -f fichier.lock                    # Force (pas de confirmation, pas d'erreur si absent)

rm -rf : la commande qui fait trembler

rm -rf supprime recursivement et sans confirmation. C'est la commande la plus dangereuse de Linux. Il n'y a pas de corbeille, pas de Ctrl+Z, pas de "etes-vous sur ?".

bash# Dangereux mais courant
rm -rf node_modules/                  # Ok, c'est regenerable
rm -rf .git/                          # Tu viens de perdre tout ton historique git
rm -rf /                              # Tu viens de detruire ton systeme (les OS modernes bloquent ca)

# L'erreur classique avec une variable
rm -rf $DIRECTORY/                    # Si $DIRECTORY est vide, ca devient rm -rf /
# TOUJOURS verifier tes variables avant un rm -rf

J'ai un collegue qui a fait rm -rf /opt /myapp au lieu de rm -rf /opt/myapp. L'espace en trop a supprime tout /opt. En prod. Un vendredi. Ca s'invente pas.

Creer des fichiers et des dossiers

bash# Creer un dossier
mkdir projet                          # Un dossier
mkdir -p projet/src/components        # Cree toute l'arborescence d'un coup

# Creer un fichier vide (ou mettre a jour la date de modification)
touch index.js
touch src/{app,main,utils}.ts         # Cree trois fichiers d'un coup

find : la recherche puissante

find est un des outils les plus puissants de Linux. Il parcourt l'arborescence et trouve des fichiers selon des critères :

bash# Par nom
find . -name "*.js"                   # Tous les .js dans le repertoire courant
find / -name "nginx.conf"             # Chercher nginx.conf sur tout le systeme
find . -iname "readme*"               # Insensible a la casse

# Par type
find . -type f                        # Fichiers uniquement
find . -type d                        # Dossiers uniquement
find . -type l                        # Liens symboliques

# Par date de modification
find . -mtime -1                      # Modifie dans les dernieres 24h
find . -mtime +30                     # Pas modifie depuis 30 jours
find . -newer reference.txt           # Plus recent que reference.txt

# Par taille
find . -size +100M                    # Plus de 100 Mo
find . -size -1k                      # Moins de 1 Ko

# Combiner avec des actions
find . -name "*.log" -delete          # Supprimer tous les .log
find . -name "*.tmp" -exec rm {} \;   # Pareil avec exec
find . -type f -empty                 # Trouver les fichiers vides

# Exclure des dossiers (tres utile pour node_modules)
find . -name "*.ts" -not -path "*/node_modules/*"

Un exemple concret que j'utilise souvent : trouver tous les fichiers modifies aujourd'hui dans un projet, en excluant les dépendances :

bashfind . -type f -mtime 0 -not -path "*/node_modules/*" -not -path "*/.git/*"

Liens : hard links et symlinks

Les liens sont des raccourcis vers des fichiers. Il y a deux types :

bash# Lien symbolique (symlink) - le plus courant
ln -s /chemin/vers/original lien
# C'est un raccourci. Si l'original est supprime, le lien est casse.

# Lien hard
ln /chemin/vers/original lien_hard
# C'est une reference directe vers les donnees sur le disque.
# Si l'original est supprime, le lien hard fonctionne toujours.

# Exemple concret
$ ln -s /etc/nginx/sites-available/monsite.conf monsite.conf
$ ls -la monsite.conf
lrwxrwxrwx 1 nicolas nicolas 42 Mar 29 10:00 monsite.conf -> /etc/nginx/sites-available/monsite.conf

En pratique, tu utiliseras presque toujours des symlinks (ln -s). Les cas courants :

• node_modules/.bin/ est plein de symlinks vers les executables des packages
• /etc/nginx/sites-enabled/ contient des symlinks vers sites-available/
• Les alternatives système (/usr/bin/python -> /usr/bin/python3.11)

Outils complémentaires

bash# tree : visualiser l'arborescence
$ tree -L 2 --dirsfirst
.
|-- src
|   |-- components
|   |-- utils
|   |-- app.ts
|   `-- main.ts
|-- package.json
`-- tsconfig.json

# file : identifier le type d'un fichier
$ file image.png
image.png: PNG image data, 1920 x 1080, 8-bit/color RGBA

$ file script
script: Bash script, ASCII text executable

# stat : informations detaillees
$ stat package.json
  File: package.json
  Size: 1247       Blocks: 8    IO Block: 4096   regular file
  Inode: 1234567   Links: 1
  Access: (0644/-rw-r--r--)  Uid: (1000/nicolas) Gid: (1000/dev)
  Modify: 2026-03-29 09:15:00.000000000 +0100

Wildcards (globbing)

Les wildcards te permettent de sélectionner plusieurs fichiers avec un motif :

bash# * : n'importe quelle chaine
ls *.js                # Tous les fichiers .js
cp src/*.ts backup/    # Tous les .ts dans src/

# ? : un seul caractere
ls file?.txt           # file1.txt, fileA.txt, mais pas file10.txt

# [] : un caractere parmi un ensemble
ls file[123].txt       # file1.txt, file2.txt, file3.txt
ls file[a-z].txt       # filea.txt, fileb.txt, etc.

# {} : expansion (bash)
mkdir -p projet/{src,test,docs}        # Cree trois dossiers
cp config.{json,json.backup}           # Copie config.json en config.json.backup
touch {lundi,mardi,mercredi}.txt       # Cree trois fichiers

L'expansion avec {} n'est pas un wildcard a proprement parler, c'est une fonctionnalité du shell. Mais c'est tellement utile que je la mets ici. mkdir -p projet/{src,test,docs}/{main,utils} créé 6 dossiers en une seule commande.

Pour d'autres astuces sur la manipulation de fichiers dans un contexte de développement, paltemps.fr couvre des cas d'usage courants.

Résumé

• ls -lah est ton meilleur ami pour inspecter un répertoire
• rm -rf n'a pas de filet de sécurité : vérifié toujours deux fois
• find avec -name, -type, -mtime couvre 90% des recherches
• Les symlinks (ln -s) sont partout dans l'ecosysteme Linux
• Les wildcards *, ?, [] et l'expansion {} evitent la répétition

Precedent : Le terminal | Suivant : Permissions

Sources

• GNU Coreutils Manual
• find man page - Linux
• Linux Filesystem Hierarchy Standard