Accueil › Git & CI/CD › Les bases
Les bases — entretien Git & CI/CD
15 questions posées en entretien sur 10 sujets, avec la bonne réponse et son explication.
Les bases
À quoi sert l'index (staging area) ?
- À accélérer les commits en mettant les fichiers en cache
- À choisir précisément ce qui entre dans le prochain commit ✓
- À conserver une sauvegarde avant modification
- À synchroniser avec le dépôt distant
Pourquoi : L'index est une zone de composition : on peut avoir modifié dix fichiers et n'en valider que trois, voire une partie d'un fichier avec `git add -p`. C'est ce qui permet des commits qui racontent une seule chose.
Niveau junior
Qu'est-ce qu'un commit, techniquement ?
- La liste des lignes ajoutées et supprimées depuis le commit précédent
- Un instantané complet du projet, plus l'empreinte de son parent ✓
- Une étiquette posée sur une version
- Un journal des modifications
Pourquoi : Git enregistre des états complets ; les différences affichées par `git diff` sont calculées au moment de l'affichage. C'est ce qui rend le changement de branche instantané : on restaure un état, on ne rejoue pas une suite de modifications.
Niveau confirme
Les trois zones
Quelle commande ramène un fichier de l'index vers le simple état « modifié », sans toucher à son contenu ?
- `git restore <fichier>`
- `git restore --staged <fichier>` ✓
- `git checkout -- <fichier>`
- `git clean -f <fichier>`
Pourquoi : Les deux variantes de `restore` agissent sur deux zones différentes, et la confusion coûte du travail. `--staged` retire le fichier de l'index et laisse les modifications dans le répertoire de travail. Sans l'option, `restore` écrase le répertoire de travail avec le contenu de l'index : les modifications sont perdues, et `reflog` ne peut rien pour ce qui n'a jamais été commité.
Niveau junior
Vous avez corrigé un bug et renommé une variable dans le même fichier. Comment en faire deux commits ?
- Impossible : l'unité de commit est le fichier
- `git add -p <fichier>`, en retenant les fragments d'un seul changement, puis commiter, puis recommencer ✓
- `git stash` puis `git stash pop` entre les deux commits
- `git commit --amend` après chaque modification
Pourquoi : L'index travaille au fragment, pas au fichier : `git add -p` propose chaque bloc de différences et on répond au cas par cas. C'est la réponse concrète à « je n'ai pas eu le temps de faire des commits propres ». Le réflexe à garder ensuite : `git diff --staged` pour relire exactement ce qui va entrer, et lancer les tests sur l'état indexé, qui n'est pas l'état du disque.
Niveau confirme
Message de commit
Quelle forme donne-t-on à la ligne de sujet d'un commit ?
- Une phrase courte à l'impératif, sans point final ✓
- Un résumé au passé composé décrivant ce qui a été fait
- La liste des fichiers touchés
- Le numéro du ticket, seul
Pourquoi : L'impératif aligne le message sur ce que Git lui-même écrit : « Merge branch… », « Revert… ». La ligne se lit alors comme la description de ce que le commit *fait* au projet quand on l'applique, ce qui est exactement la bonne question au moment d'un `revert` ou d'un `cherry-pick`. Le numéro de ticket se met en plus, jamais à la place : un ticket meurt avec l'outil qui l'héberge.
Niveau junior
Annuler
Un commit fautif a déjà été poussé sur une branche partagée. Comment l'annuler ?
- `git reset --hard HEAD~1` puis `git push --force`
- `git revert <commit>` puis `git push` ✓
- `git restore .`
- `git stash`
Pourquoi : `revert` crée un nouveau commit qui annule le précédent : l'historique partagé n'est pas réécrit et personne n'a à intervenir. Un `reset --hard` suivi d'un `push --force` réécrit l'histoire sous les pieds de tous ceux qui l'ont déjà récupérée.
Niveau confirme
Après un `git reset --hard` malencontreux, que peut-on récupérer ?
- Rien, l'opération est définitive
- Tout ce qui avait été **commité** : `git reflog` retrouve l'empreinte, `git reset --hard <empreinte>` y revient ✓
- Tout, Git sauvegarde automatiquement
- Seulement si un dépôt distant existe
Pourquoi : La nuance est décisive : un commit abandonné reste dans le dépôt et `reflog` le retrouve, alors que des modifications jamais commitées écrasées par `--hard` ne sont nulle part. C'est pourquoi commiter souvent, même imparfaitement, protège.
Niveau confirme
Quelle différence entre `git reset --soft HEAD~1` et `git reset --hard HEAD~1` ?
- Aucune, seule la vitesse change
- `--soft` garde les modifications dans l'index, `--hard` les détruit ✓
- `--soft` ne fonctionne que sur le dernier commit
- `--hard` conserve une sauvegarde
Pourquoi : Les deux reculent la branche d'un commit. `--soft` laisse tout le contenu dans l'index, prêt à être recommité autrement — c'est la façon propre de refaire un commit. `--hard` aligne aussi le répertoire de travail et détruit ce qui n'était pas enregistré.
Niveau senior
Commit atomique
Pourquoi `git bisect` impose-t-il que chaque commit laisse le projet fonctionnel ?
- Parce qu'il recompile le projet depuis le premier commit
- Parce qu'il place le projet sur un commit arbitraire et attend la réponse « bon » ou « mauvais » ✓
- Parce qu'il ignore les commits de fusion
- Parce qu'il a besoin de messages normalisés pour choisir le point milieu
Pourquoi : La dichotomie suppose un verdict à chaque étape. Un commit qui ne compile pas ne se répond ni « bon » ni « mauvais », et il faut le sauter à la main — sur une série de commits intermédiaires cassés, la recherche perd tout intérêt. C'est l'argument le plus concret en faveur des commits atomiques : sur mille commits, dix essais suffisent, mais seulement si chacun tient debout.
Niveau confirme
Fouiller l'historique
Comment retrouver le commit qui a introduit la constante `MAX_PANIER` dans le code ?
- `git log --grep=MAX_PANIER`
- `git log -S"MAX_PANIER"` ✓
- `git blame MAX_PANIER`
- `git log --author=MAX_PANIER`
Pourquoi : `-S` cherche dans le **contenu** des différences : il ne retient que les commits où le nombre d'occurrences de la chaîne change, donc celui qui l'a ajoutée et celui qui l'a retirée. `--grep` cherche dans les messages, ce qui ne sert qu'à condition que l'auteur ait pensé à y écrire le nom. `blame` répond à une autre question : qui a touché cette ligne en dernier, dans son état actuel.
Niveau confirme
`.gitignore`
Un fichier `config/local.env` est suivi depuis trois commits. Vous l'ajoutez à `.gitignore`. Que se passe-t-il ?
- Il disparaît des prochains commits
- Rien : `.gitignore` n'agit que sur les fichiers non suivis ✓
- Git refuse la ligne et affiche un avertissement
- Il est supprimé du disque au prochain `git add`
Pourquoi : C'est la méprise la plus courante : `.gitignore` décide de ce que Git **propose d'ajouter**, pas de ce qu'il continue de suivre. Il faut `git rm --cached config/local.env`, puis commiter ce retrait. Et le contenu reste visible dans les commits antérieurs : si c'était un secret, le retrait ne le protège pas.
Niveau confirme
Quelle différence entre les motifs `dist` et `/dist` dans un `.gitignore` ?
- `dist` attrape ce nom à n'importe quelle profondeur, `/dist` seulement à la racine du dépôt ✓
- `/dist` attrape le dossier, `dist` seulement un fichier de ce nom
- Aucune : le `/` initial est décoratif
- `/dist` est un chemin absolu sur le disque
Pourquoi : Un motif sans `/` au milieu s'applique à tous les niveaux : `dist` ignorerait aussi `packages/ui/dist`, ce qui est souvent voulu. Le `/` initial ancre le motif à la racine du dépôt. Et le `/` **final** dit « dossier seulement » : `coverage/` laisse passer un fichier nommé `coverage`. Trois `/` au même caractère, trois sens différents — d'où `git check-ignore -v <chemin>`, qui désigne la ligne responsable.
Niveau confirme
Identité
Qu'est-ce que la forge vérifie réellement quand vous poussez un commit signé « Camille Roux » ?
- Que l'adresse de l'auteur correspond à un compte existant
- Votre accès au dépôt — la clé ou le jeton — mais pas le nom écrit dans le commit ✓
- La correspondance entre l'auteur du commit et l'utilisateur authentifié
- Rien : la forge fait confiance au client Git sur tout
Pourquoi : `user.name` et `user.email` sont deux chaînes libres écrites par votre client : une **déclaration**, pas une preuve. La forge sait qui a poussé, elle croit sur parole qui a écrit, et se contente de chercher un compte portant cette adresse pour afficher un avatar. Quand l'attribution doit être prouvée, on signe les commits avec une clé GPG ou SSH — c'est la seule chose qui produit la mention « vérifié ».
Niveau senior
Secrets
Une clé d'API valide a été poussée hier sur le dépôt partagé. Quelle est la première action ?
- Réécrire l'historique pour effacer le commit
- Révoquer la clé et en émettre une nouvelle ✓
- Ajouter le fichier à `.gitignore`
- Passer le dépôt en privé
Pourquoi : Entre la poussée et la découverte, le commit a été cloné, mis en cache par la forge, indexé par ses robots et peut-être relayé par une notification. Rien de cela ne se rattrape. Seule la révocation ferme la porte, et elle prend deux minutes. Le nettoyage de l'historique, qui change toutes les empreintes et casse les clones existants, est une question distincte qu'on traite ensuite si elle reste utile.
Niveau senior
Conventional Commits
Qu'apporte la convention `feat:` / `fix:` / `chore:` qu'un message libre bien écrit n'apporte pas ?
- Un historique lisible par une machine : journal des versions et numéro de version déduits automatiquement ✓
- Des messages plus explicites pour les relecteurs
- Un classement des commits par branche dans `git log`
- Le refus automatique des commits non atomiques
Pourquoi : Un humain lit très bien « Corriger le calcul de TVA » ; un outil, non. Le préfixe rend le type exploitable : un `fix:` incrémente le correctif, un `feat:` la version mineure, un `!` ou un `BREAKING CHANGE:` la majeure. La limite à savoir énoncer : la convention normalise la **forme** du sujet et ne dit rien du corps, donc elle n'empêche ni un commit fourre- tout ni un message qui omet le pourquoi.
Niveau senior