git-stash - En ligne dans le Cloud

PROGRAMME:

Nom

git-stash - Rangez les modifications dans un répertoire de travail sale

SYNOPSIS

jet planque liste [ ]
jet planque spectacle [ ]
jet planque drop [-q|--silencieux] [ ]
jet planque ( pop | appliquer ) [--index] [-q|--quiet] [ ]
jet planque branche [ ]
jet planque [enregistrer [-p|--patch] [-k|--[no-]keep-index] [-q|--quiet]
[-u|--include-untracked] [-a|--all] [ ]]
jet planque clair
jet planque créer [ ]
jet planque stocker [-m|--message ] [-q|--silencieux]

DESCRIPTION

Utilisez git stash lorsque vous souhaitez enregistrer l'état actuel du répertoire de travail et le
index, mais souhaitez revenir à un répertoire de travail propre. La commande enregistre votre local
modifications et rétablit le répertoire de travail pour qu'il corresponde au commit HEAD.

Les modifications cachées par cette commande peuvent être répertoriées avec git stash list,
inspecté avec git stash show et restauré (potentiellement au-dessus d'un commit différent)
avec git stash s'appliquent. Appeler git stash sans aucun argument équivaut à git stash
enregistrer. Une cache est par défaut répertoriée comme « WIP sur Nom de la filiale ...", mais vous pouvez donner plus
message descriptif sur la ligne de commande lorsque vous en créez un.

La dernière cachette que vous avez créée est stockée dans refs/stash ; des caches plus anciennes se trouvent dans le
reflog de cette référence et peut être nommé en utilisant la syntaxe reflog habituelle (par exemple stash@{0} est
la cachette la plus récemment créée, cachette@{1} est celle qui la précède, cachette@{2.heures.ago} est
aussi possible).

OPTIONS

enregistrer [-p|--patch] [-k|--[no-]keep-index] [-u|--include-untracked] [-a|--all] [-q|--quiet]
[ ]
Enregistrez vos modifications locales dans un nouveau planque, et exécutez git reset --hard pour les annuler.
Les partie est facultative et donne la description ainsi que l'état caché.
Pour faire rapidement un instantané, vous pouvez omettre tous les deux "enregistrer" et , mais en ne donnant que
ne déclenche pas cette action pour empêcher une sous-commande mal orthographiée de faire
une cachette indésirable.

Si l'option --keep-index est utilisée, toutes les modifications déjà ajoutées à l'index sont conservées
intact.

Si l'option --include-untracked est utilisée, tous les fichiers non suivis sont également cachés et
puis nettoyé avec git clean, laissant le répertoire de travail dans un état très propre.
Si l'option --all est utilisée à la place, les fichiers ignorés sont cachés et nettoyés dans
en plus des fichiers non suivis.

Avec --patch, vous pouvez sélectionner de manière interactive des morceaux à partir de la différence entre HEAD et le
arbre de travail à ranger. L'entrée de cache est construite de telle sorte que son état d'index
est le même que l'état de l'index de votre référentiel, et son arbre de travail ne contient que le
les modifications que vous avez sélectionnées de manière interactive. Les modifications sélectionnées sont ensuite annulées à partir de
votre arbre de travail. Voir la section « Mode interactif » de git-ajouter(1) pour apprendre à
utiliser le mode --patch.

L'option --patch implique --keep-index. Vous pouvez utiliser --no-keep-index pour remplacer cela.

liste [ ]
Faites la liste des caches que vous possédez actuellement. Chaque planque est répertorié avec son nom (par exemple
stash@{0} est la dernière stash, stash@{1} est la précédente, etc.), le nom du
branche qui était en cours lorsque le stash a été fait, et une brève description du commit
la cachette était basée sur.

stash@{0} : WIP lors de la soumission : 6ebd0e2... Mettre à jour la documentation git-stash
stash@{1} : sur le maître : 9cc0589... Ajouter git-stash

La commande prend les options applicables au jet enregistrer commande pour contrôler ce qui est affiché
et comment. Voir journal git (1).

spectacle [ ]
Afficher les changements enregistrés dans la cachette comme une différence entre l'état caché et son
parent d'origine. Quand non est donné, montre le dernier. Par défaut, le
La commande affiche le diffstat, mais elle accepte tout format connu de jet diff (par exemple, git
stash show -p stash@{1} pour afficher la deuxième cachette la plus récente sous forme de patch). Vous pouvez
utilisez les variables de configuration stash.showStat et/ou stash.showPatch pour modifier la valeur par défaut
comportement.

pop [--index] [-q|--quiet] [ ]
Supprimez un seul état caché de la liste de cache et appliquez-le au-dessus de l'état actuel
état de l'arbre de travail, c'est-à-dire effectuer l'opération inverse de git stash save. Le travail
répertoire doit correspondre à l'index.

L'application de l'état peut échouer avec des conflits ; dans ce cas, il n'est pas supprimé du
liste de cachette. Vous devez résoudre les conflits à la main et appeler git stash drop manuellement
après.

Si l'option --index est utilisée, alors essaie de rétablir non seulement l'arbre de travail
changements, mais aussi ceux de l'index. Cependant, cela peut échouer, lorsque vous avez des conflits
(qui sont stockées dans l'index, où vous ne pouvez donc plus appliquer les modifications telles que
ils l'étaient à l'origine).

Quand non est donné, stash@{0} est supposé, sinon doit être une référence
de la forme stash@{ }.

appliquer [--index] [-q|--quiet] [ ]
Comme pop, mais ne supprime pas l'état de la liste de cachette. Contrairement à la pop, Peut être
tout commit qui ressemble à un commit créé par stash save ou stash create.

branche [ ]
Crée et extrait une nouvelle branche nommée à partir du commit à
lequel à a été créé à l'origine, applique les modifications enregistrées dans à
le nouvel arbre de travail et l'index. Si cela réussit, et est une référence du
forme cache@{ }, il supprime ensuite le . Quand non est donné, s'applique
le dernier.

Ceci est utile si la branche sur laquelle vous avez exécuté git stash save a suffisamment changé pour que
git stash apply échoue en raison de conflits. Étant donné que la cachette est appliquée sur le dessus de la
commit qui était HEAD au moment où git stash a été exécuté, il restaure l'original stash
État sans conflits.

clair
Supprimez tous les états cachés. Notez que ces états seront ensuite soumis à un élagage,
et peut être impossible à récupérer (voir Exemples ci-dessous pour une stratégie possible).

drop [-q|--silencieux] [ ]
Supprimez un seul état caché de la liste de cache. Quand non est donné, il
supprime le dernier. c'est-à-dire stash@{0}, sinon doit être un journal de cache valide
référence du formulaire stash@{ }.

engendrent
Créez un stash (qui est un objet commit régulier) et retournez son nom d'objet, sans
le stocker n'importe où dans l'espace de noms ref. Ceci est destiné à être utile pour les scripts.
Ce n'est probablement pas la commande que vous souhaitez utiliser ; voir "enregistrer" ci-dessus.

Boutique
Stocker une réserve donnée créée via jet planque engendrent (qui est un commit de fusion en suspens) dans
la référence de la cachette, mettant à jour le reflog de la cachette. Ceci est destiné à être utile pour les scripts.
Ce n'est probablement pas la commande que vous souhaitez utiliser ; voir "enregistrer" ci-dessus.

DISCUSSION

Un stash est représenté comme un commit dont l'arbre enregistre l'état du répertoire de travail,
et son premier parent est le commit à HEAD lorsque le stash a été créé. L'arbre du
le deuxième parent enregistre l'état de l'index lorsque la cache est faite, et il est fait un
enfant du commit HEAD. Le graphique d'ascendance ressemble à ceci :

.----W
/ /
-----SALUT

où H est le commit HEAD, I est un commit qui enregistre l'état de l'index, et W est un
commit qui enregistre l'état de l'arbre de travail.

EXEMPLES

Tirer dans un arbre sale
Quand vous êtes au milieu de quelque chose, vous apprenez qu'il y a des changements en amont
qui sont peut-être pertinents pour ce que vous faites. Lorsque vos modifications locales ne
conflit avec les changements en amont, un simple git pull vous permettra de vous déplacer
vers l'avant.

Cependant, il existe des cas dans lesquels vos modifications locales entrent en conflit avec les modifications en amont.
modifications, et git pull refuse d'écraser vos modifications. Dans un tel cas, vous pouvez ranger
vos modifications, effectuez une extraction, puis déstockez, comme ceci :

$ git tirer

fichier foobar pas à jour, impossible de fusionner.
$ git cachette
$ git tirer
$ git cachette pop

Flux de travail interrompu
Lorsque vous êtes au milieu de quelque chose, votre patron entre et exige que vous répariez
quelque chose immédiatement. Traditionnellement, vous vous engagez dans une branche temporaire pour
stockez vos modifications et retournez dans votre succursale d'origine pour effectuer la réparation d'urgence,
comme ça:

# ... pirater pirater pirater ...
$ git checkout -b mon_wip
$ git commit -a -m "WIP"
$ git checkout maître
$ modifier le correctif d'urgence
$ git commit -a -m "Réparer rapidement"
$ git checkout mon_wip
$ git reset --soft HEAD^
# ... continuez à pirater ...

Vous pouvez utiliser jet planque pour simplifier ce qui précède, comme ceci :

# ... pirater pirater pirater ...
$ git cachette
$ modifier le correctif d'urgence
$ git commit -a -m "Réparer rapidement"
$ git cachette pop
# ... continuez à pirater ...

Tester les commits partiels
Vous pouvez utiliser git stash save --keep-index lorsque vous souhaitez effectuer deux ou plusieurs commits
des modifications dans l'arbre de travail, et vous souhaitez tester chaque modification avant de valider :

# ... pirater pirater pirater ...
$ git add --patch foo # ajoute juste la première partie à l'index
$ git stash save --keep-index # enregistre toutes les autres modifications apportées à la stash
$ modifier/construire/tester la première partie
$ git commit -m 'Première partie' # commit le changement entièrement testé
$ git stash pop # préparez-vous à travailler sur tous les autres changements
# ... répétez les cinq étapes ci-dessus jusqu'à ce qu'il reste un commit ...
$ modifier/construire/tester les pièces restantes
$ git commit foo -m 'Parties restantes'

Récupérer des caches qui ont été effacées/abandonnées par erreur
Si vous laissez tomber ou effacez par erreur des cachettes, elles ne peuvent pas être récupérées par le biais de la procédure normale.
mécanismes de sécurité. Cependant, vous pouvez essayer l'incantation suivante pour obtenir une liste de
caches qui sont toujours dans votre référentiel, mais qui ne sont plus accessibles :

git fsck --inaccessible |
grep commit | couper -d\ -f3 |
xargs git log --merges --no-walk --grep=WIP

Utilisez git-stash en ligne en utilisant les services onworks.net