Git : changer de branche, guide avec exemples concrets

Lister les branches existantes

Pour afficher les branches disponibles, utilisez la commande git branch. La branche courante est marquée d’un astérisque. Par exemple, si vous avez trois branches locales nommées main, feature-x et bug-z, et que vous êtes actuellement sur main, la sortie sera :

* main
feature-x
bug-z

Basculer vers une branche distante

La commande précédente permet de passer sur une branche déjà présente en local. Pour basculer vers une branche du dépôt distant, il faut en créer une copie locale avec :

git switch -c <local-branch-name> origin/<remote-branch-name>

Ici, <local-branch-name> est le nom souhaité en local, tandis que <remote-branch-name> est le nom de la branche distante. En règle générale, on conserve le même nom pour éviter toute confusion. Par exemple, si la branche feature-x n’existe pas encore en local, vous pouvez la créer et y basculer ainsi :

git switch -c feature-x origin/feature-x

Lorsque le nom est identique, Git propose un raccourci avec l’option --track. La commande précédente équivaut donc à :

git switch --track origin/feature-x

Pour lister les branches distantes, utilisez git branch -r.

Le dépôt local ne suit pas automatiquement l’état des branches distantes. Avant de lister ou de basculer vers une branche distante, pensez à mettre à jour le dépôt local avec git fetch.

Créer une nouvelle branche et y basculer

Vous souhaitez créer une toute nouvelle branche pour démarrer une fonctionnalité. Dans ce cas, utilisez l’option -c :

git switch -c <new-branch-name>

Remplacez <new-branch-name par le nom de la branche. Par exemple, pour créer une branche nommée feature-y :

git switch -c feature-y

Revenir à la branche précédente

Il est fréquent, après un changement de branche, de vouloir revenir sur celle utilisée juste avant. Git offre un raccourci :

git switch -

Git switch vs. git checkout

La commande git checkout existe depuis les débuts de Git. Avant l’arrivée de git switch en 2019, c’était la commande utilisée pour changer de branche. Cependant, la portée de git checkout va bien au-delà de la simple navigation entre branches. Voici les principales différences :

• git switch : son objectif est d’offrir un moyen plus intuitif de basculer entre les branches et d’en créer. Il simplifie la panoplie de commandes et réduit la confusion.
• git checkout : une commande plus polyvalente, utilisable pour changer de branche, mais aussi pour extraire des fichiers et restaurer du contenu depuis d’autres commits ou branches.

La conception de git switch limite le risque d’écraser des changements par inadvertance. Sa syntaxe explicite pour le basculement et la création de branches réduit les erreurs.

Comme git checkout regroupe plusieurs usages (changement de branche, restauration de fichiers, etc.), il est plus facile de se tromper en l’utilisant.

Git switch : erreurs courantes

Lors de la gestion des branches, vous pouvez rencontrer quelques écueils. L’un d’eux consiste à tenter de créer une branche qui existe déjà en local. Un autre survient lorsque vous essayez de changer de branche avec des modifications non validées. Commençons par le premier cas.

La branche existe déjà en local

Chaque branche locale doit avoir un nom unique. Vous pouvez créer des branches locales avec git switch de deux manières :

1. Pour suivre une branche distante :

git switch --track origin/<branch-name>

2. Pour créer une nouvelle branche locale :

git switch -c <branch-name>

Dans les deux cas, si une branche locale nommée <branch-name> existe déjà, Git renverra l’erreur :

fatal: a branch named '<branch-name>' already exists

Dans ce cas, basculez simplement sur la branche sans la créer avec git switch <branch-name>.

La branche courante comporte des modifications non validées

Git n’autorise pas le changement de branche si la branche courante contient des modifications non validées qui seraient écrasées par le basculement. Dans ce cas, Git affichera :

Please commit your changes or stash them before you switch branches.

Comme l’indique le message, pour sortir de cette situation, vous devez soit valider vos changements, soit les mettre de côté. Si les modifications sont prêtes à être enregistrées dans le dépôt, validez-les avec :

git commit -m "Commit message"

Si vous souhaitez conserver les changements sans les valider pour l’instant, vous pouvez les sauvegarder temporairement avec la commande git stash :

git stash

Si vous avez mis vos changements de côté avant de changer de branche et souhaitez les réappliquer en revenant sur la branche d’origine, utilisez git stash pop.

Vous pouvez aussi décider d’abandonner les modifications avec l’option --discard-changes :

git switch --discard-changes <branch-name>

Attention, cette action supprime définitivement les changements.

Git switch : usages avancés

Lorsque vous devez créer des branches depuis des points précis de l’historique du projet ou gérer des cas particuliers, git switch propose des fonctionnalités avancées adaptées.

Créer une branche depuis un point spécifique

Par défaut, lors de la création d’une branche avec git switch, l’état initial de la nouvelle branche correspond au HEAD de la branche courante.

Imaginons que vous souhaitiez démarrer une nouvelle branche à partir d’un commit antérieur précis. Chaque commit est identifié par un <hash> unique, que vous pouvez utiliser avec git switch pour créer une branche depuis ce commit. Voici comment faire :

switch -c feature-y <hash>

Remplacez <hash> par le hash du commit visé.

Passer en mode detached HEAD

Pour explorer ou expérimenter sur un commit précis sans impacter la branche courante ni en créer une nouvelle, vous pouvez passer en mode detached HEAD avec :

git switch --detach <hash>

En détachant le HEAD, vous pouvez examiner l’état du dépôt à un commit donné, exécuter des tests ou faire des changements temporaires sans risque de les valider par mégarde sur la branche de travail. Les cas d’usage les plus fréquents incluent :

• Consulter un état ancien : si vous voulez inspecter ou tester un commit antérieur sans modifier la branche courante, basculez sur ce commit en mode détaché.
• Modifications temporaires : pour expérimenter sans affecter de branche, travaillez en detached HEAD. Notez que tout nouveau commit créé dans cet état n’appartiendra à aucune branche ; vous devrez créer une branche si vous souhaitez le conserver.
• Build/tests : il arrive de devoir construire ou tester un logiciel à un commit précis. Basculer en detached HEAD à ce commit permet de le faire sans impacter la structure des branches.

Forcer un basculement

Nous avons vu que Git n’autorise pas le changement de branche en présence de modifications non validées susceptibles de créer des conflits avec la branche cible. Si vous êtes certain de vouloir abandonner ces changements et poursuivre, vous pouvez forcer le basculement avec l’option -f :

git switch -f <branch-name>

Gardez toutefois à l’esprit quelques mises en garde importantes. 

• Toute modification non validée sera perdue sans avertissement, avec un risque réel de perte de travail si rien n’a été sauvegardé ailleurs. 
• Un usage indiscriminé de -f peut nuire à la discipline, en incitant à contourner les bonnes pratiques de versioning comme le stash ou des commits intermédiaires (WIP). Cela peut rendre l’historique chaotique et compliquer la collaboration. Ainsi, même si git switch -f est rapide et pratique, utilisez-le avec parcimonie et en connaissance de cause pour limiter les risques.

Conclusion

La commande git switch simplifie le passage et la création de branches par rapport à l’ancienne commande git checkout.

Elle fluidifie le processus et réduit les erreurs, facilitant la gestion du code pour les développeurs.

Cette commande aide à éviter des problèmes courants, comme l’écrasement involontaire de changements ou la confusion entre les différents usages de git checkout.

L’adopter rend la navigation entre branches plus intuitive et améliore la collaboration au sein des équipes de développement.