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