Formations — 1 037 leçons en français

Accueil › Git & CI/CD › Travailler à plusieurs

Travailler à plusieurs — entretien Git & CI/CD

11 questions posées en entretien sur 4 sujets, avec la bonne réponse et son explication.

Dépôts distants

Quelle est la différence entre `git fetch` et `git pull` ?

  1. Aucune, `pull` est un alias
  2. `fetch` récupère sans toucher à votre travail ; `pull` enchaîne un `fetch` puis une fusion dans votre branche ✓
  3. `fetch` ne récupère que la branche courante
  4. `pull` ne fonctionne que sur `main`

Pourquoi : `fetch` met à jour les branches de suivi et ne risque rien : on peut ensuite inspecter avec `git log main..origin/main`. `pull` ajoute une fusion automatique, qui peut créer un commit ou un conflit au moment où l'on s'y attend le moins.

Niveau junior

Que représente exactement `origin/main` ?

  1. La branche `main` telle qu'elle est actuellement sur le serveur
  2. L'état de `main` sur le serveur au moment de votre dernier `fetch` ✓
  3. Votre branche `main` locale
  4. La branche principale de votre fork

Pourquoi : C'est un instantané local, pas une vue en direct : Git ne contacte jamais le serveur de lui-même. Tant qu'on n'a pas fait `fetch` ou `pull`, `origin/main` reste figé — d'où des messages « à jour » qui ne reflètent plus la réalité.

Niveau confirme

Dans une contribution par fork — on tire de `upstream`, on pousse sur `origin` — pourquoi `git status` peut-il être trompeur ?

  1. Il ne commente que la branche amont, jamais celle vers laquelle le push partirait ✓
  2. Il ignore les distants ajoutés après le clone
  3. Il compare au dernier commit local plutôt qu'au distant
  4. Il ne fonctionne pas avec plusieurs distants configurés

Pourquoi : `git status` parle de `@{u}`, l'amont, c'est-à-dire ici du projet d'origine. La branche de destination d'un push est `@{push}`, qui pointe sur le fork et dont il ne dit rien. D'où les pull requests en retard d'un commit qu'on est pourtant sûr d'avoir poussé : `git log @{u}..@{push}` lève le doute.

Niveau confirme

Collaboration

Git connaît-il la notion de pull request ?

  1. Oui, c'est la commande `git pull-request`
  2. Non : c'est une fonctionnalité des forges comme GitHub ou GitLab, construite au-dessus des branches ✓
  3. Oui, depuis Git 2.30
  4. Oui, mais uniquement en HTTPS

Pourquoi : Git ne gère que des dépôts, des branches et des commits. La relecture, la discussion, les contrôles automatiques et le bouton de fusion sont ajoutés par la forge. La question revient en entretien et distingue ceux qui ont compris la séparation.

Niveau junior

Quel est le principal inconvénient du « squash and merge » ?

  1. Il crée des conflits supplémentaires
  2. Le détail des commits intermédiaires est perdu : `bisect` et `blame` deviennent moins précis ✓
  3. Il empêche de supprimer la branche
  4. Il est incompatible avec les branches protégées

Pourquoi : L'historique devient très lisible — une ligne par fonctionnalité — mais un commit qui condense 600 lignes fait désigner par `bisect` la fonctionnalité fautive, pas le changement fautif. Le compromis est excellent sur des branches courtes.

Niveau senior

Sauvetage

Un correctif développé sur `main` doit être appliqué à la version 1.3 déjà livrée. Que faire ?

  1. Fusionner `main` dans la branche 1.3
  2. `git cherry-pick <commit>` sur la branche 1.3 ✓
  3. Refaire le correctif à la main
  4. Rebaser `main` sur la branche 1.3

Pourquoi : Fusionner `main` apporterait tout ce qui y a été fait depuis, y compris ce qui n'a pas été validé pour cette version. `cherry-pick` rejoue exactement ce commit : c'est le cas d'usage pour lequel la commande existe.

Niveau confirme

Un mot de passe a été commité il y a trois mois. Quelle est la première action ?

  1. Réécrire l'historique avec `filter-repo`
  2. Révoquer le mot de passe et en générer un nouveau ✓
  3. Supprimer la branche concernée
  4. Passer le dépôt en privé

Pourquoi : Trois mois d'historique ont été clonés, sauvegardés, peut-être forkés. Réécrire ne reprend pas ce qui a été lu, casse tous les clones existants et prend une demi-journée. La révocation ferme la porte ; le nettoyage vient après, s'il reste utile.

Niveau senior

À quoi sert `git worktree` ?

  1. À sauvegarder le dépôt
  2. À disposer d'un second répertoire de travail sur une autre branche, sans remiser le travail en cours ✓
  3. À comparer deux branches
  4. À cloner plus vite

Pourquoi : En pleine refonte, une urgence arrive. Plutôt que de remiser, changer de branche, corriger, revenir et dépiler, on ouvre un second répertoire relié au même dépôt : les deux coexistent et le travail en cours n'est pas touché.

Niveau senior

Forçage

`git push --force-with-lease` passe alors qu'un collègue venait de pousser. Qu'est-ce qui a neutralisé la protection ?

  1. Un `fetch` intermédiaire a aligné la référence de suivi sur l'état du serveur ✓
  2. Le bail ne s'applique pas aux branches non protégées
  3. Le collègue avait poussé sans `-u`
  4. Le bail ne couvre que les commits de fusion

Pourquoi : Le bail ne compare pas votre branche au serveur : il compare le serveur à **votre référence de suivi**. Tout `fetch` rafraîchit celle-ci, y compris celui qu'un éditeur lance en tâche de fond. Le bail constate alors que le distant est bien là où vous le croyez, et il a raison — c'est votre croyance qui a bougé seule. `--force-if-includes` exige en plus que ces commits soient intégrés.

Niveau confirme

À quoi sert `git range-diff` avant une poussée forcée ?

  1. Il apparie les commits avant et après le rebase et montre ce qui a changé en plus du déplacement ✓
  2. Il liste les commits que le forçage ferait disparaître du serveur
  3. Il vérifie que la référence de suivi est à jour
  4. Il compare le contenu de deux branches fichier par fichier

Pourquoi : Un `git diff` après rebase mélange vos changements et ceux des collègues récupérés entre-temps. `range-diff` compare deux *séries* de commits deux à deux : une résolution de conflit ratée pendant le rebase y saute aux yeux. C'est la relecture de son propre rebase, et c'est le bon moment pour la faire — avant de l'imposer au serveur.

Niveau confirme

Un collègue vient de voir ses deux commits disparaître du serveur après un forçage. Quelle est la première action utile ?

  1. Poser une branche sur l'empreinte d'avant, lue dans son propre `reflog`, avant toute autre manipulation ✓
  2. Demander à l'hébergeur de restaurer le dépôt
  3. Repousser immédiatement son état local pour reprendre la main
  4. Lancer `git fsck` sur le serveur pour retrouver les objets orphelins

Pourquoi : Rien n'a été détruit : un forçage déplace une référence, les objets sont encore dans son dépôt local. Son `reflog` montre la ligne `forced-update` et l'empreinte précédente — `git branch sauvegarde <empreinte>` range le travail en une commande. Repousser dans la précipitation est la mauvaise réponse : c'est le geste qui fabrique un second incident par-dessus le premier.

Niveau senior

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