💡 Pourquoi maîtriser les commandes Git est essentiel pour gagner du temps

Dans le quotidien d’un développeur web, la maîtrise des commandes Git est bien plus qu’un simple atout : c’est un véritable levier d’efficacité. Git, le système de contrôle de version distribué le plus populaire au monde, permet de gérer facilement les versions de votre code, de collaborer à plusieurs et de sécuriser chaque étape de votre développement. Pourtant, beaucoup de développeurs ne tirent pas pleinement parti des commandes Git les plus puissantes.

Que vous soyez développeur freelance, salarié dans une entreprise tech, ou même étudiant en informatique, savoir utiliser les commandes Git indispensables peut vous faire gagner un temps précieux, éviter des erreurs critiques et améliorer la qualité de vos projets.

Dans cet article, je vous propose de découvrir les 10 commandes Git les plus utiles, celles que j’utilise personnellement chaque jour pour travailler plus rapidement, avec moins de stress et plus d’organisation. Vous découvrirez à la fois des bases incontournables, mais aussi des astuces pour aller plus loin dans votre maîtrise de Git.

🔗 Pour les débutants, je vous recommande également la documentation officielle de Git, une ressource complète pour approfondir chaque commande.

🧰 Commandes Git #1 : git status – Le point de départ indispensable

La première des commandes Git à connaître absolument est git status. C’est une commande simple, mais essentielle pour garder le contrôle sur ce que vous êtes en train de faire dans votre dépôt.

Lorsque vous exécutez git status, Git vous indique précisément :

• ✅ quels fichiers ont été modifiés depuis le dernier commit,

• 🕒 lesquels sont prêts à être enregistrés (staged),

• 🧩 et ceux qui ne sont pas suivis par Git (untracked files).

📌 Exemple d’utilisation :

git status

Résultat typique :

On branch main
Your branch is up to date with 'origin/main'.

Changes not staged for commit:
  modified:   style.css
  modified:   script.js

Untracked files:
  new-script.js

🎯 Pourquoi cette commande Git est indispensable

Avant de lancer d’autres commandes Git comme git add ou git commit, il est crucial de faire un git status. Cela vous évite d’oublier des fichiers importants ou d’inclure par erreur des fichiers non désirés. C’est comme faire un check-up avant de passer à l’action.

💡 Astuce de pro : Créez un alias court dans votre terminal pour cette commande :

git config --global alias.s status

Vous pourrez ensuite simplement taper git s !

📚 Pour aller plus loin :

👉 Consultez la page d’aide officielle de git status pour voir toutes les options disponibles.

💾 Commandes Git #2 : git add . – Ajouter tous les fichiers modifiés d’un coup

Parmi les commandes Git les plus utilisées, git add . est une des plus rapides à exécuter. Elle permet d’ajouter tous les fichiers modifiés dans le répertoire courant (et ses sous-dossiers) à la zone de staging.

En d’autres termes, avec une seule ligne, vous dites à Git : « Je veux que tous ces fichiers soient inclus dans le prochain commit ».

⚙️ Exemple :

git add .

Cette commande est pratique quand vous savez exactement ce que vous modifiez. Elle évite d’avoir à lister manuellement chaque fichier.

⚠️ Attention : git add . ajoute aussi les fichiers non suivis (untracked). Il est donc fortement recommandé de faire un git status avant, pour éviter d’ajouter des fichiers sensibles ou inutiles (comme des .env, .DS_Store, ou des fichiers de test non ignorés).

🎯 Alternative plus granulaire

Si vous préférez sélectionner manuellement chaque fichier modifié, vous pouvez utiliser :

git add fichier.css

Ou encore mieux :

git add -p

Cette variante interactive (-p pour patch) vous permet de choisir, ligne par ligne, ce que vous voulez ajouter. Une fonctionnalité puissante lorsqu’on souhaite des commits plus propres et segmentés.

📚 À lire :

👉 Pour plus de détails, consultez la documentation officielle Git sur add.

🧱 Commandes Git #3 : git commit -m “message” – Documenter efficacement votre travail

Dans la liste des commandes Git incontournables, git commit est sans doute l’une des plus fondamentales. Elle permet d’enregistrer un instantané de vos modifications dans l’historique du projet. Autrement dit, c’est à ce moment-là que votre travail devient traçable.

L’option -m permet d’ajouter un message court décrivant les modifications. C’est ce qu’on appelle un message de commit.

✍️ Exemple de base :

git commit -m "Ajout de la fonction de recherche"

🎯 Pourquoi un bon message de commit est important

Les messages de commit sont cruciaux pour comprendre l’historique d’un projet, surtout en équipe. Un bon message de commit doit répondre à ces trois critères :

1. ✅ Clair : le message doit être compréhensible même des semaines plus tard.

2. 🧠 Précis : indiquez ce qui a été modifié (ajout, correction, suppression…).

3. ⏳ Concis : restez bref mais informatif.

💡 Astuce : Suivez le format Conventional Commits pour uniformiser vos messages.

Exemple :

git commit -m "feat: ajout de la fonctionnalité de contact"

🔄 Exemple de mauvais message :

git commit -m "fix"

❌ Trop vague. Personne ne saura ce qui a été corrigé.

Un bon usage de cette commande Git facilite les relectures de code, le git log, et les éventuels git revert.

📚 Ressource externe utile :

👉 Git Commit Guidelines par Chris Beams : un classique pour apprendre à bien rédiger ses messages de commit.

🔄 Commandes Git #4 : git pull – Récupérer les dernières modifications depuis le dépôt distant

Parmi les commandes Git essentielles pour tout travail collaboratif, git pull occupe une place de choix. Cette commande permet de mettre à jour votre branche locale avec les modifications du dépôt distant, autrement dit : récupérer le travail des autres membres de l’équipe ou de vous-même si vous travaillez sur plusieurs machines.

C’est souvent la première commande à exécuter au début d’une session de travail, afin d’éviter tout conflit ultérieur.

⚙️ Fonctionnement de base

git pull

Cette commande combine en réalité deux opérations :

1. git fetch : elle récupère les dernières modifications depuis le dépôt distant.

2. git merge : elle fusionne ces modifications avec votre branche actuelle.

Résultat : vous êtes parfaitement à jour.

🧠 Bonnes pratiques

• Toujours faire un git pull avant de commencer à coder pour éviter les conflits inutiles.

• Si vous travaillez en équipe, un oubli de cette commande peut provoquer des bugs ou des suppressions de code inattendues lors d’un push.

⚠️ En cas de conflit

Si vos modifications entrent en conflit avec celles du dépôt distant, Git vous affichera un message de conflit. Il faudra alors résoudre les conflits manuellement, souvent en ouvrant les fichiers et en choisissant quelle version conserver.

💡 Astuce : Si vous souhaitez visualiser les changements avant de les fusionner, préférez git fetch, suivi de git merge.

📚 Ressources utiles pour approfondir cette commande Git :

👉 Explication complète de git pull sur Atlassian

🚀 Commandes Git #5 : git push – Envoyer vos modifications vers le dépôt distant

Parmi les commandes Git incontournables, git push est celle qui permet de partager votre travail avec les autres développeurs. Une fois vos modifications validées avec git commit, c’est grâce à git push qu’elles sont envoyées vers le dépôt distant (GitHub, GitLab, Bitbucket, etc.).

Sans cette commande, vos changements restent uniquement en local — invisibles pour vos collaborateurs ou vos outils d’intégration continue (CI/CD).

⚙️ Commande de base :

git push

Ce raccourci fonctionne si vous avez déjà configuré une branche de suivi.

Mais la version plus explicite est souvent préférable :

git push origin main

ou :

git push origin nom-de-la-branche

Cela indique clairement à Git quelle branche locale vous souhaitez pousser vers quel dépôt distant (origin étant le nom par défaut du dépôt).

🔐 Astuce sécurité & bonne pratique

Il est recommandé de vérifier vos modifications via git status et git log avant un push. En effet, une fois le code poussé sur le dépôt distant, il devient accessible à tous et peut déclencher des automatisations (build, tests, déploiements…).

💡 Conseil : Pour éviter les pushs intempestifs, configurez vos dépôts avec la protection de branches (via GitHub par exemple) afin d’imposer des revues de code ou des tests automatisés.

📚 En savoir plus :

👉 Documentation GitHub sur git push

🧪 Commandes Git #6 : git checkout -b – Créer une nouvelle branche proprement

Travailler efficacement avec Git, c’est aussi savoir organiser son code. Et pour cela, la gestion des branches est primordiale. Parmi les commandes Git liées aux branches, git checkout -b est l’une des plus pratiques. Elle vous permet de créer une nouvelle branche et de s’y positionner immédiatement, le tout en une seule ligne.

C’est une commande idéale pour lancer une nouvelle fonctionnalité, corriger un bug ou tester une idée sans perturber la branche principale (main ou master).

⚙️ Exemple de base :

git checkout -b feature/contact-form

Avec cette commande Git, vous créez une branche nommée feature/contact-form basée sur votre branche actuelle, et vous y basculez automatiquement. C’est l’équivalent de deux commandes fusionnées :

git branch feature/contact-form
git checkout feature/contact-form

🤝 Pourquoi cette commande Git est essentielle en équipe

Lorsque plusieurs développeurs collaborent sur un même projet, travailler sur des branches indépendantes permet :

• d’éviter de perturber le code en production,

• de faciliter la revue de code (via des pull requests),

• et de tester chaque fonctionnalité de manière isolée.

💡 Astuce : adoptez une convention de nommage comme feature/, bugfix/, hotfix/, test/ pour garder vos branches bien organisées.

📚 Ressource externe :
👉 Guide complet sur les branches Git – Atlassian

🔍 Commandes Git #7 : git log – Suivre l’historique des commits avec clarté

Parmi les commandes Git qui permettent d’analyser un projet, git log est un incontournable. Elle affiche l’ensemble des commits effectués, dans l’ordre chronologique inverse (du plus récent au plus ancien). Grâce à cette commande, vous pouvez retracer les modifications, identifier les contributeurs et comprendre l’évolution du code.

C’est l’outil parfait pour :

• retrouver un changement spécifique,

• diagnostiquer un bug,

• ou simplement suivre l’historique du projet dans le détail.

⚙️ Commande de base :

git log

Cette commande Git vous renvoie des informations détaillées pour chaque commit :

• l’identifiant unique du commit (SHA),

• le nom de l’auteur,

• la date et l’heure,

• le message de commit.

🔎 Astuce : vue compacte et visuelle

Si vous trouvez l’affichage par défaut trop verbeux, vous pouvez opter pour une version condensée et graphique :

git log --oneline --graph --all

Ce mode vous montre :

• chaque commit sur une ligne,

• la structure des branches via des traits ASCII,

• et l’historique complet, y compris les branches fusionnées.

Parfait pour visualiser le flow Git d’un projet.

🧠 Autres options utiles :

• git log -n 5 → Affiche les 5 derniers commits

• git log –author=”Kylian” → Filtre les commits par auteur

• git log –since=”2 weeks ago” → Historique limité à une période

🧠 Autres options utiles :

• git log -n 5 → Affiche les 5 derniers commits

• git log –author=”Kylian” → Filtre les commits par auteur

• git log –since=”2 weeks ago” → Historique limité à une période

♻️ Commandes Git #8 : git reset – Annuler proprement sans paniquer

Parmi les commandes Git avancées, git reset est sans doute l’une des plus puissantes… mais aussi des plus délicates à manier. Elle permet d’annuler des modifications, de revenir à un état antérieur du projet, ou encore de retirer des fichiers du staging area.

Utilisée correctement, elle vous sauvera d’erreurs embarrassantes. Mal utilisée, elle peut faire disparaître définitivement du code. C’est pourquoi cette commande Git doit être utilisée avec précaution, surtout en environnement collaboratif.

🧪 Les trois principaux types de git reset

1. git reset –soft HEAD~1

Annule le dernier commit, mais conserve tous les fichiers dans le staging.

Très utile si vous voulez refaire un commit avec un meilleur message ou regrouper plusieurs modifications.

git reset --soft HEAD~1

2. git reset –mixed HEAD~1 (par défaut)

Supprime le commit et retire les fichiers du staging, sans supprimer les modifications locales.

C’est la forme la plus sûre pour corriger une erreur récente sans perdre son code.

git reset HEAD~1

3. git reset –hard HEAD~1

⚠️ Attention danger : cette commande supprime le dernier commit ET toutes les modifications locales associées. Elle est irréversible si vous n’avez pas de sauvegarde.

git reset --hard HEAD~1

🎯 Quand utiliser cette commande Git ?

• Vous avez committé trop tôt ou trop de choses.

• Vous voulez annuler un commit sans laisser de trace.

• Vous souhaitez “réinitialiser” un projet à une version stable.

💡 Astuce : avant un reset –hard, pensez à créer une branche de secours :

git branch backup-temp

📚 Ressource externe :

👉 Explication complète des options git reset sur Git-SCM

🧼 Commandes Git #9 : git clean -fd – Nettoyer les fichiers non suivis pour repartir sur une base propre

Dans certains cas, votre projet local peut se retrouver encombré de fichiers temporaires, de tests, ou de dossiers générés automatiquement qui n’ont pas été ajoutés à Git. C’est là que la commande git clean devient précieuse.

Parmi les commandes Git orientées “nettoyage”, git clean -fd est celle qui vous permet de supprimer tous les fichiers non suivis et tous les répertoires non versionnés.

⚙️ Exemple d’utilisation :

git clean -fd

• -f : force la suppression (Git vous protège sinon)

• -d : inclut les dossiers non suivis, pas uniquement les fichiers

🧠 Quand utiliser cette commande Git ?

• Après avoir testé du code généré automatiquement

• Avant un commit important, pour partir sur un environnement propre

• Lorsqu’un projet contient des résidus d’anciens fichiers ignorés

⚠️ Attention : Cette commande Git est irréversible. Une fois les fichiers supprimés, ils ne peuvent pas être restaurés s’ils ne sont pas versionnés.

🔒 Astuce de sécurité :

Avant de lancer un nettoyage définitif, vous pouvez simuler le résultat avec l’option -n (ou –dry-run) :

git clean -fdn

Cela affichera la liste des fichiers qui seraient supprimés, sans rien toucher.

📚 Ressource externe :

👉 Guide complet de git clean – Atlassian

🧬 Commandes Git #10 : git stash – Mettre de côté ses changements sans les perdre

Parmi les commandes Git qui sauvent la vie au quotidien, git stash est un vrai bijou. Elle vous permet de mettre de côté vos modifications locales non validées sans avoir à les committer ni à les supprimer. C’est la commande parfaite lorsque vous devez interrompre une tâche pour en gérer une autre rapidement, sans risquer de casser votre travail en cours.

🔄 Scénario typique :

Vous travaillez sur une nouvelle fonctionnalité (feature/search) et un collègue vous demande de corriger une erreur urgente sur la branche main.

➡️ Grâce à git stash, vous pouvez :

1. Sauvegarder vos changements en cours

2. Basculer sur la branche principale

3. Corriger et pousser

4. Revenir à votre branche et récupérer votre travail là où vous l’avez laissé

⚙️ Commandes principales :

git stash

→ Enregistre vos modifications locales et restaure une copie “propre” de la branche

git stash pop

→ Restaure le dernier stash et supprime l’entrée de la liste

git stash apply

→ Restaure les modifications sans supprimer le stash (utile si vous voulez les réutiliser)

git stash list

→ Liste tous les stashes enregistrés

💡 Astuce utile :

Vous pouvez ajouter un message à votre stash pour mieux vous y retrouver :

git stash save "Début refonte formulaire de contact"

Et pour appliquer un stash spécifique :

git stash apply stash@{2}

🎯 Quand utiliser cette commande Git ?

• Pour interrompre un travail sans perdre vos modifications

• Pour tester quelque chose rapidement

• Pour passer temporairement sur une autre branche sans committer de code inachevé

📚 Ressource externe :

👉 Documentation officielle de Git sur stash


🔎 Bonus : Autres commandes Git utiles à connaître pour aller plus loin

En plus des 10 commandes Git indispensables vues précédemment, il existe de nombreuses autres commandes très pratiques à intégrer dans votre routine de développeur. Voici quelques-unes qui valent le détour pour affiner votre maîtrise de Git et booster votre efficacité.

🧰 Sélection de commandes Git bonus :

• git diff – Compare les différences entre deux versions d’un fichier ou d’un projet. Très utile pour voir ce qui a été modifié avant un commit :

git diff

• git branch – Liste toutes les branches existantes et vous indique sur laquelle vous êtes actuellement :

git branch

• git rebase – Permet de réorganiser les commits, nettoyer l’historique ou fusionner des branches de manière linéaire. À utiliser avec précaution :

git rebase main

• git clone – Sert à copier un dépôt Git existant depuis une plateforme distante comme GitHub ou GitLab :

git clone https://github.com/nom-utilisateur/mon-projet.git

• git fetch – Récupère les modifications du dépôt distant sans les fusionner dans votre branche actuelle. Très pratique si vous souhaitez simplement vérifier ce qui a changé :

git fetch

💡 Astuce : Plus vous explorez ces commandes Git, plus vous devenez capable d’adapter Git à votre propre workflow de développement.

📚 Ressource recommandée :

👉 Git Cheatsheet – GitHub : une fiche mémo très utile avec les principales commandes Git à garder sous la main.

💡 Pourquoi ces commandes Git vous font réellement gagner du temps

En tant que développeur web, votre temps est précieux. Maîtriser ces commandes Git n’est pas seulement un gain de confort : c’est un levier puissant pour travailler plus efficacement, éviter les erreurs coûteuses et mieux collaborer avec votre équipe ou vos clients.

Voici quelques exemples concrets de ce que ces commandes Git vous permettent d’éviter au quotidien :

• ❌ Des conflits lors des git pull mal anticipés

• ❌ Des fichiers oubliés dans vos commits

• ❌ Des pertes de code liées à une mauvaise manipulation

• ❌ Des heures de travail perdues à tout recommencer après un bug

En intégrant ces commandes Git indispensables dans votre workflow, vous transformez Git en véritable bouclier de sécurité et en assistant de productivité. Vous êtes ainsi plus à l’aise pour expérimenter, corriger, livrer et collaborer sans stress.

Que vous soyez freelance, salarié dans une agence ou développeur full stack en solo, ces bonnes pratiques Git renforcent votre rigueur professionnelle et vous permettent de livrer du code plus propre, plus vite, et avec plus de sérénité.

✍️ Conclusion : Intégrez ces commandes Git pour passer au niveau supérieu

Ces 10 commandes Git indispensables, accompagnées des bonus partagés plus haut, représentent les fondations d’un workflow Git propre, rapide et sécurisé. Que vous soyez encore en formation ou déjà en poste, leur maîtrise vous permettra de travailler plus efficacement, de collaborer sans crainte et d’éviter bien des erreurs que font encore beaucoup de développeurs.

En intégrant ces commandes Git dans votre routine quotidienne, vous gagnerez :

• du temps,

• de la clarté,

• et de la sérénité dans chacun de vos projets.

👉 Vous cherchez un développeur freelance pour créer ou optimiser votre site web ?

Rendez-vous sur mon portfolio ici ou contactez-moi directement pour discuter de votre projet.

📥 Téléchargez le guide complet au format PDF

👉 Commandes Git essentielles – Guide visuel à imprimer ou garder sous la main