Git apply stash: Git — git-stash Documentation

Разница между git stash pop и git stash apply

Я использую git stash pop уже довольно давно. Недавно я узнал о команде git stash apply . Когда я попробовал его, мне показалось, что он работает так же, как и git stash pop .

В чем разница между git stash pop и git stash apply ?

git

git-stash

Поделиться

Источник

Sandeep Raju Prabhakar    

08 марта 2013 в 03:14

6 ответов

• В чем разница между git-stash и git-checkout?

  Я пытаюсь перейти из одного местного отделения в другое. Git говорит мне, что я не могу этого сделать, потому что мой local changes to the following files would be overwritten by checkout . Тогда я получаю recommendation Please, commit your changes or stash them before you can switch branches . Я…

• в чем разница между ‘git stash apply stash@{2}’ и ‘ git stash apply —2’

  скажем, у меня есть список git stash, как показано ниже: $ git stash list stash@{0}: WIP on master: 049d078 added the index file stash@{1}: WIP on master: c264051 Revert added file_size stash@{2}: WIP on master: 21d80a5 added number to log в чем разница между git stash apply stash@{2} и ‘git stash. ..

1694

git stash pop выбрасывает (самый верхний, по умолчанию) тайник после его применения, в то время как git stash apply оставляет его в списке тайников для возможного последующего повторного использования (или вы можете затем git stash drop его).

Это происходит до тех пор , пока не возникнут конфликты после git stash pop, и в этом случае он не удалит тайник, оставив его вести себя точно так же, как git stash apply .

Другой способ взглянуть на это: git stash pop — это git stash apply && git stash drop .

Поделиться

John Zwinck    

08 марта 2013 в 03:15

83

Получил эту полезную ссылку, которая утверждает разницу, как заявил Джон Цвинк, и недостаток git stash pop .

Например, предположим, что ваши скрытые изменения конфликтуют с другими изменениями, которые вы сделали с момента создания тайника. И pop, и apply услужливо вызовут режим разрешения конфликтов слияния, что позволит вам красиво разрешать такие конфликты… и ни один из них не избавится от тайника, хотя, возможно, вы тоже ждете папу. Поскольку многие люди ожидают, что тайники будут просто простой стопкой, это часто приводит к тому, что они случайно вытаскивают тот же самый тайник позже, потому что они думали, что он исчез.

Ссылка: http://codingkilledthecat.wordpress.com/2012/04/27/git-stash-pop-considered-harmful/

Поделиться

briankip    

23 сентября 2013 в 20:42

69

git stash pop применяет верхний скрытый элемент и удаляет его из стека. git stash apply делает то же самое, но оставляет его в стопке тайников.

Поделиться

jchapa    

08 марта 2013 в 03:16

• Почему git stash поп действует как применить

  Кто-нибудь знает, почему капельная часть поп-музыки не сработала бы для меня? папа ведет себя так же, как и я. Мой процесс таков: git stash save name of save git stash pop затем: git stash list (and name of save will still be listed). Введите описание изображения здесь

• Разница между git stash pop и git stash drop

  Разница между git stash pop и git stash drop ? Оба убирают тайник, тогда что же еще?

45

Увидеть его в действии может помочь вам лучше понять разницу.

Предположим, что мы работаем над ветвью master и имеем файл hello.txt , содержащий строку «Hello».

Давайте изменим файл и добавим в него строку «мир». Теперь вы хотите перейти в другую ветку, чтобы исправить незначительную ошибку, которую вы только что обнаружили, поэтому вам нужно stash ваших изменений:

git stash

Вы перешли в другую ветвь, исправили ошибку и теперь готовы продолжить работу над своей ветвью master , поэтому вы pop внесли изменения:

git stash pop

Теперь если вы попытаетесь просмотреть содержимое тайника вы получите:

$ git stash show -p
No stash found.

Однако, если вместо этого вы используете git stash apply , вы получите спрятанный контент, но также сохраните его:

$ git stash show -p
diff --git a/hello.txt b/hello.txt
index e965047..802992c 100644
--- a/hello.txt
+++ b/hello.txt
@@ -1 +1 @@
-Hello
+Hello world

Таким образом, pop точно так же, как pop стека — он фактически удаляет элемент, как только он выскочил, в то время как apply больше похож на peek .

Поделиться

Maroun    

30 ноября 2016 в 12:27

8

В git stash — это область хранения, куда можно перемещать текущие измененные файлы.

Область stash полезна, когда вы хотите извлечь некоторые изменения из репозитория git и обнаружить некоторые изменения в некоторых взаимных файлах, доступных в репо git .

git stash apply //apply the changes without removing stored files from stash area.

git stash pop  // apply the changes as well as remove stored files from stash area.

Примечание: — git apply применяет только изменения из области тайника, в то время как git pop применяет, а также удаляет изменения из области stash .

Поделиться

Vikrant Kashyap    

16 мая 2019 в 13:12

2

Git Stash Pop vs apply работа

Если вы хотите применить свои верхние спрятанные изменения к текущим неэтапным изменениям и удалить этот тайник, то вам следует выбрать git stash pop .

# apply the top stashed changes and delete it from git stash area.
git stash pop  

Но если вы хотите применить свои верхние спрятанные изменения к текущим неэтапным изменениям, не удаляя их, то вам следует выбрать git stash apply .

Примечание: Вы можете связать этот случай с Stack классами pop() и peek() методами, где pop изменяет вершину на декременты (top = top-1), но peek() может получить только верхний элемент.

Поделиться

Vikrant Kashyap    

27 февраля 2019 в 09:03

Похожие вопросы:

Могу ли я использовать git pull —rebase вместо «git stash git pull git stash pop»?

В чем разница между git pull —rebase и git stash git pull git stash pop

Отбросить Git Stash Pop

Я сделал git stash pop, и теперь у меня куча конфликтов. Я зафиксировал весь свой недавний код до git stash pop , так что есть ли способ вернуться к последнему коммиту и избавиться от всех…

Разница между `git stash show -p stash@{N}` и `git show stash@{N}`?

Я думал, что они должны быть в основном одинаковыми, но когда я попробовал $ git stash show -p stash@{N} и $ git show stash@{N} последний показывает некоторую дополнительную информацию о…

В чем разница между git-stash и git-checkout?

Я пытаюсь перейти из одного местного отделения в другое. Git говорит мне, что я не могу этого сделать, потому что мой local changes to the following files would be overwritten by checkout . Тогда я…

в чем разница между ‘git stash apply stash@{2}’ и ‘ git stash apply —2’

скажем, у меня есть список git stash, как показано ниже: $ git stash list stash@{0}: WIP on master: 049d078 added the index file stash@{1}: WIP on master: c264051 Revert added file_size stash@{2}:. ..

Почему git stash поп действует как применить

Кто-нибудь знает, почему капельная часть поп-музыки не сработала бы для меня? папа ведет себя так же, как и я. Мой процесс таков: git stash save name of save git stash pop затем: git stash list (and…

Разница между git stash pop и git stash drop

Разница между git stash pop и git stash drop ? Оба убирают тайник, тогда что же еще?

возможно ли git stash pop с сухим запуском?

git stash pop слепо перезаписывает локальные изменения или объединяет их с локальными изменениями? Если он сливается, могут возникнуть конфликты слияния. Есть ли какой-нибудь способ заранее узнать,…

В чем разница между git stash apply и git stash apply —index?

Всякий раз, когда я запускаю git stash apply и git stash apply —index после выполнения git stash -a , я получаю тот же результат, даже несмотря на то, что мой каталог WIP имеет поэтапные изменения,. ..

git stash pop/применить к конкретному индексу включить предыдущий индекс

Предположим, что у меня есть история тайника следующим образом: stash@{0}: WIP on dev: stash@{1}: WIP on master: stash@{2}: WIP on dev: stash@{3}: WIP on master: Я хочу иметь следующий сценарий: Git…

Git Stash – Zencoder

Git Stash

Я прямо влюбился в команду stash от git

Команда git stash предназначена для того, чтобы поместить текущие изменения в отдельное хранилище и вернуть файлы к исходному состоянию. То есть git stash прячет изменения в файлах и сохраняет эти изменения отдельно, чтобы потом можно было их вернуть.

Сохранение изменений

git stash save "description of stash"

… создать stash с человекопонятным описанием этого stash — чтобы можно было через день, глядя на него, догадаться вообще, что это такое и зачем оно делалось.

git stash -u save "description of stash"

… создать stash с изменениями, которые еще unstaged. Иначе они просто не попадут в снимок stash.

git stash branch newAwesomeBranch

… создание новой ветки из stash@{0}. Важный момент — чтобы изменения попали с новую ветку, они должны сначала быть помещены в stash@{0}.

git stash branch newAwesomeBranch stash@{1}

… поместить изменения из конктерного stash@{1} в новую ветку newAwesomeBranch.

git stash -p

… выборочное сохранение измененых файлов. Запускается пошаговый мастер, который будет последовательно спрашивать — помещать измененый файл в stash или нет.

Показ сохраненных изменений

git stash show

… показать, какие файлы изменены. Краткая справка, которая просто показывает, где были изменения и в каких файлах.

git stash show stash@{1}

… показать краткие изменения в конкретном stash.

git stash show -p stash@{1}

… показать изменения в файле. Можно увидеть в файле, что было добавлено или удалено.

git stash list

… показать список всех снимков stash. Причем, снимок с номером stash@{0} — это самый последний по времени снимок stash. Дальше — понарастающей — чем больше номер, тем раньше по времени он был сделан.

Удаление сохраненных изменений

git stash drop stash@{1}

… удалить определенный снимок stash@{1}.

git stash drop

… удалить последний снимок stash@{0}.

git stash clear

… удалить все изменения stash.

Применение сохраненных изменений

git stash apply

… применить последний по времени снимок stash.

git stash apply stash@{2}

… применить конкретный снимок stash.

git stash pop

… сокрещение от двух команд — apply и drop — применяет и автоматически удаляет после применения последний снимок stash — stash@{0}.

git stash pop stash@{2}

… сокрещение от двух команд — apply и drop — применяет и автоматически удаляет после применения конкретный снимок stash — stash@{2}.

stashgit

Как отменить применение кошелька? — программирование

У меня есть небольшой патч, сохраненный в моем тэге git. Я применил его к моей рабочей копии с помощью git stash apply. Теперь я хотел бы отменить эти изменения, обратившись к патчу (вроде того, что git revert будет делать, но против кошелька).

Кто-нибудь знает, как это сделать?

Уточнение: В моей рабочей копии есть другие изменения. Мой конкретный случай трудно описать, но вы можете представить себе какой-то отладочный или экспериментальный код, который содержится в кошельке. Теперь он смешался в моей рабочей копии с некоторыми другими изменениями, и я хотел бы увидеть эффект с изменениями и без изменений из приставки.

Это не похоже на то, что в настоящее время поддерживается stash, но git stash apply --reverse — хорошая функция.

ОТВЕТЫ

Ответ 1

В соответствии с git -stash manpage, «Stash представлен как коммит, дерево которого записывает состояние рабочего каталога, и его первый родитель — это фиксация в HEAD при создании stash», а git stash show -p дает нам» изменения, записанные в stash, как разницу между сохраненным состоянием и исходным родителем.

Чтобы сохранить другие изменения, используйте git stash show -p | patch --reverse, как показано ниже:

$ git init
Initialized empty Git repository in /tmp/repo/. git/

$ echo Hello, world >messages

$ git add messages

$ git commit -am 'Initial commit'
[master (root-commit)]: created 1ff2478: "Initial commit"
 1 files changed, 1 insertions(+), 0 deletions(-)
 create mode 100644 messages

$ echo Hello again >>messages

$ git stash

$ git status
# On branch master
nothing to commit (working directory clean)

$ git stash apply
# On branch master
# Changed but not updated:
#   (use "git add <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#       modified:   messages
#
no changes added to commit (use "git add" and/or "git commit -a")

$ echo Howdy all >>messages

$ git diff
diff --git a/messages b/messages
index a5c1966..eade523 100644
--- a/messages
+++ b/messages
@@ -1 +1,3 @@
 Hello, world
+Hello again
+Howdy all

$ git stash show -p | patch --reverse
patching file messages
Hunk #1 succeeded at 1 with fuzz 1.

$ git diff
diff --git a/messages b/messages
index a5c1966. .364fc91 100644
--- a/messages
+++ b/messages
@@ -1 +1,2 @@
 Hello, world
+Howdy all

Edit:

Лучшим улучшением этого является использование git apply вместо патча:

git stash show -p | git apply --reverse

В качестве альтернативы вы также можете использовать git apply -R как сокращенное обозначение git apply --reverse.

В последнее время я считаю это очень полезным…

Ответ 2

git stash [save] берет ваше рабочее состояние каталога и ваше состояние индекса и задерживает их, устанавливая индекс и рабочую область для HEAD версия.

git stash apply возвращает эти изменения, поэтому git reset --hard удалит их снова.

git stash pop возвращает эти изменения и удаляет верхнее спрятанное изменение, поэтому git stash [save] вернется в предыдущее (pre-pop) состояние в этом случае.

Ответ 3

git checkout -f

удалит любые изменения без фиксации.

Ответ 4

Прямая нарезка с пасты git
Он четко сформулирован и даже содержит псевдоним;

Отменить привязку
В некоторых сценариях использования, которые вы, возможно, захотите применить спрятанные изменения, выполните некоторую работу, но затем отмените те изменения, которые первоначально были получены из кошелька. Git не предоставляет такую ​​команду unashply stash, но можно добиться эффекта, просто извлекая патч, связанный с приложением, и применяя его в обратном порядке:

$ git stash show -p [email protected]{0} | git apply -R

Опять же, если вы не укажете stash, Git принимает самый последний тайник:

$ git stash show -p | git apply -R

Возможно, вы захотите создать псевдоним и эффективно добавить команду stash-unapply к вашему Git. Например:

$ git config --global alias. stash-unapply '!git stash show -p | git apply -R'
$ git stash apply
$ #... work work work
$ git stash-unapply

Ответ 5

Это долгое время, но если я правильно понимаю проблему, я нашел простое решение, обратите внимание, что это объяснение по моей собственной терминологии:

git stash [save] сохранит текущие изменения и установит текущую ветку в «чистое состояние»

git stash list дает что-то вроде: [email protected]{0}: On develop: saved testing-stuff

git apply [email protected]{0} установит текущую ветвь как до stash [save]

git checkout . Устанавливает текущую ветвь как после stash [save]

Код, который сохраняется в кошельке, не теряется, его можно найти еще раз git apply [email protected]{0}.

Anywhay, это сработало для меня!

Ответ 6

В дополнение к ответу @Greg Bacon, если бинарные файлы были добавлены в индекс и были частью приставки, используя

git stash show -p | git apply --reverse

может привести к

error: cannot apply binary patch to '<YOUR_NEW_FILE>' without full index line
error: <YOUR_NEW_FILE>: patch does not apply

Добавление --binary устраняет проблему, но, к сожалению, пока не выяснено, почему.

 git stash show -p --binary | git apply --reverse

Прятанье | Pro Git | Рецепты Linux

Часто возникает такая ситуация, что пока вы работаете над частью своего проекта, всё находится в беспорядочном состоянии, а вам нужно переключить ветки, чтобы немного поработать над чем-то другим. Проблема в том, что вы не хотите делать коммит с наполовину доделанной работой, только для того, чтобы позже можно было вернуться в это же состояние. Ответ на эту проблему — команда git stash.

Прятанье поглощает грязное состояние рабочего каталога, то есть изменённые отслеживаемые файлы и изменения в индексе, и сохраняет их в стек незавершённых изменений, которые вы потом в любое время можете снова применить.

Прятанье своих трудов

Чтобы продемонстрировать как это работает, предположим, что вы идёте к своему проекту и начинаете работать над парой файлов и, возможно, добавляете в индекс одно из изменений. Если вы выполните git status, вы увидите грязное состояние проекта:


$ git status
# On branch master
# Changes to be committed:
# (use "git reset HEAD . .." to unstage)
#
# modified: index.html
#
# Changed but not updated:
# (use "git add ..." to update what will be committed)
#
# modified: lib/simplegit.rb
#


Теперь вы хотите поменять ветку, но не хотите делать коммит с тем, над чем вы ещё работаете; тогда вы прячете эти изменения. Чтобы создать новую “заначку”, выполните git stash:


$ git stash
Saved working directory and index state \
"WIP on master: 049d078 added the index file"
HEAD is now at 049d078 added the index file
(To restore them type "git stash apply")


Ваш рабочий каталог чист:


$ git status
# On branch master
nothing to commit (working directory clean)


В данный момент, вы легко можете переключить ветки и поработать где-то ещё; ваши изменения сохранены в стеке. Чтобы посмотреть, что у вас есть припрятанного, используйте git stash list:


$ git stash list
stash@{0}: WIP on master: 049d078 added the index file
stash@{1}: WIP on master: c264051. .. Revert "added file_size"
stash@{2}: WIP on master: 21d80a5... added number to log


В нашем случае, две “заначки” были сделаны ранее, так что у вас теперь три разных припрятанных работы. Вы можете снова применить ту, которую только что спрятали, с помощью команды показанной в справке в выводе первоначальной команды stash: git stash apply. Если вы хотите применить одну из старых заначек, можете сделать это указав её имя так: git stash apply stash@{2}. Если не указывать ничего, Git будет подразумевать, что вы хотите применить последнюю спрятанную работу:


$ git stash apply
# On branch master
# Changed but not updated:
# (use "git add ..." to update what will be committed)
#
# modified: index.html
# modified: lib/simplegit.rb
#


Как видите, Git восстановил изменения в файлах, которые вы отменили, когда использовали команду stash. В нашем случае, у вас был чистый рабочий каталог, когда вы восстанавливали спрятанные изменения, и к тому же вы делали это на той же ветке, на которой находились во время прятанья. Но наличие чистого рабочего каталога и применение на той же ветке не обязательны для git stash apply. Вы можете спрятать изменения на одной ветке, переключиться позже на другую ветку и попытаться восстановить изменения. У вас в рабочем каталоге также могут быть изменённые и недокоммиченные файлы во время применения спрятанного — Git выдаст вам конфликты слияния, если что-то уже не может быть применено чисто.

Изменения в файлах были восстановлены, но файлы в индексе — нет. Чтобы добиться такого, необходимо выполнить команду git stash apply с опцией --index, тогда команда попытается применить изменения в индексе. Если бы вы выполнили команду так, а не как раньше, то получили бы исходное состояние:


$ git stash apply --index
# On branch master
# Changes to be committed:
# (use "git reset HEAD ..." to unstage)
#
# modified: index.html
#
# Changed but not updated:
# (use "git add ..." to update what will be committed)
#
# modified: lib/simplegit. rb
#


Всё что делает опция apply это пытается применить спрятанную работу — то, что вы спрятали, всё ещё будет находиться в стеке. Чтобы удалить спрятанное, выполните git stash drop с именем “заначки”, которую нужно удалить:


$ git stash list
stash@{0}: WIP on master: 049d078 added the index file
stash@{1}: WIP on master: c264051... Revert "added file_size"
stash@{2}: WIP on master: 21d80a5... added number to log
$ git stash drop stash@{0}
Dropped stash@{0} (364e91f3f268f0900bc3ee613f9f733e82aaed43)


Также можно выполнить git stash pop, чтобы применить спрятанные изменения и сразу же удалить их из стека.

Откат применения спрятанных изменений

При некоторых сценариях использования, может понадобиться применить спрятанные изменения, поработать, а потом отменить изменения, внесённые командой stash apply. Git не предоставляет команды stash unapply, но можно добиться того же эффекта получив сначала патч для спрятанных изменений, а потом применив его в перевёрнутом виде:


$ git stash show -p stash@{0} | git apply -R


Снова, если вы не указываете параметр для stash, Git подразумевает то, что было спрятано последним:


$ git stash show -p | git apply -R


Если хотите, сделайте псевдоним и добавьте в свой git команду stash-unapply. Например, так:


$ git config --global alias.stash-unapply '!git stash show -p | git apply -R'
$ git stash
$ #... work work work
$ git stash-unapply


Создание ветки из спрятанных изменений

Если вы спрятали какие-то наработки и оставили их на время, а в это время продолжили работать на той же ветке, то у вас могут возникнуть трудности с восстановлением спрятанной работы. Если apply попытается изменить файл, который вы редактировали после прятанья, то возникнет конфликт слияния, который надо будет разрешить. Если нужен более простой способ снова потестировать спрятанную работу, можно выполнить команду git stash branch, которая создаст вам новую ветку с началом из того коммита, на котором вы находились во время прятанья, восстановит в ней вашу работу и затем удалит спрятанное, если оно применилось успешно:


$ git stash branch testchanges
Switched to a new branch "testchanges"
# On branch testchanges
# Changes to be committed:
# (use "git reset HEAD . .." to unstage)
#
# modified: index.html
#
# Changed but not updated:
# (use "git add ..." to update what will be committed)
#
# modified: lib/simplegit.rb
#
Dropped refs/stash@{0} (f0dfc4d5dc332d1cee34a634182e168c4efc3359)


Это сокращение удобно для того, чтобы легко восстановить свою работу, а затем поработать над ней в новой ветке.

Pro Git

Как восстановить сохраненные незафиксированные изменения

простой ответ на простой вопрос

git stash apply

просто проверьте ветку, в которой вы хотите внести изменения, а затем git stash apply. Тогда используйте git diff чтобы увидеть результат.

после того как вы все сделали с вашими изменениями —apply выглядит хорошо, и вы уверены, что вам больше не нужен тайник-затем использовать git stash drop, чтобы избавиться от него.

я всегда предлагаю использовать git stash apply, а не git stash pop. Разница в том, что apply оставляет тайник вокруг для легкой повторной попытки apply, или для смотреть, etc. Если pop способен извлечь тайник, он будет немедленно также drop это, и если вы вдруг поймете, что вы хотели извлечь его где-то еще (в другой ветке), или с --index или что-то в этом роде, это не так просто. Если вы apply,вы получить, чтобы выбрать, когда drop.

это все довольно незначительно так или иначе, хотя, и для новичка git, это должно быть о тот же. (И вы можете пропустить все остальное!)

что делать, если вы делаете более продвинутые или более сложные вещи?

есть по крайней мере три или четыре различных «способа использования git stash», как это было. Выше для «пути 1», «легкий путь»:

1. вы начали с чистой ветви, работали над некоторыми изменениями, а затем поняли, что вы делаете их в неправильной ветви. Вы просто хотите принять изменения, которые у вас есть сейчас и «сдвинуть» их в другую ветку.

   это простой случай, описанный выше. Беги git stash save (или обычный git stash, то же самое). Проверьте другую ветку и используйте git stash apply. Это заставляет git сливаться в ваших более ранних изменениях, используя довольно мощный механизм слияния git. внимательно проверьте результаты (с git diff) чтобы узнать, нравятся ли они вам, и если да, используйте git stash drop падение заначку. Все кончено!

2. вы начали некоторые изменения и спрятали их. Затем вы переключились на другую ветку и начали больше изменений, забыв, что у вас есть припрятанные.

   теперь вы хотите сохранить, или даже пошевелиться, эти изменения и применить свой заначку.

   вы можете git stash save опять же, как git stash делает «стек» изменений. Если вы это сделаете, у вас есть два тайника, один просто называется stash-но вы можете также написать stash@{0}-и одна прописана stash@{1}. Используйте git stash list (в любое время) чтобы увидеть их всех. Самый Новый всегда имеет самый низкий номер. Когда ты git stash drop, он падает самый новый, и тот, который был stash@{1} перемещается в верхнюю часть стека. Если бы у вас было еще больше, тот, который был stash@{2} становится stash@{1} и так далее.

   вы можете apply а то drop конкретный тайник тоже:git stash apply stash@{2} и так далее. Отбросив определенный тайник, перенумеруйте только те, которые имеют более высокий номер. Опять же, один без числа также stash@{0}.

   если вы накапливаете много тайников, он может стать довольно грязным (был тайник, который я хотел stash@{7} или stash@{4}? Подожди, я только что нажал другую, теперь они 8 и 5?). Я лично предпочитаю перенести эти изменения в новую ветку, потому что ветки имеют имена, и cleanup-attempt-in-December значит для меня гораздо больше, чем stash@{12}. (Тег git stash команда принимает необязательное сообщение сохранения, и это может помочь, но так или иначе, все мои тайники просто заканчиваются именем WIP on branch.)

3. (Экстра-продвинутый) у вас есть используется git stash save -p, или git add — ed и / или git rm — ed конкретные биты вашего кода перед запуском git stash save. У вас была одна версия в скрытом индексе/промежуточной области, а другая (другая) версия в рабочем дереве. Вы хотите сохранить все это. Так что теперь вы используете git stash apply --index, и это иногда терпит неудачу с:

   Conflicts in index.  Try without --index.
   

4. вы используете git stash save --keep-index для того, чтобы проверить «что будет совершено». Это выходит за рамки этого ответа; см. этот других сайте StackOverflow ответ вместо.

для сложных случаев я рекомендую сначала начать с «чистого» рабочего каталога, зафиксировав любые изменения, которые у вас есть сейчас (на новой ветке, если хотите). Таким образом, «где-то», что вы их применяете, не имеет ничего другого в нем, и вы просто будете пробовать спрятанные изменения:

git status               # see if there's anything you need to commit
                         # uh oh, there is - let's put it on a new temp branch
git checkout -b temp     # create new temp branch to save stuff
git add ...              # add (and/or remove) stuff as needed
git commit               # save first set of changes

теперь вы находитесь на» чистой » отправной точке. Или, может быть, это больше похоже на это:

git status               # see if there's anything you need to commit
                         # status says "nothing to commit"
git checkout -b temp     # optional: create new branch for "apply"
git stash apply          # apply stashed changes; see below about --index

в главное, помнить, что «заначка» и фиксация, это просто немного «смешная/странная» фиксация, которая не «на ветке». Элемент apply операция смотрит на то, что фиксация изменилась, и пытается повторить его, где бы вы сейчас ни находились. Тайник все еще будет там (apply держит его вокруг), так что вы можете посмотреть на него больше, или решить, что это было неправильное место для apply это и попробуйте еще раз по-другому, или что-то еще.

в любое время у вас есть тайник, вы можете использовать git stash show -p чтобы увидеть упрощенную версию того, что находится в тайнике. (Эта упрощенная версия смотрит только на изменения «final work tree»,не сохраненный индекс изменяет это --index восстанавливает отдельно.) Команда git stash apply, без --index, просто пытается сделать эти то же самое изменения в вашем рабочем каталоге сейчас.

это верно, даже если у вас уже есть некоторые изменения. Элемент apply команда рада применить тайник к изменен рабочий каталог (или, по крайней мере, попытаться применить его). Вы можете, например, сделать так:

git stash apply stash      # apply top of stash stack
git stash apply stash@{1}  # and mix in next stash stack entry too

вы можете выбрать порядок «применить» здесь, выбирая конкретные тайники для применения в определенной последовательности. Обратите внимание, однако, что каждый раз, когда вы в основном делаете «слияние git», и как предупреждает документация слияния:

выполняется слияние git с нетривиальными незафиксированными изменениями
обескураженный: хотя это возможно, это может оставить вас в состоянии, которое трудно
назад в случае конфликта.

если вы начинаете с чистого каталога и просто делают несколько git apply операции, это легко отступить: используйте git reset --hard, чтобы вернуться в исходное состояние, и изменить свой apply операции. (Вот почему я рекомендую начать с чистого рабочего каталога сначала, для этих сложных случаев. )

как насчет самого худшего из возможных случаев?

Допустим ты делая много продвинутых вещей Git, и вы сделали тайник, и хотите git stash apply --index, но это больше не возможно применить сохраненный тайник с --index, потому что ветка слишком сильно разошлась с тех пор, как вы ее сохранили.

это git stash branch для.

если вы:

1. проверьте точной фиксации вы были на, когда вы сделали оригинал stash, потом
2. создать новую ветку, и наконец-то
3. git stash apply --index

попытка воссоздать изменения определенно будет работа. Вот что git stash branch newbranch делает. (И затем он сбрасывает тайник, так как он был успешно применен.)

несколько последних слов о

--index (что это за чертовщина?)

какого --index делает это просто объяснить, но немного сложно внутренне:

• когда у вас есть изменения, вы должны git add (или «этап») их перед commiting.
• таким образом, когда вы запускали git stash, вы может отредактировал оба файла foo и zorg, но только поставил один из них.
• поэтому, когда вы просите вернуть тайник, было бы неплохо, если бы это git addс add Эд вещи и делает неgit add не добавлены вещи. То есть, если вы addЭд foo а не zorg обратно, прежде чем вы сделали stash, было бы неплохо имейте ту же самую установку. То, что было поставлено, должно быть снова поставлено; то, что было изменено, но не поставлено, должно быть снова изменено, но не поставлено.

The --index флаг apply пытается настроить вещи таким образом. Если ваше рабочее дерево чисто, это обычно просто работает. Если ваша работа-дерево уже есть вещи addЭд, однако, вы можете видеть, как здесь могут быть некоторые проблемы. Если вы оставите --index на apply операция не пытается сохранить целое поэтапная / неустановленная настройка. Вместо этого он просто вызывает механизм слияния git, используя фиксацию рабочего дерева в «заначка сумка». Если вы не заботитесь о сохранении staged / unstaged, оставляя--index делает его намного проще для git stash apply делать свое дело.

Как внести изменения в Git Stash — devconnected

Команда git stash , вероятно, одна из самых мощных команд в Git.

Git stash используется для того, чтобы сохранить все изменения, сделанные в текущем рабочем каталоге , и вернуться к последней фиксации, выполненной в ветке (также называемой HEAD).

Сохранение изменений поставляется со специальным набором команд Git, предназначенных для создания , удаления и применения тайников по желанию.

В этом руководстве мы узнаем о командах git stash и о том, как их можно использовать в практических случаях.

Создайте тайник Git

Самый простой способ создать git stash — просто запустить команду «git stash» без каких-либо параметров.

  $ git stash  

Как следствие, все изменения, подготовленные для фиксации в вашем текущем рабочем каталоге, будут сохранены для дальнейшего использования.

  $ git stash
Сохраненный рабочий каталог и состояние индекса WIP на ветке 2: 808b598 Начальная фиксация  

Как видите, мой рабочий каталог, а также мой индекс были сохранены для «ветки2», которая является текущим именем моей ветки.

После двоеточий вы можете увидеть хэш фиксации HEAD , а также сообщение фиксации: это имя вашего тайника.

В этом случае нашему тайнику не было присвоено никаких имен, что может быть не очень удобно, если вы захотите открыть свой тайник позже.

Создайте тайник Git с именем

Чтобы создать git stash с именем, используйте команду «save» и укажите имя вашего stash.

  $ git stash save "my_stash_name"  

Вернемся к примеру, который мы привели ранее для ветки с именем «branch2», мы бы запустили

  $ git stash save "измененный README.мкр "
Сохраненный рабочий каталог и состояние индекса На ветке 2: измененный README.md  

Теперь Git не предоставил имя по умолчанию (созданное последним сообщением фиксации HEAD), но присвоил ему собственное имя.

В качестве альтернативы вы можете использовать команду « git stash push », чтобы создать тайник с именем.

  $ git stash push -m "снова изменил README.md"
Сохраненный рабочий каталог и состояние индекса На ветке 2: снова изменен READ.me  

Убрать определенный файл

Используя предыдущие команды, вы поместили все отслеживаемые файлы в текущий рабочий каталог.

В некоторых случаях вам может понадобиться спрятать определенный файл, чтобы получить его позже.

Чтобы сохранить определенный файл, используйте команду «git stash push» и укажите файл, который вы хотите сохранить.

  $ git stash push -m "сообщение" <файл>  

Например, чтобы сохранить файл «README.md» в нашем текущем рабочем каталоге, но сохранить изменения, внесенные в другие файлы, мы должны запустить

  $ git stash push -m "изменил README.мкр "README.md
Сохраненный рабочий каталог и состояние индекса На ветке 2: измененный README.md  

Однако другие отслеживаемые файлы, которые могут быть изменены в вашем текущем рабочем каталоге, остаются нетронутыми.

Тайник с неотслеживаемыми файлами

Как вы, наверное, заметили раньше при создании тайников, по умолчанию в тайнике сохраняются только отслеживаемые файлы вашего рабочего каталога.

Но что, если вы хотите спрятать неотслеживаемые файлы вашего текущего рабочего каталога?

Чтобы сохранить неотслеживаемые файлы, добавьте параметр « –include-untracked » в исходную команду « git stash ».

В качестве альтернативы вы можете просто использовать « -u », что эквивалентно более длинной версии без отслеживания.

  $ git stash --include-untracked
Сохраненный рабочий каталог и состояние индекса WIP в branch2: 808b598 Начальная фиксация

$ git stash -u  

Тайник в отдельной ветке

В некоторых случаях вы можете захотеть спрятать ваши текущие изменения в определенную ветку .

Допустим, вы работали над веткой « master » над модификациями, но решили, что вашей работе может потребоваться конкретная ветка для интеграции.

Это можно сделать с помощью команды « git stash branch ».

  $ git stash branch <имя_отрасли>

$ git stash branch  [адрес электронной почты защищен] {stash_index}  

Предположим, например, что вы хотите сохранить текущие изменения в ветке с именем «ветка2», которую вы должны выполнить.

  $ git stash branch branch2 [защита электронной почты] {0}

Перешел на новую ветку branch2
В филиале branch5
Изменения, не предназначенные для фиксации:
  (используйте "git add <файл>. .. "обновить то, что будет совершено)
  (используйте "git checkout - <файл> ...", чтобы отменить изменения в рабочем каталоге)

        изменено: README.md

в фиксацию изменений не добавлено (используйте "git add" и / или "git commit -a")
Удалено [адрес электронной почты защищен] {0} (8bf64dd0e0045069bf3b3e7d9e34f5e5227aefa7)  

Как вы можете видеть, тайник удаляется в конце процесса, по сути, полностью удаляя его из стека тайника.

Список тайников Git

Теперь, когда вы создали несколько тайников, пришло время перечислить только что созданные тайники.

Для вывода списка тайников Git используйте команду « git stash list ».

  $ список тайников git

[электронная почта защищена] {0}: WIP на ветке 2: 808b598 Начальная фиксация
[электронная почта защищена] {1}: на ветке 2: изменен README.md
[электронная почта защищена] {2}: На ветке 2: снова изменен READ.me  

Как видите, тайникам присваивается индекс, начинающийся с нуля.

При создании новых тайников элементы добавляются в стек, что означает, что самый последний тайник имеет индекс 0, а самый старый тайник находится внизу стека.

Это тесно связано с концепцией стека в разработке программного обеспечения. Ссылка на подробную статью включена, если вам интересно узнать о стеках.

Применить тайники Git

Теперь, когда вы сохранили свои тайники Git сбоку, вы можете захотеть « вынуть их из стека » и применить их к вашему текущему рабочему каталогу.

Для того, чтобы применить ваше хранилище Git к текущему рабочему каталогу, используйте команду « git stash apply » и укажите тайник, который вы хотите применить.

Если вы не укажете никаких аргументов для команды apply, будет применена вершина стека .

  $ git stash apply [адрес электронной почты защищен] {stash_index}

$ git stash apply (ярлык для git stash apply [адрес электронной почты] {0})  

Например, чтобы применить изменения, сделанные в тайнике с индексом 1, мы должны запустить

  $ git stash применить [электронная почта] {1}

Уже в актуальном состоянии!
В филиале branch2
В вашей ветке установлена ​​последняя версия origin / branch2. Изменения, не предназначенные для фиксации:
  (используйте "git add  ...", чтобы обновить то, что будет зафиксировано)
  (используйте "git checkout - <файл> ...", чтобы отменить изменения в рабочем каталоге)

        изменено: README.md

Не отслеживаемые файлы:
  (используйте "git add  ..." для включения в то, что будет зафиксировано)

        файл  

По умолчанию команда stash apply отобразит ваш текущий рабочий каталог после применения соответствующих stash.

Теперь, если вы составите список своих тайников, вы заметите, что применение вашего тайника не удаляет и не удаляет тайник из списка.

  $ список тайников git

[электронная почта защищена] {0}: WIP на ветке 2: 808b598 Начальная фиксация
[электронная почта защищена] {1}: на ветке 2: изменен README.md
[электронная почта защищена] {2}: На ветке 2: снова изменен READ.me  

Если вы хотите, чтобы ваши тайники были удалены после их применения, вам нужно использовать команду «git stash pop».

Pop Git тайники

Итак, в чем разница между git stash pop и git stash apply?

Основное отличие состоит в том, что «git stash pop» применяет ваши изменения к вашему текущему рабочему каталогу, но также удаляет тайник из стека тайника.

Чтобы открыть тайники Git, просто используйте команду « git stash pop » и укажите индекс тайника, который вы хотите открыть.

  $ git stash pop [адрес электронной почты защищен] {stash_index}  

Возвращаясь к нашему предыдущему примеру тайника, это даст нам

  $ git stash pop [адрес электронной почты] {1}

Уже в актуальном состоянии!
В филиале branch2
В вашей ветке установлена ​​последняя версия origin / branch2.

Изменения, не предназначенные для фиксации:
  (используйте "git add  ...", чтобы обновить то, что будет зафиксировано)
  (используйте "git checkout - <файл>... "отменить изменения в рабочем каталоге)

        изменено: README. md

Не отслеживаемые файлы:
  (используйте "git add  ..." для включения в то, что будет зафиксировано)

        файл

Удалено [адрес электронной почты защищен] {1} (1adaf79224dca78aa6568b1e8154cbc4f747042f)  

Видите разницу в последней строке примера?

В тайнике было , выпало , а удалило из стека.

Показать различия в тайнике Git

Когда вы создаете тайник, он, скорее всего, выполнит некоторые коммиты перед тем, как вернуться к вашему сохраненному контенту.

Как следствие, вы можете захотеть, чтобы видел различия между вашим тайником и самой последней фиксацией вашей ветки (также называемой HEAD)

Чтобы показать различия между тайником и самой последней фиксацией, используйте команду « git stash show ».

  $ git stash show [защита электронной почты] {stash_index}

README.md | 4 +++ -
1 файл изменен, 3 вставки (+), 1 удаление (-)  

Как следствие, вы будете перечислены с различиями между файлами, выполненными вставками и удалениями.

Чтобы увидеть все различия, включая содержимое , добавьте параметр « -p ».

  $ git stash show -p [защита электронной почты] {stash_index}

diff --git a / README.md b / README.md
индекс f25b874..1088f9a 100644
--- a / README.md
+++ b / README.md
@@ -1 +1,3 @@
- # приват-репо
\ Нет новой строки в конце файла
+ Файл был изменен!  

Drop Git тайники

В некоторых случаях вы можете захотеть удалить запись Git stash из вашего стека.

Чтобы сбросить тайники, у вас есть два варианта: с сбросить или очистить .

Если вы хотите удалить указанный тайник из своего стека, используйте опцию удаления и укажите индекс тайника.

  $ git stash drop [защита электронной почты] {stash_index}  

Например, чтобы удалить тайник с индексом 1 из предыдущего примера, вы должны запустить

  $ git stash drop [защита электронной почты] {1}
Удалено [адрес электронной почты защищен] {1} (c11c6ae6c347d23dff8fbbf79d54a9e6e2e79b1c)  

Отбросьте все тайники с помощью clear

Если вы хотите удалить все тайники Git в своем стеке, вы должны использовать команду clear.

  $ git stash clear  

Убедитесь, что все ваши тайники были удалены с помощью команды list.

  $ список хранения git  

Заключение

В этом руководстве вы узнали о git stash: как вы можете создавать тайники, удалять тайники и вставлять их , чтобы восстановить вашу работу.

Git stash довольно полезен, но есть много других команд, которые могут оказаться полезными при использовании Git:

Если вас интересует программная инженерия, на нашем веб-сайте есть целый раздел, посвященный этой теме, поэтому обязательно ознакомьтесь с ним!

git — Как восстановить спрятанные незафиксированные изменения

Простой ответ на простой вопрос:

git stash apply

Просто проверьте ветку, в которой хотите внести изменения, а затем git stash примените .Затем используйте git diff , чтобы увидеть результат.

После того, как вы закончите вносить изменения — apply выглядит хорошо, и вы уверены, что вам больше не нужен тайник — затем используйте git stash drop , чтобы избавиться от него.

Я всегда предлагаю использовать git stash apply , а не git stash pop . Разница в том, что apply оставляет тайник для удобства повторной попытки apply или для просмотра и т. Д.Если pop может извлечь тайник, он сразу же сбросит его, и если вы вдруг поймете, что хотите извлечь его где-то еще (в другой ветке), или с --index , или некоторые такие, это не так просто. Если вы примените , вы сможете выбрать, когда сбросить .

Это все довольно незначительно, так или иначе, и для новичка в git это должно быть примерно так же. (А все остальное можно пропустить!)

Что делать, если вы делаете более сложные или более сложные вещи?

Существует как минимум три или четыре различных «способа использования git stash».Выше для «пути 1», «легкого пути»:

1. Вы начали с чистой ветки, работали над некоторыми изменениями, а затем поняли, что делаете их не в той ветке. Вы просто хотите взять изменения, которые у вас есть сейчас, и «переместить» их в другую ветку.

   Это простой случай, описанный выше. Запустите git stash save (или простой git stash , то же самое). Проверьте другую ветку и используйте git stash apply . Это заставляет git объединяться с вашими предыдущими изменениями, используя довольно мощный механизм слияния git. Внимательно проверьте результаты (с помощью git diff ), чтобы узнать, нравятся ли они вам, и, если да, используйте git stash drop , чтобы сбросить тайник. Готово!

2. Вы внесли некоторые изменения и сохранили их. Затем вы переключились на другую ветку и начали другие изменения, забыв, что у вас есть спрятанные.

   Теперь вы хотите сохранить или даже переместить эти изменения , и также примените ваш тайник.

   Фактически, вы можете снова сохранить git stash, поскольку git stash создает «стек» изменений. Если вы это сделаете, у вас будет два тайника, один просто называется тайник - но вы также можете написать тайник @ {0} - и один пишется тайник @ {1} . Используйте git stash list (в любое время), чтобы увидеть их все. Самый новый всегда имеет самый низкий номер. Когда вы сбрасываете git stash , он отбрасывает самый новый, а тот, который был stash @ {1} , перемещается на вершину стека. Если у вас было еще больше, то та, которая была stash @ {2} , стала stash @ {1} , и так далее.

   Вы можете применить , а затем удалить конкретный тайник: git stash apply stash @ {2} и так далее. Отбрасывая определенный тайник, перенумеровываются только те, которые имеют больший номер. Опять же, номер без номера - это также stash @ {0} .

   Если вы накопите много тайников, это может стать довольно беспорядочным (был ли тайник, который я хотел тайник @ {7} , или это был тайник @ {4} ? Подождите, я только что нажал еще один, теперь они 8 и 5?). Я лично предпочитаю перенести эти изменения в новую ветку, потому что у веток есть имена, а попытка очистки в декабре для меня гораздо больше, чем stash @ {12} .(Команда git stash принимает необязательное сообщение сохранения, и это может помочь, но каким-то образом все мои тайники просто заканчиваются под названием WIP в ветке .)

3. (Extra-advanced) Вы использовали git stash save -p или осторожно git add -ed и / или git rm -ed определенные биты вашего кода перед запуском git stash save . У вас была одна версия в спрятанном индексе / промежуточной области, а другая (другая) версия - в рабочем дереве.Вы хотите все это сохранить. Итак, теперь вы используете git stash apply --index , и это иногда дает сбой:

     Конфликты в index. Попробуйте без --index.
     

4. Вы используете git stash save --keep-index , чтобы проверить, «что будет зафиксировано». Это выходит за рамки этого ответа; вместо этого см. этот другой ответ StackOverflow.

В сложных случаях я рекомендую сначала начать с «чистого» рабочего каталога, зафиксировав все изменения, которые у вас есть сейчас (в новой ветке, если хотите).Таким образом, "где-то", где вы их применяете, не будет больше ничего, и вы просто попробуете спрятанные изменения:

  git status # посмотрим, нужно ли что-нибудь зафиксировать
                         # ах, есть - давайте поместим его в новую временную ветку
git checkout -b temp # создать новую временную ветку для сохранения
git add ... # добавляем (и / или удаляем) нужные вещи
git commit # сохранить первый набор изменений
  

Теперь вы на "чистой" отправной точке.Или, может быть, это выглядит так:

  git status # посмотрим, нужно ли что-нибудь зафиксировать
                         # статус говорит "нечего делать"
git checkout -b temp # необязательно: создать новую ветку для «применить»
git stash apply # применить сохраненные изменения; см.  ниже о --index
  

Главное, что нужно запомнить, это то, что «stash» - это фиксация, это просто слегка «забавная / странная» фиксация, которая не находится «в ветке». Операция apply проверяет, что изменилось в фиксации, и пытается повторить ее, где бы вы ни находились.Тайник все еще будет там ( apply сохраняет его), так что вы можете посмотреть на него поближе или решить, что это не то место, чтобы применить и попробовать еще раз, или что-то еще.

Каждый раз, когда у вас есть тайник, вы можете использовать git stash show -p , чтобы увидеть упрощенную версию того, что находится в тайнике. (Эта упрощенная версия рассматривает только изменения «окончательного рабочего дерева», , а не , сохраненные изменения индекса, которые --index восстанавливает отдельно.Команда git stash apply , без --index , просто пытается сделать те же те же изменения в вашем рабочем каталоге.

Это верно, даже если у вас уже есть некоторые изменения. Команда apply с радостью применяет тайник к измененному рабочему каталогу (или, по крайней мере, пытается применить его). Вы можете, например, сделать это:

  git stash применить тайник # применить верх стека тайника
git stash apply stash @ {1} # и добавляйте следующую запись стека тайника
  

Здесь вы можете выбрать порядок «применения», выбрав определенные тайники, которые будут применяться в определенной последовательности.Обратите внимание, однако, что каждый раз, когда вы в основном выполняете «git merge», и, как предупреждает документация слияния:

Запуск git merge с нетривиальными незафиксированными изменениями
обескуражен: хотя это возможно, это может оставить вас в тяжелом состоянии
отступить в случае конфликта.

Если вы начинаете с чистого каталога и просто выполняете несколько операций git apply , можно легко вернуться: используйте git reset --hard , чтобы вернуться в чистое состояние, и измените свой , примените операции . (Вот почему я рекомендую сначала начать с чистого рабочего каталога для этих сложных случаев.)

А как насчет самого худшего из возможных случаев?

Допустим, вы делаете много продвинутых вещей Git, создали тайник и хотите применить git stash --index , но уже невозможно применить сохраненный тайник с --index , потому что ветка слишком сильно разошлась с того момента, как вы ее сохранили.

Это то, для чего предназначена ветка git stash .

Если вы:

1. проверьте точную фиксацию , в которой вы были, когда делали исходный тайник , затем
2. создать новую ветку и, наконец,
3. git stash применить --index

попытка воссоздать изменения однозначно сработает. Это то, что делает git stash branch newbranch . (И затем он сбрасывает тайник, поскольку он был успешно применен.)

Несколько заключительных слов о

--index (какого черта?)

То, что делает --index , просто объяснить, но внутренне немного сложно:

• Когда у вас есть изменения, вы должны git добавить (или "этап") их до зафиксировать ing.
• Таким образом, когда вы запускали git stash , вы могли отредактировать оба файла foo и zorg , но поставили только один из них.
• Итак, когда вы просите вернуть тайник, было бы неплохо, если бы он git добавил s, добавил ed вещи и не git добавил не добавленные вещи. То есть, если вы добавите ed foo , но не zorg , прежде чем вы сделали stash , было бы неплохо иметь точно такую ​​же настройку.То, что было поставлено, нужно снова поставить; то, что было изменено, но не поставлено, следует снова изменить, но не постановку.

Флаг --index для apply пытается настроить вещи таким образом. Если ваше рабочее дерево чистое, это обычно просто работает. Если в вашем рабочем дереве уже есть материал добавить ed, вы можете увидеть, как здесь могут быть некоторые проблемы. Если вы не укажете --index , операция apply не попытается сохранить всю поэтапную / неэтапную установку.Вместо этого он просто вызывает механизм слияния git, используя фиксацию рабочего дерева в «сумке». Если вы не заботитесь о сохранении постановки / неустановки, исключение --index значительно упростит работу с git stash apply .

Каков предполагаемый вариант использования git stash?

Я знаю, что StackOverflow - не место для ответов, основанных на мнениях, но на самом деле у меня есть хорошее мнение о том, когда откладывать изменения в тайник.

Вы не хотите вносить экспериментальные изменения

Когда вы вносите изменения в свое рабочее пространство / рабочее дерево, если вам нужно выполнить какие-либо операции на основе ветвей, такие как слияние, push, выборка или извлечение, вы должны быть в чистой точке фиксации.Поэтому, если у вас есть изменения в рабочем пространстве, вам необходимо их зафиксировать. Но что, если вы не хотите их совершать? Что, если они экспериментальные? Что-то, что вам не нужно в истории коммитов? Что-то, чего вы не хотите, чтобы другие видели, когда вы нажимаете на GitHub?

Вы не хотите потерять локальные изменения при аппаратном сбросе

В этом случае вы можете сделать полный сброс. Но если вы выполните полный сброс, вы потеряете все изменения вашего локального рабочего дерева, потому что все будет перезаписано на то место, где оно было во время последней фиксации, и вы потеряете все свои изменения.

Итак, что касается ответа «когда следует прятать», то ответ - когда вам нужно вернуться к чистой точке фиксации с синхронизированным рабочим деревом / индексом / фиксацией, но вы не хотите потерять свои локальные изменения в процессе. Просто отложите свои изменения в тайник, и все будет хорошо.

И после того, как вы сделали свой тайник, а затем слились, или потянули, или нажали, вы можете просто припрятать pop или apply, и вы вернетесь туда, откуда начали.

Git stash и GitHub

GitHub постоянно добавляет новые функции, но на данный момент есть способ сохранить там тайник.Опять же, идея тайника заключается в том, что он локальный и частный. Никто другой не сможет заглянуть в ваш тайник без физического доступа к вашей рабочей станции. Точно так же, как git reflog является закрытым, а журнал git является общедоступным. Вероятно, это не было бы приватным, если бы оно было перенесено на GitHub.

Один из приемов может заключаться в том, чтобы выполнить различие в вашей рабочей области, проверить разницу в вашем репозитории git, зафиксировать и затем нажать. Затем вы можете сделать тягу из дома, получить дифференциал и затем размотать его. Но это довольно грязный способ добиться таких результатов.

  git diff> git-dif-file.diff
  

Полезные трюки о Git stash

, о которых вы могли не знать

Я запустил информационный бюллетень Git Better, чтобы помочь изучить новые приемы и продвинутые темы Git. Если вы хотите улучшить свою игру в Git, вам обязательно стоит это проверить.

Если вы какое-то время использовали Git, возможно, вы использовали Git stash. Это одна из полезных функций Git.

Вот несколько полезных приемов, которые я узнал о Git stash на прошлой неделе.

1. Git stash save
2. Git stash list
3. Git stash apply
4. Git stash pop
5. Git stash show
6. Git stash branch
7. Git stash clear
8. Git stash drop 9037 save

   Эта команда похожа на Git stash. Но у этой команды есть разные опции. Я расскажу о некоторых важных вариантах в этом посте.

   Git stash с сообщением

     git stash save «Ваше секретное сообщение».  

   Приведенная выше команда помещается в тайник с сообщением. Мы увидим, насколько это поможет.

   Хранение неотслеживаемых файлов

   Вы также можете хранить неотслеживаемые файлы.

     git stash save -u
   
   или же
   
   git stash save --include-untracked  

   Git stash list

   Прежде чем обсуждать эту команду, позвольте мне рассказать вам кое-что о том, как работает stash.

   Когда вы сохраняете Git stash или Git stash save, Git фактически создает объект фиксации Git с некоторым именем, а затем сохраняет его в вашем репозитории.

   Значит, вы можете просмотреть список созданных вами тайников в любое время.

     git stash list  

   См. Пример ниже:

   git stash list example

   Вы можете увидеть список созданных тайников. И последний сделанный тайник находится наверху.

   И вы можете видеть, что верхний тайник получает настраиваемое сообщение (используя Git stash save «message»).

   Git stash apply

   Эта команда берет самый верхний тайник в стеке и применяет его к репо. В нашем случае это тайник @ {0}

   . Если вы хотите применить какой-либо другой тайник, вы можете указать идентификатор тайника.

   Вот пример:

     git stash apply stash @ {1}  

   Git stash pop

   Эта команда очень похожа на команду stash apply, но после применения удаляет тайник из стека.

   Вот пример:

   Git stash pop example

   Как видите, верхний тайник удален, а тайник @ {0} обновлен с использованием старого тайника.

   Аналогично, если вы хотите, чтобы открывался конкретный тайник, вы можете указать его идентификатор.

     git stash pop stash @ {1}  

   Git stash show

   Эта команда показывает сводку различий в тайнике. Вышеупомянутая команда рассматривает только последний тайник.

   Вот пример:

   Git stash show example

   Если вы хотите увидеть полную разницу, вы можете использовать

     git stash show -p  

   Аналогично другим командам, вы также можете указать идентификатор stash, чтобы получить сводка diff.

     git stash show stash @ {1}  

   Git stash branch me>

   Эта команда создает новую ветку с последним тайником, а затем удаляет последний тайник (например, stash pop).

   Если вам нужен конкретный тайник, вы можете указать его идентификатор.

     git stash branch  stash @ {1}  

   Это будет полезно, когда вы столкнетесь с конфликтами после того, как применили stash к последней версии вашей ветки.

   Git stash clear

   Эта команда удаляет все тайники, сделанные в репо. Возможно, это невозможно вернуть.

   Git stash drop

   Эта команда удаляет последний тайник из стека. Но используйте его с осторожностью, возможно, будет сложно вернуть его обратно.

   Также можно указать id тайника.

     git stash drop stash @ {1}  

   Надеюсь, у вас есть несколько полезных трюков с Git stash.

   Если вы зашли так далеко, то я думаю, что вы в значительной степени заинтересованы в Git.Просмотрите мой информационный бюллетень Git Better, чтобы узнать о новых приемах и дополнительных темах о Git. 🙂

   Если статья вам понравилась, попробуйте похлопать и поделиться ею 🙂 🙂

   Как временно сохранить локальные изменения в Git

   Git имеет область, называемую тайником, где вы можете временно сохранить снимок ваших изменений, не фиксируя их в репозитории. Он отделен от рабочего каталога, промежуточной области или репозитория.

   Эта функция полезна, когда вы внесли изменения в ветку, которую не готовы зафиксировать, но вам нужно переключиться на другую ветку.

   Изменения тайника

   Чтобы сохранить изменения в тайнике, выполните команду:

     git stash save «необязательное сообщение для себя»  

   Это сохранит ваши изменения и вернет рабочий каталог к ​​тому, как он выглядел в последний раз совершить. Сохраненные изменения доступны из любой ветки в этом репозитории.

   Обратите внимание, что изменения, которые вы хотите спрятать, должны быть в отслеживаемых файлах. Если вы создали новый файл и попытаетесь сохранить изменения, вы можете получить ошибку Нет локальных изменений для сохранения .

   Просмотр сохраненных изменений

   Чтобы увидеть, что находится в вашем тайнике, выполните команду:

     git stash list  

   Это возвращает список ваших сохраненных снимков в формате stash @ {0}: BRANCH-STASHED- ДЛЯ ИЗМЕНЕНИЙ: СООБЩЕНИЕ . Часть stash @ {0} - это имя тайника, а число в фигурных скобках ( {} ) - это индекс этого тайника. Если у вас хранится несколько наборов изменений, каждый из них будет иметь свой индекс.

   Если вы забыли, какие изменения были внесены в тайник, вы можете просмотреть их сводку с помощью команды git stash show NAME-OF-STASH .Если вы хотите увидеть типичный макет патча в стиле diff (с + ‘s и-’ для построчных изменений), вы можете включить опцию -p (for patch). Вот пример:

     git stash show -p stash @ {0}
   
   # Пример результата:
   diff --git a / PathToFile / fileA b / PathToFile / fileA
   индекс 2417dd9..b2c9092 100644
   --- a / PathToFile / fileA
   +++ b / PathToFile / fileA
   @@ -1,4 +1,4 @@
   -Как выглядит эта линия на ветке
   + Как выглядит эта строка с сохраненными изменениями  

   Получить сохраненные изменения

   Чтобы извлечь изменения из тайника и применить их к текущей ветке, в которой вы находитесь, у вас есть два варианта:

   1. git stash apply STASH- NAME применяет изменения и оставляет копию в тайнике
   2. git stash pop STASH-NAME применяет изменения и удаляет файлы из тайника

   При применении изменений могут возникнуть конфликты. Вы можете разрешить конфликты аналогично слиянию (подробнее см. git merge ).

   Удалить сохраненные изменения

   Если вы хотите удалить сохраненные изменения, не применяя их, выполните команду:

     git stash drop ИМЯ ЗАПИСИ  

   Чтобы очистить весь тайник, выполните команду:

     git stash clear  

   CSS {в реальной жизни}

   При манипуляциях с несколькими ветвями в Git легко случайно начать работу не с той веткой, прежде чем вы поймете, что вам нужно переключиться на другую.Или иногда вы можете работать над функцией и еще не готовы зафиксировать свои изменения, когда кто-то просит вас исправить срочную ошибку, и вам нужно перейти на другую ветку. Здесь пригодится команда Git stash .

   Создание и применение записи тайника

   Stashing позволяет нам сохранять копию наших незафиксированных изменений в текущей рабочей ветке.

   В простейшей форме команда git stash создает запись в тайнике. Чтобы повторно применить наши спрятанные изменения позже, мы можем использовать git stash apply .

   Создать тайник:

     git stash
     

   Примените запись тайника к вашей текущей рабочей ветке:

     git stash применить
     

   Мы можем применить запись тайника к другой ветке - это не обязательно должна быть ветка, из которой мы создали тайник.

   Хранение неотслеживаемых файлов

   По умолчанию git stash будет хранить только отслеженных файлов . Если мы хотим создать или применить запись тайника, включающую неотслеживаемых файлов (например,грамм. файлы, которые ранее не были размещены, или файлы, которые находятся в нашем .gitignore ), мы можем добавить к нашей команде флаг -u (или --include-untracked ):

   Создать запись тайника, включая неотслеживаемые файлы:

     git stash -u
     

   Чтобы применить запись тайника, включая неотслеживаемые файлы:

     git применить -u
     

   Несколько записей в тайнике

   git stash apply применит последнюю созданную вами запись тайника к вашей текущей рабочей ветке. Но можно хранить несколько тайников одновременно и применять их по отдельности. Чтобы перечислить все записи тайника, используйте git stash list . Появится список, который выглядит примерно так:

     git список тайников
   stash @ {0}: WIP в my-branch: ca96af0 Сообщение фиксации 3
   stash @ {1}: WIP в my-branch: 03af20c Сообщение о фиксации 2
   stash @ {2}: WIP в my-branch: 216b662 Сообщение фиксации 1
   
     

   По умолчанию записи тайника называются WIP (Работа в процессе), за ними следует ветвь и фиксация, из которой была создана запись тайника.Это может быть не очень полезно, если у нас есть несколько записей в тайнике - не очень легко увидеть, какие изменения мы будем применять! Вместо этого мы могли бы сохранить наш тайник с настраиваемым сообщением, чтобы было легче увидеть, к чему он относится:

     git stash save 'мой новый тайник'
     

   Теперь, когда мы перечисляем записи в тайнике, мы увидим собственное сообщение вместо общего:

     git список тайников
   Тайник @ {0}: В моей ветке: мой новый тайник
   stash @ {1}: WIP в my-branch: ca96af0 Сообщение о фиксации 3
   stash @ {2}: WIP в my-branch: 03af20c Сообщение о фиксации 2
   stash @ {3}: WIP в my-branch: 216b662 Сообщение фиксации 1
     

   Чтобы применить конкретную запись тайника из нашего списка, мы можем ссылаться на нее с помощью команды apply :

     git stash применить stash @ {2}
     

   (замените последнюю часть той ссылкой на тайник, которую мы хотим использовать. )

   Последующие записи тайников добавляются в начало списка тайников. Самый последний тайник будет иметь ссылку тайник @ {0} .

   Список тайников может содержать записи тайников из разных веток, каждая из которых может быть применена к другим ветвям вашего проекта.

   Наложение против хлопка

   Применение записи тайника сохранит копию в списке тайников, поэтому мы можем применить одну и ту же запись тайника к нескольким ветвям. Если мы запустим git stash list после применения тайника, мы увидим, что примененный тайник все еще там.

   Список всех наших текущих тайников:

     git список тайников
     

   Если мы хотим удалить запись тайника из списка при ее применении, мы могли бы использовать pop вместо `apply:

     git stash pop
     

   Это работает аналогично apply , где по умолчанию будет выталкиваться последняя запись тайника. Или мы могли бы вместо этого выдвинуть отдельный тайник:

     git pop stash @ {2}
     

   Popping, вероятно, является хорошей идеей, если вы знаете, что вам не нужно применять запись в тайнике в каких-либо других ветках, и вы хотите, чтобы ваш список тайников был красивым и чистым.

   Создание новой ветки с примененным тайником

   Мы можем использовать ветку для новой ветки и применить самую последнюю запись в тайнике:

     ветка git stash
     

   Это в основном ярлык для следующего:

     git checkout -b моя новая ветка
   git stash применить
     

   Опять же, он может взять ссылку на конкретную запись тайника, если вы хотите применить другую запись:

     git stash Branch stash @ {2}
     

   Удаление и очистка тайников

   Хорошая идея - содержать магазин в чистоте и удалять ненужные нам записи в тайнике, особенно при перемещении между филиалами.Жизнь будет намного проще, если у нас будет всего несколько тайников, а не сотни! К тому же, как только наши изменения будут внесены, нам все равно не понадобятся эти тайники.

   Мы можем удалить отдельные тайники из списка тайников с помощью команды drop . Как и в случае с pop и применяется , это по умолчанию повлияет на последнюю запись в тайнике. Если вы хотите настроить таргетинг на конкретный тайник, мы можем передать ему ссылку на тайник:

     git stash drop stash @ {2}
     

   В качестве альтернативы мы можем очистить все записи в тайнике сразу:

     git stash очистить
     

   изменений тайника - TortoiseGit - Документация - TortoiseGit - Интерфейс оболочки Windows для Git

   Часто, когда вы работали над частью своего проекта, все происходит в беспорядочном состоянии, и вы хотите немного переключить ветки, чтобы над чем-то поработать еще.Проблема в том, что вы не хотите выполнять наполовину сделанную работу только для того, чтобы вернуться к этому моменту позже. Ответ на этот вопрос - команда git stash.

   Stashing принимает грязное состояние вашего рабочего каталога, то есть ваши измененные отслеживаемые файлы и поэтапные изменения, и сохраняет его в стеке незавершенных изменений, которые вы можете повторно применить в любое время (даже в другой ветке).

   Если вы хотите записать текущее состояние рабочего каталога и индекса, но хотите вернуться в чистый рабочий каталог, щелкните правой кнопкой мыши папку, чтобы открыть контекстное меню, а затем выберите команду → Откроется диалоговое окно вверх, где вы можете дополнительно ввести сообщение для этого состояния:

   Рисунок 2.51. Диалоговое окно «Скрыть изменения»

   Вы также можете выбрать «Включить неотслеживаемые», чтобы убрать неотслеживаемые файлы. Чтобы спрятать все файлы, включая игнорируемые файлы в дополнение к неотслеживаемым файлам, выберите --all.

   Когда TortoiseGit обнаруживает, что сохраненные изменения существуют, контекстное меню будет расширено:

   Рисунок 2.52. Опции (не) тайника

   Тайник реализован в виде стека. применит изменения последнего тайника к вашему рабочему дереву.делает то же самое, но удаляет последний тайник из стека после его применения. все еще возможно и сохранит текущие изменения рабочей копии наверху стека.

   No related posts.