Git pour Débutants : Les Commandes Essentielles en 2026

Git est l'outil que tu utiliseras à chaque instant de ta vie de développeur. Que tu travailles seul ou en équipe, que tu fasses du JavaScript, Python, PHP ou n'importe quoi d'autre, Git est universel — il sauvegarde ton travail, trace chaque modification, et te permet de collaborer sans détruire le code des autres. Ce guide te donne toutes les commandes essentielles, expliquées clairement, avec les cas d'usage concrets du quotidien.

Qu'est-ce que Git ?

Git est un système de contrôle de version — il prend des "photos" de ton code à chaque point important, et te permet de naviguer entre ces photos, de travailler sur plusieurs versions en parallèle, et de fusionner le travail de plusieurs personnes.

Git : le logiciel installé sur ta machine, qui gère l'historique local
GitHub / GitLab / Bitbucket : des plateformes en ligne pour héberger tes dépôts et collaborer
Repository (repo) : le dossier versionné, avec tout son historique
Commit : une "photo" de l'état du code à un instant donné
Branch : une ligne de développement parallèle

Installer Git

# macOS — via Homebrew
brew install git

# Linux (Debian/Ubuntu)
sudo apt install git

# Windows — télécharger Git for Windows sur git-scm.com
# Vérifier l'installation
git --version  # git version 2.44.x

Après l'installation, configure ton identité — elle apparaîtra dans chaque commit :

git config --global user.name "Ton Nom"
git config --global user.email "ton@email.com"
git config --global core.editor "code --wait"  # VS Code comme éditeur par défaut

Le workflow Git du quotidien

Le cycle de base : modifier → indexer → valider → envoyer

Initialiser et cloner un dépôt

# Créer un nouveau dépôt dans le dossier courant
git init

# Cloner un dépôt existant depuis GitHub
git clone https://github.com/utilisateur/mon-projet.git

# Cloner dans un dossier avec un nom différent
git clone https://github.com/utilisateur/mon-projet.git mon-dossier

Les commandes de base : add, commit, status

# Voir l'état du dépôt — à utiliser très souvent
git status

# Voir les modifications précises ligne par ligne
git diff

# Indexer des fichiers (les préparer pour un commit)
git add fichier.js          # Un seul fichier
git add src/               # Tout un dossier
git add .                  # Tout ce qui a changé (attention aux secrets !)
git add -p                 # Interactif — sélectionner les changements par morceaux

# Créer un commit
git commit -m "feat: ajouter la page de connexion"

# Indexer ET commiter les fichiers déjà suivis en une seule commande
git commit -am "fix: corriger le calcul du total"

Les messages de commit comptent. Ils doivent décrire pourquoi le changement, pas quoi. Une convention très répandue : les Conventional Commits — feat:, fix:, docs:, refactor:, chore:.

Voir l'historique

# Historique complet
git log

# Format compact — une ligne par commit
git log --oneline

# Avec un graphe des branches
git log --oneline --graph --all

# Les N derniers commits
git log -5

# Modifications d'un fichier spécifique
git log --follow fichier.js

# Qui a modifié quelle ligne ?
git blame fichier.js

Branches : travailler en parallèle

Une branche feature part de main, se développe, puis fusionne

# Voir toutes les branches
git branch        # locales
git branch -a     # locales + distantes

# Créer une branche
git branch ma-feature

# Créer ET basculer dessus (commande moderne)
git switch -c ma-feature
# Ou avec l'ancienne syntaxe
git checkout -b ma-feature

# Basculer sur une branche existante
git switch main
git checkout main  # ancienne syntaxe

# Supprimer une branche (après merge)
git branch -d ma-feature

# Supprimer une branche distante
git push origin --delete ma-feature

Remote : GitHub et le travail collaboratif

# Voir les remotes configurés
git remote -v

# Ajouter un remote
git remote add origin https://github.com/user/repo.git

# Envoyer ses commits vers GitHub (premier push)
git push -u origin main
# Ensuite, simplement :
git push

# Récupérer les changements distants
git fetch              # récupère sans fusionner
git pull               # fetch + merge automatique
git pull --rebase      # fetch + rebase (historique plus propre)

# Pousser une branche feature
git push -u origin ma-feature

Merge et Rebase

# Fusionner une branche dans main
git switch main
git merge ma-feature

# Merge --no-ff — préserve l'historique de la branche
git merge --no-ff ma-feature

# Rebase — rejoue les commits sur une autre base
git switch ma-feature
git rebase main   # applique les commits de ma-feature sur main

# En cas de conflit lors d'un merge ou rebase
# 1. Ouvrir les fichiers conflictuels, résoudre
# 2. git add fichier-resolu.js
# 3. git merge --continue ou git rebase --continue
# Pour annuler :
git merge --abort
git rebase --abort

Merge vs Rebase : merge crée un commit de fusion visible dans l'historique. rebase réécrit l'historique pour qu'il soit linéaire. Règle d'or : ne jamais rebase une branche partagée (déjà pushée et utilisée par d'autres).

Annuler des erreurs

C'est souvent la situation la plus stressante pour un débutant. Voici les solutions selon les cas :

# Annuler les modifications d'un fichier non indexé
git restore fichier.js

# Désindexer un fichier (annuler git add)
git restore --staged fichier.js

# Modifier le dernier commit (message ou contenu)
git commit --amend -m "nouveau message"
# ⚠️ Ne pas amender un commit déjà pushé

# Annuler un commit en créant un nouveau commit inverse (safe)
git revert HEAD

# Revenir à un commit précédent (garder les modifs en staging)
git reset --soft HEAD~1

# Revenir à un commit précédent (garder les modifs non indexées)
git reset HEAD~1

# ⚠️ DANGER — supprime définitivement les modifications
git reset --hard HEAD~1

# Sauvegarder temporairement sans commiter
git stash           # met de côté les changements
git stash pop       # les réapplique
git stash list      # voir les stashs
git stash drop      # supprimer le dernier stash

.gitignore : ne pas versionner ce qui ne doit pas l'être

# .gitignore — à créer à la racine du projet
node_modules/
.env
.env.local
dist/
build/
*.log
.DS_Store
.vscode/settings.json
coverage/

Les variables d'environnement (clés API, mots de passe) ne doivent jamais être commitées. Ajoute toujours .env à ton .gitignore avant le premier commit.

Le workflow GitHub : Pull Requests

# Workflow type en équipe

# 1. Créer une branche pour ta feature
git switch -c feat/ajout-authentification

# 2. Coder, commiter régulièrement
git add src/auth/
git commit -m "feat(auth): ajouter formulaire de connexion"
git commit -m "feat(auth): valider les champs côté client"
git commit -m "test(auth): ajouter tests unitaires login"

# 3. Pousser la branche
git push -u origin feat/ajout-authentification

# 4. Ouvrir une Pull Request sur GitHub
# (via l'interface web ou GitHub CLI)
gh pr create --title "feat: authentification utilisateur" --body "Closes #42"

# 5. Après review et merge, nettoyer
git switch main
git pull
git branch -d feat/ajout-authentification

Commandes Git + IA en 2026

En 2026, les outils IA ont transformé le workflow Git. Quelques usages concrets :

# GitHub Copilot dans le terminal — suggère des commandes
gh copilot suggest "annuler les 3 derniers commits mais garder les fichiers"

# Claude Code — automatiser des tâches Git complètes
# Exemple : créer une PR, patcher des fichiers, commiter
# Claude Code peut exécuter des commandes git dans son workflow

# git log pour générer un changelog avec l'IA
git log --oneline v1.0..HEAD | claude -p "génère un changelog markdown"

# Résoudre des conflits avec l'aide de l'IA
# Colle le diff conflictuel dans Claude pour obtenir la résolution

Cheat sheet : les 20 commandes que tu utiliseras 90% du temps

Commande	Ce qu'elle fait
`git init`	Initialiser un repo
`git clone <url>`	Cloner un repo distant
`git status`	État du repo (à utiliser souvent)
`git add .`	Indexer tous les changements
`git add -p`	Indexer en sélectionnant par morceaux
`git commit -m "msg"`	Créer un commit
`git log --oneline`	Historique compact
`git diff`	Voir les changements non indexés
`git push`	Envoyer sur le remote
`git pull`	Récupérer depuis le remote
`git switch -c <branche>`	Créer et basculer sur une branche
`git switch <branche>`	Basculer sur une branche
`git merge <branche>`	Fusionner une branche
`git stash`	Mettre de côté les changements
`git stash pop`	Réappliquer le stash
`git restore <fichier>`	Annuler les modifs d'un fichier
`git reset --soft HEAD~1`	Défaire le dernier commit (safe)
`git revert HEAD`	Annuler un commit (safe pour remote)
`git blame <fichier>`	Voir qui a écrit quoi
`git tag v1.0.0`	Créer un tag de version

Conclusion

Git semble complexe au début, mais la réalité du quotidien se résume à 5–6 commandes : status, add, commit, push, pull, et switch. Le reste s'apprend au fur et à mesure des besoins. L'essentiel est de commiter souvent avec des messages clairs — chaque commit est un filet de sécurité.

Pour la référence complète de toutes les commandes, la documentation officielle Git est exhaustive. Et si tu démarres avec GitHub, le guide GitHub Docs en français couvre les Pull Requests, Actions et tout l'écosystème.

Git est l'outil de base de tout développeur — que tu codes en JavaScript, Python ou PHP. Retrouve nos ateliers interactifs GoGoKodo pour pratiquer les langages dans le navigateur, et utilise Git dès le premier projet pour prendre les bonnes habitudes.