Parcourir les aide-mémoire · Git

Technologie: GitCatégorie: Gestion de versionsNiveau: IntermédiaireMis à jour

Branches et fusions

Créez, mettez à jour, comparez, fusionnez et nettoyez vos branches Git en toute sécurité, en préservant l’historique partagé et en évitant toute divergence accidentelle ou résolution de conflits destructrice.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Démarrer une branche de fonctionnalité à partir d’un main à jour
  5. 2. Créer une branche à partir d’une base distante précise
  6. 3. Afficher la branche courante
  7. 4. Lister les branches
  8. 5. Changer de branche en toute sécurité
  9. 6. Renommer la branche courante
  10. 7. Comparer les commits de la branche de fonctionnalité avec main
  11. 8. Voir les commits de main que votre branche n’a pas
  12. 9. Comparer les modifications de code avec main
  13. 10. Afficher uniquement les fichiers modifiés
  14. 11. Lancer git fetch avant de choisir comment mettre à jour
  15. 12. Fusionner le dernier main dans la branche de fonctionnalité
  16. 13. Faire un rebase de la branche de fonctionnalité sur le dernier main
  17. 14. Comprendre merge ou rebase
  18. 15. Fusionner une autre branche dans la branche courante
  19. 16. Fusionner en fast-forward lorsque c’est possible
  20. 17. Forcer volontairement un commit de merge
  21. 18. Évaluer à l’avance si un merge s’annonce simple
  22. 19. Annuler un merge en cours
  23. 20. Détecter un merge actif
  24. 21. Résoudre les conflits de fusion de manière délibérée
  25. 22. Lister les fichiers en conflit
  26. 23. Inspecter les blocs en conflit
  27. 24. Comprendre ours et theirs pendant un merge
  28. 25. Indexer les fichiers résolus
  29. 26. Poursuivre le merge après les conflits
  30. 27. Fusionner une branche après sa revue
  31. 28. Regrouper le travail de la fonctionnalité en un seul commit local
  32. 29. Comprendre le compromis du squash merge
  33. 30. Faire un push d’une nouvelle branche de fonctionnalité
  34. 31. Faire un push après avoir fusionné main dans une branche de fonctionnalité
  35. 32. Faire un push après un rebase d’une branche de fonctionnalité distante
  36. 33. Éviter le rebase des branches d’intégration partagées
  37. 34. Supprimer en toute sécurité une branche locale fusionnée
  38. 35. Vérifier les commits non fusionnés avant la suppression
  39. 36. Forcer la suppression d’une branche locale uniquement si nécessaire
  40. 37. Supprimer une branche distante
  41. 38. Élaguer les branches de suivi distant obsolètes
  42. 39. Trouver les branches locales déjà fusionnées dans main
  43. 40. Trouver les branches locales non fusionnées dans main
  44. 41. Comprendre les branches de suivi distant
  45. 42. Définir l’upstream d’une branche
  46. 43. Inspecter l’état d’avance/de retard
  47. 44. Trouver la base de fusion
  48. 45. Afficher le graphe des branches
  49. 46. Comparer directement les extrémités de deux branches
  50. 47. Ne pas fusionner accidentellement un main obsolète
  51. 48. Créer une branche de sauvegarde avant des modifications d’historique complexes
  52. 49. Utiliser le reflog si un déplacement de branche tourne mal
  53. 50. Garder des branches de fonctionnalité ciblées
  54. Interpréter le résultat
  55. Points à vérifier
  56. La branche de fonctionnalité contient des commits inattendus
  57. Le merge crée de nombreux conflits
  58. Le merge indique « Already up to date »
  59. La branche distante a changé après votre rebase
  60. La suppression de la branche est refusée
  61. Le même conflit réapparaît sans cesse
  62. Notes de production
  63. La politique de branches doit correspondre à la collaboration de l’équipe
  64. Les branches partagées doivent éviter la réécriture de l’historique
  65. Des branches de courte durée réduisent le coût des conflits
  66. La résolution des conflits de fusion est une revue de code
  67. Le CI/CD s’exécute généralement sur l’état de la branche, pas sur l’intention
  68. Les branches de suivi distant sont des instantanés
  69. Erreurs fréquentes
  70. 1. Créer une branche de fonctionnalité à partir d’un main obsolète
  71. 2. Fusionner en étant sur la mauvaise branche
  72. 3. Faire un rebase d’une branche que vos coéquipiers utilisent déjà
  73. 4. Faire un force push après un merge normal
  74. 5. Choisir --ours ou --theirs à l’aveugle
  75. 6. Supprimer une branche avec -D sans vérifier ses commits propres
  76. 7. Considérer le squash merge comme identique à un merge normal
  77. 8. Comparer les extrémités des branches alors que vous voulez seulement les modifications de la fonctionnalité
  78. 9. Supposer que origin/main est à jour sans lancer git fetch
  79. 10. Garder des branches de fonctionnalité ouvertes trop longtemps
  80. Étape suivante
  81. Pour aller plus loin

Problème

Vous devez travailler sur des modifications en parallèle sans casser la branche partagée.

Les workflows d’ingénierie typiques consistent à :

  • créer une branche de fonctionnalité à partir de la bonne base
  • maintenir la branche de fonctionnalité à jour
  • comparer la branche avec main
  • fusionner les modifications en toute sécurité
  • résoudre les conflits de manière délibérée
  • éviter les commits de merge accidentels
  • nettoyer les branches locales et distantes
  • comprendre quand un merge est plus sûr qu’un rebase

L’objectif est de garder un historique de branches compréhensible et un travail partagé en sécurité.

Réponse rapide

Pour une branche de fonctionnalité classique :

git switch main
git pull --ff-only
git switch -c feature/report-engine

Travaillez et faites un commit :

git add -p
git commit -m "Add report engine endpoint"

Avant de fusionner :

git fetch origin
git diff origin/main...HEAD
git log --oneline origin/main..HEAD

Mettez à jour la branche de fonctionnalité selon la politique privilégiée par votre équipe :

git merge origin/main

ou :

git rebase origin/main

Puis faites un push :

git push -u origin feature/report-engine

Pour un historique de branche partagé, un merge ou un revert est généralement plus sûr que la réécriture de commits que vos coéquipiers utilisent peut-être déjà.

Code / commandes

1. Démarrer une branche de fonctionnalité à partir d’un main à jour

git switch main
git pull --ff-only
git switch -c feature/report-engine

Cela évite de créer la branche à partir d’un main local obsolète.

Utilisez --ff-only pour éviter de créer un commit de merge inattendu lors de la mise à jour du main local.


2. Créer une branche à partir d’une base distante précise

git fetch origin
git switch -c feature/report-engine origin/main

Utilisez cette méthode lorsque vous voulez que la branche parte directement du dernier main de suivi distant (remote-tracking).


3. Afficher la branche courante

git branch --show-current

À utiliser avant un commit ou un merge en cas de doute sur la branche où vous vous trouvez.


4. Lister les branches

Locales :

git branch

Locales + de suivi distant :

git branch -a

Avec le suivi de l’upstream :

git branch -vv

Utilisez -vv pour voir si la branche est en avance ou en retard sur son upstream.


5. Changer de branche en toute sécurité

git switch feature/report-engine

Git peut refuser si des modifications non commitées risquent d’être écrasées.

Ne forcez pas le changement de branche simplement pour « passer » l’avertissement.

Faites un commit, un stash ou réglez l’état de l’arbre de travail de manière intentionnelle.


6. Renommer la branche courante

git branch -m feature/new-name

Si l’ancienne branche a déjà fait l’objet d’un push, la branche distante n’est pas renommée automatiquement.

En général, vous ferez un push du nouveau nom et supprimerez l’ancienne branche distante séparément.


7. Comparer les commits de la branche de fonctionnalité avec main

git log --oneline origin/main..HEAD

Cette commande affiche les commits que votre branche courante possède et que origin/main n’a pas.

À utiliser avant d’ouvrir ou de mettre à jour une pull request.


8. Voir les commits de main que votre branche n’a pas

git log --oneline HEAD..origin/main

Si cette commande renvoie des commits, votre branche est en retard sur origin/main.


9. Comparer les modifications de code avec main

git diff origin/main...HEAD

La syntaxe à trois points compare votre branche avec la base de fusion (merge base).

Cela représente généralement l’ensemble des modifications introduites par la branche de fonctionnalité.


10. Afficher uniquement les fichiers modifiés

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

Utile pour vérifier rapidement le périmètre.

Exemple :

M  src/api.py
A  src/report_engine.py
D  src/legacy_report.py

11. Lancer git fetch avant de choisir comment mettre à jour

git fetch origin

Cette commande met à jour les références de suivi distant sans modifier votre arbre de travail.

Inspectez ensuite :

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

Ne faites pas de merge ni de rebase sur un origin/main périmé.


12. Fusionner le dernier main dans la branche de fonctionnalité

git merge origin/main

Utilisez cette approche lorsque :

  • la préservation de l’historique est privilégiée
  • la branche est déjà partagée
  • la réécriture des commits serait perturbatrice

Cela peut créer un commit de merge si les historiques ont divergé.


13. Faire un rebase de la branche de fonctionnalité sur le dernier main

git rebase origin/main

À utiliser lorsque :

  • la branche est principalement la vôtre
  • le workflow de l’équipe privilégie un historique linéaire
  • la réécriture des commits de la branche de fonctionnalité est acceptable

Évitez de faire un rebase à la légère sur des commits dont vos coéquipiers dépendent déjà.


14. Comprendre merge ou rebase

Conceptuellement :

MERGE
A---B---C main
     \   \
      D---E---M feature

par rapport à :

REBASE
A---B---C main
         \
          D'---E' feature

Le rebase crée de nouveaux identifiants de commit pour les commits rejoués.

Le merge préserve les commits d’origine et ajoute un historique de fusion si nécessaire.


15. Fusionner une autre branche dans la branche courante

git merge feature/other-work

Vérifiez toujours d’abord la branche courante :

git branch --show-current

Git fusionne dans la branche sur laquelle vous vous trouvez.


16. Fusionner en fast-forward lorsque c’est possible

Si la branche courante n’a aucun commit qui lui est propre :

git merge --ff-only feature/report-engine

Cette commande fait avancer le pointeur de branche sans créer de commit de merge.

Si le fast-forward est impossible, Git s’arrête au lieu d’appliquer une autre stratégie de merge.


17. Forcer volontairement un commit de merge

git merge --no-ff feature/report-engine

À utiliser uniquement si le workflow du dépôt préserve intentionnellement les commits de merge des branches de fonctionnalité.

N’ajoutez pas de commits de merge par défaut lorsque l’équipe privilégie un historique linéaire.


18. Évaluer à l’avance si un merge s’annonce simple

git log --oneline --graph --decorate --all -30

et :

git diff HEAD...feature/report-engine

Git ne propose pas de simulation (dry-run) parfaite pour tous les résultats de merge, mais inspecter d’abord la divergence réduit les surprises.


19. Annuler un merge en cours

git merge --abort

À utiliser lorsque :

  • vous êtes parti de la mauvaise branche
  • les conflits sont plus étendus que prévu
  • vous devez revenir à l’état antérieur au merge

Ne réinitialisez pas manuellement des fichiers pendant qu’un merge est actif, sauf si vous en comprenez les conséquences.


20. Détecter un merge actif

git status

Git indiquera qu’il existe des conflits ou qu’un merge est en cours.

git status doit être la première commande après un merge interrompu.


21. Résoudre les conflits de fusion de manière délibérée

Un fichier en conflit peut contenir :

<<<<<<< HEAD
version de la branche courante
=======
version de la branche entrante
>>>>>>> feature/other-work

Modifiez le fichier pour obtenir le résultat final voulu.

Ensuite :

git add path/to/file

Une fois tous les conflits résolus :

git commit

ou laissez Git terminer le merge selon l’état courant.

Ne laissez pas de marqueurs de conflit dans le code commité.


22. Lister les fichiers en conflit

git diff --name-only --diff-filter=U

À utiliser lors de la résolution d’un conflit volumineux.


23. Inspecter les blocs en conflit

git diff

Pendant un conflit de fusion, Git affiche les sections non résolues.

À utiliser avant de choisir l’un ou l’autre côté.


24. Comprendre ours et theirs pendant un merge

Pendant un merge :

ours
→ branche courante

theirs
→ branche en cours de fusion

Exemple :

git checkout --ours path/to/file

ou la forme moderne avec restore :

git restore --ours path/to/file

N’utilisez pas --ours / --theirs à l’aveugle.

Une résolution correcte combine souvent les deux versions.


25. Indexer les fichiers résolus

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

Puis vérifiez :

git status

Le merge n’est terminé que lorsque chaque conflit est résolu et indexé (ajouté à la zone de préparation, ou staging area).


26. Poursuivre le merge après les conflits

En général :

git commit

Git proposera un message de commit de merge.

Relisez-le avant de l’enregistrer.


27. Fusionner une branche après sa revue

Flux local typique :

git switch main
git pull --ff-only
git merge --ff-only feature/report-engine

Cela ne fonctionne que si la branche de fonctionnalité est déjà basée directement sur le dernier main.

Sinon, la politique de merge du dépôt peut exiger :

  • un commit de merge
  • un squash merge
  • un rebase merge

Cela est souvent géré par la plateforme d’hébergement Git.


28. Regrouper le travail de la fonctionnalité en un seul commit local

git merge --squash feature/report-engine
git commit -m "Add report engine"

Cette commande applique les modifications de la fonctionnalité à l’arbre de travail et à l’index sans créer de relation de merge avec la branche de fonctionnalité.

À utiliser uniquement lorsque l’historique en squash est la politique voulue.


29. Comprendre le compromis du squash merge

Le squash produit un seul nouveau commit contenant le diff final.

Avantages :

  • historique de main compact
  • revert facile au niveau de la fonctionnalité

Compromis :

  • les commits individuels de la fonctionnalité ne sont pas conservés sur main
  • Git n’enregistre pas de relation de merge normale avec la branche de fonctionnalité

Cela affecte les comparaisons de branches ultérieures et le comportement des merges répétés.


30. Faire un push d’une nouvelle branche de fonctionnalité

git push -u origin feature/report-engine

Une fois l’upstream défini :

git push

31. Faire un push après avoir fusionné main dans une branche de fonctionnalité

git push

Un merge normal ne réécrit pas les commits existants de la fonctionnalité ; un push classique suffit donc généralement.


32. Faire un push après un rebase d’une branche de fonctionnalité distante

Si vous avez fait un rebase de commits déjà poussés :

git push --force-with-lease

Préférez cette commande à :

git push --force

À utiliser uniquement lorsque la réécriture de cette branche de fonctionnalité est acceptable.


33. Éviter le rebase des branches d’intégration partagées

Ne faites pas de rebase à la légère sur :

main
develop
release
branches d’équipe partagées

car les identifiants de commit changent et vos collaborateurs ont peut-être déjà basé leur travail dessus.


34. Supprimer en toute sécurité une branche locale fusionnée

git branch -d feature/report-engine

-d refuse de supprimer une branche que Git ne considère pas comme entièrement fusionnée.

C’est plus sûr que -D.


35. Vérifier les commits non fusionnés avant la suppression

git log main..feature/report-engine

Si cette commande affiche des commits, vérifiez qu’ils peuvent intentionnellement être abandonnés avant de supprimer la branche.


36. Forcer la suppression d’une branche locale uniquement si nécessaire

git branch -D feature/report-engine

Cette commande peut supprimer le nom de la branche même s’il reste des commits qui lui sont propres.

À utiliser uniquement après avoir confirmé que ces commits sont conservés ailleurs ou ne sont plus nécessaires.


37. Supprimer une branche distante

git push origin --delete feature/report-engine

La suppression d’une branche distante affecte les autres collaborateurs.

Faites-la après le merge ou la clôture, conformément au workflow de l’équipe.


38. Élaguer les branches de suivi distant obsolètes

git fetch --prune

Cette commande supprime les références obsolètes telles que :

origin/feature/old-branch

lorsque la branche distante correspondante n’existe plus.

Elle ne supprime pas les branches locales.


39. Trouver les branches locales déjà fusionnées dans main

git branch --merged main

Utilisez-la comme aide au nettoyage.

Vérifiez tout de même les branches importantes avant de les supprimer.


40. Trouver les branches locales non fusionnées dans main

git branch --no-merged main

Cela permet d’identifier le travail qui pourrait encore être unique.


41. Comprendre les branches de suivi distant

origin/main n’est pas la branche distante elle-même.

C’est la dernière vue récupérée par git fetch de la branche distante dans votre dépôt local.

Mettez-la à jour avec :

git fetch origin

Ne supposez pas que origin/main est à jour si vous n’avez pas lancé git fetch récemment.


42. Définir l’upstream d’une branche

git branch \
  --set-upstream-to=origin/feature/report-engine \
  feature/report-engine

En général, git push -u s’en charge lors du premier push d’une branche.


43. Inspecter l’état d’avance/de retard

git status

ou :

git branch -vv

Pour obtenir le nombre exact de commits :

git rev-list \
  --left-right \
  --count \
  origin/main...HEAD

Exemple :

3    2

signifie :

3 commits propres à origin/main
2 commits propres à HEAD

44. Trouver la base de fusion

git merge-base origin/main HEAD

Cette commande affiche l’ancêtre commun utilisé pour les comparaisons à trois points.

Utile pour comprendre la divergence entre branches.


45. Afficher le graphe des branches

git log \
  --oneline \
  --graph \
  --decorate \
  --all \
  -30

À utiliser lorsque la relation entre les branches prête à confusion.


46. Comparer directement les extrémités de deux branches

git diff main feature/report-engine

Cette commande compare les instantanés aux extrémités des deux branches.

Elle diffère de :

git diff main...feature/report-engine

qui compare à partir de la base de fusion et convient généralement mieux à la revue d’une branche de fonctionnalité.


47. Ne pas fusionner accidentellement un main obsolète

Avant de fusionner une fonctionnalité terminée dans le main local :

git switch main
git fetch origin
git pull --ff-only

Effectuez ensuite le merge prévu.

Cela évite d’intégrer dans une base locale obsolète.


48. Créer une branche de sauvegarde avant des modifications d’historique complexes

git branch backup-before-integration

Faites-le avant :

  • un rebase risqué
  • une résolution de conflits complexe
  • une chirurgie de branche locale

La création d’une branche ne coûte presque rien et fournit un point de récupération.


49. Utiliser le reflog si un déplacement de branche tourne mal

git reflog

Retrouvez le commit précédent :

git show <commit>

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

git switch -c recovery <commit>

Le reflog est particulièrement utile après un reset ou un rebase accidentel.


50. Garder des branches de fonctionnalité ciblées

Privilégiez :

feature/report-engine

pour contenir un ensemble de travail cohérent.

Évitez de mélanger :

  • des refactorisations sans rapport
  • des mises à niveau de dépendances
  • du reformatage sur l’ensemble du dépôt
  • des travaux sur des fonctionnalités distinctes

Des branches ciblées produisent des merges plus simples et moins de conflits.

Interpréter le résultat

Opération Effet sur l’historique Usage typique
git switch -c Crée un nouveau pointeur de branche Démarrer un travail isolé
git fetch Met à jour les références de suivi distant Inspecter l’état actuel du dépôt distant
git merge Préserve les deux historiques Intégrer des branches en toute sécurité
git merge --ff-only Déplace uniquement le pointeur de branche Intégration propre en fast-forward
git merge --no-ff Force un commit de merge Préserver la délimitation de la branche de fonctionnalité
git merge --squash Applique uniquement le diff combiné Un seul commit pour la fonctionnalité
git rebase Réécrit les identifiants des commits rejoués Linéariser l’historique d’une fonctionnalité privée
git branch -d Supprime la référence de la branche locale fusionnée Nettoyage sûr
git push --delete Supprime la branche distante Nettoyage côté distant
git merge --abort Annule le merge actif Revenir d’un merge erroné ou risqué

La décision centrale est :

Besoin de préserver l’historique partagé ?
→ merge

Besoin de linéariser l’historique d’une fonctionnalité privée ?
→ un rebase peut convenir

Points à vérifier

La branche de fonctionnalité contient des commits inattendus

Exécutez :

git log --oneline origin/main..HEAD

et inspectez le graphe.

La branche a peut-être été créée à partir de la mauvaise base.

Le merge crée de nombreux conflits

Causes probables :

  • branche de longue durée
  • refactorisation étendue qui se chevauche
  • branche de fonctionnalité obsolète
  • nombreuses modifications sans rapport dans une même branche

Rétablissez d’abord la justesse du code, puis envisagez de modifier le workflow de branches.

Le merge indique « Already up to date »

Vous êtes peut-être sur la mauvaise branche ou vous fusionnez dans le mauvais sens.

Vérifiez :

git branch --show-current
git log --oneline --graph --decorate --all -20

La branche distante a changé après votre rebase

Ne l’écrasez pas à l’aveugle.

Lancez git fetch et vérifiez si quelqu’un d’autre a poussé des modifications.

La suppression de la branche est refusée

Git estime que la branche contient des commits non fusionnés dans l’historique cible.

Inspectez-les avant d’utiliser -D.

Le même conflit réapparaît sans cesse

Une divergence de longue durée ou des rebases/cherry-picks répétés peuvent provoquer des chevauchements récurrents.

Envisagez des branches plus petites et une intégration plus fréquente.

Notes de production

La politique de branches doit correspondre à la collaboration de l’équipe

Il n’existe pas de politique universellement meilleure.

Les modèles courants sont notamment :

commits de merge
squash merge
rebase + fast-forward

Choisissez-en une délibérément et appliquez-la de manière cohérente.

Les branches partagées doivent éviter la réécriture de l’historique

Dès que d’autres personnes dépendent des identifiants de commit, la réécriture entraîne une coordination et des risques inutiles.

Des branches de courte durée réduisent le coût des conflits

Plus une branche de fonctionnalité diverge longtemps de main, plus une résolution de conflits importante devient probable.

Intégrez suffisamment souvent pour que les différences restent gérables.

La résolution des conflits de fusion est une revue de code

Un conflit n’est pas qu’un simple problème mécanique de Git.

L’ingénieur doit comprendre le comportement combiné attendu.

Le CI/CD s’exécute généralement sur l’état de la branche, pas sur l’intention

Avant de fusionner, vérifiez :

  • la bonne branche
  • les commits attendus
  • un arbre de travail propre
  • l’état des tests et du build
  • l’absence de fichiers ajoutés par accident

Les branches de suivi distant sont des instantanés

Lancez toujours git fetch avant de prendre des décisions d’intégration fondées sur origin/*.

Erreurs fréquentes

1. Créer une branche de fonctionnalité à partir d’un main obsolète

Vous démarrez avec une divergence évitable.

2. Fusionner en étant sur la mauvaise branche

Git fusionne dans la branche courante.

Vérifiez d’abord.

3. Faire un rebase d’une branche que vos coéquipiers utilisent déjà

Cela réécrit les identifiants de commit et complique leur historique.

4. Faire un force push après un merge normal

Un merge ne nécessite normalement pas de force push.

5. Choisir --ours ou --theirs à l’aveugle

Une résolution de conflit correcte peut nécessiter les deux côtés.

6. Supprimer une branche avec -D sans vérifier ses commits propres

Vous pouvez perdre le pointeur de branche vers du travail non fusionné.

7. Considérer le squash merge comme identique à un merge normal

Le squash ne préserve pas la même relation d’ascendance.

8. Comparer les extrémités des branches alors que vous voulez seulement les modifications de la fonctionnalité

Pour une revue de type pull request, la comparaison à trois points est généralement plus utile.

9. Supposer que origin/main est à jour sans lancer git fetch

Les références de suivi distant peuvent être obsolètes.

10. Garder des branches de fonctionnalité ouvertes trop longtemps

Une divergence prolongée augmente la complexité des conflits et de la revue.

Étape suivante

Utilisez l’état de la branche pour choisir l’action suivante.

  • Démarrage d’un nouveau travail → mettez à jour main, puis créez une nouvelle branche de fonctionnalité.
  • Besoin de voir le périmètre de la branche → utilisez git log origin/main..HEAD et git diff origin/main...HEAD.
  • La branche de fonctionnalité est en retard sur main → faites un merge ou un rebase selon la politique de l’équipe.
  • La branche est déjà partagée → préférez le merge à la réécriture de l’historique.
  • Une branche de fonctionnalité privée a besoin d’un historique linéaire → un rebase peut convenir.
  • Des conflits de fusion apparaissent → résolvez-les intentionnellement, indexez-les, puis terminez ou annulez le merge.
  • La branche est fusionnée → supprimez la branche locale avec -d, puis la branche distante si nécessaire.
  • L’historique de la branche semble incorrect → inspectez le graphe et la base de fusion avant de modifier quoi que ce soit.
  • Besoin de réécrire proprement des commits → passez à Rebase : référence rapide.
  • Besoin de récupérer après des erreurs de branche → passez à Annuler des modifications en toute sécurité.

← Tous les aide-mémoire