Parcourir les aide-mémoire · Git

Technologie: GitCatégorie: Gestion de versionsNiveau: DébutantMis à jour

Commandes Git du quotidien

Utilisez les commandes Git dont les ingénieurs ont le plus souvent besoin pour inspecter les modifications, créer des commits, synchroniser les branches, consulter l’historique et réparer les erreurs locales courantes.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Vérifier l’état actuel du dépôt
  5. 2. Afficher un état compact
  6. 3. Voir les modifications non indexées
  7. 4. Voir les modifications indexées
  8. 5. Afficher à la fois le contexte indexé et non indexé
  9. 6. Créer une nouvelle branche et basculer dessus
  10. 7. Basculer sur une branche existante
  11. 8. Lister les branches locales
  12. 9. Renommer la branche courante
  13. 10. Indexer un fichier
  14. 11. Indexer plusieurs fichiers connus
  15. 12. Indexer toutes les modifications en cours
  16. 13. Indexer de façon interactive
  17. 14. Retirer un fichier de l’index sans abandonner ses modifications
  18. 15. Faire un commit des modifications indexées
  19. 16. Inspecter le commit avant de faire un push
  20. 17. Modifier le dernier commit local avec amend
  21. 18. Récupérer les mises à jour distantes sans modifier vos fichiers
  22. 19. Inspecter ce qui a changé sur la branche main distante
  23. 20. Mettre à jour votre branche main locale
  24. 21. Faire un rebase d’une branche de fonctionnalité sur main à jour
  25. 22. Faire un merge de main dans la branche de fonctionnalité
  26. 23. Faire un push d’une nouvelle branche
  27. 24. Faire un push des commits suivants
  28. 25. Préférer force-with-lease à force
  29. 26. Ne jamais faire de push forcé à la légère sur des branches partagées et protégées
  30. 27. Consulter l’historique récent
  31. 28. Afficher les commits d’un fichier
  32. 29. Voir qui a modifié des lignes précises
  33. 30. Comparer votre branche avec main
  34. 31. Comparer deux commits
  35. 32. Restaurer un fichier non indexé à sa dernière version commitée
  36. 33. Restaurer un fichier depuis un autre commit
  37. 34. Annuler un commit partagé en toute sécurité avec revert
  38. 35. Ne pas confondre revert et reset
  39. 36. Reculer HEAD en gardant les modifications indexées
  40. 37. Reculer HEAD en gardant les modifications non indexées
  41. 38. Éviter reset --hard sauf si vous êtes certain
  42. 39. Mettre temporairement de côté les modifications locales avec stash
  43. 40. Faire un stash des fichiers suivis et non suivis
  44. 41. Lister les stashs
  45. 42. Inspecter un stash avant de l’appliquer
  46. 43. Appliquer un stash sans le supprimer
  47. 44. Appliquer et supprimer un stash
  48. 45. Supprimer un stash de façon délibérée
  49. 46. Supprimer une branche locale déjà fusionnée
  50. 47. Forcer la suppression d’une branche locale uniquement de façon délibérée
  51. 48. Supprimer une branche distante
  52. 49. Voir les dépôts distants configurés
  53. 50. Inspecter le suivi de la branche amont
  54. 51. Définir manuellement une branche amont
  55. 52. Afficher la racine du dépôt
  56. 53. Afficher le nom de la branche courante
  57. 54. Afficher le commit courant
  58. 55. Vérifier que l’arbre de travail est propre dans une automatisation
  59. 56. Lancer un fetch en élaguant les branches distantes supprimées
  60. 57. Voir les commits propres à votre branche
  61. 58. Voir les fichiers modifiés par rapport à main
  62. 59. Rechercher dans les messages de commit
  63. 60. Trouver les commits qui ont modifié une chaîne
  64. 61. Trouver les commits dont le patch correspond à un motif
  65. 62. Afficher un commit
  66. 63. Faire un cherry-pick d’un commit connu
  67. 64. Interrompre un cherry-pick en conflit
  68. 65. Interrompre un rebase
  69. 66. Poursuivre un rebase après avoir résolu les conflits
  70. 67. Interrompre un merge
  71. 68. Inspecter les marqueurs de conflit
  72. 69. Utiliser reflog pour récupérer l’historique local
  73. 70. Créer une branche de sécurité avant des modifications risquées de l’historique local
  74. Interpréter le résultat
  75. Points à vérifier
  76. git status affiche des modifications indexées et non indexées pour le même fichier
  77. Le push est rejeté
  78. Le commit contient des fichiers sans rapport
  79. Le merge ou le rebase a créé des conflits
  80. Vous avez perdu un commit local après un reset ou un rebase
  81. La branche de fonctionnalité contient des commits inattendus
  82. Notes de production
  83. L’historique partagé doit être considéré comme immuable par défaut
  84. --force-with-lease est plus sûr, pas sans risque
  85. Git ne protège pas automatiquement le travail non commité contre toutes les commandes
  86. Un arbre de travail propre simplifie les opérations risquées
  87. Des commits petits et ciblés facilitent la récupération
  88. L’historique Git fait partie de l’ingénierie de production
  89. Erreurs fréquentes
  90. 1. Lancer git add . sans vérifier l’état
  91. 2. Faire un commit sans relire git diff --cached
  92. 3. Utiliser git pull sans comprendre la stratégie configurée
  93. 4. Utiliser git push --force
  94. 5. Utiliser git reset --hard comme nettoyage général
  95. 6. Modifier avec amend des commits déjà partagés avec l’équipe
  96. 7. Supprimer une branche sans vérifier ses commits propres
  97. 8. Considérer git stash comme un stockage permanent
  98. 9. Utiliser git blame pour désigner un coupable
  99. 10. Supposer qu’un push rejeté impose un push forcé
  100. Étape suivante
  101. Pour aller plus loin

Problème

Vous utilisez Git tous les jours, mais vous ne voulez ni mémoriser chaque commande ni risquer d’en lancer une destructrice au mauvais moment.

La plupart des workflows d’ingénierie ont régulièrement besoin de :

  • inspecter ce qui a changé
  • créer une branche ou changer de branche
  • indexer des fichiers choisis
  • faire un commit de son travail
  • se mettre à jour depuis le dépôt distant
  • faire un push d’une branche
  • comparer des modifications
  • inspecter l’historique
  • abandonner ou restaurer des modifications locales en toute sécurité
  • réparer une petite erreur locale

L’objectif est d’utiliser un petit ensemble de commandes fiables en comprenant clairement ce que chacune modifie.

Réponse rapide

Pour une branche de fonctionnalité classique :

git status
git switch -c feature/my-change
git add path/to/file
git diff --cached
git commit -m "Describe the change"
git fetch origin
git rebase origin/main
git push -u origin feature/my-change

Avant toute commande qui modifie l’historique ou supprime du travail, lancez :

git status
git diff
git log --oneline --decorate -10

L’habitude la plus sûre est :

inspecter
→ indexer de façon délibérée
→ relire le diff indexé
→ commit
→ synchroniser
→ push

Code / commandes

1. Vérifier l’état actuel du dépôt

git status

Commencez par cette commande.

Elle affiche :

  • la branche courante
  • les fichiers indexés
  • les fichiers modifiés
  • les fichiers non suivis
  • si la branche est en avance ou en retard sur sa branche amont (upstream)

Avant un reset, un restore, un rebase ou un changement de branche, vérifiez git status.


2. Afficher un état compact

git status --short

Sortie typique :

 M src/app.py
M  README.md
?? notes.txt

Interprétation :

colonne de gauche = état dans l’index
colonne de droite = état dans l’arbre de travail
??                = non suivi

Un fichier peut avoir à la fois des modifications indexées et non indexées.


3. Voir les modifications non indexées

git diff

Cette commande compare :

l’arbre de travail
avec
l’index (zone de préparation)

Utilisez-la avant d’indexer.


4. Voir les modifications indexées

git diff --cached

Équivalent :

git diff --staged

Cette commande compare :

la zone de préparation
avec
HEAD

Lancez-la avant de faire un commit.

Elle répond à la question :

Que contiendra exactement ce commit ?

5. Afficher à la fois le contexte indexé et non indexé

git diff
git diff --cached

Rien ne remplace la compréhension de ces deux états.

Une erreur fréquente consiste à ne relire que le diff de l’arbre de travail en oubliant les modifications déjà indexées.


6. Créer une nouvelle branche et basculer dessus

git switch -c feature/report-engine

Cette commande crée :

feature/report-engine

à partir du commit courant et bascule dessus.

Avec les versions récentes de Git, préférez git switch pour changer de branche.


7. Basculer sur une branche existante

git switch main

Ancien équivalent :

git checkout main

checkout fonctionne toujours, mais switch rend l’intention de changer de branche plus claire.


8. Lister les branches locales

git branch

Afficher les branches locales et les branches de suivi distantes :

git branch -a

Afficher les informations de suivi :

git branch -vv

9. Renommer la branche courante

git branch -m new-branch-name

Si l’ancienne branche a déjà fait l’objet d’un push, renommer la branche locale ne renomme pas automatiquement la branche distante.

Gérez le nettoyage côté distant séparément et de façon délibérée.


10. Indexer un fichier

git add src/app.py

Utilisez cette commande lorsque vous voulez que le périmètre du commit reste explicite.


11. Indexer plusieurs fichiers connus

git add src/app.py src/config.py README.md

C’est plus sûr que de tout indexer lorsque le dépôt contient du travail sans rapport.


12. Indexer toutes les modifications en cours

git add -A

Cette commande indexe :

  • les nouveaux fichiers
  • les fichiers modifiés
  • les suppressions

Ne l’utilisez qu’après avoir vérifié :

git status

et contrôlé que chaque modification a sa place dans le même commit.


13. Indexer de façon interactive

git add -p

Utilisez cette commande lorsqu’un même fichier contient des modifications destinées à plusieurs commits logiques.

Git vous permet d’indexer les blocs de modifications (hunks) de façon sélective.

C’est l’une des commandes les plus utiles pour garder des commits ciblés.


14. Retirer un fichier de l’index sans abandonner ses modifications

git restore --staged src/app.py

Cette commande sort le fichier de la zone de préparation.

Vos modifications dans l’arbre de travail sont conservées.

Utilisez-la si vous avez indexé le mauvais fichier.


15. Faire un commit des modifications indexées

git commit -m "Add pipeline retry handling"

Les messages de commit doivent décrire la modification, pas l’action d’éditer.

Préférez :

Add pipeline retry handling

à :

Changes

16. Inspecter le commit avant de faire un push

git show --stat

Afficher le patch complet :

git show

Par défaut, cette commande affiche le commit HEAD courant.


17. Modifier le dernier commit local avec amend

Si vous avez oublié d’indexer un fichier :

git add src/config.py
git commit --amend --no-edit

Ou pour changer le message :

git commit --amend

Utilisez amend librement pour un commit qui n’a pas encore été partagé.

Si le commit se trouve déjà sur une branche partagée, amend réécrit l’historique et peut nécessiter un push forcé.


18. Récupérer les mises à jour distantes sans modifier vos fichiers

git fetch origin

Cette commande met à jour les références de suivi distantes, par exemple :

origin/main
origin/develop

Elle ne fait ni merge ni rebase de votre branche courante.

C’est ce qui fait de fetch une première étape sûre avant de décider comment synchroniser.


19. Inspecter ce qui a changé sur la branche main distante

git log --oneline HEAD..origin/main

Cette commande affiche les commits présents sur origin/main qui ne sont pas dans votre branche courante.

Pour voir les commits de votre branche absents de origin/main :

git log --oneline origin/main..HEAD

20. Mettre à jour votre branche main locale

git switch main
git pull --ff-only

--ff-only refuse de créer un commit de merge inattendu.

Si main en local a divergé, Git s’arrête et vous laisse enquêter au lieu de faire un merge automatique.


21. Faire un rebase d’une branche de fonctionnalité sur main à jour

git fetch origin
git rebase origin/main

Utilisez cette approche lorsque votre équipe préfère un historique linéaire pour les branches de fonctionnalité.

Sur le principe :

vos commits
→ rejoués au-dessus du dernier origin/main

Ne faites pas de rebase à la légère sur des commits sur lesquels d’autres personnes travaillent déjà.


22. Faire un merge de main dans la branche de fonctionnalité

Alternative au rebase :

git fetch origin
git merge origin/main

Utilisez cette approche lorsqu’un historique basé sur des merges est préféré ou lorsqu’il n’est pas souhaitable de réécrire l’historique de la branche.

Le choix entre merge et rebase relève du workflow de l’équipe.


23. Faire un push d’une nouvelle branche

git push -u origin feature/report-engine

-u définit la branche amont (upstream).

Ensuite, en général :

git push

suffit.


24. Faire un push des commits suivants

git push

Si Git indique que le dépôt distant contient du travail que vous n’avez pas, ne faites pas immédiatement un push forcé.

Lancez un fetch et inspectez la divergence.


25. Préférer force-with-lease à force

Si vous avez volontairement fait un rebase de votre propre branche de fonctionnalité distante :

git push --force-with-lease

Préférez cette commande à :

git push --force

--force-with-lease refuse d’écraser la branche distante si elle a changé d’une manière que votre dépôt local n’attend pas.

Utilisez-la tout de même avec prudence.


26. Ne jamais faire de push forcé à la légère sur des branches partagées et protégées

Évitez de réécrire :

main
master
develop
les branches de release
les branches partagées de l’équipe

sauf si le workflow de votre dépôt l’exige explicitement.

La réécriture de l’historique sur des branches partagées peut perturber les autres développeurs et la CI/CD.


27. Consulter l’historique récent

git log --oneline -10

Avec la décoration des branches et des tags :

git log --oneline --decorate -10

Avec le graphe :

git log --oneline --graph --decorate --all -20

C’est utile pour comprendre les relations entre les branches.


28. Afficher les commits d’un fichier

git log --oneline -- src/app.py

Afficher les patchs :

git log -p -- src/app.py

Utilisez cette commande pour savoir quand et pourquoi un fichier a changé.


29. Voir qui a modifié des lignes précises

git blame src/app.py

Utilisez blame comme outil de navigation pour retrouver le commit pertinent.

Ne le considérez pas comme la preuve de qui a « causé » un bug actuel ; la ligne a pu être déplacée ou héritée d’une logique plus ancienne.


30. Comparer votre branche avec main

git diff origin/main...HEAD

La comparaison à trois points est utile pour relire les modifications introduites par votre branche depuis la base de merge avec origin/main.

Cela correspond de près à l’ensemble des modifications généralement relu dans une pull request.


31. Comparer deux commits

git diff <commit-a> <commit-b>

Exemple :

git diff a1b2c3d e4f5a6b

Ajoutez :

--stat

pour obtenir un résumé :

git diff --stat a1b2c3d e4f5a6b

32. Restaurer un fichier non indexé à sa dernière version commitée

git restore src/app.py

Avertissement :

Cette commande abandonne les modifications non indexées de ce fichier.

Lancez :

git diff src/app.py

d’abord en cas de doute.


33. Restaurer un fichier depuis un autre commit

git restore \
  --source=<commit> \
  -- path/to/file

Exemple :

git restore \
  --source=HEAD~1 \
  -- src/app.py

Cette commande place cette version dans votre arbre de travail.

Elle ne crée pas de commit automatiquement.


34. Annuler un commit partagé en toute sécurité avec revert

git revert <commit>

Cette commande crée un nouveau commit qui inverse le commit sélectionné.

Utilisez-la pour un historique déjà partagé, car elle préserve le graphe de commits existant.

Exemple :

git revert a1b2c3d

35. Ne pas confondre revert et reset

git revert
→ crée un nouveau commit inverse

git reset
→ déplace une référence de branche et peut modifier l’état de l’index ou de l’arbre de travail

Pour un historique public ou partagé, revert est généralement plus sûr.


36. Reculer HEAD en gardant les modifications indexées

git reset --soft HEAD~1

Cette commande retire le dernier commit local tout en laissant ses modifications indexées.

Utilisez-la pour nettoyer l’historique local avant de le partager.


37. Reculer HEAD en gardant les modifications non indexées

git reset HEAD~1

Mode par défaut équivalent :

--mixed

Le commit est retiré localement, mais les modifications des fichiers restent dans l’arbre de travail.


38. Éviter reset --hard sauf si vous êtes certain

git reset --hard HEAD

Cette commande abandonne les modifications suivies de l’arbre de travail et de l’index.

Elle peut détruire du travail non commité.

Ne l’utilisez pas comme commande de nettoyage courante.

Inspectez d’abord :

git status
git diff
git diff --cached

39. Mettre temporairement de côté les modifications locales avec stash

git stash push -m "WIP report changes"

Utilisez cette commande lorsque vous avez temporairement besoin d’un arbre de travail propre.


40. Faire un stash des fichiers suivis et non suivis

git stash push -u -m "WIP"

-u inclut les fichiers non suivis.

Les fichiers ignorés restent exclus.


41. Lister les stashs

git stash list

Exemple :

stash@{0}: On feature/report-engine: WIP

42. Inspecter un stash avant de l’appliquer

git stash show -p stash@{0}

Utile lorsque vous avez plusieurs stashs et ne vous souvenez plus de leur contenu.


43. Appliquer un stash sans le supprimer

git stash apply stash@{0}

Utilisez cette commande lorsque vous voulez conserver le stash comme sauvegarde jusqu’à ce que vous ayez validé le résultat.


44. Appliquer et supprimer un stash

git stash pop

Cette commande applique le stash le plus récent et le supprime si l’application réussit sans conflit.

Pour un travail précieux, utiliser apply d’abord peut être plus sûr.


45. Supprimer un stash de façon délibérée

git stash drop stash@{0}

Ne lancez pas :

git stash clear

sauf si vous voulez volontairement supprimer tous les stashs.


46. Supprimer une branche locale déjà fusionnée

Après avoir confirmé qu’elle a été fusionnée :

git branch -d feature/report-engine

-d refuse la suppression si Git ne considère pas la branche comme entièrement fusionnée.

C’est plus sûr que -D.


47. Forcer la suppression d’une branche locale uniquement de façon délibérée

git branch -D feature/report-engine

Cette commande supprime la branche locale même si elle contient des commits qui n’ont été fusionnés nulle part ailleurs.

Vérifiez d’abord :

git log main..feature/report-engine

48. Supprimer une branche distante

git push origin --delete feature/report-engine

Faites-le une fois la branche fusionnée ou devenue inutile.

La suppression côté distant affecte les autres collaborateurs ; confirmez donc d’abord à qui appartient la branche et le workflow en place.


49. Voir les dépôts distants configurés

git remote -v

Utile avant un push si plusieurs dépôts distants existent.


50. Inspecter le suivi de la branche amont

git branch -vv

Cette commande indique si une branche locale suit :

origin/main
origin/feature/...

et si elle est en avance ou en retard.


51. Définir manuellement une branche amont

git branch \
  --set-upstream-to=origin/main \
  main

En général, git push -u la définit automatiquement pour les branches de fonctionnalité.


52. Afficher la racine du dépôt

git rev-parse --show-toplevel

Utile lorsque vous travaillez dans des répertoires imbriqués et ne savez pas avec certitude dans quel dépôt vous êtes.


53. Afficher le nom de la branche courante

git branch --show-current

Utile dans les scripts et pour des vérifications rapides.


54. Afficher le commit courant

git rev-parse HEAD

Version courte :

git rev-parse --short HEAD

Utile pour les journaux de déploiement et les métadonnées de build.


55. Vérifier que l’arbre de travail est propre dans une automatisation

git status --porcelain

L’absence de sortie signifie qu’il n’y a aucune modification suivie ou non suivie que Git signalerait normalement.

Utile dans les scripts, car le format de sortie est stable pour une analyse automatique.


56. Lancer un fetch en élaguant les branches distantes supprimées

git fetch --prune

Cette commande supprime les références de suivi distantes obsolètes, par exemple :

origin/feature/old-branch

lorsque la branche a été supprimée sur le dépôt distant.

Elle ne supprime pas les branches locales.


57. Voir les commits propres à votre branche

git log --oneline origin/main..HEAD

Utilisez cette commande avant d’ouvrir une pull request pour confirmer ce que votre branche apporte.


58. Voir les fichiers modifiés par rapport à main

git diff --name-status origin/main...HEAD

Exemple de sortie :

M  src/app.py
A  src/new_module.py
D  src/old_module.py

Utile pour un contrôle rapide du périmètre.


59. Rechercher dans les messages de commit

git log \
  --oneline \
  --grep="pipeline"

Utile pour retrouver une ancienne modification par thème.


60. Trouver les commits qui ont modifié une chaîne

git log \
  -S "old_function_name" \
  --oneline

Utilisez -S lorsque vous cherchez les commits qui ont modifié le nombre d’occurrences d’une chaîne précise.

C’est utile pour le débogage historique.


61. Trouver les commits dont le patch correspond à un motif

git log \
  -G "retry.*count" \
  --oneline

-G recherche une expression régulière dans le diff.

Utilisez cette option pour enquêter sur l’historique du code.


62. Afficher un commit

git show <commit>

Résumé uniquement :

git show --stat <commit>

Utilisez cette commande avant de faire un revert ou un cherry-pick d’un commit.


63. Faire un cherry-pick d’un commit connu

git cherry-pick <commit>

Utilisez cette commande lorsqu’un commit précis doit être appliqué sur une autre branche.

Avant un cherry-pick, confirmez que le commit est autonome.

Un cherry-pick peut provoquer des conflits ou entraîner des dépendances cachées envers les commits voisins.


64. Interrompre un cherry-pick en conflit

git cherry-pick --abort

Utilisez cette commande si l’opération doit être abandonnée et que vous voulez revenir à l’état antérieur au cherry-pick.


65. Interrompre un rebase

git rebase --abort

Utilisez cette commande lorsqu’un rebase devient risqué ou que vous vous rendez compte que vous êtes parti du mauvais état.


66. Poursuivre un rebase après avoir résolu les conflits

Après avoir modifié les fichiers en conflit :

git add path/to/resolved-file
git rebase --continue

Répétez jusqu’à la fin.

Ne faites pas de commit manuel des résolutions de conflits pendant un rebase normal, sauf si le workflow le demande explicitement.


67. Interrompre un merge

Si un merge est en cours et doit être abandonné :

git merge --abort

Utilisez cette commande au lieu d’essayer de réinitialiser manuellement les fichiers pendant un merge actif.


68. Inspecter les marqueurs de conflit

Un fichier en conflit peut contenir :

<<<<<<< HEAD
votre version
=======
version entrante
>>>>>>> branch-name

Résolvez le code réellement voulu, supprimez les marqueurs, puis indexez le fichier :

git add path/to/file

Ne choisissez pas aveuglément « ours » ou « theirs » sans comprendre la modification.


69. Utiliser reflog pour récupérer l’historique local

git reflog

Cette commande affiche les déplacements récents de HEAD et des références de branche dans le dépôt local.

Elle est souvent utile après :

  • un reset accidentel
  • un rebase
  • la suppression d’une branche
  • une erreur de checkout ou de switch

Exemple de démarche de récupération :

git reflog
git show <old-commit>

Créez ensuite une branche de récupération :

git switch -c recovery <old-commit>

70. Créer une branche de sécurité avant des modifications risquées de l’historique local

Avant un rebase ou un reset compliqué :

git branch backup-before-rewrite

Poursuivez ensuite.

C’est une assurance peu coûteuse lorsque vous manipulez un historique local non publié.

Interpréter le résultat

Commande Modifie les fichiers ou l’historique ? Usage typique
git status Non Inspecter l’état
git diff Non Relire les modifications non indexées
git diff --cached Non Relire les modifications indexées
git add Zone de préparation Choisir le contenu du commit
git commit Historique Créer un commit
git fetch Références distantes Inspecter les mises à jour distantes en toute sécurité
git pull --ff-only Branche/fichiers Avancer la branche locale uniquement en fast-forward
git rebase Historique Rejouer les commits locaux
git merge Historique Combiner des historiques
git restore Arbre de travail/index Restaurer le contenu ou l’état d’un fichier
git revert Historique Inverser en toute sécurité un commit partagé
git reset Branche/index/fichiers selon le mode Réécrire l’état ou l’historique local
git stash Stash + arbre de travail Mettre temporairement du travail de côté
git reflog Non Retrouver l’historique local des références

La distinction importante est la suivante :

commandes d’inspection
→ risque faible

commandes sur l’arbre de travail/l’index
→ peuvent modifier l’état non commité

commandes de réécriture de l’historique
→ exigent de savoir si les commits sont déjà partagés

Points à vérifier

git status affiche des modifications indexées et non indexées pour le même fichier

Vous avez indexé une version, puis modifié de nouveau le fichier.

Vérifiez les deux :

git diff --cached
git diff

avant de faire un commit.

Le push est rejeté

La branche distante contient du travail que vous n’avez pas.

Lancez :

git fetch origin

puis inspectez :

git log --oneline --graph --decorate HEAD origin/<branch>

Ne passez pas directement au push forcé.

Le commit contient des fichiers sans rapport

Utilisez :

git restore --staged <file>

et refaites un commit avec uniquement le périmètre voulu.

Le merge ou le rebase a créé des conflits

Déterminez si les deux branches ont modifié le même code logique.

Résolvez en fonction du comportement voulu, et non en choisissant mécaniquement un côté.

Vous avez perdu un commit local après un reset ou un rebase

Vérifiez :

git reflog

avant de considérer qu’il a disparu.

La branche de fonctionnalité contient des commits inattendus

Comparez-la avec main :

git log --oneline origin/main..HEAD

et inspectez le graphe.

Notes de production

L’historique partagé doit être considéré comme immuable par défaut

Une fois que les commits ont fait l’objet d’un push et sont utilisés par d’autres, préférez :

git revert

à la réécriture de l’historique.

Les branches de fonctionnalité appartenant à un seul développeur se prêtent généralement mieux aux workflows de rebase et d’amend.

--force-with-lease est plus sûr, pas sans risque

Il vous protège contre l’écrasement de mises à jour distantes que vous n’avez pas vues.

Il réécrit tout de même volontairement l’historique distant.

Git ne protège pas automatiquement le travail non commité contre toutes les commandes

Des commandes comme :

git restore
git reset --hard

peuvent abandonner des modifications locales.

Inspectez d’abord.

Un arbre de travail propre simplifie les opérations risquées

Avant un rebase, un merge ou une intervention délicate sur les branches :

git status

Faites un commit ou un stash du travail sans rapport.

Des commits petits et ciblés facilitent la récupération

Des commits ciblés facilitent :

  • la revue
  • le revert
  • le cherry-pick
  • le bisect
  • la compréhension de l’historique

Ne mélangez pas des refactorisations sans rapport et des changements de comportement, sauf si vous avez une bonne raison.

L’historique Git fait partie de l’ingénierie de production

Les identifiants de commit apparaissent souvent dans :

  • les déploiements
  • la CI/CD
  • les chronologies d’incident
  • les notes de version
  • les retours arrière

Faites des commits explicites et évitez de réécrire inutilement l’historique partagé.

Erreurs fréquentes

1. Lancer git add . sans vérifier l’état

Vous risquez d’indexer des fichiers sans rapport, des fichiers générés ou des secrets.

2. Faire un commit sans relire git diff --cached

Le commit peut contenir plus ou moins que prévu.

3. Utiliser git pull sans comprendre la stratégie configurée

Selon la configuration, pull peut faire un merge ou un rebase.

Pour les branches main locales protégées, git pull --ff-only est souvent plus prévisible.

4. Utiliser git push --force

Préférez --force-with-lease lorsque la réécriture de votre propre branche distante est réellement nécessaire.

5. Utiliser git reset --hard comme nettoyage général

Cette commande peut abandonner définitivement des modifications suivies non commitées.

6. Modifier avec amend des commits déjà partagés avec l’équipe

Cela change les identifiants de commit et peut perturber les branches de vos collègues.

7. Supprimer une branche sans vérifier ses commits propres

Inspectez :

git log main..branch-name

d’abord.

8. Considérer git stash comme un stockage permanent

Les stashs sont des instantanés temporaires de l’état de travail, pas une stratégie de branches durable.

9. Utiliser git blame pour désigner un coupable

Utilisez-le pour retrouver le contexte historique et les commits pertinents.

10. Supposer qu’un push rejeté impose un push forcé

En général, cela signifie que vous devez d’abord lancer un fetch et comprendre les modifications distantes.

Étape suivante

Choisissez la commande suivante en fonction de la situation.

  • Vous ne savez pas ce qui a changé → git status, git diff, git diff --cached.
  • Besoin d’une nouvelle branche de fonctionnalité → git switch -c <branch>.
  • Besoin d’un commit ciblé → git add -p, puis git diff --cached.
  • Besoin du dernier état distant sans modifier les fichiers locaux → git fetch.
  • Besoin de mettre à jour main en local en toute sécurité → git pull --ff-only.
  • Besoin de placer la branche de fonctionnalité sur le dernier main → faites un rebase ou un merge selon la politique de l’équipe.
  • Push rejeté → lancez un fetch et inspectez la divergence avant de décider.
  • Besoin d’annuler un commit partagé → git revert.
  • Besoin de corriger le dernier commit non partagé → git commit --amend.
  • Besoin de mettre temporairement du travail de côté → git stash push.
  • Vous pensez avoir perdu un commit local → inspectez git reflog.
  • Besoin de workflows plus avancés sur les branches ou l’historique → passez à Branches et fusions, Rebase : référence rapide, Annuler des modifications en toute sécurité ou Git stash : mettre des modifications de côté.

← Tous les aide-mémoire