Aller au contenu principal
Télécharger
Carrière

Git en entretien : 12 questions et leurs réponses

Les questions Git posées aux devs juniors en entretien, avec pour chacune une réponse courte, le piège à éviter et un exercice pour t'entraîner.

Par Anaïs Sparesotto (nouvelle fenêtre)Publié le 11 min de lecture

Voici 12 questions Git courantes en entretien pour un poste de dev junior, chacune avec une réponse modèle courte et le piège qui se cache derrière. Pour chaque notion, tu trouveras aussi un moyen concret de t'entraîner avant le jour J.

Ne les apprends pas par cœur : lis la réponse, puis réexplique-la à voix haute avec tes mots, idéalement avec un exemple tiré d'un de tes projets. Si un terme te bloque, le glossaire Git le définit en une ligne.

Fiche récapitulative : les commandes Git à savoir expliquer en entretien, classées par thème.
Une ligne par commande, classée par thème : à imprimer ou à garder sur ton téléphone.

Les notions de base

1. Quelle différence entre Git et GitHub ?

Git est un logiciel de gestion de versions : il tourne sur ta machine et enregistre l'historique de ton projet, même sans internet. GitHub est un service en ligne qui héberge des dépôts Git et ajoute des outils d'équipe : pull requests, issues, revue de code, intégration continue. GitLab et Bitbucket jouent le même rôle.

Le piège : répondre « GitHub, c'est Git en ligne ». Ce n'est pas faux, mais ça mélange l'outil et la plateforme : montre que tu sais lequel fait quoi.

Pour t'entraîner : crée un dépôt avec git init et fais deux commits sans jamais ouvrir GitHub. La comparaison complète est dans Git vs GitHub.

2. Qu'est-ce qu'un commit ?

Un commit est un instantané de ton projet à un moment donné, enregistré dans ton dépôt local. Il contient l'état des fichiers suivis, un message, une date, le nom de la personne qui l'a créé et un lien vers le commit précédent, son parent. Chaque commit est identifié par une empreinte unique, le hash, que tu verras souvent en version courte, comme 5f06859.

Le piège : dire qu'un commit envoie ton code sur GitHub. Il reste sur ta machine jusqu'au git push. Autre approximation à éviter : « un commit stocke les différences ». Git enregistre un instantané complet, et les fichiers inchangés ne sont simplement pas dupliqués.

Pour t'entraîner : l'enquête GitQuest « Mon premier dépôt » te fait créer tes premiers commits avec les cinq commandes de base.

3. À quoi sert la zone de staging ?

La zone de staging, aussi appelée index, est une étape entre tes fichiers et ton dépôt : git add y place ce qui entrera dans le prochain commit, et git commit n'enregistre que ce qu'elle contient. Elle te permet de découper ton travail en commits cohérents. On la voit bien quand un fichier change encore après le git add :

Terminal
git add index.html# tu modifies encore index.html, et style.cssgit statusOn branch mainChanges to be committed:  (use "git restore --staged <file>..." to unstage)        modified:   index.html Changes not staged for commit:  (use "git add <file>..." to update what will be committed)  (use "git restore <file>..." to discard changes in working directory)        modified:   index.html        modified:   style.css

index.html apparaît deux fois : seule la version ajoutée partira dans le commit.

Le piège : croire que git commit -a dispense de git add. Il prend les fichiers déjà suivis qui ont été modifiés, mais ignore les nouveaux fichiers : ceux-là demandent toujours un git add.

Pour t'entraîner : l'enquête « Le déstageur » te fait retirer un seul fichier de l'index avec git restore --staged, sans toucher au reste.

Branches et fusion

4. Qu'est-ce que HEAD ?

HEAD indique où tu te trouves dans l'historique. La plupart du temps, HEAD pointe sur une branche, qui pointe elle-même sur son dernier commit : quand tu commites, la branche avance et HEAD la suit.

Terminal
cat .git/HEADref: refs/heads/maingit log --oneline --decorate5f06859 (HEAD -> main) Ajoute le message de bienvenuea525a26 Ajoute la page d'accueil

HEAD~1 désigne le parent du commit actuel.

Le piège : confondre HEAD avec main, ou avec « le dernier commit du dépôt ». Si tu te places directement sur un commit (git switch --detach a525a26), HEAD ne pointe plus sur aucune branche : c'est la HEAD détachée, et les commits faits à cet endroit risquent d'être perdus de vue.

Pour t'entraîner : l'enquête « Le commit détaché » te fait rattacher à une branche trois commits faits en HEAD détachée.

5. Quelle différence entre merge et rebase ?

Les deux intègrent le travail d'une branche dans une autre. git merge garde l'historique tel qu'il s'est passé et ajoute un commit de fusion quand les deux branches ont divergé. git rebase main rejoue tes commits un par un au bout de main : l'historique devient linéaire, mais ces commits sont recréés avec de nouveaux hashes. Dans notre dépôt de test, git rebase main a transformé les commits 79a44b0 et 5a2baa5 de la branche menu en 6b40e7d et 7b4aed2.

Le piège : dire que l'un est « meilleur » que l'autre. Montre plutôt que tu connais la règle d'or : on ne rebase pas des commits déjà poussés sur une branche partagée, car tes collègues travaillent sur les anciens hashes.

Pour t'entraîner : l'enquête « Le cauchemar du rebase » te fait résoudre des conflits en plein rebase. Les deux approches sont comparées dans le guide du workflow de branches Git.

Annuler

6. Quelle différence entre git reset et git revert ?

git revert <commit> crée un nouveau commit qui fait l'inverse du commit visé : l'historique est conservé, c'est donc la bonne option pour un commit déjà poussé. git reset déplace ta branche vers un commit précédent, comme si les commits suivants n'avaient jamais existé : c'est une réécriture de l'historique, à réserver à ce qui n'est pas encore partagé.

Terminal
git revert HEAD --no-edit# (sortie raccourcie)[main a05db42] Revert "Ajoute la bannière promo" 1 file changed, 1 deletion(-)

Le piège : oublier les trois modes de git reset. --soft garde tes modifications dans l'index, --mixed (le mode par défaut) les garde dans tes fichiers, et --hard les efface, y compris le travail non commité, que Git ne pourra pas te rendre.

Pour t'entraîner : joue l'enquête « Le bouton annuler », puis compare toutes les méthodes dans le guide pour annuler des modifications avec Git.

7. Comment récupérer un commit supprimé par erreur ?

Avec git reflog. Git note dans ce journal chaque déplacement de HEAD sur ta machine : commit, reset, changement de branche, rebase. Un commit « supprimé » par un git reset --hard n'est plus sur aucune branche, mais il existe encore, et le reflog donne son hash :

Terminal
git reset --hard HEAD~1HEAD is now at a05db42 Revert "Ajoute la bannière promo"git reflog# (sortie raccourcie)a05db42 HEAD@{0}: reset: moving to HEAD~1cbba034 HEAD@{1}: commit: Ajoute le formulaire de contactgit branch recuperation cbba034

La branche recuperation pointe sur le commit retrouvé ; git reset --hard cbba034 y ramènerait directement ta branche.

Le piège : promettre que le reflog sauve tout. Il ne connaît que des commits : des modifications jamais commitées puis effacées par --hard sont perdues. Il est aussi local, et ses entrées expirent (par défaut, 30 jours pour un commit qui n'est plus sur aucune branche).

Pour t'entraîner : l'enquête « Le reset catastrophique » reprend ce scénario : retrouver le commit, puis ramener la branche dessus.

Travail en équipe

8. Quelle différence entre git fetch et git pull ?

git fetch télécharge les nouveaux commits du dépôt distant et met à jour les branches de suivi comme origin/main, sans toucher à ta branche ni à tes fichiers. git pull fait un git fetch, puis intègre ces commits dans ta branche par un merge (ou un rebase, si c'est configuré ainsi). Après un git fetch, tu peux regarder avant d'intégrer :

Terminal
git statusOn branch mainYour branch is behind 'origin/main' by 1 commit, and can be fast-forwarded.  (use "git pull" to update your local branch) nothing to commit, working tree cleangit log --oneline main..origin/main6c47460 Ajoute le README

Le piège : dire que git fetch « ne fait rien ». Il ne modifie pas ta branche, mais il met à jour origin/main : c'est ce qui te permet de comparer avant de fusionner.

Pour t'entraîner : l'enquête « Le rejet du push » part d'un push refusé et te fait récupérer le travail distant avant de renvoyer le tien. Toutes les commandes distantes sont dans Git remote et collaboration.

9. Quelle stratégie de branches utiliser en équipe ?

Il n'y a pas de réponse unique, mais une réponse solide décrit une organisation simple : main reste stable, chaque fonctionnalité ou correctif se fait sur une branche courte (git switch -c ajout-panier), puis revient dans main par une pull request relue par quelqu'un d'autre. D'autres modèles existent, comme Git Flow et ses branches de release, ou le trunk-based development, où l'on fusionne dans main plusieurs fois par jour.

Le piège : réciter Git Flow sans dire pourquoi. Explique ce qu'une stratégie doit garantir (une branche principale qui fonctionne, des changements relus, des branches courtes), puis demande comment l'équipe travaille.

Pour t'entraîner : sur un projet perso, interdis-toi de commiter sur main pendant une semaine : une branche et une pull request par changement, même seul·e.

10. Qu'est-ce qu'un bon message de commit ?

Une première ligne courte, une cinquantaine de caractères, qui dit ce que fait le commit : « Corrige le calcul des frais de port ». Si besoin, une ligne vide puis un corps qui explique pourquoi. Certaines équipes ajoutent un préfixe de type, comme feat: ou fix: (la convention Conventional Commits).

Le piège : traiter le message comme un détail. « fix » ou « wip » ne diront rien dans six mois, ni à toi, ni à la personne qui cherchera l'origine d'un bug avec git log ou git blame.

Pour t'entraîner : relis tes dix derniers messages avec git log --oneline -10, puis joue l'enquête « L'historique chaotique ».

Questions de mise en situation

11. Ton merge s'arrête sur un conflit : que fais-tu ?

Commence par git status, qui liste les fichiers en conflit sous both modified. Dans chaque fichier, Git encadre les deux versions par des marqueurs :

Terminal
cat index.html<<<<<<< HEAD<h1>Accueil du site</h1>=======<h1>Bienvenue chez nous</h1>>>>>>>> titre<p>Bienvenue</p>

Le haut est ta branche actuelle (HEAD), le bas la branche fusionnée, ici titre. Écris la bonne version, parfois un mélange des deux, supprime les marqueurs, puis termine avec git add index.html et git commit. Pour revenir à l'état d'avant, tape git merge --abort.

Le piège : choisir une version au hasard pour aller vite, ou laisser des marqueurs dans le code. Précise que tu testes le résultat avant de commiter, et que tu demandes à l'auteur ou l'autrice de l'autre version en cas de doute.

Pour t'entraîner : l'enquête « Le conflit de merge » te fait composer une version qui n'est ni l'une ni l'autre.

12. Tu as poussé un mot de passe ou une clé d'API : que fais-tu ?

D'abord, considère le secret comme compromis : révoque-le ou change-le tout de suite (nouvelle clé, nouveau mot de passe), avant même de toucher à Git, car toute personne qui a eu accès au dépôt a pu le copier. Ensuite, retire-le du suivi et empêche qu'il revienne :

Terminal
git rm --cached .envrm '.env'echo ".env" >> .gitignoregit add .gitignoregit commit -m "Retire .env du suivi"[main 5682f70] Retire .env du suivi 2 files changed, 1 insertion(+), 1 deletion(-) delete mode 100644 .env create mode 100644 .gitignoregit show HEAD~1:.envAPI_KEY=abc

La dernière commande le montre : le secret reste lisible dans l'historique. Pour l'en effacer, il faut réécrire l'historique avec un outil à installer à part, comme git filter-repo (git filter-repo --invert-paths --path .env retire le fichier de tous les commits) ou BFG Repo-Cleaner, forcer le push, puis demander à l'équipe de repartir d'un clone propre.

Le piège : répondre « je supprime le fichier et je refais un commit », ou commencer par réécrire l'historique. La réécriture vient en second : des clones, des forks ou des caches peuvent avoir gardé le secret, et seule la révocation le rend inutilisable.

Pour t'entraîner : l'enquête « Le fichier secret » te fait mettre en place un .gitignore pour toute l'équipe, pour que ça n'arrive pas.

Questions fréquentes

Comment se préparer à des questions Git en entretien ?

Pratique dans un vrai terminal plutôt que de relire des définitions : crée un dépôt de test, provoque un conflit, fais un git reset --hard puis retrouve le commit avec git reflog. L'aide-mémoire Git te sert de liste de révision.

Faut-il connaître toutes les commandes Git par cœur ?

Non. Ce qui compte, c'est de comprendre ce que fait chaque commande et quand elle est risquée. Les options, elles, se retrouvent en quelques secondes avec git help <commande> ou dans la documentation officielle.

Que répondre si je ne connais pas la réponse ?

Dis-le simplement, puis raisonne à voix haute : ce que tu sais de la notion, ce que tu essaierais, et comment tu vérifierais sans risque, par exemple dans un dépôt de test. Une réponse honnête et méthodique vaut mieux qu'une définition approximative.

Quel niveau de Git viser pour un premier poste ?

Sache cloner un dépôt, créer une branche, commiter, pousser, ouvrir une pull request, récupérer le travail des autres et résoudre un conflit simple. Sache aussi annuler un commit sans casser l'historique de l'équipe. Le rebase interactif, git bisect ou les hooks peuvent venir ensuite.

Passe de la lecture à la pratique

Tape ces commandes pour de vrai dans le terminal simulé de GitQuest Academy : gratuit, sans rien installer, avec un certificat à la fin.

A

GitQuest est conçu par Anaïs (nouvelle fenêtre), développeuse web et responsable pédagogique, spécialisée en formations tech et accessibilité numérique.