Git 🌙
Português (Brasil) ▾ Topics ▾ Latest version ▾ git-stash last updated in 2.43.0

NOME

git-stash - Guarda as alterações em um outro diretório de trabalho

RESUMO

git stash list [<opções-do-log>]
git stash show [-u | --include-untracked | --only-untracked] [<opções-do-diff>] [<stash>]
git stash drop [-q | --quiet] [<stash>]
git stash pop [--index] [-q | --quiet] [<stash>]
git stash apply [--index] [-q | --quiet] [<stash>]
git stash branch <branchname> [<stash>]
git stash [push [-p | --patch] [-S | --staged] [-k | --[no-]keep-index] [-q | --quiet]
	     [-u | --include-untracked] [-a | --all] [(-m | --message) <mensagem>]
	     [--pathspec-from-file=<file> [--pathspec-file-nul]]
	     [--] [<pathspec>…​]]
git stash save [-p | --patch] [-S | --staged] [-k | --[no-]keep-index] [-q | --quiet]
	     [-u | --include-untracked] [-a | --all] [<message>]
git stash clear
git stash create [<mensagem>]
git stash store [(-m | --message) <mensagem>] [-q | --quiet] <commit>

DESCRIÇÃO

Use o comando git stash quando quiser registrar o estado atual do diretório de trabalho e do índice, mas queira retornar para um diretório de trabalho limpo. O comando salva a suas alterações locais e reverte o diretório de trabalho para corresponder ao commit HEAD.

As alterações armazenadas por este comando podem ser listadas com o comando git stash list, inspecionadas através do comando git stash show e restauradas (potencialmente em cima de um commit diferente) com o comando git stash apply. Ao invocar o comando git stash sem nenhum argumento é o mesmo que usar o comando git stash push. É predefinido que um "stash" seja listado como "WIP on branchname …​", mas você pode dar uma mensagem mais descritiva na linha de comando ao criá-lo.

O último "stash" que você criou é armazenado em refs/stash; os "stash" mais antigos são encontrados no "reflog" desta referência e podem ser nomeados usando a sintaxe usual do "reflog" (por exemplo, stash@{0} é o "stash" criado mais recentemente, o stash@{1} é o anterior, o stash@{2.hours.ago} também é possível). As pilhas "stash" também podem ser referenciadas definindo apenas o índice "stash" (por exemplo, o número inteiro n é o equivalente a um stash@{n}).

COMANDOS

push [-p|--patch] [-S|--staged] [-k|--[no-]keep-index] [-u|--include-untracked] [-a|--all] [-q|--quiet] [(-m|--message) <mensagem>] [--pathspec-from-file=<arquivo> [--pathspec-file-nul]] [--] [<pathspec>…​]

Salve as suas alterações locais numa nova "entrada de armazenamento" (stash entry) e reverta-as para HEAD (na árvore de trabalho e no índice). A parte da <mensagem> é opcional e fornece a descrição juntamente com o estado de armazenamento.

Para criar rapidamente um instantâneo, você pode omitir "push". Neste modo, argumentos que não sejam opções não são permitidos para evitar que um subcomando mal escrito faça uma entrada indesejada no estoque. As duas exceções são stash -p, que atua como um atalho para stash push -p e elementos pathpec, que são permitidos após um hífen duplo -- para desambiguação.

save [-p|--patch] [-S|--staged] [-k|--[no-]keep-index] [-u|--include-untracked] [-a|--all] [-q|--quiet] [<mensagem>]

Esta opção foi descontinuada em favor do comando git stash push. Ele difere do "stash push" pelo fato de não poder usar o pathspec. Em vez disso, todos os argumentos sem opção são concatenados para formar a mensagem de armazenamento.

list [<opções-do-registro-log>]

Liste as entradas do "stash" que você tem atualmente. Cada "entrada da pilha" (stash entry) é listada com seu nome (por exemplo, stash@{0} é a entrada mais recente, stash@{1} é a anterior, etc.), o nome do ramo que estava ativo quando a entrada foi feita e uma breve descrição do commit onde a entrada se baseou.

stash@{0}: WIP on submit: 6ebd0e2... Update git-stash documentation
stash@{1}: On master: 9cc0589... Add git-stash

O comando aceita as opções aplicáveis ao comando git log para controlar o que é exibido e como. See git-log[1].

show [-u|--include-untracked|--only-untracked] [<opções-do-diff>] [<stash>]

Mostra as alterações registradas na entrada do estoque (stash) como uma diferença entre o conteúdo do estoque e o commit de quando a entrada do estoque foi criado pela primeira vez. É predefinido que o comando mostre o diffstat, mas aceitará qualquer formato conhecido pelo comando git diff (por exemplo, git stash show -p stash@{1} para visualizar a segunda entrada mais recente em forma de correção). Se nenhuma <opções-diff> for informada, o comportamento padrão será dado pelas variáveis de configuração em stash.showStat e em stash.showPatch. Você também pode usar stash.showIncludeUntracked para definir se a opção --include-untracked está predefinitivamente ativa.

pop [--index] [-q|--quiet] [<stash>]

Remova a única condição do empilhamento da lista e aplique-o sobre a condição atual da árvore de trabalho, ou seja, faça a operação inversa do comando git stash push. O diretório de trabalho deve corresponder ao índice. O diretório de trabalho deve coincidir com o índice.

A aplicação da condição pode falhar com conflitos; neste caso, ele não é removido da lista stash. É necessário resolver os conflitos manualmente e chamar o comando git stash drop manualmente depois.

apply [--index] [-q|--quiet] [<stash>]

Como pop ', porém não remova a condição da lista de estoque 'stash'. Diferente de `pop, <stash> pode ser qualquer commit que se pareça com um commit criado através do comando stash push ou stash create.

branch <nome-do-ramo> [<stash>]

Cria e verifica um novo ramo chamado <nome-do-ramo> a partir do commit onde o <stash> foi originalmente criado, aplica as alterações registradas no <stash> à nova árvore de trabalho e ao índice. Se isso for bem-sucedido e o <stash> for uma referência do tipo stash@{<revisão>}, ele eliminará o <stash>.

É útil caso o ramo onde você executou o git stash push mude o suficiente para que o git stash apply falhe devido aos conflitos. Como a entrada que está acumulada "stash" é aplicada no topo do commit que era o HEAD no momento onde o git stash foi executado, ela restaura a condição originalmente armazenada e sem os conflitos.

clear

Remova todos os lançamentos que estiverem armazenados. Observe que estas entradas estarão sujeitas a remoção e podem ser impossíveis de serem recuperadas (consulte Exemplos abaixo para uma possível estratégia).

drop [-q|--quiet] [<stash>]

Remova uma única entrada "stash" da lista das entradas "stash".

create

Crie uma entrada no estoque (onde é um objeto de commit regular) e retorne o nome do objeto, sem armazená-lo em nenhum lugar no espaço de nome ref. Esse recurso deve ser útil para scripts. Provavelmente, esse não é o comando que você deseja usar; consulte "push" acima.

store

Armazena um determinado estoque criado via comando git stash create (onde é a mesclagem de um commit pendente) na referência do estoque, atualizando o reflog do estoque. Esse recurso deve ser útil para scripts. Provavelmente, esse não é o comando que você deseja usar; consulte "push" acima.

OPÇÕES

-a
--all

Esta opção só é válida para os comandos push e save.

Todos os arquivos ignorados e não monitorados também são armazenados em cache e limpos com o comando git clean.

-u
--include-untracked
--no-include-untracked

Quando usado em conjunto com os comandos push e save, todos os arquivos não monitorados também são armazenados em cache e limpos com o comando git clean.

Quando usado com o comando show, mostra os arquivos não rastreados na entrada acumulada como parte do diff.

--only-untracked

Esta opção só é válida para o comando show.

Mostra apenas os arquivos não rastreados na entrada do stash como parte do diff.

--index

Esta opção só é válida para os comandos pop e apply.

Tenta restabelecer não apenas as alterações da árvore de trabalho, mas também as do índice. No entanto, isso pode falhar quando há conflitos (que são armazenados no índice e portanto, não é mais possível aplicar as alterações como eram originalmente).

-k
--keep-index
--no-keep-index

Esta opção só é válida para os comandos push e save.

Todas as alterações que já foram adicionadas ao índice não são alteradas.

-p
--patch

Esta opção só é válida para os comandos push e save.

Selecione interativamente as partes da diferença entre o HEAD e a árvore de trabalho a serem armazenadas. A entrada do estoque é construída de maneira que a sua condição no índice seja igual a condição no índice do seu repositório e a sua árvore de trabalho contenha apenas as alterações que você selecionou interativamente. As alterações selecionadas são revertidas de sua árvore de trabalho. Consulte a seção “Modo Interativo” do git-add[1] para saber como operar o modo --patch.

A opção --patch implica no uso da opção --keep-index. Você pode usar a opção --no-keep-index para substituir isso.

-S
--staged

Esta opção só é válida para os comandos push e save.

Armazene apenas as alterações que estão sendo preparadas atualmente. Isto é similar ao comando git commit básico, exceto que o estado do commit é feito na pilha armazenada em vez do ramo atual.

A opção --patch tem prioridade sobre esta.

--pathspec-from-file=<arquivo>

Esta opção só é válida para o comando push.

O "pathspec" é passado com <arquivo> em vez dos argumentos da linha de comando. Caso o <arquivo> seja exatamente -, a entrada padrão será utilizada. Os elementos do "pathspec" são separados por caracteres de término de linha LF ou CR/LF. Os elementos do "pathspec" podem ser citados conforme explicado na variável de configuração core.quotePath (consulte git-config[1]). Consulte também opção --pathspec-file-nul e o global --literal-pathspecs.

--pathspec-file-nul

Esta opção só é válida para o comando push.

Só faz algum sentido caso seja utilizado junto com a opção --pathspec-from-file. Os elementos "pathspec" são separados com caracteres NUL e todos os outros caracteres são considerados de forma literal (incluindo as novas linhas e as citações).

-q
--quiet

Esta opção só é válida para os comandos apply, drop, pop, push, save e store.

Silencioso, suprima as mensagens de feedback.

--

Esta opção só é válida para o comando push.

Separa o pathspec das opções para fins de desambiguação.

<pathspec>…​

Esta opção só é válida para o comando push.

A nova entrada no estoque registra os estados modificados apenas para os arquivos que correspondem ao pathpec. As entradas de índice e os arquivos da árvore de trabalho são revertidos para o estado em HEAD somente para esses arquivos também, deixando intactos os arquivos que não correspondem ao pathpec.

Para mais detalhes sobre a sintaxe, consulte a entrada pathspec em gitglossary[7].

<stash>

Esta opção só é válida para os comandos apply, branch, drop, pop e show.

Uma referência do formulário stash@{<revisão>}. Quando nenhum <stash> é informado, o último "stash" é assumido (ou seja, stash@{0}).

DISCUSSÃO

Uma entrada no estoque é representada como um commit cuja árvore registra a condição do diretório de trabalho, e o seu principal primário é o commit em HEAD quando a entrada foi criada. A árvore do principal secundário registra a condição do índice quando a entrada é feita, e ela se torna um relacionado do commit HEAD. O gráfico de ascendência tem a seguinte aparência:

       .----W
      /    /
-----H----I

onde H é o commit HEAD, I é um commit que registra a condição do índice e W é um commit que registra a condição da árvore de trabalho.

EXEMPLOS

Obtendo de um diretório sujo

Quando você está no meio de algo, fica sabendo que há alterações no topo que possivelmente são relevantes para o que você está fazendo. Quando as suas alterações locais não entrarem em conflito com as alterações no topo, um simples git pull permitirá que você siga em frente.

No entanto, há casos onde as suas alterações locais entram em conflito com as alterações no topo e o comando git pull se recusa a substituir as suas alterações. Nesse caso, você pode estocar as suas alterações, fazer um "pull" e, em seguida, desfazer o estoque, da seguinte maneira:

$ git pull
 ...
file foobar not up to date, cannot merge.
$ git stash
$ git pull
$ git stash pop
Fluxo de trabalho interrompido

Quando você está no meio de um trabalho, seu chefe chega e exige que você conserte algo imediatamente. Tradicionalmente, você faria um commit numa ramificação temporária para armazenar as suas alterações e retornaria à ramificação original para fazer a correção de emergência, assim:

# ... hack hack hack ...
$ git switch -c my_wip
$ git commit -a -m "WIP"
$ git switch master
$ edit emergency fix
$ git commit -a -m "Arruma na pressa"
$ git switch my_wip
$ git reset --soft HEAD^
# ... continue a hackear ...

Você pode utilizar o comando git stash para simplificar o exemplo acima:

# ... hack hack hack ...
$ git stash
$ edit emergency fix
$ git commit -a -m "Arrumando na correria"
$ git stash pop
# ... continue a hackear ...
Testando commits parciais

Você pode utilizar o comando git stash push --keep-index quando quiser fazer dois ou mais commits das alterações na árvore de trabalho e queira testar cada uma das alterações antes de fazer o commit:

# ... hack hack hack ...
$ git add --patch foo            # adiciona apenas a primeira parte ao índice
$ git stash push --keep-index    # armazene todas as outras alterações
$ edit/build/test first part
$ git commit -m 'First part'     # faça o commit completo de todas as modificações testadas
$ git stash pop                  # prepare para trabalhar em todas as outras modificações
# ... repita os cinco passos acima até que sobre apenas um commit ...
$ edit/build/test remaining parts
$ git commit foo -m 'Partes resultantes'
Salvando as alterações não relacionadas para utilização futura

Quando estiver no meio de grandes alterações e encontre algum problema não relacionado que você não queira deixar de corrigir, você pode fazer as alterações, organizá-las e usar o comando git stash push --staged deixando guardado para uso posterior. Isso se assemelha ao fazer o commit das alterações acumuladas, apenas o commit acaba ficando armazenado e não no ramo atual.

# ... hack hack hack ...
$ git add --patch foo           # adiciona alterações não relacionadas ao índice
$ git stash push --staged       # salva estas alterações na pilha
# ... hack hack hack, conclui as alterações atuais ...
$ git commit -m 'Massive'       # faz o commit de das alterações totalmente testadas
$ git switch fixup-branch       # alterna para outro ramo
$ git stash pop                 # para concluir o trabalho nas alterações salvas
Recuperando entradas "stash" que foram limpas/eliminadas erroneamente

Se você deixar cair ou limpar entradas de estoque por engano, elas não poderão ser recuperadas por meio dos mecanismos de segurança normais. No entanto, você pode tentar a seguinte magia para obter uma lista de entradas do estoque que ainda estão em seu repositório, mas que não podem mais ser acessadas:

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

CONFIGURAÇÃO

Warning

Missing pt_BR/includes/cmd-config-section-all.txt

See original version for this content.
Warning

Missing pt_BR/config/stash.txt

See original version for this content.

VEJA TAMBÉM

git-checkout[1], git-commit[1], git-reflog[1], git-reset[1], git-switch[1]

GIT

Parte do conjunto git[1]

scroll-to-top