Stash git changes: Git — git-stash Documentation

ХХ полезных советов для пользователей Git среднего уровня. Часть 1 / Хабр

Вообще-то изначально я планировал перевести статью Энди Джеффриса (Andy Jeffries) 25 Tips for Intermediate Git Users, но в процессе я отбросил бестолковые, общеизвестные или самые простые советы вроде «настройте первым делом user.name и user.email», которые явно не подходят людям, уже более-менее плотно знакомым с Git.
Взамен я дополню статью моментами из личной практики («Своя практика»! Звучит здорово, будто я частный врач или адвокат! :-] )

1. Самое начало.

Поскольку user.{name,email,signingkey} настроены, можно посмотреть в сторону мелких удобств, вроде $ git config —global help.autocorrect 1 — в случае опечаток, гит попробует угадать что же вы имели в виду

[solar@hasher couchdb]$ git statu

WARNING: You called a Git command named ‘statu’, which does not exist.

Continuing under the assumption that you meant ‘status’

in 0.1 seconds automatically…

# On branch 0.10.x-alt

nothing to commit (working directory clean)

Значение 1 здесь показывает десятые доли секунды.

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

Из альясов я добавляю только

git config —global alias.logp ‘log —pretty=format:»%h — %an: %s»‘ — 10 последних коммитов в формате «SHA — Author: Commit message»

git config —global alias.unstage ‘reset HEAD’

git config —global alias.remotes ‘remote -v’ — Это сделает вывод git remote чуть более подробным, но не столь много словным, как git remote show $branch, в котором, к тому же, нужно указать конкретный сервер.

2. Конфликты при мердже

При имеющем место конфликте можно посмотреть предмет раздора в нормальном стандартного diff -u:

$ git diff —merge
diff --cc dummy.rb

index 5175dde,0c65895..4a00477

--- a/dummy.rb

+++ b/dummy.rb

@@@ -1,5 -1,5 +1,5 @@@

class MyFoo

def say

- puts "Bonjour"

- puts "Hello world"

++ puts "Annyong Haseyo"

end

end


Если нужно получить файл из одного из мерджащихся бранчей, можно сделать git checkout —ours flash/foo.fla либо git checkout —theirs flash/foo.fla — это избавит от необходимости помнить какие бранчи сливаются.

Так же всегда можно посмотреть различия перед объединением — $ git diff branch2 branch3

3. Тэги.

Чтобы удобно определять эволюционные стадии кода, надо использовать тэги.

$ git tag -m ‘$tag_description’ $tag_name

Если из вашего гита содержимое отправляется на сборку, все можно будет собрать конкретную указанную версию. Кстати, скорее всего, нужно будет создавать тэги, подписанные Вашим gpg-ключём (git config —global user.singingkey $key_ID)

4. Новые бранчи

Как всем должно быть известно, в новый бранч можно попасть либо создаев его и переключившись ($git branch new_branch; git checkout new_branch), либо сразу — $ git checkout -b new_branch.

Кстати, переименовать текущий бранч можно с помощью git branch -m new_name, а сторонний — git branch -m current_name new_name.

Не самая часто используемая возможность, но иногда приходится и так получается всяко быстрее чем checkout -b и последующее ручное удаление старого бранча.

5. Объединение бранчей. Merge и rebase.

Чтобы поместить в один бранч изменения из другого бранча, можно использовать либо merge — m создаёт новый коммит, в котором находятся необходимые правки, либо rebase — r же переписывает историю. С одной стороны, после rebase история получается более аккуратной, с другой — это уже другая история, поэтому в случае опубликованных общеступных бранчей лучше пользоваться merge. Тем более, что за количество коммитов никто денег не берёт.

Можно посмотреть бранчи, изменения в которых еще не перенесены в текущий бранч — это можно сделать через git branch —no-merged. Такие бранчи лучше не дропать, хехе.

6. Удалённые бранчи

Удалённые — в смысле, remote :-]

Можно пушить в удалённый бранч напрямую — git push origin branch_name, если имена локального и удалённого бранчей совпадают, а можно и с помощью полной формы — git push origin localBranch:refs/heads/Remote_Branch_Name

Кстати, чтобы не указывать каждый раз имя сервера и бранч, можно создавать отслеживаемые бранчи с помощью git checkout -b myfeature origin/myfeature. Теперь, находясь в этом бранче, можно пушить/фетчить/пуллить без конкретных имен.

7. Stash

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

i. hack-hack-hack

ii. git stash

iii. fix-fix-fix

iv. git commit -a -m ‘bugfix #31337’

v. git stash pop

Те же, кто знает про git stash, посмотрите на последнюю строку — её отличие от apply в том, что откладываемые результаты не остаются во временном хранилище (посмотрите git stash list после нескольких примений stash!)

Если изменение было фактически законченным, можно оформить коммит не отходят от кассы — git stash save ‘commit msg’

8. Поиск в истории

Если про коммит известно хоть что-то, можно попробовать его найти!

$ git log —grep=«Something in the message» — поиск по описанию коммита

$ git log -S»{% include \«header.

P.S.: Спасибо за такой нужный +1, %username% )

Сохраняем временно свои изменения с помощью git stash

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

Git stash

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

Saved working directory and index state WIP on app-refactoring: 38e8211 add app footer

Если мы сейчас выполним — git status, то увидим, что ветка пустая (без изменений).

On branch app-refactoring

nothing to commit, working tree clean

Git stash save

Кроме того, когда сохраняем новые изменения, можем указать имя, чтобы запомнить, какие изменения мы делали. Для этого нужно выполнить git stash save <message> и указать имя сообщения:

git stash save 'wip: refactoring'

Git stash list

Для того чтобы посмотреть, что у нас есть в stash, нужно выполнить git stash list.

Stash — это структура стека, в которой все сообщения будут появляться один за другим: stash@{0}, stash@{1} и так далее.

Выполнив git stash list мы увидем, что у нас есть два сообщения: stash@{1} было сгенерировано автоматически, а stash@{0} — созданное нами.

stash@{0}: On app-refactoring: wip: refactoring
stash@{1}: WIP on app-refactoring: 38e8211 add app footer

Git stash pop

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

Git stash apply

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

Чтобы применить конкретный stash, нужно выполнить git stash apply "stash@{n}" и указать номер stash. Некоторые системы требуют указывать "stash@{n}" с двойными кавычками, а некоторые нет stash@{n}.

git stash apply stash@{0}

Git stash show

Данная команда показывает сводку различий в stash. При этом учитывает только последний stash.

Если нужно увидеть полный diff, мы можем использовать:

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

Git stash branch

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

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

git stash branch <name> stash@{1}

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

Git stash drop

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

git stash drop <stash_id>

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

Git stash clear

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

использование stash и rebase для обновления локального бранча

Имеется локальный бранч, созданный из develop.

После его создания — в develop было сделано много изменений, и перед созданием pull-реквеста — хочется их синхронизировать.

Отличная документация по rebase и merge есть тут>>>.

Для того, что бы не потерять изменения, которые мы уже сделали в локальном бранче — сначала выполняем stash:

d:***plugins>git stash
Saved working directory and index state WIP on NG-5071-add-propertygroup-to-csproj-file: 14a423c Merged in upldate_plugins_sln (pull request #1097)
HEAD is now at 14a423c Merged in upldate_plugins_sln (pull request #1097)

Если бранч develop не загружен — загружаем:

d:***plugins>git pull origin develop

Объединяем бранч с «главным» бранчем — в данном примере это develop:

d:***plugins>git rebase origin/develop
First, rewinding head to replay your work on top of it...
Fast-forwarded NG-5071-add-propertygroup-to-csproj-file to origin/develop.

Возвращаем наши изменения из stash:

d:***plugins>git stash pop
On branch NG-5071-add-propertygroup-to-csproj-file
Your branch is ahead of 'origin/NG-5071-add-propertygroup-to-csproj-file' by 8 commits.
(use "git push" to publish your local commits)

Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git checkout -- <file>..." to discard changes in working directory)

modified: Plugins/AbstractGUI/AbstractGUI.csproj
modified: Plugins/AnimationFlyer/AnimationFlyer.csproj
...
modified: Plugins/UnityUI_Api/UnityUI_Api.csproj
modified: Plugins/WalkingNavigation/WalkingNavigation.csproj

no changes added to commit (use "git add" and/or "git commit -a")
Dropped refs/stash@{0} (11e43ec11678eb5f953fe6ceffdad3261346453f)

Проверяем статус:

d:***plugins>git status
On branch NG-5071-add-propertygroup-to-csproj-file
Your branch is ahead of 'origin/NG-5071-add-propertygroup-to-csproj-file' by 8 commits.
(use "git push" to publish your local commits)
...

modified: Plugins/AbstractGUI/AbstractGUI.csproj
modified: Plugins/AnimationFlyer/AnimationFlyer.csproj
...
modified: Plugins/UnityUI_Api/UnityUI_Api.csproj
modified: Plugins/WalkingNavigation/WalkingNavigation.csproj

no changes added to commit (use "git add" and/or "git commit -a"

Добавляем изменения:

d:***plugins>git add -A

Комитим:

d:***plugins>git commit -m "NG-5071 Add <PropertyGroup> to .csproj files"
[NG-5071-add-propertygroup-to-csproj-file 94ca007] NG-5071 Add <PropertyGroup> to .csproj files
63 files changed, 425 insertions(+), 339 deletions(-)

И сохраняем все обновления и наши изменения:

d:***plugins>git push origin

как посмотреть что лежит в git stash?

git stash apply

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

git stash show — команда покажет файлы из последнего stash. Пример:

$ git stash show
 3rdparty/PhpWhois         | 2 +-
 framework                 | 2 +-
 lib/Git/Stash.php         | 2 ++
 3 files changed, 4 insertions(+), 2 deletions(-)

Если нужно посмотреть, какие конкретно изменения сделаны в файлах, то нужно к предыдущей команде добавить ключ -p:

git stash show -p — покажет какие изменения лежат в stash

Git Stash — это стэк. Можно достать и предыдущие изменения, положенные в stash git.

Посмотреть весь список stash:

git stash list

$ git stash list
stash@{0}: WIP on master: f1f1d84 typo
stash@{1}: WIP on master_mywot: 33601de Скипнул тест CommentNotes (нет в выдаче после смены вёртски)
stash@{2}: WIP on master_mturk_revert: c410f9d typo
stash@{3}: WIP on master_mturk_modernize: 5096512 typo
stash@{4}: WIP on master: 9072aa9 typo fix
stash@{5}: WIP on master_moderate: 74c6ca8 Merge remote-tracking branch 'origin/master' into master_moderate
stash@{6}: WIP on master_moderate: 6d162fb dashboard
stash@{7}: WIP on master_moderate: 3ede2e5 typo
stash@{8}: WIP on master: df443f3 Merge pull request #600 from vicman-wi/master_max_exec_time
stash@{9}: WIP on master: f7c9dc3 typo add whitespace
stash@{10}: WIP on master: 96fa4ae more secured cookie

Тут будет список из 40 последних стэшей.

Команда git stash apply применяет последний stash т.е. следующая команда будет равнозначная:

git stash apply stash@{0}

А эта команда внесёт изменения, которые хранятся в стэке под 5-ым номером:

git stash apply stash@{5}

Узнать какие изменения в git stash под конкретным номером:

git stash show -p stash@{5}

Команда apply лишь выдаёт изменения, которые спрятаны в стэке. При этом сами наработки остаются храниться в стэке. Чтобы удалить (очистить) последний сохранённый git stash:

git stash drop   # удалит последний git stash
git stash drop stash@{5}  #удалит git stash под номером 5

Подробнее об очистке git stash.

Как игнорировать ошибку в «git pull» о моих локальных изменениях, которые будут перезаписаны слиянием?

вот моя стратегия решения проблемы.

Постановка Задачи

нужно внести изменения в более чем 10 файлов. Мы пытались!—0—>, но мерзавец крикнул:

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

мы пытались выполнить commit а то pull, но они не работают любой.

решение

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

проверьте эту ссылку для получения информации о различных этапах Git в ясной форме: этапы GIT

мы следовали следующему шаги

• git stash (это сделало наш рабочий каталог чистым. Ваши изменения хранятся в стеке Git).
• git pull origin master (вытащите изменения с сервера)
• git stash apply (применены все изменения из стека)
• git commit -m 'message' (внесенные изменения)
• git push origin master (передвинул изменения на сервер)
• git stash drop (падение стека)

давайте поймем, когда и почему вам нужно тайник

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

из книги ProGIT, 2-е издание:

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

git stash — Сохранение изменений

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

Хранение вашей работы

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

  $ git status На главном сервере ветки Изменения, которые необходимо зафиксировать: новый файл: style.css Изменения, не поставленные для фиксации: изменено: index.html $ git stash Сохраненный рабочий каталог и состояние индекса WIP на главном сервере: 5002d47 теперь находится наша новая домашняя страница HEAD в 5002d47 наша новая домашняя страница $ git status На мастере ветки нечего фиксировать, рабочее дерево очищено  

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

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

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

Вы можете повторно применить ранее сохраненные изменения с помощью git stash pop :

  $ git status На мастере ветки нечего фиксировать, рабочее дерево очищено $ git stash pop На мастере ветки Изменения, которые необходимо зафиксировать: новый файл: style.css Изменения, не запланированные для фиксации: modified: index.html Отброшены refs / stash @ { 0} (32b3aa1d185dfe6d57b3c3cc3b32cbf3e380cc6a)  

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

В качестве альтернативы вы можете повторно применить изменения к своей рабочей копии и сохранить их в своем тайнике с помощью git stash apply :

  $ git stash apply В главном узле ветки Изменения, которые необходимо зафиксировать: новый файл: style.css Изменения, не поставленные для фиксации: изменено: index.html  

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

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

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

По умолчанию при запуске git stash будет сохранено:

• изменений, которые были добавлены в ваш индекс (поэтапные изменения)
• изменения, внесенные в файлы, которые в настоящее время отслеживаются Git (неустановленные изменения)

Но это будет , а не тайник:

• новых файлов в вашей рабочей копии, которые еще не были размещены
• файлов, которые были проигнорированы

Итак, если мы добавим третий файл в наш пример выше, но не будем его размещать (т.е.е. мы не запускаем git add ), git stash не будет его прятать.

  $ script.js $ git status В мастере ветки Изменения, которые необходимо зафиксировать: новый файл: style.css Изменения, не поставленные для фиксации: изменено: index.html Файлы без отслеживания: script.js $ git stash Сохраненный рабочий каталог и состояние индекса WIP на master: 5002d47 наша новая домашняя страница HEAD теперь находится на 5002d47 наша новая домашняя страница $ git status На ветке master Не отслеживаемые файлы: script.js  

Добавление параметра -u (или --include-untracked ) сообщает git stash , что нужно также хранить ваши неотслеживаемые файлы:

  $ git status В мастере ветки Изменения, которые необходимо зафиксировать: новый файл: стиль.css Изменения, не поставленные для фиксации: изменено: index.html Файлы без отслеживания: script.js $ git stash -u Сохраненный рабочий каталог и состояние индекса WIP на главном сервере: 5002d47 наша новая домашняя страница HEAD теперь находится на 5002d47 наша новая домашняя страница $ git status On branch Мастер ничего не фиксирует, рабочее дерево чистое  

Вы также можете включить изменения в игнорируемые файлы, передав параметр -a (или --all ) при запуске git stash .

Управление несколькими тайниками

Вы не ограничены одним тайником.Вы можете запустить git stash несколько раз, чтобы создать несколько тайников, а затем использовать git stash list для их просмотра. По умолчанию тайники идентифицируются просто как «незавершенная работа» — над веткой и фиксацией, из которой вы создали тайник. Через некоторое время может быть трудно вспомнить, что содержит каждый тайник:

  $ git stash list stash @ {0}: WIP на главной странице: 5002d47 наша новая домашняя страница stash @ {1}: WIP на главной странице: 5002d47 наша новая домашняя страница stash @ {2}: WIP на главной странице: 5002d47 наша новая домашняя страница  

Чтобы предоставить немного больше контекста, рекомендуется аннотировать ваши тайники с описанием, используя git stash save "message" :

  $ git stash save «добавить стиль на наш сайт» Сохраненный рабочий каталог и состояние индекса На главном: добавить стиль на наш сайт HEAD теперь находится на 5002d47 наша новая домашняя страница $ git stash list stash @ {0}: На мастере: добавить стиль на наш сайт, тайник @ {1}: WIP на главной странице: 5002d47, наш новый тайник главной страницы @ {2}: WIP на главной странице: 5002d47, наша новая домашняя страница  

По умолчанию git stash pop повторно применяет последний созданный тайник: stash @ {0}

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

  $ git stash pop stash @ {2}  

Просмотр различий в тайнике

Вы можете просмотреть сводку тайника с помощью git stash show :

  $ git stash show index.html | 1 + style.css | 3 +++ 2 файла изменено, 4 прошивки (+)  

Или передайте опцию -p (или --patch ), чтобы просмотреть полную разницу в тайнике:

  $ git stash show -p diff --git a / style.css b / style.css новый режим файла 100644 индекс 0000000..d92368b --- / dev / null +++ b / style.css @@ -0 , 0 +1,3 @@ + * {+ text-decoration: blink; +} diff --git a / index.html b / index.html index 9daeafb..ebdcbd2 100644 --- a / index.html +++ b / index.html @@ -1 +1,2 @@ +  

Частичные тайники

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

  $ git stash -p diff --git a / style.css b / style.css новый режим файла 100644 index 0000000..d92368b --- / dev / null +++ b / style.css @@ -0, 0 +1,3 @@ + * {+ text-decoration: blink; +} Убрать этот кусок [y, n, q, a, d, /, e ,?]? y diff --git a / index.html b / index.html index 9daeafb..ebdcbd2 100644 --- a / index.html +++ b / index.html @@ -1 +1,2 @@ + Убрать этот кусок [y, n, q, a, d, /, e ,?]? n  

Можно ударить ? для получения полного списка команд Hunk. Обычно полезные:

9

Нет явной команды «abort», но нажатие CTRL-C (SIGINT) прервет процесс сохранения.

Создание ветки из вашего тайника

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

  $ git stash branch add-stylesheet stash @ {1} Переключился на новую ветку 'add-stylesheet' В ветке add-stylesheet Изменения, которые необходимо зафиксировать: новый файл: style.css Изменения, не поставленные для фиксации: modified: index.html Отброшенные ссылки / тайник @ {1} (32b3aa1d185dfe6d57b3c3cc3b32cbf3e380cc6a)  

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

Очистка вашего тайника

Если вы решите, что вам больше не нужен конкретный тайник, вы можете удалить его с помощью git stash drop :

  $ git stash drop stash @ {1} Drop stash @ {1} (17e2697fd8251df6163117cb3d58c1f62a5e7cdb)  

Или вы можете удалить все свои тайники с помощью:

  $ git stash clear  

Как работает git stash

Если вы просто хотели узнать, как использовать git stash , можете перестать читать здесь.Но если вам интересно, как Git (и git stash ) работает под капотом, читайте дальше!

Тайники фактически кодируются в вашем репозитории как объекты фиксации. Специальный ref в .git / refs / stash указывает на ваш последний созданный тайник, а на ранее созданные тайники ссылается журнал reflog stash ref. Вот почему вы ссылаетесь на тайники с помощью stash @ {n}: на самом деле вы имеете в виду n-ю запись журнала для stash ref.Поскольку тайник — это просто фиксация, вы можете проверить его с помощью git log :

  $ git log --oneline --graph stash @ {0} * -. 953ddde WIP на главном сервере: 5002d47 наша новая домашняя страница | \ \ | | * 24b35a1 неотслеживаемые файлы на главном сервере: 5002d47 наша новая домашняя страница | * 7023dd4 index on master: 5002d47 наша новая домашняя страница | / * 5002d47 наша новая домашняя страница  

В зависимости от того, что вы спрятали, одна операция git stash создает либо два, либо три новых коммита. Коммиты на диаграмме выше:

• stash @ {0} , новый коммит для хранения отслеживаемых файлов, которые были в вашей рабочей копии, когда вы запускали git stash
• stash @ {0} первого родителя, ранее существовавшего коммита это было в HEAD, когда вы запускали git stash
• stash @ {0} второй родительский элемент , новый коммит, представляющий индекс, когда вы запускали git stash
• stash @ {0} третий parent, новый коммит, представляющий неотслеживаемые файлы, которые были в вашей рабочей копии, когда вы запускали git stash .Этот третий родительский элемент создается только в том случае, если:
  • ваша рабочая копия действительно содержала неотслеживаемые файлы; и
  • вы указали вариант --include-untracked или --all при вызове git stash .

Как git stash кодирует ваше рабочее дерево и индекс как коммиты:

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

• Вызов git stash кодирует любые изменения в отслеживаемых файлах в виде двух новых коммитов в вашей группе DAG: один для неустановленных изменений, а другой для изменений, помещенных в индекс. Специальная ссылка refs / stash ref обновлена, чтобы указывать на них.

• Использование опции --include-untracked также кодирует любые изменения в неотслеживаемых файлах как дополнительную фиксацию.

• Использование опции --all включает изменения любых игнорируемых файлов наряду с изменениями неотслеживаемых файлов в одной фиксации.

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

Как увидеть сохраненные изменения с помощью git stash

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

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

список $ git stash
тайник @ {0}:
тайник @ {1}:
тайник @ {2}:
тайник @ {3}:

Каждый раз, когда вы храните свой рабочий каталог, git будет сохранять состояние рабочего каталога в нечто, что хранит историю дерева тайников.Каждый раз, когда вы сохраняете свои изменения, они будут сохраняться как своего рода фиксация в дереве тайников. Все сохраненные изменения складываются в порядке с серийным номером или ссылкой. stash @ {0} — это первый или самый верхний или самый последний тайник. Каждый раз, когда вы хотите сослаться на конкретный тайник, вы должны использовать его ссылочный идентификатор, например stash @ {3}, stash @ {5}… и т. Д.

Думайте о каждом тайнике как о отдельной фиксации. Эти коммиты хранятся и складываются по-разному и не перекрываются с обычной историей коммитов git

Тайник представлен как фиксация, в дереве которой записано состояние рабочего каталога, а ее первым родителем является фиксация в HEAD, когда тайник был создан.

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

• git stash показать
• git показать
• git diff
• git difftool

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

Команда git stash show

Простая команда git stash show дает очень краткую сводку изменений файла, но не показывает разницу изменений относительно текущей HEAD.Что-то вроде,

Что-то вроде ниже

git stash show
etc / project.conf | 6 + ——
1 файл изменен, 1 вставка (+), 5 удалений (-)

Иногда это не так полезно. Вы можете захотеть увидеть разницу с текущим HEAD, любым конкретным коммитом или текущим каталогом.

Если вы используете git stash show вместе с опцией -p , он покажет все изменения.

Проверить разницу с выбранным тайником.

git stash show -p stash @ {0}

Команда git show

Команда git-show используется для просмотра различных типов объектов.

Команда git-show используется не только для визуализации изменений тайника, но также для просмотра одного или нескольких объектов, таких как капли, деревья, теги и коммиты. Для получения дополнительной информации проверьте git-show

Справка:

git show [параметры] <объект>…

Чтобы увидеть максимальную разницу между тайниками и HEAD:

Чтобы получить разницу выбранного тайника с HEAD:

git stash — временное сохранение изменений

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

Например, вы находитесь в процессе исправления ошибки, когда замечаете опечатку в том же месте, где вы вносите изменения. Вы также можете быстро изменить опечатку и позже зафиксировать ее вместе с исправлением ошибки, но тогда вы смешиваете два несвязанных изменения. Не лучшая практика. Позже, когда кто-то прочитает изменение и захочет понять его, эта смесь будет сбивать с толку.Будет непонятно. Было ли это исправление опечатки частью исправления ошибки? Лучшим подходом было бы разделить два исправления.

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

Как вы это делаете:

$ git stash
 

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

Ответ git stash выглядит так:

$ git stash
Сохраненный рабочий каталог и состояние индекса WIP на главном сервере: 271c4b5 СООБЩЕНИЕ САМЫЙ ПОСЛЕДНИЙ КОМИТЕТ
 

С соответствующим SHA1 и сообщением о самой последней фиксации в конце ответа.

Затем вы исправляете опечатку. Зафиксируйте это. Тогда ты бежишь

$ git stash pop
 

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

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

Ответ будет выглядеть так:

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

изменено: README

в фиксацию изменений не добавлено (используйте "git add" и / или "git commit -a")
Выпавшие ссылки / тайник @ {0} (7f14ba3a7afa71a7b61df8afdd059542b4761c76)
 

Тайник — стопка

Пока вы исправляете опечатку, вы можете заметить другую проблему, которая даже более важна, чем исправление опечатки.Не волнуйтесь, вы можете запускать git stash несколько раз, и он сохранит текущие изменения в тайнике в отдельных записях. Он обрабатывает весь тайник как стек, а это означает, что если вы вызываете git stash несколько раз, то git pop вернет изменения из самой последней команды git stash. (ЛИФО).

Вывод содержимого тайника

В списке команд git stash будут перечислены все сохраненные изменения:

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

тайник @ {0}: WIP на главном сервере: 2b71505 COMMIT_MESSAGE
stash @ {1}: WIP на главном сервере: 2b71505 COMMIT_MESSAGE
 

Самый последний созданный тайник имеет идентификатор 0.

Показывает содержимое тайника

Мы также можем видеть, что находится в тайнике, не пытаясь его восстановить.
Нам просто нужно передать идентификатор тайника:

$ git stash показать 1
 README | 2 + -
 1 файл изменен, 1 вставка (+), 1 удаление (-)

$ git stash показать 0
 README | 2 + -
 1 файл изменен, 1 вставка (+), 1 удаление (-)
 

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

Мы можем передать параметры формата git diff, например -p:

$ git stash show -p 0

diff --git a / README b / README
index 10c055e..bc08efb 100644
--- a / README
+++ b / README
@@ -1,5 +1,5 @@
 Первая строка
 Вторая строка
-Третья строка
+ Строка 3
 Строка 4
 Строка пятая
 

$ git stash show -p 1

diff --git a / README b / README
индекс 10c055e..a5a4aef 100644
--- a / README
+++ b / README
@@ -1,4 +1,4 @@
-Строка первая
+ Строка 1
 Вторая строка
 Третья строка
 Строка 4
 

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

Без какого-либо идентификатора git stash show по умолчанию будет использовать самый последний тайник.(тайник 0)

$ git stash show
 README | 2 + -
 1 файл изменен, 1 вставка (+), 1 удаление (-)
 

Удаление записи из тайника

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

Например:

git stash drop 1
 

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

Итак, если бы у нас был такой список git stash:

stash @ {0}: WIP при отправке: 2ead3e3 ... Добавить кнопку на главную страницу
stash @ {1}: На главном сервере: 9cc0589 ... Исправить опечатку в электронной почте
stash @ {2}: На главном сервере: 9b80575 ... Введите ошибку № 42
 

тогда

$ git stash pop 1
 

приведет к следующему списку git stash:

stash @ {0}: WIP при отправке: 2ead3e3 ... Добавить кнопку на главную страницу
stash @ {1}: На главном сервере: 9b80575 ... Введите ошибку № 42
 

Очистка тайника

Если у вас есть несколько записей в тайнике, и вы больше не хотите возиться с ними, вы можете использовать

git stash clear
 

команда, чтобы удалить все записи сразу.

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

Бывают случаи, когда в нашем репозитории появляются новые и еще не отслеживаемые файлы, и мы бы хотели все это отложить.
Для этого мы можем использовать флаг -u, также известный как —include-untracked:

$ git stash -u
 

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

Конфликт слияния в тайнике

$ git stash pop
Авто-слияние README
КОНФЛИКТ (содержание): конфликт слияния в README
 

Содержимое файла README (того, в котором возник конфликт слияния):

<<<<<<< Обновлено в апстриме
Линия первая
=======
Строка 1
>>>>>>> Изменения припрятаны
Вторая строка
Третья строка
Строка 4
Строка пятая
 

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

Строка 1 первая
Вторая строка
Третья строка
Строка 4
Строка пятая
 

Затем мы можем проверить статус

$ git status

О мастере филиала
Не объединенные пути:
  (используйте "git reset HEAD <файл> ...", чтобы отключить сцену)
  (используйте "git add  ...", чтобы отметить разрешение)

оба изменены: README

в фиксацию изменений не добавлено (используйте "git add" и / или "git commit -a")
 

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

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

Manpage Ubuntu: git-stash — спрятать изменения в грязном рабочем каталоге подальше от

Предоставлено: git-man_2.7.4-0ubuntu1_all

НАИМЕНОВАНИЕ

       git-stash - спрятать изменения в грязном рабочем каталоге.

 

ОБЗОР

         git   stash  list [<опции>]
         git   stash  show []
         git   stash  drop [-q | --quiet] []
         git   stash  (pop | apply) [--index] [-q | --quiet] []
         git   stash  branch  []
         git   stash  [сохранить [-p | --patch] [-k | - [no-] keep-index] [-q | --quiet]
                    [-u | --include-untracked] [-a | --all] [<сообщение>]]
         git   stash  clear
         git   stash  create [<сообщение>]
         git   stash  store [-m | --message ] [-q | --quiet] 

 

ОПИСАНИЕ

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

       Изменения, спрятанные с помощью этой команды, могут быть перечислены в списке git stash list,
       проверено с помощью git stash show и восстановлено (возможно, поверх другого коммита)
       с применением git stash. Вызов git stash без аргументов эквивалентен вызову git stash
       спасти. Тайник по умолчанию отображается как "WIP на  филиале  ...", но вы можете указать больше
       описательное сообщение в командной строке при его создании.Последний созданный вами тайник хранится в refs / stash; старые тайники находятся в
       reflog этой ссылки и может быть назван с использованием обычного синтаксиса reflog (например, stash @ {0} -
       последний созданный тайник, stash @ {1} - перед ним, stash@{2.hours.ago} -
       также возможно).

 

ОПЦИИ

       сохранить [-p | --patch] [-k | - [no-] keep-index] [-u | --include-untracked] [-a | --all] [-q | --quiet]
       [<сообщение>]
           Сохраните локальные изменения в новом тайнике   и запустите git reset --hard, чтобы отменить их.Часть  является необязательной и дает описание вместе с сохраненным состоянием.
           Для быстрого создания снимка вы можете опустить ,  «save» и , но указать только
           <сообщение> не запускает это действие, чтобы подкоманда с ошибкой
           нежелательный тайник.

           Если используется опция --keep-index, все изменения, уже добавленные в индекс, остаются.
           неповрежденный.

           Если используется опция --include-untracked, все неотслеживаемые файлы также сохраняются и
           затем очистил с помощью git clean, оставив рабочий каталог в очень чистом состоянии.Если вместо этого используется параметр --all, игнорируемые файлы сохраняются и очищаются в
           дополнение к неотслеживаемым файлам.

           С помощью --patch вы можете интерактивно выбирать блоки из разницы между HEAD и
           рабочее дерево, которое нужно спрятать. Запись в тайнике построена так, что ее индексное состояние
           то же самое, что и состояние индекса вашего репозитория, а его рабочее дерево содержит только
           изменяет ваш выбор в интерактивном режиме. Выбранные изменения затем откатываются от
           ваше рабочее дерево.См. Раздел «Интерактивный режим» в  git-add  (1), чтобы узнать, как
           работать в режиме --patch.

           Параметр --patch подразумевает --keep-index. Вы можете использовать --no-keep-index, чтобы переопределить это.

       список [<опции>]
           Перечислите тайники, которые у вас есть. Каждый тайник   указан с его именем (например,
           stash @ {0} - последний тайник, stash @ {1} - предыдущий и т. д.), имя
           ветка, которая была текущей на момент создания тайника, и краткое описание фиксации
           тайник был основан на.stash @ {0}: WIP при отправке: 6ebd0e2 ... Обновить документацию git-stash
               stash @ {1}: На главном сервере: 9cc0589 ... Добавить git-stash

           Команда принимает параметры, применимые к команде  git   log  для управления тем, что отображается.
           и как. См.  git-log  (1).

       показать []
           Показать изменения, записанные в тайнике, как разницу между состоянием в хранилище и его
           оригинальный родитель. Если  не указан, отображается последний.По умолчанию
           показывает команду diffstat, но она принимает любой формат, известный для  git   diff  (например, git
           stash show -p stash @ {1}, чтобы просмотреть второй самый последний тайник в форме патча). Вы можете
           используйте переменные конфигурации stash.showStat и / или stash.showPatch, чтобы изменить значение по умолчанию
           поведение.

       pop [--index] [-q | --quiet] []
           Удалите одно сохраненное состояние из списка тайников и примените его поверх текущего
           состояние рабочего дерева, т.е.е. выполните операцию, обратную git stash save. Рабочая
           каталог должен соответствовать индексу.

           Применение состояния может привести к возникновению конфликтов; в этом случае он не удаляется из
           список тайников. Вам нужно разрешить конфликты вручную и вызвать git stash drop вручную
           потом.

           Если используется параметр --index, то пытается восстановить не только рабочее дерево
           изменений, но и индекса. Однако это может потерпеть неудачу, если у вас есть конфликты.
           (которые хранятся в индексе, поэтому вы больше не можете применять изменения как
           они были изначально).Если  не указан, предполагается, что stash @ {0}, в противном случае  должен быть ссылкой.
           формы stash @ {}.

       применить [--index] [-q | --quiet] []
           Как pop, но не удаляйте состояние из списка тайников. В отличие от pop,  может быть
           любой коммит, который выглядит как коммит, созданный при помощи сохранения или создания тайника.

       ветка <имя-ветки> [<ветка>]
           Создает и проверяет новую ветку с именем , начиная с фиксации в
           который изначально был создан , применяет изменения, записанные в , к
           новое рабочее дерево и индекс.Если это удалось, и  является ссылкой на
           form stash @ {}, затем он удаляет . Если  не указан, применяется
           самый последний.

           Это полезно, если ветка, в которой вы запускали git stash save, изменилась достаточно, чтобы
           Применить git stash не удается из-за конфликтов. Так как тайник накладывается поверх
           коммит, который был HEAD на момент запуска git stash, он восстанавливает первоначально спрятанный
           состояние без конфликтов.Чисто
           Удалите все спрятанные состояния. Обратите внимание, что эти состояния будут затем удалены,
           и может быть невозможно восстановить (см. примеры   ниже для возможной стратегии).

       drop [-q | --quiet] []
           Удалите одно сохраненное состояние из списка тайников. Если  не указан, он
           удаляет последний. то есть stash @ {0}, в противном случае  должен быть действительным журналом хранения
           ссылка на форму stash @ {}.Создайте
           Создайте тайник (который является обычным объектом фиксации) и верните его имя объекта без
           сохраняя его где угодно в пространстве имен ref. Это предназначено для использования в сценариях.
           Вероятно, это не та команда, которую вы хотите использовать; см. «сохранить» выше.

       магазин
           Сохраните заданный тайник, созданный с помощью  git   stash   create  (который является висящим коммитом слияния) в
           ссылка на тайник, обновляющая журнал ссылок тайника. Это предназначено для использования в сценариях.Вероятно, это не та команда, которую вы хотите использовать; см. «сохранить» выше.

 

ОБСУЖДЕНИЕ

       Тайник представлен как фиксация, в дереве которой записано состояние рабочего каталога,
       а его первый родитель - это фиксация в HEAD, когда был создан тайник. Дерево
       второй родитель записывает состояние индекса при создании тайника, и он становится
       потомок коммита HEAD. График предков выглядит так:

                  .---- Вт
                 / /
           -----ЗДРАВСТВУЙ

       где H - фиксация HEAD, I - фиксация, которая записывает состояние индекса, а W -
       commit, который записывает состояние рабочего дерева.

 

ПРИМЕРЫ

       Въезжая в грязное дерево
           Когда вы что-то делаете, вы узнаете, что произошли изменения в восходящем направлении.
           которые, возможно, имеют отношение к тому, что вы делаете. Когда ваши локальные изменения не
           конфликт с изменениями в восходящем потоке, простой git pull позволит вам двигаться
           вперед.Однако бывают случаи, когда ваши локальные изменения конфликтуют с вышестоящим
           changes, а git pull отказывается перезаписывать ваши изменения. В таком случае вы можете спрятать
           ваши изменения прочь, выполните извлечение, а затем отключите, например:

               $ git pull
                ...
               файл foobar устарел, не может быть объединен.
               $ git stash
               $ git pull
               $ git stash pop

       Прерванный рабочий процесс
           Когда вы занимаетесь чем-то, ваш босс приходит и требует, чтобы вы исправили
           что-то сразу.
               #... продолжайте взламывать ...

           Вы можете использовать  git   stash , чтобы упростить приведенное выше, например:

               # ... хак хак хак ...
               $ git stash
               $ edit аварийное исправление
               $ git commit -a -m "Исправить в спешке"
               $ git stash pop
               # ... продолжить взлом ...

       Тестирование частичных коммитов
           Вы можете использовать git stash save --keep-index, если хотите сделать два или более коммитов
           изменений в рабочем дереве, и вы хотите протестировать каждое изменение перед фиксацией:

               #... взломать взломать взломать ...
               $ git add --patch foo # добавить только первую часть в индекс
               $ git stash save --keep-index # сохранить все остальные изменения в тайнике
               $ edit / build / test первая часть
               $ git commit -m 'First part' # зафиксировать полностью протестированное изменение
               $ git stash pop # готовимся ко всем другим изменениям
               # ... повторять пять шагов, пока не останется одна фиксация ...
               $ edit / build / test остальные части
               $ git commit foo -m 'Остальные части'

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

               git fsck --unreachable |
               grep commit | вырезать -d \ -f3 |
               xargs git log --merges --no-walk --grep = WIP

 

СМОТРИ ТАКЖЕ

         git-checkout  (1),  git-commit  (1),  git-reflog  (1),  git-reset  (1)

 

GIT

       Часть набора  git  (1)
 

git stash — Как временно сохранить изменения

Существует множество ситуаций, когда чистая рабочая копия рекомендуется или даже требуется: при объединении ветвей, при извлечении с удаленного компьютера или просто при извлечении из другой ветки.

Команда «git stash» может помочь вам (временно, но безопасно) сохранить незафиксированные локальные изменения — и оставить вам чистую рабочую копию.

Шпаргалка по Git

Не нужно запоминать все эти команды и параметры: получите нашу популярную «Шпаргалку по Git» — бесплатно!

git stash: буфер обмена для ваших изменений

Допустим, у вас сейчас есть пара локальных модификаций:

  $ git status
  изменено: index.php
  изменено: css / styles.css
  

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

Вот где пригодится git stash:

  $ git stash
Сохраненный рабочий каталог и состояние индекса WIP на главном сервере:
   2dfe283 Реализовать новое окно входа
HEAD теперь на 2dfe283 Реализуйте новое окно входа в систему
  

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

Продолжение с того места, где вы остановились

Как уже упоминалось, Git’s Stash предназначен для временного хранения. Когда вы будете готовы продолжить с того места, на котором остановились, вы можете легко восстановить сохраненное состояние:

  $ git stash pop
  

Флаг «pop» повторно применит последнее сохраненное состояние и в то же время удалит его представление в тайнике (другими словами: он выполняет очистку за вас).

Если вы хотите применить определенный элемент тайника (не самый последний), вы можете указать индексное имя этого элемента в опции «pop»:

  $ git stash pop stash @ {2}
  

Наконечник

Использование тайника в башне

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

Узнать больше

stash (1) — справочная страница Linux

Имя

git-stash — Убрать изменения в грязный рабочий каталог.

Сводка

  git stash  список [<параметры>]
  git stash  показать []
  git stash  drop [-q | --quiet] []
  git stash  (pop | применить) [--index] [-q | --quiet] []
  git stash  ветка <имя-ветки> []
  git stash  [сохранить [--patch] [-k | - [no-] keep-index] [-q | --quiet] []]
  git stash  очистить
  git stash  создать 

Описание

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

Изменения, спрятанные с помощью этой команды, могут быть перечислены в списке git stash list, проверены с помощью git stash show и восстановлены (возможно, поверх
другой коммит) с применением git stash. Вызов git stash без аргументов эквивалентен вызову git stash save. Тайник по умолчанию отображается как «НЗП на
branchname … «, но вы можете дать более информативное сообщение в командной строке при его создании.

Последний созданный вами тайник хранится в refs / stash; более старые тайники находятся в журнале ссылок этой ссылки и могут быть названы с использованием обычного синтаксиса журнала ссылок
(например, stash @ {0} — это последний созданный тайник, stash @ {1} — предыдущий, stash@{2.hours.ago} также возможен).

Опции

сохранить [—patch] [- [no-] keep-index] [-q | —quiet] [<сообщение>]

Сохраните локальные изменения в новом тайнике и запустите git reset —hard, чтобы отменить их.Часть не является обязательной и дает описание
вместе со спрятанным состоянием. Для быстрого создания снимка вы можете опустить и «save» и , но указание только не даст
запускайте это действие, чтобы подкоманда с ошибкой не создавала нежелательного хранилища.

Если используется опция —keep-index, все изменения, уже добавленные в индекс, остаются без изменений.

С помощью —patch вы можете в интерактивном режиме выбирать блоки в разнице между HEAD и рабочим деревом, которые нужно сохранить.Запись в тайник построена так, что
его состояние индекса совпадает с состоянием индекса вашего репозитория, а его рабочее дерево содержит только изменения, которые вы выбрали в интерактивном режиме. Выбранные изменения
затем откатываются от вашего рабочего дерева.

Параметр —patch подразумевает —keep-index. Вы можете использовать —no-keep-index, чтобы переопределить это.

список [<опции>]

Перечислите текущие тайники. Каждый тайник указан с его названием (например, тайник @ {0} — последний тайник, тайник @ {1} — предыдущий и т. Д.),
имя ветки, которая была текущей на момент создания тайника, и краткое описание фиксации, на которой был основан тайник.

 stash @ {0}: WIP при отправке: 6ebd0e2 ... Обновить документацию git-stash
stash @ {1}: На главном сервере: 9cc0589 ... Добавьте git-stash 

Команда принимает параметры, применимые к команде git log , чтобы контролировать, что и как показывать. См. git-log (1).

показать []

Показать изменения, записанные в тайнике, как разницу между сохраненным состоянием и его исходным родителем.Если не указан, отображается последний. От
по умолчанию команда показывает diffstat, но принимает любой формат, известный для git diff (например, git stash show -p stash @ {1} для просмотра второго по величине
недавний тайник в виде патча).

pop [—index] [-q | —quiet] []

Удалите одно сохраненное состояние из списка тайников и примените его поверх текущего рабочего состояния дерева, то есть выполните операцию, обратную git stash save.
Рабочий каталог должен соответствовать индексу.

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

Если используется опция —index, то пытается восстановить не только изменения рабочего дерева, но и изменения индекса. Однако это может потерпеть неудачу, если у вас есть
конфликты (которые хранятся в индексе, поэтому вы больше не можете применять изменения в том виде, в котором они были изначально).

Если не задан, предполагается, что stash @ {0}.

применить [—index] [-q | —quiet] []

Как pop, но не удаляет состояние из списка тайников.

филиал <название филиала> []

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

No related posts.