Guide
L'aide-mémoire des commandes Git est un tableau directement utilisable : 149 commandes réparties en onze situations — initialisation et configuration, commits au quotidien, branches, fusions et rebase, retour en arrière et annulation, travail à distance, stash, étiquettes, sous-modules et worktrees, historique et dépannage, ignore et attributs. Chaque ligne donne une explication, un exemple à coller tel quel et un niveau de risque « attention / danger » : les commandes qui font perdre des modifications non validées ou réécrivent un historique déjà partagé se repèrent au premier coup d'œil.
Mis à jour le 2026-09-094 sources11 min read
L'aide-mémoire des commandes Git est un tableau directement utilisable : 149 commandes réparties en onze situations — initialisation et configuration, commits au quotidien, branches, fusions et rebase, retour en arrière et annulation, travail à distance, stash, étiquettes, sous-modules et worktrees, historique et dépannage, ignore et attributs. Chaque ligne donne une explication, un exemple à coller tel quel et un niveau de risque « attention / danger » : les commandes qui font perdre des modifications non validées ou réécrivent un historique déjà partagé se repèrent au premier coup d'œil.
Il répond à trois moments : vous savez ce que vous voulez faire mais avez oublié comment s'écrit la commande (cherchez « annuler commit », « supprimer branche distante ») ; vous connaissez la commande mais ignorez si elle peut faire perdre quelque chose (regardez le niveau de risque et les notes) ; et vous découvrez Git et voulez comprendre ce qui circule vraiment entre add, commit et push (regardez le schéma des quatre zones en haut de page et les schémas d'opérations plus bas).
En bas de page se trouve un terminal Git simulé, entièrement en mémoire : plus de 30 sous-commandes courantes, un graphe de commits qui évolue à droite en temps réel à chaque commande, et 10 niveaux d'exercice, du « premier commit » à la « résolution d'un conflit de fusion ». Ce n'est pas le vrai Git et il ne touche ni votre ordinateur ni le réseau, mais sa sémantique suit le manuel officiel : l'entraînement se transpose directement sur une machine réelle.
En saisissant « annuler commit » dans la recherche, on obtient ces lignes du groupe « retour en arrière et annulation » (extrait) :
La résolution du niveau 4, « annuler le dernier commit mais garder les modifications », dans le terminal simulé :
git reset --soft HEAD~1 annule le dernier commit, les modifications restent indexées attention
git reset HEAD~1 annule le dernier commit, les modifications reviennent non indexées dans le répertoire de travail
git reset --hard <commit> pointeur de branche, index et répertoire de travail reviennent tous à <commit> danger
git revert <commit> crée un nouveau commit qui annule les modifications, sans réécrire l'historique : push sûruser@toolun-lab:~/project (main)$ git log --oneline
7f3a1c2 (HEAD -> main) wip: commit en désordre
2b9e0d4 init: add README
user@toolun-lab:~/project (main)$ git reset --soft HEAD~1
HEAD est maintenant à 2b9e0d4 init: add README
--soft : seul le pointeur de branche bouge ; l'index et le répertoire de travail sont conservés (le contenu du commit annulé reste indexé)
Avertissement : le commit abandonné 7f3a1c2 reste récupérable avec git reflog
user@toolun-lab:~/project (main)$ git status -s
A app.js
A secret.env
✔ Niveau réussi : annuler le dernier commit, mais garder les modifications.Presque toutes les commandes Git se comprennent comme « déplacer du contenu d'une zone vers une autre ». Le répertoire de travail, ce sont les fichiers que vous voyez et pouvez modifier ; l'index (staging area) est la liste de « à quoi ressemblera le prochain commit » ; le dépôt local (.git) conserve tous les commits ; le dépôt distant est le même ensemble sur une autre machine.
Une fois ce schéma compris, beaucoup de questions « comment annuler ? » ont une réponse unique : erreur pas encore add, récupérez avec git restore <file> depuis l'index ; add fait mais commit non voulu, utilisez git restore --staged ; commit fait et à défaire, utilisez git reset ; déjà poussé, seul git revert peut ajouter un commit inverse.
Un objet commit enregistre : l'instantané de toute l'arborescence (pas un diff), l'id du commit parent, l'auteur et l'horodatage, et le message. Cet ensemble est haché en SHA-1 (SHA-256 en option sur les nouveaux dépôts) pour produire l'id du commit : la moindre modification, fût-ce une lettre du message, donne donc un id entièrement nouveau. C'est pourquoi --amend, rebase et cherry-pick « réécrivent l'historique » : ils créent de nouveaux commits et les anciens cessent simplement d'être référencés.
Une branche est un fichier de 40 caractères dans .git/refs/heads/<name>, dont le contenu est l'id d'un commit. HEAD pointe en général vers le nom d'une branche. Créer une branche est donc instantané (écrire un petit fichier) ; changer de branche consiste à faire pointer HEAD vers un autre nom et à mettre le répertoire de travail à jour avec l'instantané de ce commit ; supprimer une branche ne fait que supprimer un pointeur : les commits eux-mêmes ne disparaissent pas immédiatement.
merge consigne fidèlement ce qui s'est passé : les deux lignes se rejoignent au commit de fusion et chacun peut voir que cette fonctionnalité a été développée en parallèle. rebase donne l'impression d'un historique toujours linéaire, avec un git log plus lisible et un git bisect plus efficace, mais au prix d'un changement de tous les ids de commit. Règle empirique : rebasez librement vos branches personnelles pas encore poussées ; sur une branche que d'autres utilisent peut-être, faites seulement des merge. git pull --rebase est l'application quotidienne de cette règle : il replace vos quelques commits locaux non poussés après le dernier commit distant et évite une série de « Merge branch 'main' of … ».
--soft convient à « scinder ou regrouper des commits » : le pointeur recule, le contenu reste dans l'index. --mixed (par défaut) convient à « choisir à nouveau ce que l'on valide ». --hard abandonne vraiment : les modifications jamais validées du répertoire de travail ne peuvent plus être récupérées, alors que les commits annulés restent dans la base d'objets ; git reflog montre chaque déplacement de HEAD et git reset --hard HEAD@{1} ramène à l'état d'avant le reset. Par défaut, le reflog est conservé 90 jours (30 jours pour les entrées inaccessibles) : c'est la fenêtre de rattrapage offerte par Git.
La mention « danger » vise deux familles : les commandes qui abandonnent du contenu non validé du répertoire de travail (restore, reset --hard, clean, stash drop, checkout -- <file>) et celles qui réécrivent un historique que d'autres ont pu récupérer (push --force, branch -D sur une branche non fusionnée). « Attention » vise les commandes qui changent l'état mais restent rattrapables, ou qui exigent de vérifier d'abord leur portée (commit --amend, rebase, merge --squash, push --delete). Les commandes en lecture seule (log, diff, status, show, blame) ne portent aucune mention.
git switch / git restore exigent la version 2.23 ou supérieure, et l'ancienne écriture checkout est aussi listée.hash-object, cat-file, update-ref, etc.) et les opérations propres à une plateforme (actions web des PR GitHub ou MR GitLab) sont exclues.reset, rebase linéaire, stash, push et pull distants) ; il ne prend pas en charge le rebase interactif, bisect, les sous-modules, les hooks ni toutes les options des fichiers de configuration, et un rebase qui rencontre un conflit s'abandonne automatiquement au lieu d'attendre votre résolution..git de votre ordinateur et ne fournit pas de résolveur de conflits graphique.Cherchez « annuler » ou ouvrez le groupe « retour en arrière et annulation », distinguez d'abord « pas encore poussé » (reset / --amend) et « déjà poussé » (revert), puis choisissez la commande. Dans « combinaisons courantes » se trouvent des recettes complètes, comme « j'ai commité sur main et veux le déplacer sur une nouvelle branche ».
git rebase -i HEAD~N avec squash, fixup ou reword ; la carte rebase des schémas montre comment l'historique passe d'une bifurcation à une ligne droite et pourquoi les anciens commits deviennent gris.
Le groupe « travail à distance » va de remote add à push -u et --force-with-lease ; les niveaux 8 (pousser) et 9 (annuler un commit déjà poussé) du terminal d'entraînement couvrent les deux « je n'arrive pas à pousser » les plus fréquents.
git reflog, git fsck --lost-found et git stash list sont voisins dans « retour en arrière et annulation » ; la recette « retrouver une branche supprimée par erreur » se fait en deux étapes.
Tout dépend de savoir si le commit a été poussé. Pas poussé : reset ramène directement le pointeur en arrière et l'historique reste propre. Déjà poussé : revert ajoute un commit inverse sans réécrire l'historique que d'autres ont déjà ; sinon, leur prochain pull tombera sur une bifurcation.
Parce que vous avez des commits locaux non poussés et que le distant en a de nouveaux : le pull par défaut réunit les deux côtés par une fusion. Pour l'éviter, utilisez git pull --rebase ou réglez-le une fois pour toutes avec git config --global pull.rebase true.
--force écrase la branche distante sans condition. --force-with-lease vérifie d'abord que la branche distante est toujours au commit vu lors de votre dernier fetch et refuse si quelqu'un a poussé du nouveau : l'accident « écraser le commit d'un collègue » est bloqué. Après une réécriture d'historique, poussez toujours avec cette variante.
Dans le vrai Git, l'id résulte du hachage du contenu, de l'auteur et de l'horodatage ; le simulateur remplace le temps réel par une horloge logique et utilise un hachage déterministe : la même séquence d'opérations donne le même id, pratique pour comparer avec la solution. Ses ids ne correspondent pas à ceux du vrai Git, et c'est volontaire.
Les commandes elles-mêmes sont identiques d'une plateforme à l'autre. La différence est dans le shell : sous PowerShell, && exige la version 7.x et il est plus sûr d'entourer les chemins de guillemets ; pour les fins de ligne, suivez l'entrée core.autocrlf du groupe « initialisation et configuration ».
Toutes les données de cette page (tableau de commandes, schémas, terminal simulé) sont du contenu statique téléchargé avec la page et exécuté dans votre navigateur ; la recherche, la copie, les favoris et les exercices n'envoient aucune requête au serveur. Les favoris sont conservés dans le localStorage de la machine et le site ne peut pas les lire. Les liens externes pointent vers la documentation officielle de Git et, une fois cliqués, relèvent du site de destination.
Mis à jour le 2026-09-09
149 commandes Git classées par situation, chacune avec explication, exemple et niveau de risque, avec recherche, copie en un clic et favoris ; schémas et terminal d’entraînement inclus
Cet outil n’est pas entièrement traduit ; certains contenus utilisent la langue source ou une langue de repli.
git init git init -b main # Spécifie le nom initial de la branche
git clone https://github.com/git/git.git git clone git@github.com:user/repo.git my-dir
git clone --depth 1 --branch v2.0 https://github.com/user/repo.git
git clone -b develop https://github.com/user/repo.git
git config --global user.name "Zhang San" git config --global user.email "zs@example.com"
git config user.email "me@company.com"
git config --list --show-origin git config --get user.name
git config --global core.autocrlf input
git config --global alias.lg "log --oneline --graph --all" git lg
Windows est généralement livré avec un gestionnaire ; macOS utilise osxkeychain pour plus de sécurité.
git help rebase git reset -h # Utilisation courte
git status git status -s # Format court : M Modifier A Ajouter D Supprimer ?? Non suivi
git add src/app.js git add src/ # Répertoire entier git add "*.md" # caractère générique
git add -A git add -u # Seules les modifications et suppressions temporaires des fichiers suivis sont stockées, à l'exclusion des nouveaux fichiers.
git add -p src/app.js # y sauvegarder temporairement ce morceau n sauter s diviser en morceaux plus petits q quitter
git commit -m "fix: Corriger le jugement du délai de connexion"
git commit -am "docs: update readme"
Il est facile d’apporter des changements que vous ne souhaitez pas engager. Exécutez simplement git status avant de vous engager.
git add forgotten.js git commit --amend --no-edit #Ajouter des fichiers mais ne pas modifier la description git commit --amend -m "nouvelle description"
Générez un nouvel identifiant de commit ; ne modifiez pas les commits qui ont déjà été poussées, sinon elles doivent être poussées.
git diff git diff src/app.js # Afficher un seul fichier
git diff --staged
git diff main feature git diff HEAD~3 HEAD -- src/ git diff main...feature # Modifications des fonctionnalités par rapport au point de fourche
git diff --stat HEAD~1
git diff --word-diff=color README.md
git log git log -5 # 5 dernières entrées git log --oneline # Une ligne par ligne
git log --oneline --graph --all --decorate
git show HEAD git show a1b2c3d --stat git show HEAD:src/app.js # Afficher le contenu du fichier d'une certaine version
git rm old.txt git rm -r legacy/
git rm --cached .env echo ".env" >> .gitignore
git mv utils.js helpers.js
git branch git branch -a # inclut les branches distantes git branch -vv # Avec la dernière relation de validation et de suivi
git branch feature/login git branch hotfix a1b2c3d # Créer à partir du commit spécifié
git switch main git switch - #Revenir à la branche précédente
git switch -c feature/search git switch -c hotfix origin/main # Basé sur la branche distante
git checkout -b release/1.2
git branch -m master main git push -u origin main && git push origin --delete master
git branch -d feature/login
git branch -D experiment
Les commits uniques sur la branche deviendront orphelins et pourront être récupérés à l'aide de reflog à court terme.
git branch --merged main git branch --no-merged # à l'inverse
git branch -u origin/feature/login
git branch -a --contains a1b2c3d
git checkout v1.0 git switch -c fix-from-v1 # Si vous souhaitez conserver les modifications, créez une branche ici
Les commits dans cet état n’appartiennent à aucune branche et sont facilement perdues après avoir été coupées.
git branch --sort=-committerdate | head
git fetch -p git remote prune origin
git switch main git merge feature/login
git merge --no-ff feature/login
git merge --squash feature/login git commit -m "feat: login"
git merge --abort
git add src/app.js git commit #Description par défaut Fusionner les branches...
git checkout --theirs package-lock.json git add package-lock.json
Lors du rebase, les sens de la nôtre/la leur sont inversés : la nôtre est la branche qui est rebasée.
git switch feature git rebase main
Tous les identifiants de validation déplacés changeront ; les branches qui ont été poussées et sur lesquelles quelqu'un travaille ne doivent pas être rebasées.
git rebase -i HEAD~3 # choisir conserver reformuler modifier la description écraser fusionner avec la précédente correction fusionner et perdre la description supprimer supprimer
git add . git rebase --continue
git rebase --abort
git rebase --onto main server client
Convient à la situation où « la branche est ouverte au mauvais endroit ».
git commit --fixup a1b2c3d git rebase -i --autosquash a1b2c3d~1
git cherry-pick a1b2c3d git cerise-pick a1b2c3d..e5f6g7h # Une plage (hors a1b2c3d)
git cherry-pick -n a1b2c3d
git config --global merge.tool vscode git config --global mergetool.vscode.cmd "code --wait $MERGED" git mergetool
git restore src/app.js git restaurer . # Répertoire entier
Les modifications non planifiées seront perdues directement et ne pourront pas être récupérées à l'aide de Git.
git restore --staged src/app.js git reset HEAD src/app.js #Ancienne façon d'écrire
git restore --source HEAD~2 config.yml git restore --source v1.0 -- src/
git reset --soft HEAD~1 git commit -m "Une description plus appropriée"
git reset HEAD~1
git reset --hard HEAD~1 # Jetez le dernier commit git reset --hard origin/main # Exactement la même chose que la télécommande
Les modifications de l'espace de travail sont irréversibles ; ceux validés peuvent être récupérés en utilisant git reflog.
git reset package-lock.json
git revert HEAD git revert a1b2c3d --no-edit
git revert --no-commit HEAD~3..HEAD git commit -m "revert last 3 commits"
git revert -m 1 f00ba12
Après avoir annulé la fusion, vous devez annuler cette restauration avant de la fusionner dans la même branche.
git reflog
git reset --hard HEAD@{2} # Retour à l'état avant l'étape 2
git branch Rescue a1b2c3d # Créer une branche pour la commit orphelinegit clean -n # Aperçu de ce qui sera supprimé git clean -fd # exécuter git clean -fdx # Supprime même ceux ignorés dans .gitignore (comme node_modules)
git checkout -- src/app.js
git fsck --lost-found git show <dangling-commit-id>
git fsck --unreachable | grep commit | cut -d" " -f3 | xargs git log --merges --no-walk
git remote -v
git remote add origin git@github.com:user/repo.git
git remote set-url origin git@github.com:user/repo.git
git remote rename origin upstream
git remote remove upstream
git fetch git fetch origin main git fetch --all --prune
git pull git pull origin main
git pull --rebase origin main
git push git push origin main
git push -u origin feature/login
git push origin --delete feature/old git push origin --delete v0.1 # Vous pouvez également supprimer les balises distantes
git push --force-with-lease origin feature/login
Utilisez-le de préférence à --force.
git push -f origin feature/login
Les commits poussées par d’autres seront effacées ; les branches partagées sont interdites.
git push --all origin
git ls-remote --heads origin git ls-remote --tags https://github.com/git/git.git
git remote add upstream https://github.com/original/repo.git git fetch upstream git switch main && git merge upstream/main
git pull --ff-only
git stash git stash push -m "Page de connexion semi-finie"
git stash -u git stash -a # Collecte même les fichiers ignorés
git stash list
git stash pop
git stash pop stash@{2}git stash apply stash@{1}git stash show -p stash@{0}git stash drop stash@{0}
git stash clear # supprimer toutgit stash branch fix-from-stash stash@{0}git stash push -m "Réduire uniquement les styles" -- src/styles/
git tag git tag -l "v1.*" # Filtrer par modèle
git tag -a v1.2.0 -m "Release 1.2.0"
git tag build-2026-09-09
git tag -a v1.1.1 a1b2c3d -m "maquillage"
git show v1.2.0
git tag -d v1.2.0
git push origin --delete v1.2.0
git describe --tags --always
git submodule add https://github.com/user/lib.git vendor/lib
git submodule update --init --recursive
git clone --recurse-submodules https://github.com/user/repo.git
git submodule update --remote vendor/lib git add vendor/lib && git commit -m "bump lib"
git submodule status
git submodule deinit -f vendor/lib git rm -f vendor/lib rm -rf .git/modules/vendor/lib
git worktree add ../repo-hotfix hotfix/1.2.1 git worktree add -b review ../repo-review origin/pr-42
git worktree list
git worktree remove ../repo-hotfix git worktree prune # Nettoyer l'enregistrement des répertoires supprimés manuellement
git clone --filter=blob:none --sparse <url> cd repo && git sparse-checkout set apps/web packages/ui
git log -p -- src/app.js git log --follow -- src/app.js # Suivi des renommages croisés
git log --grep="connexion" -i --oneline
git log -S"validateToken" --oneline git log -G"regex" --oneline # Version régulière
git log main..feature --oneline git log origin/main..HEAD # Commits qui n'ont pas encore été poussés
git log --pretty=format:"%h %ad %an %s" --date=short -10
git log --since="2026-09-01" --until="2026-09-09" --oneline
git shortlog -sn --all --no-merges
git blame -L 40,60 src/app.js git blâme -w -C src/app.js # Ignorer les espaces, suivre les mouvements
git bisect start git bisect bad # Actuellement mauvais git bisect good v1.1.0 # Cette version est bonne # Testez à plusieurs reprises et exécutez git bisect good/bad git bisect reset
git bisect run npm test
git grep -n "TODO" -- "*.ts" git grep "foo" v1.0 # Rechercher dans une certaine version
git show HEAD~5:src/config.js > old-config.js
git diff --name-only HEAD~3 HEAD git diff --name-status main # avec statut M/A/D
git count-objects -vH
git gc --aggressive --prune=now
prune supprimera en fait les objets inaccessibles et le médicament contre les regrets dans le reflog disparaîtra ensemble.
git rev-parse --short HEAD git rev-parse --abbrev-ref HEAD git rev-parse --show-toplevel # Répertoire racine de l'dépôt
git archive -o release.zip v1.2.0 git archive HEAD src/ | tar -x -C /tmp/out
# .gitignore node_modules/ dist/ *.log .env* !.env.example
git check-ignore -v dist/app.js
git rm -r --cached . git add . git commit -m "chore: apply .gitignore"
echo ".DS_Store" >> ~/.gitignore_global git config --global core.excludesFile ~/.gitignore_global
git update-index --skip-worktree config/local.php git update-index --no-skip-worktree config/local.php # Annuler
* text=auto *.sh text eol=lf *.png binary *.psd filter=lfs diff=lfs merge=lfs -text
git lfs install git lfs track "*.psd" git add .gitattributes
Enchaînez quelques commandes dans une recette « faire une chose » ; dépliez-la pour copier l’ensemble.
La commit a été trop tôt / la description a été mal rédigée / Je souhaite la diviser en deux commits (et elle n'a pas encore été poussée)
git reset --soft HEAD~1Soumettre et retirer, les changements sont toujours dans la zone de préparationgit statusConfirmez que les fichiers sont tous dans « Modifications à soumettre »git commit -m "nouvelle description"D’autres l’ont peut-être déjà pris, l’histoire ne peut pas être réécrite.
git revert <commit>Générer un commit inverségit pushL'expérience locale est ratée et je veux revenir complètement à un certain engagement
git log --onelineTrouver l'ID de commit ciblegit stash -u(Facultatif) Réduisez d'abord les modifications que vous souhaitez conservergit reset --hard <commit>J'ai oublié d'ouvrir une branche et je l'ai soumise N fois.
git branch feature/xCréer une branche à l'emplacement actuel ("enregistrer" ces commits)git reset --hard origin/mainle principal retourne dans un état éloignégit switch feature/xOrganiser l'historique avant d'ouvrir un PR (la branche n'est pas utilisée par d'autres)
git rebase -i HEAD~4Remplacez le choix dans les lignes suivantes par squash ou fixupgit push --force-with-leaseObligatoire uniquement si la branche a été pousséemain a un nouveau commit, et la branche de fonctionnalités doit continuer par-dessus
git fetch origingit switch feature/xgit rebase origin/mainou git merge origin/main (conserver les commits de fusion)Unifier le nom de la branche par défaut
git branch -m master maingit push -u origin maingit push origin --delete masterTout d’abord, coupez la branche par défaut en main sur la plateforme d’hébergementJe l'ai trouvé utile après git branch -D
git reflogRechercher l'identifiant du dernier commit de la branche (tel que "commit: xxx")git branch <name> <commit-id>.env ou des centaines de Mo de fichiers entrés dans l'historique
git rm --cached .env && echo ".env" >> .gitignoreSi seul le dernier commit est effectué : alors git commit --amendgit filter-repo --path .env --invert-pathsDéjà profondément ancré dans l'histoire : réécrivez tout l'historique avec git-filter-repo (doit être installé séparément)git push --force-with-lease --allTous les collaborateurs doivent être reclonés ; les clés divulguées doivent être invalidées et rééditées de toute façonLes bugs corrigés sur main seront également déplacés vers la version/1.2
git switch release/1.2git cherry-pick <commit>git pushgit merge / pull report CONFLIT
git statusVoir quels documents ont été « modifiés par les deux parties »code <file>Traiter les balises <<<<<<< ======= >>>>>>> dans l'éditeur, en conservant le contenu correctgit add <file>Ajoutez-en un après que chacun soit corrigégit commitLors du rebase, git rebase --continueJ'ai d'abord écrit le code localement, puis j'ai construit un dépôt sur GitHub.
git init -b main && git add -A && git commit -m "init"git remote add origin git@github.com:user/repo.gitgit push -u origin mainLes points sont des commits et les flèches pointent vers le commit parent ; une étiquette verte indique une branche, une violette la branche où se trouve HEAD ; un point gris n’est plus référencé par aucune branche (récupérable via le reflog) et un point plein est un commit créé par l’opération en cours.
git add . && git commit -m "…"Chaque commit retient son commit parent ; une branche n’est qu’un pointeur mobile vers un commit, donc après un commit, main et HEAD avancent ensemble.
git switch -c featureLa nouvelle branche et main pointent vers le même commit, donc la création est instantanée ; ensuite, les commits sur feature ne font avancer que feature.
git switch main && git merge featureAucun nouveau commit n’est créé et l’historique reste une ligne droite. Pour garder la trace qu’une branche a existé, utilisez --no-ff.
git merge featureGit trouve l’ancêtre commun b2, combine les modifications de chaque côté par rapport à b2 et crée m6 avec deux commits parents. Un conflit n’apparaît que si la même zone a été modifiée différemment.
git switch feature && git rebase mainL’historique devient une ligne droite, mais c3 et d4 sont remplacés par de nouveaux commits c3′ et d4′ (les id changent). Ne faites pas de rebase sur une branche déjà poussée, sinon l’historique des autres divergera du vôtre.
git reset --hard HEAD~1--soft ne déplace que le pointeur ; --mixed vide en plus la zone de préparation ; --hard rétablit aussi l’arbre de travail. Le commit orphelin c3 reste récupérable via le reflog (conservé au moins 30 jours par défaut).
git revert HEADc3 reste dans l’historique et le nouveau commit r4 contient l’inverse des modifications de c3. Pour annuler un commit déjà poussé, utilisez revert plutôt que reset.
git cherry-pick x7Rejoue sur main les modifications que x7 a introduites par rapport à son parent, ce qui donne x7′ au contenu identique mais à l’id différent. Idéal pour porter un correctif isolé vers une branche de publication.
Un simulateur Git entièrement en mémoire (pas le vrai Git, aucune connexion réseau) : il prend en charge les sous-commandes courantes init / add / commit / branch / switch / merge / rebase / reset / revert / stash / tag / remote / push / pull, et le graphe à droite se met à jour en temps réel. 10 niveaux, de la première validation à la résolution d’un conflit de fusion. Pour les commandes Linux, l’entraînement se trouve dansAide-mémoire des commandes Linux.