Formations — 1 037 leçons en français

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) ?

  1. À accélérer les commits en mettant les fichiers en cache
  2. À choisir précisément ce qui entre dans le prochain commit ✓
  3. À conserver une sauvegarde avant modification
  4. À 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 ?

  1. La liste des lignes ajoutées et supprimées depuis le commit précédent
  2. Un instantané complet du projet, plus l'empreinte de son parent ✓
  3. Une étiquette posée sur une version
  4. 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 ?

  1. `git restore <fichier>`
  2. `git restore --staged <fichier>` ✓
  3. `git checkout -- <fichier>`
  4. `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 ?

  1. Impossible : l'unité de commit est le fichier
  2. `git add -p <fichier>`, en retenant les fragments d'un seul changement, puis commiter, puis recommencer ✓
  3. `git stash` puis `git stash pop` entre les deux commits
  4. `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 ?

  1. Une phrase courte à l'impératif, sans point final ✓
  2. Un résumé au passé composé décrivant ce qui a été fait
  3. La liste des fichiers touchés
  4. 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 ?

  1. `git reset --hard HEAD~1` puis `git push --force`
  2. `git revert <commit>` puis `git push` ✓
  3. `git restore .`
  4. `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 ?

  1. Rien, l'opération est définitive
  2. Tout ce qui avait été **commité** : `git reflog` retrouve l'empreinte, `git reset --hard <empreinte>` y revient ✓
  3. Tout, Git sauvegarde automatiquement
  4. 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` ?

  1. Aucune, seule la vitesse change
  2. `--soft` garde les modifications dans l'index, `--hard` les détruit ✓
  3. `--soft` ne fonctionne que sur le dernier commit
  4. `--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 ?

  1. Parce qu'il recompile le projet depuis le premier commit
  2. Parce qu'il place le projet sur un commit arbitraire et attend la réponse « bon » ou « mauvais » ✓
  3. Parce qu'il ignore les commits de fusion
  4. 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 ?

  1. `git log --grep=MAX_PANIER`
  2. `git log -S"MAX_PANIER"` ✓
  3. `git blame MAX_PANIER`
  4. `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 ?

  1. Il disparaît des prochains commits
  2. Rien : `.gitignore` n'agit que sur les fichiers non suivis ✓
  3. Git refuse la ligne et affiche un avertissement
  4. 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` ?

  1. `dist` attrape ce nom à n'importe quelle profondeur, `/dist` seulement à la racine du dépôt ✓
  2. `/dist` attrape le dossier, `dist` seulement un fichier de ce nom
  3. Aucune : le `/` initial est décoratif
  4. `/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 » ?

  1. Que l'adresse de l'auteur correspond à un compte existant
  2. Votre accès au dépôt — la clé ou le jeton — mais pas le nom écrit dans le commit ✓
  3. La correspondance entre l'auteur du commit et l'utilisateur authentifié
  4. 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 ?

  1. Réécrire l'historique pour effacer le commit
  2. Révoquer la clé et en émettre une nouvelle ✓
  3. Ajouter le fichier à `.gitignore`
  4. 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 ?

  1. Un historique lisible par une machine : journal des versions et numéro de version déduits automatiquement ✓
  2. Des messages plus explicites pour les relecteurs
  3. Un classement des commits par branche dans `git log`
  4. 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

S'entraîner sur ces questions, chronométré →