Apprendre Git : plan d'apprentissage, exercices interactifs, documentation et pratique

Git s'apprend en pratiquant, pas en lisant. Pour travailler sereinement en équipe, il suffit de maîtriser une vingtaine de commandes et de comprendre trois idées : un commit est un instantané du projet, une branche est un pointeur vers un commit, et un dépôt distant n'est qu'une copie de plus de l'historique. Voici un plan pour apprendre Git par étapes, avec des exercices, des ressources gratuites et des critères qui indiquent qu'une étape est acquise.

Ce plan s'adresse à un débutant qui sait déjà utiliser un terminal, au moins au niveau de cd et ls. Si ce n'est pas le cas, consacrez une soirée aux bases de la ligne de commande : sans elles, apprendre Git est nettement plus difficile.

Pourquoi apprendre Git de manière structurée

Beaucoup vivent des années avec cinq commandes copiées d'un tutoriel et paniquent au premier conflit ou au premier « detached HEAD ». La cause est presque toujours la même : l'absence de modèle mental — on ne comprend pas ce que la commande change exactement dans l'historique et dans les fichiers.

Un apprentissage structuré de Git est vite rentabilisé. Vous n'avez plus peur d'expérimenter, puisque vous savez revenir en arrière ; vous résolvez les conflits calmement ; vous tenez un historique propre, visible par les relecteurs et les recruteurs. Git est évalué en entretien dans presque tous les métiers de l'informatique, du front-end au DevOps en passant par l'analyse de données.

Étape 1. Les bases : dépôt, index, commit

L'objectif de la première étape est de comprendre le cycle de base et les trois zones de Git : le répertoire de travail, l'index et le dépôt. Comptez 2 à 4 jours à raison d'une heure par jour.

• Installation et configuration initiale : git config --global user.name, user.email, branche par défaut main.
• Création d'un dépôt : git init.
• Le cycle git status → git add → git commit ; ajout sélectif avec git add -p.
• Consulter l'historique : git log --oneline, git diff, git diff --staged, git show.
• Le fichier .gitignore : ce qui ne doit pas entrer dans le dépôt.

Exercice. Créez un dépôt pour vos notes ou un petit script. Faites 15 à 20 commits, chacun correspondant à une modification logique avec un message clair. Après chaque commande, lancez git status et expliquez-vous ce qui a changé.

L'étape est acquise si vous savez dire sans aide en quoi la sortie de git diff diffère de celle de git diff --staged, et commiter seulement une partie des fichiers modifiés.

Étape 2. Branches et fusion

Les branches sont le cœur de Git et la principale source d'angoisse des débutants. L'important n'est pas de mémoriser des commandes, mais d'apprendre à se représenter le graphe des commits. Prévoyez environ une semaine.

• Créer et changer de branche : git branch, git switch, git switch -c.
• Ce qu'est HEAD et l'état detached HEAD.
• Fusion : git merge, fast-forward et commit de merge, option --no-ff.
• Conflits : marqueurs <<<<<<< et >>>>>>>, git merge --abort.
• Visualisation : git log --oneline --graph --all.

Exercice. Créez deux branches à partir de main et modifiez dans chacune la même ligne du même fichier. Fusionnez-les l'une après l'autre, provoquez un conflit et résolvez-le. Recommencez jusqu'à ce que ce soit devenu ennuyeux.

À ce stade, rien ne vaut un outil interactif pour s'entraîner à Git — voir plus bas. Il affiche le graphe après chaque commande et forge rapidement l'intuition.

Étape 3. Dépôts distants et travail en équipe

Le but : apprendre à travailler avec un serveur comme on le fait en équipe. Il vous faut un compte sur GitHub, GitLab ou n'importe quel autre hébergeur Git. Durée : environ une semaine.

• Connexion et clonage : git remote add, git clone, authentification par clé SSH.
• Synchronisation : git push, git push -u, git fetch, git pull et leurs différences.
• Les branches de suivi distantes comme origin/main.
• Forks, branches de fonctionnalité et pull requests avec revue de code.
• Workflows d'équipe : GitHub Flow, Git Flow, trunk-based development.

Exercice. Travaillez sur un même dépôt depuis deux « ordinateurs » : clonez-le dans deux dossiers différents. Commitez dans l'un, poussez, récupérez dans l'autre. Provoquez une situation où le push est refusé parce que le serveur a avancé, et comprenez pourquoi.

git clone git@github.com:you/sandbox.git copy-a
git clone git@github.com:you/sandbox.git copy-b
cd copy-a && echo "depuis A" >> notes.txt && git commit -am "Modif depuis A" && git push
cd ../copy-b && echo "depuis B" >> notes.txt && git commit -am "Modif depuis B"
git push          # rejected : le serveur a avancé
git pull          # on récupère la modif de A, on résout le conflit dans notes.txt
git push

Ce court scénario reproduit la situation la plus fréquente en équipe. Analysez la sortie de chaque commande : pourquoi le push est refusé, ce qui apparaît dans origin/main après le fetch, d'où vient le commit de merge. Recommencez ensuite avec git pull --rebase et comparez les graphes avec git log --oneline --graph --all.

Mieux encore : trouvez un binôme et réalisez ensemble un petit projet via des pull requests. Vous ressentirez concrètement la revue de code, les conflits et les conventions de branches.

Étape 4. Annuler ses erreurs

Cette étape transforme Git, source d'inquiétude, en filet de sécurité. 3 à 5 jours.

• git restore et git restore --staged — annuler dans les fichiers et dans l'index.
• git commit --amend — corriger le dernier commit.
• git reset en modes --soft, --mixed, --hard.
• git revert — annuler sans risque un commit déjà publié.
• git reflog — récupérer des commits « perdus ».

Exercice. Faites quelques commits, lancez git reset --hard HEAD~3 et récupérez-les grâce au reflog. Annulez un commit sur une branche « partagée » avec revert et observez le résultat dans l'historique.

Étape 5. Les outils avancés

On les apprend au fil des besoins, mais il vaut mieux savoir qu'ils existent.

Outils interactifs pour s'entraîner à Git

Un outil d'entraînement a l'avantage d'offrir un bac à sable sans risque et de montrer le résultat immédiatement. Quelques options gratuites :

• Learn Git Branching (learngitbranching.js.org) — le meilleur exercice interactif sur les branches. Des niveaux avec des défis, un graphe de commits animé, et une interface en français. Il couvre commit, branch, merge, rebase, cherry-pick, le rebase interactif et le travail avec les dépôts distants.
• Oh My Git! — un jeu gratuit et open source où les commandes Git prennent la forme de cartes, avec un vrai Git sous le capot.
• Votre propre dépôt bac à sable — l'outil d'entraînement le plus sous-estimé. Créez un dossier git-sandbox et cassez-y tout ce que vous voulez : vous n'avez rien à perdre.

Ces outils développent très bien la compréhension du graphe, mais ne remplacent pas un vrai projet : il n'y a ni vrais fichiers, ni éditeur, ni conflits dans du code, ni IDE. Utilisez-les en complément.

Documentation Git et livres de référence

La documentation officielle de Git se trouve sur git-scm.com. Le livre Pro Git de Scott Chacon et Ben Straub y est disponible gratuitement, y compris en traduction française. C'est le meilleur manuel sur Git : les trois premiers chapitres (bases, branches) sont indispensables, le chapitre « Les tripes de Git » s'adresse à ceux qui veulent comprendre le modèle de données jusqu'au bout.

L'aide intégrée est toujours à portée de main : git help <commande> ouvre le manuel complet, git <commande> -h la liste résumée des options. La documentation de Git est austère mais précise ; prenez l'habitude de vous y référer plutôt qu'au premier résultat d'un moteur de recherche.

git help rebase        # manuel complet
git switch -h          # aide résumée des options
git help -g            # liste des guides conceptuels (gitworkflows, gittutorial…)

Les guides gittutorial et giteveryday sont aussi utiles — ils font partie de la distribution standard de Git et s'ouvrent avec git help.

Seul ou avec une formation

Apprendre Git seul est tout à fait possible : le livre, un outil interactif et un bac à sable fournissent tout le nécessaire. La difficulté est ailleurs : sans structure, on reste facilement bloqué dans la théorie ou, à l'inverse, on accumule des commandes sans les comprendre, et sans retour personne ne vous dira que votre historique est brouillon.

Une formation Git est utile si vous voulez progresser vite et dans l'ordre : du premier commit à la pull request dans un vrai dépôt, avec des exercices à chaque étape. Pour choisir un cours, regardez moins la durée que la part de pratique : y a-t-il des exercices avec des conflits, de l'annulation d'erreurs, du travail en équipe et un projet final ?

Combien de temps faut-il pour apprendre Git

Ces chiffres sont indicatifs : c'est la régularité qui compte. Une heure chaque jour rapporte plus qu'un marathon de week-end une fois par mois.

Les erreurs courantes quand on apprend Git

• Apprendre uniquement avec une interface graphique. Les clients graphiques sont pratiques, mais cachent le modèle. Comprenez d'abord la ligne de commande, choisissez ensuite l'outil qui vous convient.
• Apprendre les options par cœur. Ce sont les idées qu'il faut retenir, les options sont toujours dans -h.
• Avoir peur de casser. Tant que vous n'avez pas fait un reset --hard puis tout récupéré, vous ne savez pas que Git vous protège.
• Faire l'impasse sur les dépôts distants. Git en local sans push, pull ni pull request, c'est la moitié de la compétence.
• Des commits « fix » et « update ». L'habitude d'écrire des messages parlants se prend plus facilement dès le début.

Un projet final pour consolider

Le meilleur test est une simulation de développement en équipe. Créez un dépôt, protégez la branche main contre les push directs, invitez un binôme ou travaillez avec deux comptes. Chaque tâche fait l'objet d'une branche de fonctionnalité et d'une pull request avec revue ; provoquez au moins un conflit, annulez au moins une fois un commit raté avec revert, marquez une release avec un tag.

Après un tel projet, Git cesse d'être une suite d'incantations. Vous voyez le graphe, vous comprenez les conséquences des commandes et vous êtes prêt pour les questions d'entretien.

En résumé

Pour apprendre Git efficacement, suivez l'ordre : le cycle de base, les branches, le travail avec le serveur, l'annulation des erreurs, puis les outils avancés. Un outil interactif aide à visualiser le graphe, Pro Git et la documentation officielle apportent la profondeur, et votre propre bac à sable ainsi qu'un projet d'équipe transforment les connaissances en compétence. C'est exactement ce parcours — de git init à la pull request du projet final — que suit le cours Git sur Skillaria.