Sauvegarder le travail en cours

Introduction

Bienvenue, explorateur de Git ! Aujourd'hui, nous allons plonger dans l'une des fonctionnalités les plus utiles de Git pour gérer votre travail en cours : le stash (ou la remise). Vous est-il déjà arrivé d'être en plein milieu du développement d'une fonctionnalité quand, soudainement, vous devez passer à une autre tâche urgente ? Git stash est là pour vous sauver la mise !

Considérez Git stash comme un tiroir magique où vous pouvez ranger temporairement votre travail inachevé. Cela vous permet de changer rapidement de contexte sans avoir à valider (committer) un travail à moitié terminé. C'est incroyablement pratique lorsque vous devez changer de branche, récupérer des mises à jour ou corriger un bug urgent.

Dans ce lab, nous explorerons comment utiliser Git stash pour sauvegarder votre travail en cours, comment réappliquer ces modifications, créer des branches à partir de vos remises, gérer plusieurs remises simultanément et faire le ménage dans votre liste. À la fin de ce lab, vous disposerez d'un nouvel outil puissant dans votre panoplie Git qui rendra votre flux de travail plus fluide et plus flexible.

C'est parti, libérons la puissance de Git stash !

Configurer votre espace de travail

Avant de nous lancer dans la mise en remise, configurons un espace de travail pour nos expérimentations. Nous allons créer un nouveau répertoire, initialiser un dépôt Git et ajouter un contenu initial.

Ouvrez votre terminal et tapez ces commandes :

cd ~/project
mkdir git-stash-lab
cd git-stash-lab
git init
echo "## Git Stash Lab" > README.md
git add README.md
git commit -m "Initial commit"

Analysons ce que font ces commandes :

1. cd ~/project : Change votre répertoire actuel vers le dossier "project" de votre répertoire personnel.
2. mkdir git-stash-lab : Crée un nouveau répertoire nommé "git-stash-lab".
3. cd git-stash-lab : Vous déplace dans le répertoire nouvellement créé.
4. git init : Initialise un nouveau dépôt Git dans le répertoire actuel.
5. echo "## Git Stash Lab" > README.md : Crée un nouveau fichier nommé "README.md" avec le contenu "## Git Stash Lab".
6. git add README.md : Indexe le nouveau fichier pour la validation.
7. git commit -m "Initial commit" : Crée votre premier commit avec les modifications indexées.

Parfait ! Nous avons maintenant un dépôt avec un commit. Vérifions notre état :

git status

Vous devriez voir un message indiquant que votre arbre de travail est propre. Cela signifie que nous sommes prêts à commencer à expérimenter avec Git stash !

Si vous rencontrez des problèmes, assurez-vous d'être dans le bon répertoire et que Git est correctement installé sur votre système. Vous pouvez vérifier votre installation de Git en exécutant git --version.

Remiser des modifications

Maintenant que notre espace de travail est prêt, créons quelques modifications et apprenons à les remiser.

Tout d'abord, modifions notre fichier README.md :

echo "This is a work in progress" >> README.md

Cette commande ajoute une nouvelle ligne à notre fichier README.md. Créons également un nouveau fichier :

echo "Some important notes" > notes.txt

Maintenant, si nous lançons git status, nous verrons que nous avons à la fois des fichiers modifiés et des fichiers non suivis :

git status

Vous devriez voir une sortie indiquant que README.md est modifié et que notes.txt n'est pas suivi.

Imaginez qu'à ce stade, vous deviez passer rapidement à une autre tâche, mais que vous n'êtes pas prêt à valider ces changements. C'est là que git stash devient utile !

Pour remiser vos modifications, exécutez :

git stash

Vous devriez voir une sortie similaire à celle-ci :

Saved working directory and index state WIP on master: 1234567 Initial commit

Maintenant, si vous relancez git status, vous remarquerez quelque chose d'intéressant :

git status

Vous constaterez que si README.md n'apparaît plus comme modifié, notes.txt est toujours listé comme un fichier non suivi. C'est un point crucial concernant git stash :

Important : Par défaut, git stash ne remise que :

1. Les modifications des fichiers suivis (les fichiers que Git connaît déjà)
2. Les modifications indexées

Les fichiers non suivis (comme notre notes.txt) ne sont pas inclus dans la remise par défaut. Ce comportement garantit que Git ne cache pas accidentellement de nouveaux fichiers que vous ne souhaiteriez peut-être pas inclure dans le dépôt.

Si vous voulez inclure les fichiers non suivis dans votre remise, vous pouvez utiliser l'option -u (ou --include-untracked) :

git stash -u

Après avoir exécuté cette commande, les modifications de README.md et le nouveau fichier notes.txt seront tous deux remisés.

Pour voir ce qui se trouve dans votre pile de remises, vous pouvez utiliser :

git stash list

Vous devriez voir une ou deux entrées de remise, selon que vous avez utilisé l'option -u ou non.

Appuyez sur q pour quitter la vue de la liste des remises.

N'oubliez pas que le stashing est parfait pour les changements de contexte rapides. Cependant, ce n'est pas un substitut aux commits dans votre flux de travail à long terme. Les remises sont destinées à être un stockage temporaire.

Appliquer les modifications remisées

Maintenant que nous avons remisé nos modifications, apprenons comment les récupérer. Il existe deux commandes principales pour cela : git stash apply et git stash pop.

Commençons par git stash apply :

git stash apply

Après avoir exécuté cette commande, vous pourriez remarquer quelque chose d'inattendu. Vérifions l'état :

git status

Vous devriez voir une sortie similaire à celle-ci :

On branch master
Untracked files:
  (use "git add <file>..." to include in what will be committed)
        notes.txt

nothing added to commit but untracked files present (use "git add" to track)

Étonnamment, vous ne verrez que notes.txt comme fichier non suivi, et vous ne verrez aucune modification sur README.md. Ce comportement se produit parce que :

1. À l'étape 2, nous avons d'abord utilisé git stash sans l'option -u, ce qui n'a remisé que les modifications de README.md.
2. Ensuite, nous avons utilisé git stash -u, qui a remisé le fichier non suivi notes.txt (README.md était déjà propre suite à la remise précédente).
3. Lorsque nous appliquons la remise, Git applique la remise la plus récente (celle créée avec -u), qui ne contient que notes.txt, donc vous ne voyez pas les modifications de README.md.

Pour voir toutes les modifications, y compris celles de README.md, vous pouvez utiliser :

git stash apply stash@{1}

Maintenant, si vous vérifiez à nouveau l'état, vous devriez voir à la fois les modifications de README.md et notes.txt comme fichier non suivi.

Cette situation met en évidence un aspect important du travail avec les remises : l'ordre dans lequel vous créez et appliquez les remises peut affecter le résultat. Il est toujours recommandé de vérifier le contenu de vos remises avant de les appliquer, surtout lorsque vous en gérez plusieurs.

La différence entre apply et pop est que apply conserve les modifications dans votre pile de remises, tandis que pop les supprime de la pile après les avoir appliquées.

git stash clear
git stash -u
git stash list

Nous commençons par vider toutes les remises pour repartir sur de bonnes bases, puis nous remisons nos modifications avec l'option -u pour inclure les fichiers non suivis. Enfin, nous listons nos remises pour vérifier qu'elle a bien été créée.

Remisons à nouveau nos modifications et essayons pop :

git stash pop

Vous verrez une sortie similaire à la précédente, mais si vous lancez git stash list maintenant, vous verrez que votre pile de remises est vide.

Pourquoi avoir à la fois apply et pop ? apply est utile lorsque vous souhaitez appliquer les mêmes modifications remisées à plusieurs branches. pop est plus couramment utilisé lorsque vous reprenez simplement le travail sur la même branche.

Créer une branche à partir d'une remise

Parfois, vous pouvez réaliser que les modifications que vous avez remisées devraient en fait se trouver sur leur propre branche. Git facilite cela avec la commande git stash branch.

Tout d'abord, créons de nouvelles modifications et remisons-les :

echo "Feature in progress" >> README.md
echo "More notes" >> notes.txt
git stash -u

Maintenant, créons une nouvelle branche avec ces modifications :

git stash branch feature-branch

Cette commande crée une nouvelle branche nommée "feature-branch", bascule dessus (checkout), puis y applique les modifications remisées. La remise est ensuite supprimée de votre liste.

Vous devriez voir une sortie similaire à celle-ci :

Switched to a new branch 'feature-branch'
On branch feature-branch
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   README.md

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        notes.txt

no changes added to commit (use "git add" and/or "git commit -a")
Dropped refs/stash@{0} (1234567890abcdef1234567890abcdef12345678)

Cette fonctionnalité est particulièrement utile lorsque vous avez remisé des modifications expérimentales et que vous décidez plus tard qu'elles méritent d'être poursuivies sur leur propre branche.

N'oubliez pas qu'après avoir créé une branche à partir d'une remise, vous devrez valider les modifications si vous souhaitez les conserver :

git add README.md notes.txt
git commit -m "Start new feature"

Pour revenir à votre branche master, utilisez :

git checkout master

Gérer plusieurs remises

Au fur et à mesure que vous travaillez avec Git, vous pourriez vous retrouver à remiser plusieurs ensembles de modifications. Git vous permet de gérer facilement plusieurs remises. Explorons comment créer, lister et gérer plusieurs entrées.

Tout d'abord, créons trois remises avec des modifications différentes :

## Première remise
echo "Change 1" >> README.md
git stash push -m "First change"

## Deuxième remise avec fichier non suivi
echo "Change 2" >> README.md
echo "Note 2" >> notes.txt
git stash push -u -m "Second change"

## Troisième remise
echo "Change 3" >> README.md
git stash push -m "Third change"

Note : Vous remarquerez que nous utilisons maintenant git stash push au lieu de simplement git stash. La sous-commande push est la méthode moderne et préférée pour créer des remises, surtout lorsque vous souhaitez ajouter des messages personnalisés avec le drapeau -m. Bien que git stash et git stash -u fonctionnent toujours (ce sont des raccourcis pour git stash push et git stash push -u), l'utilisation explicite de git stash push vous offre plus de contrôle et de clarté, en particulier pour gérer plusieurs remises avec des messages descriptifs.

Analysons ce que nous avons fait :

1. Création de la première remise avec une modification de README.md.
2. Création de la deuxième remise avec à la fois une modification de README.md et un nouveau fichier non suivi.
3. Création de la troisième remise avec une autre modification de README.md.
4. Utilisation du drapeau -m pour ajouter des messages descriptifs.
5. Utilisation du drapeau -u pour la deuxième remise afin d'inclure le fichier non suivi.

Maintenant, listons nos remises :

git stash list

Vous devriez voir une sortie similaire à celle-ci :

stash@{0}: On master: Third change
stash@{1}: On master: Second change
stash@{2}: On master: First change

Vous pouvez examiner le contenu d'une remise sans l'appliquer :

git stash show stash@{1}

Pour plus de détails, ajoutez le drapeau -p pour voir le diff complet :

git stash show -p stash@{1}

Créons deux remises supplémentaires pour nous entraîner à gérer un ensemble plus important de modifications :

## Quatrième remise
echo "Change 4" >> README.md
git stash push -m "Fourth change"

## Cinquième remise
echo "Change 5" >> README.md
git stash push -m "Fifth change"

Vérifiez à nouveau votre liste de remises :

git stash list

Vous devriez maintenant voir cinq remises dans votre liste :

stash@{0}: On master: Fifth change
stash@{1}: On master: Fourth change
stash@{2}: On master: Third change
stash@{3}: On master: Second change
stash@{4}: On master: First change

Gérer plusieurs remises peut être utile lorsque vous jonglez avec plusieurs tâches à la fois. Cependant, essayez de ne pas accumuler trop de remises car cela peut devenir déroutant. Envisagez d'utiliser des branches pour le travail à plus long terme.

Rappel : les remises sont censées être temporaires. Si vous gardez des remises pendant longtemps, envisagez plutôt d'utiliser des branches de fonctionnalités ou de valider vos modifications.

Nettoyer les remises

Au fur et à mesure que vous utilisez les remises dans votre flux de travail, vous pourriez accumuler des entrées dont vous n'avez plus besoin. Il est de bonne pratique de nettoyer régulièrement vos remises pour rester organisé.

Pour supprimer une seule remise, vous pouvez utiliser la commande drop que nous avons entrevue :

git stash drop stash@{2}

Cela supprime la troisième remise (celle avec "Third change") de notre liste.

Si vous souhaitez supprimer toutes vos remises d'un coup, vous pouvez utiliser :

git stash clear

Soyez très prudent avec cette commande ! Elle supprimera toutes vos remises et cette action est irréversible.

Une autre commande utile est git stash pop, que nous avons vue plus tôt. Elle applique la remise la plus récente puis la supprime de la liste :

git stash pop

N'oubliez pas qu'il est généralement préférable de garder votre liste de remises courte. Les remises sont destinées au stockage temporaire du travail en cours. Si vous vous retrouvez à accumuler de nombreuses remises, c'est peut-être le signe que vous devriez valider vos modifications plus fréquemment ou créer des branches dédiées pour vos travaux de longue durée.

Résumé

Félicitations, maître du Git stash ! Vous venez d'ajouter un outil puissant à votre panoplie Git. Récapitulons les concepts clés que nous avons abordés :

1. Remiser des modifications : Vous avez appris à stocker temporairement votre travail en cours avec git stash.
2. Appliquer les modifications remisées : Vous avez découvert comment récupérer vos modifications avec git stash apply et git stash pop.
3. Créer des branches à partir de remises : Vous avez vu comment transformer un ensemble de modifications remisées en une nouvelle branche avec git stash branch.
4. Gérer plusieurs remises : Vous avez appris à travailler avec plusieurs remises, en appliquant ou en affichant des remises spécifiques selon vos besoins.
5. Nettoyer les remises : Vous avez pratiqué une bonne hygiène de travail en apprenant à supprimer des remises individuelles ou à vider toute la pile.

Git stash est une fonctionnalité incroyablement utile qui vous permet de changer rapidement de contexte sans valider un travail inachevé. C'est l'outil idéal pour les moments où vous devez basculer rapidement entre différentes tâches ou branches.

Gardez à l'esprit que, bien que les remises soient utiles, elles sont destinées à être temporaires. Pour un travail à plus long terme, il est généralement préférable de valider vos modifications ou de créer une nouvelle branche. Utilisez les remises à bon escient, et elles vous aideront à maintenir un flux de travail fluide et flexible.