Sauvegarder les travaux en cours

Introduction

Bienvenue de retour, explorateur Git! Aujourd'hui, nous allons plonger dans l'une des fonctionnalités les plus utiles de Git pour gérer votre travail en cours : la pile d'états (stash). Avez-vous déjà été en pleine implémentation d'une fonctionnalité quand soudain vous avez dû passer à une autre tâche? Git stash est là pour vous sauver la mise!

Imaginez Git stash comme un tiroir magique où vous pouvez stocker temporairement votre travail inachevé. Il vous permet de changer rapidement de contexte sans avoir à valider (commit) un travail inachevé. Cela est incroyablement utile lorsque vous devez changer de branche, tirer (pull) des mises à jour ou résoudre une erreur urgente.

Dans ce laboratoire (LabEx), nous allons explorer comment utiliser Git stash pour sauvegarder votre travail en cours, comment appliquer les modifications mises en attente, créer des branches à partir des états mis en pile, gérer plusieurs états mis en pile et nettoyer votre pile d'états. À la fin de ce laboratoire, vous disposerez d'un nouvel outil puissant dans votre boîte à outils Git qui rendra votre flux de travail plus fluide et plus flexible.

Commençons et débloquons le pouvoir de Git stash!

Skills Graph

Configuration de votre espace de travail

Avant de plonger dans l'utilisation de la pile d'états (stash), configurons un espace de travail pour effectuer des expériences. 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 ces commandes font :

1. cd ~/project : Cette commande change votre répertoire actuel pour le dossier "project" dans votre répertoire personnel.
2. mkdir git-stash-lab : Cette commande crée un nouveau répertoire nommé "git-stash-lab".
3. cd git-stash-lab : Cette commande vous déplace dans le répertoire nouvellement créé.
4. git init : Cette commande initialise un nouveau dépôt Git dans le répertoire actuel.
5. echo "## Git Stash Lab" > README.md : Cette commande crée un nouveau fichier nommé "README.md" avec le contenu "## Git Stash Lab".
6. git add README.md : Cette commande prépare le nouveau fichier pour le commit.
7. git commit -m "Initial commit" : Cette commande crée votre premier commit avec les modifications préparées.

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

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.

Mise en attente des modifications

Maintenant que notre espace de travail est configuré, créons quelques modifications et apprenons à les mettre en attente (stash).

Tout d'abord, apportons quelques modifications à 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 exécutons git status, nous verrons que nous avons à la fois des fichiers modifiés et des fichiers non suivis (untracked) :

git status

Vous devriez voir un résultat indiquant que README.md est modifié et que notes.txt n'est pas suivi.

Imaginez que vous deviez rapidement passer à une autre tâche, mais que vous n'êtes pas prêt à valider (commit) ces modifications. C'est là que git stash devient utile!

Pour mettre vos modifications en attente, exécutez :

git stash

Vous devriez voir un résultat similaire à ceci :

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

Maintenant, si vous exécutez git status à nouveau, vous verrez quelque chose d'intéressant :

git status

Vous remarquerez que tandis que README.md n'est plus affiché comme modifié, notes.txt est toujours répertorié comme un fichier non suivi. Voici un point crucial concernant git stash :

Important : Par défaut, git stash ne met en attente que :

1. Les modifications apportées aux fichiers suivis (les fichiers que Git suit déjà)
2. Les modifications préparées (staged)

Les fichiers non suivis (comme notre notes.txt) ne sont pas inclus dans la pile d'états (stash) par défaut. Ce comportement garantit que Git ne cache pas accidentellement de nouveaux fichiers que vous pourriez ne pas vouloir inclure dans le dépôt.

Si vous souhaitez inclure les fichiers non suivis dans votre pile d'états, vous pouvez utiliser l'option -u (ou --include-untracked) :

git stash -u

Après avoir exécuté cette commande, à la fois les modifications apportées à README.md et le nouveau fichier notes.txt seront mis en attente.

Pour voir ce qui se trouve dans votre pile d'états, vous pouvez utiliser :

git stash list

Vous devriez voir une ou deux entrées dans la pile d'états, selon que vous avez utilisé l'option -u ou non.

Appuyez sur q pour quitter la vue de la liste des états mis en attente.

N'oubliez pas que la mise en attente des modifications est parfaite pour les changements rapides de contexte. Cependant, ce n'est pas un remplacement pour les commits dans votre flux de travail à long terme. Les états mis en attente sont destinés à être des stockages temporaires.

Application des modifications mises en attente

Maintenant que nous avons mis nos modifications en attente (stash), apprenons à 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 le statut :

git status

Vous devriez voir un résultat similaire à ceci :

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 un fichier non suivi, et vous ne verrez aucune modification apportée à README.md. Ce comportement se produit parce que :

1. Dans l'Étape 2, nous avons utilisé git stash sans l'option -u d'abord, ce qui n'a mis en attente que les modifications apportées à README.md.
2. Ensuite, nous avons utilisé git stash -u, qui a mis en attente à la fois les modifications apportées à README.md et le fichier non suivi notes.txt.
3. Lorsque nous appliquons la pile d'états, Git applique la pile d'états la plus récente (celle créée avec -u), mais il n'affiche pas les modifications apportées à README.md car ces modifications étaient déjà incluses dans la pile d'états précédente.

Pour voir toutes les modifications, y compris celles apportées à README.md, vous pouvez utiliser :

git stash apply stash@{1}

Maintenant, si vous vérifiez le statut à nouveau, vous devriez voir à la fois les modifications apportées à README.md et notes.txt comme un fichier non suivi.

Cette situation souligne un aspect important de la manipulation des piles d'états : l'ordre dans lequel vous créez et appliquez les piles d'états peut affecter le résultat. Il est toujours recommandé de vérifier le contenu de vos piles d'états avant de les appliquer, surtout lorsque vous travaillez avec plusieurs piles d'états.

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

git stash clear
git stash -u
git stash list

Nous commençons par supprimer toutes les piles d'états pour repartir sur de bonnes bases, puis nous mettons nos modifications en attente avec l'option -u pour inclure les fichiers non suivis. Enfin, nous listons nos piles d'états pour vérifier que la pile d'états a été créée.

Mettons nos modifications en attente à nouveau et essayons pop :

git stash pop

Vous verrez un résultat similaire à celui obtenu précédemment, mais si vous exécutez git stash list maintenant, vous verrez que votre pile d'états est vide.

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

Création d'une branche à partir d'une pile d'états (stash)

Parfois, vous pourriez réaliser que les modifications que vous avez mises en attente devraient en fait être sur une branche à part. Git facilite cette opération grâce à la commande git stash branch.

Tout d'abord, créons quelques nouvelles modifications et mettons-les en attente :

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 sur cette branche et applique ensuite les modifications mises en attente. La pile d'états est ensuite supprimée de votre liste de piles d'états.

Vous devriez voir un résultat similaire à ceci :

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 mis en attente des modifications expérimentales et que vous décidez plus tard qu'elles valent la peine d'être poursuivies sur une branche à part.

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

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

Pour revenir à votre branche principale (master), utilisez :

git checkout master

Gestion de plusieurs piles d'états (stashes)

Lorsque vous utilisez Git, vous pourriez vous retrouver à mettre en attente plusieurs ensembles de modifications. Git vous permet de gérer facilement plusieurs piles d'états. Explorons comment créer, lister et gérer plusieurs piles d'états.

Tout d'abord, créons trois piles d'états avec différentes modifications :

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

## Second stash with untracked file
echo "Change 2" >> README.md
echo "Note 2" >> notes.txt
git stash push -u -m "Second change"

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

Analysons ce que nous avons fait :

1. Créé la première pile d'états avec une modification apportée à README.md
2. Créé la deuxième pile d'états avec à la fois une modification apportée à README.md et un nouveau fichier non suivi
3. Créé la troisième pile d'états avec une autre modification apportée à README.md
4. Utilisé le flag -m pour ajouter des messages descriptifs
5. Utilisé le flag -u pour la deuxième pile d'états afin d'inclure le fichier non suivi

Maintenant, listons nos piles d'états :

git stash list

Vous devriez voir un résultat similaire à ceci :

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 pile d'états sans l'appliquer :

git stash show stash@{1}

Pour plus de détails, ajoutez le flag -p pour voir la différence complète (diff) :

git stash show -p stash@{1}

Créons deux autres piles d'états pour pratiquer la gestion d'un ensemble plus important de modifications :

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

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

Vérifiez à nouveau votre liste de piles d'états :

git stash list

Vous devriez maintenant voir cinq piles d'états 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 piles d'états peut être utile lorsque vous gérez plusieurs tâches en même temps. Cependant, évitez d'accumuler trop de piles d'états car cela peut devenir confus. Pensez à utiliser des branches pour les travaux à plus long terme.

N'oubliez pas : les piles d'états sont destinées à être temporaires. Si vous vous rendez compte que vous conservez des piles d'états pendant longtemps, envisagez d'utiliser des branches de fonctionnalités (feature branches) ou de valider (commit) vos modifications à la place.

Nettoyage des piles d'états (stashes)

Au fur et à mesure que vous utilisez les piles d'états dans votre flux de travail, vous risquez d'accumuler des piles d'états que vous n'avez plus besoin. Il est recommandé de nettoyer régulièrement vos piles d'états pour garder tout organisé.

Pour supprimer une seule pile d'états, vous pouvez utiliser la commande drop que nous avons vue précédemment :

git stash drop stash@{2}

Cela supprime la pile d'états la plus ancienne de notre liste.

Si vous souhaitez supprimer toutes vos piles d'états d'un coup, vous pouvez utiliser :

git stash clear

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

Une autre commande utile est git stash pop, que nous avons également vue précédemment. Elle applique la pile d'états la plus récente puis la supprime de la liste des piles d'états :

git stash pop

N'oubliez pas qu'il est généralement recommandé de garder votre liste de piles d'états courte. Les piles d'états sont destinées au stockage temporaire de travaux en cours. Si vous vous rendez compte que vous accumulez de nombreuses piles d'états, cela pourrait être un signe que vous devriez valider (commit) vos modifications plus souvent ou créer des branches de fonctionnalités (feature branches) pour les travaux à plus long terme.

Résumé

Félicitations, maître des piles d'états (stash) Git! Vous venez d'ajouter un nouvel outil puissant à votre boîte à outils Git. Récapitulons les concepts clés que nous avons couverts :

1. Mise en attente des modifications : Vous avez appris à stocker temporairement vos travaux en cours à l'aide de git stash.
2. Application des modifications mises en attente : Vous avez découvert comment récupérer vos modifications mises en attente en utilisant git stash apply et git stash pop.
3. Création de branches à partir de piles d'états : Vous avez vu comment transformer un ensemble de modifications mis en attente en une nouvelle branche avec git stash branch.
4. Gestion de plusieurs piles d'états : Vous avez appris à travailler avec plusieurs piles d'états, en appliquant et en affichant des piles d'états spécifiques selon les besoins.
5. Nettoyage des piles d'états : Vous avez pratiqué une bonne hygiène des piles d'états en apprenant à supprimer des piles d'états individuelles et à vider toutes les piles d'états.

La fonctionnalité de piles d'états de Git est incroyablement utile car elle vous permet de changer rapidement de contexte sans valider (commit) des travaux inachevés. C'est parfait pour les moments où vous devez rapidement changer de tâche ou de branche.

N'oubliez pas que bien que les piles d'états soient utiles, elles sont destinées à être temporaires. Pour les travaux à plus long terme, il est généralement préférable de valider vos modifications ou de créer une nouvelle branche. Utilisez les piles d'états judicieusement, et elles vous aideront à maintenir un flux de travail fluide et flexible.