Si vous souhaitez travailler dans le Big Data ou le DevOps, vous devez maîtriser bon nombre d’outils essentiels. C’est le cas des outils tels que Docker, Kubernetes ou encore Git. Si vous ne les connaissez pas encore, nous vous invitons à parcourir notre blog, car il existe des guides complets sur chacun d’eux. Mais aujourd’hui, nous allons nous concentrer sur Git et plus précisément sur une de ses commandes à savoir git stash.

La commande git stash ou stashe permet de stocker les changements effectués sur la copie de votre travail pendant un laps temps. L’objectif est de vous permettre d’effectuer d’autres tâches avant de revenir et exécuter les changements. Il est très facile de passer d’un contexte de travail à un autre grâce au stashing. Dans cet article nous allons découvrir la manière d’utiliser cette commande et le moment où l’on doit l’utiliser.

Quelle est l’utilité de la commande git stash ?

Avant de répondre à cette question, il faut chercher à savoir pourquoi le stockage des modifications dans Git est crucial.

Pour comprendre cela, supposons qu’il n’existe pas une commande dans Git pour permettre le stockage des modifications. 

Par exemple, si nous avons deux branches dans un référentiel, la première nommée A et la deuxième nommée B. À un moment donné, A et B divergent l’une de l’autre pendant un certain temps et ont des sources différentes.

Soudain, à notre grande surprise, l’équipe demande une assistance afin de corriger un bug dans la branche B alors que l’on travaille sur certains fichiers de la branche A. Alors là, on est obligé de sortir de cette dernière pour corriger le bug. C’est lors de ce genre de situation que l’on trouve l’utilité de la commande git stash. 

Pour ne pas perdre le travail en cours sur la branche A, on doit enregistrer temporairement les changements. En effet, en voulant nous rendre directement sur la branche B grâce à git checkout B, Git écrase automatiquement toutes les modifications apportées aux fichiers dans la branche A.

C’est pour éviter cela que Git stash est conçu. Cette commande va enregistrer localement les modifications non validées. Cela permet de changer branche sans écraser des données en cours de traitement.

Voici comment elle fonctionne réellement et comment elle encode l’arborescence du travail et l’index en forme de commit :

  • Avant de lancer un stash, il se peut que les modifications apportées aux fichiers traqués soient présentes dans l’arborescence du travail.
avant-stashing
  • Une fois qu’on a lancé la commande git stash, les modifications apportées aux fichiers traqués se regroupent en deux commits. L’un est pour le changement non stashé et l’autre pour stashé dans l’index.
apres-stashing
  • Maintenant, si l’on ajoute l’option – -include -untracked, l’encodage change.
stash-include-untracked
  • Avec l’option – -all, git stash prend en compte toutes les modifications apportées aux fichiers ignorés ainsi que les fichiers non traqués.
git-stash-all

Comment utiliser git stash dans notre cas ?

Pour réussir à l’utiliser, il faut suivre les étapes suivantes :

  • Sauvegarder les modifications de la branche A ;
  • Lancer la commande git stash ;
  • Aller sur la branche B pour corriger le bug ;
  • Revenir sur la branche A ;
  • Lancer la commande git stash pop pour la récupération de vos modifications.

Toutes les modifications sont stockées par Git dans le répertoire git/refs/stash. Ainsi, on peut rapidement les récupérer en cas de besoin. C’est vraiment pratique, surtout quand on a besoin de basculer d’une branche à une autre.

Comment créer une réserve ?

Comme vous le savez déjà, la commande la plus simple pour sauvegarder les changements est git stash.

En effet, cette commande stocke par défaut les modifications non validées et ignore les fichiers non suivis. 

Généralement, il n’est pas nécessaire de stocker les fichiers non suivis, mais il arrive parfois que ces fichiers interfèrent avec d’autres fichiers sur lesquels on travaille.

Dans ce cas, il existe quelques options pour permettre à git stash de sauvegarder les fichiers non suivis :

  • Stocker des fichiers non suivis avec git stash -u ou git stash — include -untracked ;
  • Sauvegarder les fichiers ignorés et non suivis avec git stash -a ou git stash –all ;
  • Et stocker des fichiers biens spécifiques avec git stash -p ou git stash -patch.

Comment récupérer des modifications stockées ?

Pour récupérer vos modifications sauvegardées, il faut passer par les deux commandes suivantes : git stash apply et git stash pop. Ces deux commandes permettent de retrouver les modifications stockées dans la dernière réserve stash@{0}.

Quand on utilise pop pour récupérer les modifications, elle supprime la sauvegarde après qu’elle nous les présente, mais avec apply, la sauvegarde demeure toujours.

Pour faire apparaître les modifications, on peut utiliser comme argument le répertoire où les fichiers sont stockés, comme ceci :

git stash pop stash@{1}

ou

git stash apply stash@{1}

Comment lister les modifications sauvegardées dans Git ?

Les modifications sont stockées selon une approche LIFO, c’est-à-dire le dernier entré, le premier sorti. La commande à utiliser est la suivante :

git stash list

Comment effacer les modifications sauvegardées dans Git ?

Il est conseillé de supprimer les changements sauvegardés qui ne sont plus utiles. Cela se fait manuellement grâce aux commandes suivantes :

  • git stash clear qui sert à vider le répertoire ;
  • git stash drop <stash_id> qui sert à supprimer un fichier en particulier.

Comment afficher des comparaisons entre stash ?

Grâce à la commande git stash show, on obtient un résumé sur nos stash.

$ git stash show
 index.html | 1 +
 style.css | 3 +++
 2 files changed, 4 insertions(+)

Comment gérer plusieurs stashes ?

Il faut savoir que l’utilisation de git stash n’est pas limitée. On a la possibilité de la lancer plusieurs fois pour créer différentes stashes.

Git identifie les stashes par défaut comme WIP c’est-à-dire Work In Progress en haut de la branche et du commit à partir duquel on a créé le stash. Si l’on crée plusieurs stashes, il serait difficile de se souvenir de ce que contient chaque stash. C’est pour cela qu’il est nécessaire de les gérer un par un afin de les différencier. Pour ce faire, il faut lancer la commande suivante pour tout d’abord les lister :

$ git stash list
stash@{0}: WIP on main: 5002d47 our new homepage
stash@{1}: WIP on main: 5002d47 our new homepage
stash@{2}: WIP on main: 5002d47 our new homepage

Pour plus de clarté, on peut par exemple y ajouter un message avec git stash “message”.

$ git stash save "ajout de style au site"
Saved working directory and index state On main: ajout de style au site
HEAD is now at 5002d47 our new homepage

$ git stash list
stash@{0}: On main: ajout de style au site
stash@{1}: WIP on main: 5002d47 our new homepage
stash@{2}: WIP on main: 5002d47 our new homepage

Comment créer une branche depuis un stash ?

Parfois, les changements dans une branche peuvent être différents de celles se trouvant dans le stash. Cela peut provoquer un conflit quand on aura besoin d’utiliser les changements stashés.

Donc pour éviter cela, il faut créer une branche dans laquelle on pourra appliquer les changements stashés. La commande à utiliser dans ce cas est la suivante :

$ git stash branch 

Ainsi, il y aura une nouvelle branche basée sur le commit dans laquelle on pourra lancer nos stash. Tous nos changements se trouveront sur cette branche.

Comment stocker nos changements sans déranger le reflog de la réserve ?

Il y a des cas rares où l’on devra créer un stash tout en conservant le reflog, c’est-à-dire le journal de référence du stash intact. Ce genre de situation arrive quand on a besoin de stocker un script en tant que détail d’implémentation. Pour réaliser cela, il faut lancer la commande git stash create. Cette dernière crée une entrée de cachette et renvoie son nom d’objet sans le pousser vers le journal de référence.

Quelle est la différence entre la commande git stash et d’autre commande ?

git satsh VS git commit

Ces deux commandes sont similaires dans le sens où elles prennent un instantané des fichiers modifiés et le stockent dans un répertoire de Git. Les points divergents entre les deux commandes sont les suivantes :

  • Un commit crée un nouveau répertoire de sauvegarde dans la branch tandis que le stash utilise le point de sauvegarde précédent ;
  • Un commit ne supprime pas les fichiers de travail et les gardes intacts, mais le stash réinitialise les fichiers ;
  • git commit est une opération publique de modification de fichiers alors que stash est locale.

git stash VS git reset

Ces deux commandes sont, quant à elles, similaires dans le sens où elles ramènent tous les fichiers du répertoire à l’état initial. Les points qui les différentient sont les suivantes :

  • La commande reset créé lors de son exécution un nouveau point de validation dans l’historique de la branche tandis que stash ne le fait pas ;
  • reset peut revenir à n’importe quel état précédent alors que stash ne peut revenir qu’à l’état précédent dans l’espace de travail ;
  • reset annule toutes les modifications en cours, mais stash garde les instantanés des fichiers modifiés.

git stash VS git stage

Ces deux commandes peuvent être confondues simplement au niveau de leur nom, mais il faut noter qu’elles sont belles et bien différentes. git stage ajoute simplement des fichiers à l’index git pour les permettre de figurer parmi les instantanés du système de fichier lorsqu’un commit se produit.

Voilà, nous sommes arrivés à la fin de cet article. En résumé, dans le domaine de développement logiciel, il est inévitable d’apporter des modifications au code source du projet. Beaucoup de développeurs se retrouvent parfois dans une situation où ils ne sont pas sûrs de leur modification de code. Et pour ne pas perdre les changements effectués avant de s’en assurer, git stash est là pour leur permettre de sauvegarder les changements. Ainsi, quelles que soient l’interruption ou les autres actions qui doivent être effectuées avant la validation de ces modifications, le projet n’est jamais compromis.

Si vous souhaitez continuer votre lecture, il existe sur notre blog plusieurs articles sur Git ainsi que sur d’autres sujets Big Data et DevOps. Nous vous invitons également à recevoir gratuitement notre formation sur le développement d’applications Spark avec Scala afin d’augmenter vos compétences en Big Data.


Juvénal JVC

Juvénal est spécialisé depuis 2011 dans la valorisation à large échelle des données. Son but est d'aider les professionnels de la data à développer les compétences indispensables pour réussir dans le Big Data. Il travaille actuellement comme Lead Data Engineer auprès des grands comptes. Lorsqu'il n'est pas en voyage, Juvénal rédige des livres ou est en train de préparer la sortie d'un de  ses livres. Vous pouvez télécharger un extrait de son dernier livre en date ici : https://www.data-transitionnumerique.com/extrait-ecosystme-hadoop/

>