Aide-mémoire Git — les commandes par tâche
Les commandes Git classées selon ce que vous voulez faire : annuler le dernier commit, renommer une branche, supprimer une branche distante. switch/restore modernes avec leurs équivalents classiques et badges de danger.
Dernière vérification : 2026-10-18, d’après la référence git-scm.com pour Git 2.56 et le manuel de GitHub CLI. Sources : Git reference (git-scm.com/docs), git restore, git switch, git reset, git config, GitHub CLI manual.
Configuration (une fois par machine)
Avec --global, les réglages vont dans ~/.gitconfig. Depuis Git 2.46, la forme documentée est git config set / get / list ; la forme classique fonctionne toujours.
git config set --global user.name "Ana Lee" git config set --global user.email "ana@example.com"
Classique : git config --global user.name "Ana Lee"
Enregistrés dans chacun de vos commits. Utilisez l’e-mail connu de votre hébergeur Git pour que les commits soient liés à votre compte.
git config set --global init.defaultBranch main
Classique : git config --global init.defaultBranch main
Sans cela, git init nomme toujours la première branche master (et affiche un conseil).
git config set --global core.editor "code --wait"
Classique : git config --global core.editor "code --wait"
Toute commande qui attend la fermeture du fichier convient : "nano", "vim", "subl -n -w".
git config set --global core.autocrlf true # Windows git config set --global core.autocrlf input # macOS, Linux
Classique : git config --global core.autocrlf true
Commite en LF, extrait en CRLF sous Windows. Pour toute une équipe, un fichier .gitattributes avec "* text=auto" est plus fiable que des réglages individuels.
git --version
git switch et git restore exigent 2.23+, les sous-commandes de git config 2.46+.
Démarrer un dépôt
git init
git init -b main # name the first branchCrée un répertoire .git. Ajoutez un .gitignore avant le premier commit pour que les fichiers de build et les secrets n’y entrent jamais.
git clone https://github.com/owner/repo.git git clone git@github.com:owner/repo.git my-folder
Télécharge tout l’historique et définit le dépôt distant "origin". La seconde forme utilise SSH et un nom de dossier personnalisé.
git clone --depth 1 https://github.com/owner/repo.git
Ignore l’historique ; idéal pour la CI et les gros dépôts. git fetch --unshallow récupère le reste plus tard.
git remote add origin git@github.com:owner/repo.git git push -u origin main
Créez d’abord le dépôt vide chez l’hébergeur (ou utilisez gh repo create, plus bas). -u mémorise origin/main comme branche amont.
Indexer et commiter
git status
git status -s # short formListe les fichiers indexés, non indexés et non suivis, et suggère la commande suivante.
git add file.txt
git add . # everything in this folder and belowgit add -A indexe aussi les suppressions partout dans le dépôt.
git add -p file.txt
Passe en revue chaque modification ("hunk") : y pour indexer, n pour passer, s pour scinder, e pour modifier.
git commit -m "Add login form"
git commit -am "Fix typo" # stage tracked files and commit-a prend les fichiers suivis modifiés et supprimés, jamais les nouveaux.
git mv old.txt new.txt git rm file.txt
Les deux indexent la modification pour vous. Git détecte les renommages par le contenu : un simple mv suivi de git add fonctionne aussi.
git rm --cached .env echo ".env" >> .gitignore
Le retire du dépôt à partir du prochain commit. Il reste dans les commits précédents : s’il contenait un secret, changez ce secret.
Branches
git branch git branch -a # include remote branches git branch -vv # show upstream and ahead/behind
La branche courante est marquée d’un *.
git switch -c feature/login
Classique : git checkout -b feature/login
Part du commit courant ; ajoutez un point de départ pour partir d’ailleurs : git switch -c hotfix origin/main.
git switch main
git switch - # back to the previous branchClassique : git checkout main
Si seule origin/feature existe, git switch feature crée automatiquement une branche locale de suivi.
git branch -m new-name # current branch
git branch -m old-name new-nameRenomme en local uniquement. Pour renommer aussi sur le dépôt distant, voir l’entrée suivante.
git branch -m old-name new-name git push -u origin new-name git push origin --delete old-name
Il n’y a pas de renommage distant : poussez le nouveau nom et supprimez l’ancien. Les pull requests ouvertes sur l’ancien nom peuvent se fermer ; le bouton de renommage de l’interface web de GitHub les redirige.
git branch -d feature/login
git branch -D feature/login # even if unmerged-d refuse si la branche a des commits non fusionnés dans sa branche amont ou dans HEAD ; -D supprime quand même.
Récupération : Les commits non fusionnés sont encore dans le reflog : git reflog, trouvez le sommet, puis git branch feature/login <sha>.
git push origin --delete feature/login
Classique : git push origin :feature/login
Vos collègues la voient encore jusqu’à ce qu’ils lancent git fetch --prune.
Récupération : Quiconque a la branche en local (ou vous, via git reflog) peut la repousser.
git branch -u origin/main
git push -u origin HEAD # push current branch and track itClassique : git branch --set-upstream-to=origin/main
La branche amont est celle qu’utilisent git pull et git push sans argument.
git switch --detach a1b2c3d
git switch -c rescue # keep work made thereClassique : git checkout a1b2c3d
Les commits faits en HEAD détachée n’appartiennent à aucune branche ; créez-en une avant de partir, sinon ils ne sont accessibles que via le reflog.
Merge, rebase et cherry-pick
git switch main
git merge feature/login
git merge --no-ff feature/login # always create a merge commitFait un fast-forward si possible ; --no-ff garde la branche visible dans l’historique.
git merge --squash feature/login git commit -m "Add login"
Indexe les modifications combinées sans enregistrer de fusion ; la branche n’est pas marquée comme fusionnée ensuite.
git status # list conflicted files # edit the files, remove <<<<<<< ======= >>>>>>> markers git add file.txt git commit # or: git rebase --continue
Prenez un côté en bloc avec git restore --ours file.txt ou --theirs. Pendant un rebase, "ours" est la branche sur laquelle on rebase, l’inverse d’une fusion.
git merge --abort
Revient à l’état d’avant le début de la fusion.
Récupération : Les résolutions de conflits déjà faites sont perdues. Si vous aviez des modifications non commitées au début de la fusion, --abort peut ne pas pouvoir les restaurer : commitez ou faites un stash avant de fusionner.
git switch feature/login git rebase main
Rejoue vos commits au-dessus de main pour un historique linéaire. Résolvez les conflits, git add, puis git rebase --continue ; --abort abandonne.
Récupération : Juste après : git reset --hard ORIG_HEAD. Plus tard : retrouvez l’ancien sommet dans git reflog.
git rebase -i HEAD~3
Ouvre une liste : remplacez pick par squash/fixup pour combiner, reword pour modifier un message, drop pour supprimer, ou réordonnez les lignes.
Récupération : git reflog affiche le commit d’avant le rebase ; git reset --hard <sha> le restaure.
git commit --fixup=a1b2c3d git rebase -i --autosquash a1b2c3d~1
Le commit fixup est intégré automatiquement à a1b2c3d lors du rebase.
Récupération : Comme pour le rebase interactif : git reflog.
git pull --rebase
git config set --global pull.rebase true # make it the defaultRebase vos commits locaux au-dessus de ce qui a été récupéré.
git cherry-pick a1b2c3d
git cherry-pick -x a1b2c3d # note the source in the messageCrée un nouveau commit avec les mêmes modifications. Une plage : git cherry-pick A..B (A exclu).
Dépôts distants : fetch, pull, push
git remote -v git remote set-url origin git@github.com:owner/repo.git
set-url fait passer un clone de HTTPS à SSH (ou vers un dépôt renommé).
git fetch
git fetch --prune # also drop deleted remote branchesMet à jour origin/* uniquement ; vos branches ne sont pas touchées.
git pull
git fetch plus merge (ou rebase, si pull.rebase est défini).
git push
git push -u origin HEAD # first push of a new branch
git config set --global push.autoSetupRemote trueAvec push.autoSetupRemote (Git 2.37+), un simple git push sur une nouvelle branche définit lui-même la branche amont.
git push --force-with-lease
Refuse si le dépôt distant a des commits que vous n’avez pas récupérés, contrairement à --force. Ajoutez --force-if-includes (Git 2.30+) pour plus de sécurité avec les fetch en arrière-plan.
Récupération : Les commits distants écrasés survivent dans le reflog de ceux qui les avaient, et GitHub les garde accessibles par SHA pendant un certain temps.
git remote add upstream https://github.com/original/repo.git git fetch upstream git switch main git merge upstream/main
Ou avec GitHub CLI : gh repo sync.
Annuler
Choisissez selon l’endroit où se trouve l’erreur : dans le répertoire de travail, dans l’index, dans un commit local ou dans un commit déjà poussé. Tout ce qui a été commité un jour peut en général être retrouvé avec git reflog ; les modifications non commitées que vous abandonnez, non.
git reset --soft HEAD~1
Le commit disparaît ; ses modifications restent indexées, prêtes à être recommitées. Utilisez git reset HEAD~1 (sans --soft) pour les garder plutôt non indexées.
Récupération : git reset ORIG_HEAD ramène le commit. S’il était déjà poussé, utilisez plutôt git revert.
git reset --hard HEAD~1
Recule la branche d’un commit et remet chaque fichier suivi dans cet état.
Récupération : Le commit est dans git reflog (les entrées inaccessibles expirent par défaut après 30 jours) : git reset --hard HEAD@{1}. Les modifications non commitées des fichiers suivis sont perdues pour de bon.
git revert a1b2c3d
git revert HEAD # the latest commitAjoute un nouveau commit qui inverse l’ancien, sans changer l’historique des autres. C’est l’annulation sûre pour les branches partagées.
git revert -m 1 <merge-sha>
-m 1 garde le premier parent (généralement main). Pour refusionner la branche plus tard, il faut d’abord annuler ce revert.
git commit --amend -m "Better message"
Remplace le dernier commit par un nouveau. Sans souci avant le push ; après, il faut --force-with-lease.
Récupération : git reset --soft HEAD@{1} revient au commit d’avant l’amend.
git add forgotten.txt git commit --amend --no-edit
Garde le message, ajoute le fichier.
Récupération : git reset --soft HEAD@{1}.
git restore --staged file.txt
git restore --staged . # everythingClassique : git reset HEAD file.txt
Les modifications restent dans le répertoire de travail ; seule l’indexation est annulée.
git restore file.txt
Classique : git checkout -- file.txt
Remet le fichier dans sa version indexée (ou celle du dernier commit si rien n’est indexé).
Récupération : Irrécupérable avec Git : les modifications n’ont jamais été commitées. L’historique local de votre éditeur les a peut-être encore.
git restore --staged --worktree .
git clean -fd # also delete untracked filesClassique : git reset --hard
git clean -fd
Retour au dernier commit. Lancez d’abord git clean -n pour voir ce qui serait supprimé.
Récupération : Irrécupérable : les modifications non commitées et les fichiers non suivis sont supprimés. git stash -u est l’alternative réversible.
git restore file.txt # deletion not committed git restore --source=a1b2c3d~1 file.txt # deleted in commit a1b2c3d
Classique : git checkout a1b2c3d~1 -- file.txt
Trouvez le commit qui l’a supprimé avec git log --diff-filter=D -- file.txt.
git restore --source=main -- config.yml
Classique : git checkout main -- config.yml
N’écrase que la copie de travail ; ajoutez --staged --worktree pour l’indexer aussi. Pour simplement regarder : git show main:config.yml.
Récupération : Les modifications non commitées de ce fichier sont écrasées.
git reflog git branch rescued a1b2c3d
Le reflog enregistre chaque position de HEAD. Trouvez le SHA d’avant l’erreur et placez-y une branche.
git reset --hard ORIG_HEAD
ORIG_HEAD est défini par merge, rebase et reset sur votre position précédente. Il est écrasé par la prochaine commande de ce type.
Récupération : git reflog liste toujours le commit de fusion.
git reflog # find "rebase (start)"; the entry below it is the old tip
git reset --hard HEAD@{5}Juste après le rebase, git reset --hard ORIG_HEAD fait la même chose.
Récupération : --hard supprime les modifications non commitées ; mettez-les d’abord dans un stash.
git reset --hard HEAD@{1}HEAD@{1} est la position de HEAD avant son dernier déplacement. Ne fonctionne que pour le travail commité.
git filter-repo --invert-paths --path secrets.env
git filter-repo est un outil séparé (pip install git-filter-repo), recommandé par la documentation de git-filter-branch. Chaque clone doit ensuite être recloné. Changez le secret dans tous les cas : il était public dès le push.
Récupération : filter-repo travaille sur un clone neuf ; gardez l’ancien clone jusqu’à être sûr.
Stash
git stash
git stash push -m "half-done login"
git stash -u # include untracked filesEnregistre les modifications suivies et nettoie le répertoire de travail pour pouvoir changer de branche.
git stash pop # apply and drop git stash apply stash@{1} # apply, keep the stash
Des conflits sont possibles ; avec pop, le stash est conservé si l’application échoue.
git stash list
git stash show -p stash@{0}Du plus récent au plus ancien ; stash@{0} est le dernier.
git stash push -- src/login.ts
git stash push --staged # only what is staged (2.35+)Un stash limité à des chemins laisse tout le reste en place.
git stash branch feature/login stash@{0}Crée la branche sur le commit où vous avez fait le stash, applique le stash puis le supprime ; évite les conflits.
git stash drop stash@{0}
git stash clearclear supprime tous les stashs.
Récupération : Un stash supprimé reste un commit inaccessible jusqu’au ramasse-miettes : git fsck --unreachable | grep commit, puis git stash apply <sha>.
Historique et diffs
git log --oneline --graph --all
Une ligne par commit avec la structure des branches. Ajoutez --decorate sur un Git très ancien pour voir les noms de branches.
git log --follow -p -- path/file.txt
--follow suit les renommages ; -p affiche chaque modification.
git log -S "functionName" --oneline git log -G "regex" --oneline
-S compte les changements du nombre d’occurrences ; -G compare chaque ligne modifiée à une regex.
git log --author="Ana" --since="2 weeks ago" --oneline
Aussi --until, --grep="fix" pour les messages, et main..feature pour les commits présents sur feature mais pas sur main.
git show a1b2c3d git show a1b2c3d:path/file.txt
La seconde forme affiche le fichier tel qu’il était dans ce commit sans toucher à votre copie.
git diff # unstaged git diff --staged # staged, i.e. what will be committed
--stat résume par fichier ; --word-diff convient mieux pour du texte rédigé.
git diff main...feature # changes on feature since it branched git diff main feature # the two tips directly
Trois points comparent avec la base de fusion, c’est-à-dire ce qu’affiche une pull request.
git blame -L 10,20 path/file.txt
Ajoutez -w pour ignorer les espaces et -C pour suivre les lignes déplacées depuis d’autres fichiers.
git bisect start git bisect bad # current commit is broken git bisect good v1.4.0 # this one worked # test, then mark each step good or bad git bisect reset
Recherche dichotomique : environ log2(n) étapes. git bisect run ./test.sh l’automatise.
git grep -n "TODO"
Plus rapide que grep sur les gros dépôts et ignore les fichiers ignorés. Ajoutez un commit pour chercher dans une ancienne version.
Tags et versions
git tag -a v1.2.0 -m "Release 1.2.0"
git tag -a v1.1.1 a1b2c3d -m "Hotfix" # tag an older commitLes tags annotés (-a) stockent auteur, date et message ; préférez-les pour les versions. git tag v1.2.0 seul crée un tag léger.
git tag -d v1.2.0 git push origin --delete v1.2.0
Évitez de réutiliser le nom d’un tag de version supprimé : les autres clones gardent l’ancien tag.
Récupération : Le commit tagué n’est pas affecté ; recréez le tag dessus.
Sous-modules et worktrees
git submodule add https://github.com/owner/lib.git vendor/lib git commit -m "Add lib submodule"
Enregistre l’URL dans .gitmodules et fixe un commit précis de l’autre dépôt.
git clone --recurse-submodules <url>
git submodule update --init --recursive # already clonedSans cela, les dossiers des sous-modules sont vides.
git submodule update --remote git commit -am "Bump submodules"
Récupère la branche suivie de chaque sous-module ; commitez les nouvelles références dans le dépôt parent.
git worktree add ../repo-hotfix hotfix git worktree add -b review ../repo-review origin/main
Un second dossier de travail partageant le même dépôt ; pas besoin de stash ni de second clone.
git worktree list
git worktree remove ../repo-hotfix
git worktree prune # forget folders deleted by handremove refuse si le worktree a des modifications non commitées (utilisez --force pour passer outre).
Nettoyage
git clean -n -d
Lancez toujours ceci avant git clean -f.
git clean -fd # untracked files and folders git clean -fdx # also ignored files (build output, .env!)
-x supprime aussi les fichiers ignorés, dont la configuration locale comme .env.
Récupération : Irrécupérable : ces fichiers n’ont jamais été dans Git.
git branch --merged main git branch -d branch-a branch-b
Vérifiez d’abord la liste ; -d refuse les branches non fusionnées, vous pouvez donc essayer sans risque.
git fetch --prune git config set --global fetch.prune true
Supprime les références origin/* dont les branches ont été supprimées sur le serveur.
git maintenance start git gc
maintenance start planifie en arrière-plan le prefetch, le commit-graph et le repack ; gc compacte les objets et élague immédiatement ceux qui sont inaccessibles.
Configuration et alias
git config list --show-origin
Classique : git config --list --show-origin
Affiche les valeurs système, globales et du dépôt avec le fichier où se trouve chacune.
git config set --global alias.st "status -s" git config set --global alias.lg "log --oneline --graph --all"
Classique : git config --global alias.st "status -s"
Ensuite git st et git lg. Préfixez par ! pour exécuter une commande shell : alias.root "!pwd".
git config set --global pull.rebase true git config set --global push.autoSetupRemote true git config set --global rerere.enabled true git config set --global merge.conflictStyle zdiff3 git config set --global diff.algorithm histogram
Classique : git config --global pull.rebase true
Rebase lors du pull ; branche amont automatique au premier push (2.37+) ; mémorisation des résolutions de conflits ; ancêtre commun affiché dans les conflits (2.35+) ; diffs plus clairs.
git config set --global core.excludesFile ~/.gitignore_global
Classique : git config --global core.excludesFile ~/.gitignore_global
Pour les fichiers parasites du système et de l’éditeur (.DS_Store, .idea/). Les règles propres au projet vont dans le .gitignore du dépôt.
Bases de GitHub CLI (gh)
gh est l’outil en ligne de commande de GitHub, installé séparément de Git.
gh auth login
gh auth setup-git # let git use gh for HTTPS credentialsOuvre un navigateur ou accepte un jeton ; fonctionne pour github.com et GitHub Enterprise.
gh repo create my-app --private --source=. --push
Crée le dépôt, l’ajoute comme origin et pousse la branche courante.
gh repo clone owner/repo
Pour un fork, ajoute aussi le dépôt parent comme dépôt distant upstream.
gh pr create --fill gh pr create --draft --title "WIP: login" --body "…"
--fill utilise les messages de commit pour le titre et la description.
gh pr checkout 123
Récupère la branche de la PR (forks compris) et bascule dessus.
gh pr list gh pr view 123 --web gh pr merge 123 --squash --delete-branch
gh pr status affiche les PR qui vous concernent.
gh issue create --title "Bug: …" --body "…" gh issue list --assignee @me
gh issue view 42 --comments affiche un fil de discussion dans le terminal.
gh run list gh run watch
gh run view --log-failed n’affiche que les étapes en échec.
Besoin d’un .gitignore de départ ? Utilisez le générateur de .gitignore. Vous comparez deux versions d’un fichier hors de Git ? Le comparateur de texte affiche les modifications côte à côte.
Une référence statique : la recherche s’exécute dans votre navigateur et rien de ce que vous tapez n’est envoyé nulle part. Parcourir tous les outils gratuits.
Un problème, ou quelque chose à améliorer ? Nous lisons chaque message et corrigeons vite.
Cet aide-mémoire Git est organisé par tâche et non par commande, car personne ne cherche « git reset --soft » : on cherche « annuler dernier commit ». Trouvez ce que vous essayez de faire, copiez la commande et lisez l’explication d’une ligne sur ce qu’elle modifie. La recherche classe d’abord les tâches : « supprimer branche distante » ou « renommer branche » mène directement à la bonne entrée.
Les commandes qui réécrivent l’historique ou jettent du travail sont signalées, avec une note sur ce qui peut être récupéré : presque tout ce qui a été commité un jour peut être retrouvé avec git reflog, alors que les modifications non commitées que vous supprimez avec restore, reset --hard ou clean sont perdues. Quand Git propose désormais une commande plus claire (git switch et git restore depuis la 2.23, git config set et list depuis la 2.46), elle est affichée en premier avec la forme classique à côté : l’aide-mémoire sert que votre équipe ait appris Git l’an dernier ou en 2010. Vérifié par rapport à la référence git-scm.com pour Git 2.56.
Mode d’emploi
- Tapez ce que vous voulez faire dans le champ de recherche, par exemple « annuler dernier commit », « désindexer » ou « squash commits », ou cliquez sur l’une des tâches courantes.
- Lisez les badges avant d’exécuter quoi que ce soit : orange signifie que la commande réécrit l’historique, rouge qu’elle peut supprimer du travail. La note de récupération indique comment revenir en arrière.
- Cliquez sur Copier la commande. La copie omet les commentaires # pour se coller proprement dans un terminal ; remplacez les valeurs d’exemple comme a1b2c3d ou feature/login par les vôtres.
- Partagez une réponse précise avec le lien # à côté de chaque tâche, ou imprimez tout l’aide-mémoire en PDF sur deux colonnes.
Questions fréquentes
Comment annuler le dernier commit dans Git ?
Si vous ne l’avez pas poussé, git reset --soft HEAD~1 supprime le commit et garde ses modifications indexées, et git reset HEAD~1 les garde non indexées. git reset --hard HEAD~1 supprime le commit et ses modifications. Si le commit est déjà poussé sur une branche partagée, utilisez plutôt git revert HEAD, qui ajoute un nouveau commit l’annulant sans réécrire l’historique de qui que ce soit.
Quelle est la différence entre git reset, git restore et git revert ?
git restore agit sur les fichiers : il supprime les modifications du répertoire de travail ou les retire de l’index, et ne déplace jamais une branche. git reset déplace la branche courante vers un autre commit (et avec --hard écrase aussi vos fichiers) : il réécrit donc l’historique. git revert crée un nouveau commit qui applique l’inverse d’un commit précédent ; l’historique ne fait que s’allonger, ce qui en fait le choix sûr sur les branches utilisées par d’autres.
Comment renommer une branche Git, en local et sur le dépôt distant ?
git branch -m nouveau-nom renomme la branche sur laquelle vous êtes (git branch -m ancien nouveau pour une autre). Les dépôts distants n’ont pas d’opération de renommage : poussez le nouveau nom avec git push -u origin nouveau-nom et supprimez l’ancien avec git push origin --delete ancien-nom. Sur GitHub, renommer la branche dans l’interface web redirige aussi les pull requests ouvertes.
Faut-il utiliser git switch ou git checkout ?
Les deux fonctionnent. git checkout fait deux choses sans rapport, changer de branche et restaurer des fichiers, c’est pourquoi Git 2.23 les a séparées en git switch et git restore. Les nouvelles commandes sont plus claires et plus difficiles à mal utiliser (git checkout -- fichier supprime des modifications sans prévenir) : cet aide-mémoire les affiche donc en premier. git checkout n’est pas obsolète et chaque commande indique ici son équivalent classique.
Peut-on récupérer un commit après git reset --hard ?
Le plus souvent, oui. Lancez git reflog, trouvez la ligne d’avant le reset, puis exécutez git reset --hard HEAD@{n} ou créez une branche sur ce SHA. Par défaut, les commits restent accessibles via le reflog pendant 30 jours une fois que plus rien d’autre ne pointe vers eux. Ce qui ne peut pas être récupéré, c’est le travail non commité : les modifications jamais commitées ni mises dans un stash sont écrasées pour de bon.
Que fait git push --force-with-lease ?
Il écrase la branche distante uniquement si elle pointe toujours là où votre dernier fetch l’a vue. Si quelqu’un a poussé entre-temps, le push est refusé au lieu de supprimer silencieusement ses commits, ce que fait un simple --force. Utilisez-le après un rebase ou un amend sur une branche que vous avez déjà poussée.
Quelle commande d’annulation ? Tout dépend d’où se trouve la modification
• Vous avez modifié un fichier et voulez effacer la modification : git restore fichier. Irrécupérable, car jamais commité.
• Vous avez indexé quelque chose par erreur : git restore --staged fichier. Rien n’est perdu ; la modification reste dans le fichier.
• Commité mais pas poussé : git reset --soft HEAD~1 pour refaire le commit, ou git commit --amend pour le corriger sur place.
• Commité et poussé sur une branche partagée : git revert <sha>. Ne faites pas de reset sur une branche que d’autres ont récupérée.
• Commit, branche ou résultat d’un rebase raté perdu : git reflog, puis git branch rescued <sha>.
La règle de fond : tout ce qui réécrit des commits ne pose pas de problème tant que ces commits ne sont qu’à vous, et devient le problème de tout le monde dès qu’ils sont partagés.
Merge ou rebase ?
Les deux intègrent les modifications d’une branche dans une autre. Un merge enregistre la jonction de deux historiques, avec un commit de fusion à deux parents ; rien n’est réécrit, c’est donc toujours sûr sur les branches partagées. Un rebase rejoue vos commits par-dessus l’autre branche et produit un historique linéaire, comme si vous étiez parti du dernier commit, mais il crée de nouveaux identifiants de commit : quiconque possède déjà les anciens doit se resynchroniser.
Une convention d’équipe courante : rebasez votre propre branche de fonctionnalité sur main pour rester à jour (git pull --rebase, ou git rebase main), et fusionnez la branche terminée dans main via une pull request. Le squash merge donne un commit par fonctionnalité sur main ; un merge classique conserve chaque commit et la forme de la branche. Choisissez une méthode par dépôt et configurez-la dans les réglages de l’hébergeur pour garder un historique cohérent.
Les réglages Git qui méritent d’être changés
• pull.rebase true : git pull fait un rebase au lieu de créer un commit de fusion à chaque synchronisation.
• push.autoSetupRemote true (Git 2.37+) : le premier git push d’une nouvelle branche définit sa branche amont, sans -u.
• merge.conflictStyle zdiff3 (Git 2.35+) : les marqueurs de conflit incluent l’ancêtre commun, ce qui rend la plupart des conflits évidents.
• rerere.enabled true : Git mémorise la façon dont vous avez résolu un conflit et la réapplique quand le même conflit revient pendant un rebase.
• fetch.prune true : les branches distantes supprimées sur le serveur disparaissent localement au fetch suivant.
• init.defaultBranch main : les nouveaux dépôts démarrent sur main.
Outils gratuits similaires
- Générateur de .gitignore — Combinez des modèles .gitignore de langages, frameworks, éditeurs et systèmes d’exploitation en un seul fichier propre.
- Comparateur de texte — Comparez deux versions d’un texte, d’un code ou d’un fichier JSON et voyez exactement quelles lignes, quels mots et quels caractères ont changé.
- Aide-mémoire Markdown — Chaque élément Markdown avec sa source et son rendu, la syntaxe étendue (tableaux, listes de tâches, notes de bas de page, maths, Mermaid, alertes), un tableau de compatibilité sur 9 plateformes et un bac à sable en direct.
- Aide-mémoire regex — Chaque token d’expression régulière avec un exemple fonctionnel, sa prise en charge en JavaScript, PCRE/PHP, Python, Go, Java et .NET, et un lien Essayer qui ouvre le testeur de regex prérempli.