git-stash - Online nel cloud

PROGRAMMA:

NOME

git-stash - Conserva le modifiche in una directory di lavoro sporca

SINOSSI

git scorta elenco [ ]
git scorta mostrare [ ]
git scorta drop [-q|--silenzioso] [ ]
git scorta ( pop | apply ) [--index] [-q|--quiet] [ ]
git scorta ramo [ ]
git scorta [salva [-p|--patch] [-k|--[no-]keep-index] [-q|--quiet]
[-u|--include-untracked] [-a|--all] [ ]]
git scorta pulire campo
git scorta creare [ ]
git scorta memorizzare [-m|--messaggio ] [-q|--tranquillo]

DESCRIZIONE

Usa git stash quando vuoi registrare lo stato corrente della directory di lavoro e il
index, ma si desidera tornare a una directory di lavoro pulita. Il comando salva il tuo locale
elimina le modifiche e ripristina la directory di lavoro in modo che corrisponda al commit HEAD.

Le modifiche nascoste da questo comando possono essere elencate con git stash list,
ispezionato con git stash show e ripristinato (potenzialmente in cima a un commit diverso)
con git stash si applicano. Chiamare git stash senza argomenti è equivalente a git stash
Salva. Una scorta è elencata per impostazione predefinita come "WIP attivato nome del ramo ...", ma puoi dare di più
messaggio descrittivo sulla riga di comando quando ne crei uno.

L'ultima scorta che hai creato è memorizzata in refs/stash; le scorte più vecchie si trovano nel
reflog di questo riferimento e può essere nominato usando la solita sintassi reflog (es stash@{0} is
la scorta creata più di recente, stash@{1} è quella precedente, stash@{2.hours.ago} è
anche possibile).

VERSIONI

salva [-p|--patch] [-k|--[no-]keep-index] [-u|--include-untracked] [-a|--all] [-q|--quiet]
[ ]
Salva le tue modifiche locali in una nuova scortaed esegui git reset --hard per ripristinarli.
Il parte è facoltativa e fornisce la descrizione insieme allo stato nascosto.
Per fare rapidamente un'istantanea, puoi omettere entrambi "salva" e , ma dando solo
non attiva questa azione per impedire l'esecuzione di un sottocomando errato
una scorta indesiderata.

Se viene utilizzata l'opzione --keep-index, tutte le modifiche già aggiunte all'indice vengono lasciate
intatto.

Se viene utilizzata l'opzione --include-untracked, anche tutti i file non tracciati vengono memorizzati e
quindi ripulito con git clean, lasciando la directory di lavoro in uno stato molto pulito.
Se invece viene utilizzata l'opzione --all, i file ignorati vengono nascosti e puliti in
oltre ai file non tracciati.

Con --patch, puoi selezionare interattivamente hunk dal diff tra HEAD e the
albero funzionante da riporre. La voce stash è costruita in modo tale che il suo stato indice
è lo stesso dello stato dell'indice del tuo repository e il suo albero di lavoro contiene solo il
modifiche selezionate in modo interattivo. Le modifiche selezionate vengono quindi ripristinate da
il tuo albero di lavoro. Vedere la sezione "Modalità interattiva" di git-aggiungi(1) per imparare a
utilizzare la modalità --patch.

L'opzione --patch implica --keep-index. Puoi usare --no-keep-index per sovrascriverlo.

elenco [ ]
Elenca le scorte che hai attualmente. Ogni scorta è elencato con il suo nome (es
stash@{0} è l'ultima scorta, stash@{1} è quella precedente, ecc.), il nome del
ramo che era corrente quando è stata creata la scorta e una breve descrizione del commit
la scorta era basata su.

stash@{0}: WIP all'invio: 6ebd0e2... Aggiorna la documentazione di git-stash
stash@{1}: Sul master: 9cc0589... Aggiungi git-stash

Il comando accetta le opzioni applicabili al git ceppo comando per controllare ciò che viene mostrato
e come. Vedere git log(1).

mostrare [ ]
Mostra le modifiche registrate nella scorta come differenza tra lo stato nascosto e il suo
genitore originario. quando no è dato, mostra l'ultimo. Per impostazione predefinita, il
comando mostra il diffstat, ma accetterà qualsiasi formato noto git diff (ad esempio, git
stash show -p stash@{1} per visualizzare la seconda scorta più recente sotto forma di patch). Puoi
usa le variabili di configurazione stash.showStat e/o stash.showPatch per modificare l'impostazione predefinita
comportamento.

pop [--indice] [-q|--silenzioso] [ ]
Rimuovi un singolo stato nascosto dall'elenco di scorta e applicalo sopra quello corrente
stato dell'albero funzionante, ad esempio, eseguire l'operazione inversa di git stash save. Il lavoro
la directory deve corrispondere all'indice.

L'applicazione dello stato può fallire con i conflitti; in questo caso, non viene rimosso dal
lista di scorta. Devi risolvere i conflitti a mano e chiamare manualmente git stash drop
successivamente.

Se viene utilizzata l'opzione --index, prova a ripristinare non solo l'albero di lavoro
cambiamenti, ma anche quelli dell'indice. Tuttavia, questo può fallire, quando si hanno conflitti
(che sono memorizzati nell'indice, dove quindi non è più possibile applicare le modifiche in quanto
erano in origine).

quando no viene fornito, si presume stash@{0}, altrimenti deve essere un riferimento
del modulo stash@{ }.

applica [--indice] [-q|--quiet] [ ]
Come pop, ma non rimuovere lo stato dall'elenco delle scorte. A differenza del pop, può essere
qualsiasi commit che assomigli a un commit creato da stash save o stash create.

ramo [ ]
Crea ed esegue il check-out di un nuovo ramo denominato a partire dal commit at
quale è stato originariamente creato, applica le modifiche registrate in a
il nuovo albero di lavoro e indice. Se ha successo, e è un riferimento del
forma scorta@{ }, quindi rilascia il . quando no è dato, si applica
l'ultimo.

Questo è utile se il ramo su cui hai eseguito git stash save è cambiato abbastanza che
git stash apply fallisce a causa di conflitti. Poiché la scorta viene applicata sopra il
commit che era HEAD al momento dell'esecuzione di git stash, ripristina l'originale nascosto
Stato senza conflitti.

pulire campo
Rimuovi tutti gli stati nascosti. Si noti che tali stati saranno quindi soggetti a potatura,
e potrebbe essere impossibile da recuperare (vedi Esempi di seguito per una possibile strategia).

drop [-q|--silenzioso] [ ]
Rimuovere un singolo stato nascosto dall'elenco di scorta. quando no è dato, è
rimuove l'ultimo. cioè stash@{0}, altrimenti deve essere un registro di scorta valido
riferimento del modulo stash@{ }.

creare
Crea una scorta (che è un normale oggetto di commit) e restituisci il nome dell'oggetto, senza
memorizzandolo ovunque nello spazio dei nomi ref. Questo è pensato per essere utile per gli script.
Probabilmente non è il comando che vuoi usare; vedi "salva" sopra.

Tornare al suo account
Conserva una determinata scorta creata tramite git scorta creare (che è un commit di fusione penzolante) in
il ref stash, aggiornando il reflog stash. Questo è pensato per essere utile per gli script.
Probabilmente non è il comando che vuoi usare; vedi "salva" sopra.

DISCUSSIONE

Uno stash è rappresentato come un commit il cui albero registra lo stato della directory di lavoro,
e il suo primo genitore è il commit in HEAD quando è stato creato lo stash. L'albero della
il secondo genitore registra lo stato dell'indice quando viene creato lo stash, e viene creato a
figlio del commit HEAD. Il grafico dell'ascendenza ha questo aspetto:

.----W
/ /
-----CIAO

dove H è il commit HEAD, I è un commit che registra lo stato dell'indice e W è a
commit che registra lo stato dell'albero di lavoro.

ESEMPI

Tirando su un albero sporco
Quando sei nel mezzo di qualcosa, impari che ci sono cambiamenti a monte
che sono possibilmente rilevanti per quello che stai facendo. Quando le modifiche locali non lo fanno
conflitto con i cambiamenti nell'upstream, un semplice git pull ti permetterà di muoverti
inoltrare.

Tuttavia, ci sono casi in cui le modifiche locali entrano in conflitto con l'upstream
modifiche e git pull si rifiuta di sovrascrivere le modifiche. In tal caso, puoi riporre
le tue modifiche via, esegui un pull e poi unstash, in questo modo:

$ git tirare
...
file foobar non aggiornato, impossibile unire.
$ git scorta
$ git tirare
$ git stash pop

Flusso di lavoro interrotto
Quando sei nel bel mezzo di qualcosa, il tuo capo entra e ti chiede di aggiustare
qualcosa subito. Tradizionalmente, ti impegneresti in un ramo temporaneo per
memorizzare le modifiche e tornare al ramo originale per effettuare la correzione di emergenza,
come questo:

# ... hack hack hack ...
$ git checkout -b mio_wip
$ git commit -a -m "WIP"
$ git checkout master
$ modifica correzione di emergenza
$ git commit -a -m "Riparazione in fretta"
$ git verifica my_wip
$ git reset --soft HEAD^
# ... continua a hackerare ...

Puoi usare git scorta per semplificare quanto sopra, in questo modo:

# ... hack hack hack ...
$ git scorta
$ modifica correzione di emergenza
$ git commit -a -m "Riparazione in fretta"
$ git stash pop
# ... continua a hackerare ...

Testare commit parziali
Puoi usare git stash save --keep-index quando vuoi fare due o più commit
delle modifiche nell'albero di lavoro e si desidera testare ogni modifica prima di eseguire il commit:

# ... hack hack hack ...
$ git add --patch foo # aggiunge solo la prima parte all'indice
$ git stash save --keep-index # salva tutte le altre modifiche allo stash
$ modifica/costruisci/testa la prima parte
$ git commit -m 'Prima parte' # commit del cambiamento completamente testato
$ git stash pop # preparati a lavorare su tutte le altre modifiche
# ... ripeti i cinque passaggi precedenti finché non rimane un commit ...
$ modifica/costruisci/testa le parti rimanenti
$ git commit foo -m 'Parti rimanenti'

Recupero di scorte che sono state cancellate/lasciate erroneamente
Se per errore lasci cadere o svuoti le scorte, non possono essere recuperate attraverso il normale
meccanismi di sicurezza. Tuttavia, puoi provare il seguente incantesimo per ottenere un elenco di
stash che sono ancora nel tuo repository, ma non più raggiungibili:

git fsck --non raggiungibile |
grep commit | taglia -d\ -f3 |
xargs git log --merges --no-walk --grep=WIP

Usa git-stash online usando i servizi onworks.net