Aide-mémoire des commandes Git essentielles pour les développeurs

31 mars 2026 · 12 min de lecture

Git est la colonne vertébrale du développement logiciel moderne. Que vous travailliez seul ou en collaboration avec une équipe de centaines de personnes, maîtriser les commandes Git est essentiel pour un contrôle de version et une gestion de code efficaces.

Cet aide-mémoire complet couvre tout, des opérations de base aux techniques avancées. Mettez cette page en favori et consultez-la chaque fois que vous avez besoin d'une référence rapide pour les commandes Git.

Installation et configuration

Avant de commencer à utiliser Git, vous devez configurer votre identité et vos préférences. Ces paramètres déterminent comment Git se comporte et comment vos commits sont attribués.

Configuration initiale

Exécutez ces commandes une fois par machine pour configurer votre environnement Git :

# Set your name and email (required)
git config --global user.name "Your Name"
git config --global user.email "[email protected]"

# Set default branch name to 'main'
git config --global init.defaultBranch main

# Enable color output for better readability
git config --global color.ui auto

# Set your preferred text editor
git config --global core.editor "code --wait"  # VS Code
git config --global core.editor "vim"          # Vim
git config --global core.editor "nano"         # Nano

# View all configuration settings
git config --list

# View specific configuration
git config user.name
git config user.email

Le drapeau --global applique les paramètres à tous les dépôts sur votre machine. Pour configurer les paramètres d'un seul dépôt, naviguez vers ce dépôt et omettez le drapeau --global.

Niveaux de configuration

Git a trois niveaux de configuration, chacun remplaçant le précédent :

Options de configuration utiles

# Set up credential caching (avoid repeated password prompts)
git config --global credential.helper cache
git config --global credential.helper 'cache --timeout=3600'

# Enable automatic line ending conversion
git config --global core.autocrlf true   # Windows
git config --global core.autocrlf input  # Mac/Linux

# Set up aliases for common commands
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status
git config --global alias.unstage 'reset HEAD --'
git config --global alias.last 'log -1 HEAD'

# Configure merge and diff tools
git config --global merge.tool vimdiff
git config --global diff.tool vimdiff

Commandes Git de base

Ce sont les commandes fondamentales que vous utiliserez quotidiennement. Maîtrisez-les d'abord avant de passer aux opérations avancées.

Initialisation du dépôt

# Initialize a new Git repository
git init

# Initialize with a specific branch name
git init -b main

# Clone an existing repository
git clone https://github.com/user/repo.git
git clone [email protected]:user/repo.git  # SSH
git clone https://github.com/user/repo.git my-folder  # Custom folder name

# Clone only recent history (faster for large repos)
git clone --depth 1 https://github.com/user/repo.git

Travailler avec les modifications

# Check status of working directory
git status
git status -s  # Short format
git status -sb # Short format with branch info

# Stage files for commit
git add filename.js        # Single file
git add src/               # Entire directory
git add .                  # All changes in current directory
git add -A                 # All changes in entire repo
git add -p                 # Interactive staging (patch mode)
git add *.js               # All JavaScript files

# Unstage files
git reset filename.js      # Unstage specific file
git reset                  # Unstage all files

# Commit staged changes
git commit -m "feat: add user authentication"
git commit -am "fix: resolve login bug"  # Stage + commit tracked files
git commit --amend         # Modify the last commit
git commit --amend --no-edit  # Amend without changing message

# View differences
git diff                   # Unstaged changes
git diff --staged          # Staged changes
git diff HEAD              # All changes since last commit
git diff main..feature     # Between branches
git diff --stat            # Summary of changes

Supprimer et déplacer des fichiers

# Remove files
git rm filename.js         # Remove from working directory and stage deletion
git rm --cached filename.js # Remove from Git but keep in working directory
git rm -r directory/       # Remove directory recursively

# Move or rename files
git mv old-name.js new-name.js
git mv src/file.js lib/file.js  # Move to different directory

Lorsque vous utilisez git mv ou git rm, les modifications sont automatiquement indexées. C'est plus pratique que d'utiliser des commandes shell ordinaires puis d'indexer les modifications séparément.

Branches et fusion

Les branches sont la fonctionnalité phare de Git. Elles vous permettent de travailler sur plusieurs fonctionnalités simultanément sans interférer avec la base de code principale.

Gestion des branches

# List branches
git branch                 # Local branches
git branch -r              # Remote branches
git branch -a              # All branches (local + remote)
git branch -v              # With last commit info
git branch --merged        # Branches merged into current branch
git branch --no-merged     # Branches not yet merged

# Create branches
git branch feature-login   # Create new branch
git checkout -b feature-login  # Create and switch to new branch
git switch -c feature-login    # Modern alternative to checkout

# Switch branches
git checkout main          # Switch to main branch
git switch main            # Modern alternative
git checkout -            # Switch to previous branch

# Rename branches
git branch -m old-name new-name  # Rename branch
git branch -M new-name     # Force rename current branch

# Delete branches
git branch -d feature-login     # Delete merged branch
git branch -D feature-login     # Force delete (even if unmerged)
git push origin --delete feature-login  # Delete remote branch

Stratégies de fusion

# Merge branches
git merge feature-login    # Merge feature-login into current branch
git merge --no-ff feature-login  # Create merge commit even for fast-forward
git merge --squash feature-login # Squash all commits into one

# Abort a merge
git merge --abort

# Continue after resolving conflicts
git merge --continue

Rebaser

Le rebasage réécrit l'historique des commits en déplaçant votre branche vers un nouveau commit de base. Cela crée un historique plus propre et linéaire, mais doit être utilisé avec précaution.

# Rebase current branch onto main
git rebase main

# Interactive rebase (edit, squash, reorder commits)
git rebase -i HEAD~3       # Last 3 commits
git rebase -i main         # All commits since branching from main

# Continue after resolving conflicts
git rebase --continue

# Skip current commit
git rebase --skip

# Abort rebase
git rebase --abort

Résoudre les conflits de fusion

Lorsque Git ne peut pas fusionner automatiquement les modifications, vous devrez résoudre les conflits manuellement :

1. Exécutez git status pour voir quels fichiers ont des conflits
2. Ouvrez les fichiers en conflit et recherchez les marqueurs de conflit (<<<<<<<, =======, >>>>>>>)
3. Modifiez le fichier pour résoudre les conflits, en supprimant les marqueurs
4. Indexez les fichiers résolus avec git add
5. Terminez la fusion avec git commit ou git merge --continue

# Use merge tools to resolve conflicts
git mergetool

# Accept all changes from one side
git checkout --ours filename.js    # Keep your version
git checkout --theirs filename.js  # Keep their version

Opérations distantes

Les dépôts distants permettent la collaboration. Ces commandes vous aident à synchroniser votre travail local avec des serveurs distants comme GitHub, GitLab ou Bitbucket.

Gérer les dépôts distants

# List remote repositories
git remote
git remote -v              # With URLs

# Add remote repository
git remote add origin https://github.com/user/repo.git
git remote add upstream https://github.com/original/repo.git

# Change remote URL
git remote set-url origin [email protected]:user/repo.git

# Remove remote
git remote remove origin

# Rename remote
git remote rename origin upstream

# Show remote details
git remote show origin

Récupérer et tirer

# Fetch changes from remote (doesn't merge)
git fetch origin
git fetch --all            # Fetch from all remotes
git fetch --prune          # Remove deleted remote branches

# Pull changes (fetch + merge)
git pull origin main
git pull --rebase origin main  # Fetch + rebase instead of merge
git pull --ff-only         # Only fast-forward, fail if merge needed

# Pull with automatic stash
git pull --autostash

La différence entre fetch et pull est importante. Fetch télécharge les modifications mais ne modifie pas votre répertoire de travail, tandis que pull fusionne automatiquement les modifications.

Pousser les modifications

# Push to remote
git push origin main
git push -u origin feature-login  # Set upstream and push
git push --all             # Push all branches
git push --tags            # Push all tags

# Force push (use with caution!)
git push --force           # Overwrite remote history
git push --force-with-lease # Safer force push, fails if remote updated

# Delete remote branch
git push origin --delete feature-login
git push origin :feature-login  # Alternative syntax

Branches de suivi

# Set upstream branch
git branch --set-upstream-to=origin/main main
git branch -u origin/main  # Shorthand

# Create tracking branch
git checkout -b feature origin/feature
git checkout --track origin/feature  # Automatic naming

# View tracking relationships
git branch -vv

Remiser les modifications

La remise met temporairement de côté les modifications afin que vous puissiez travailler sur autre chose sans commiter un travail incomplet.

# Stash current changes
git stash
git stash save "work in progress on login feature"
git stash -u               # Include untracked files
git stash -a               # Include untracked and ignored files

# List stashes
git stash list

# Apply stashed changes
git stash apply            # Apply most recent stash
git stash apply stash@{2}  # Apply specific stash
git stash pop              # Apply and remove from stash list

# View stash contents
git stash show
git stash show -p          # Show full diff
git stash show stash@{1}   # Show specific stash

# Create branch from stash
git stash branch feature-name

# Remove stashes
git stash drop stash@{1}   # Remove specific stash
git stash clear            # Remove all stashes

La remise est parfaite