Як я можу зберігати лише один із декількох змінених файлів у своїй гілці?

Відмова від відповідальності : наступна відповідь стосується git перед git 2.13. Для git 2.13 і більше, перегляньте ще одну відповідь далі .

Увага

Як зазначається в коментарях, це ставить усе в сховище, як поетапне, так і нестандартне. --Keep-індекс просто залишає індекс в спокої після того, як буде зроблено сховано. Це може спричинити конфлікти злиття, коли пізніше викинете скрипт.

Це приховає все, що ви раніше не додавали. Просто git addті речі, які ви хочете зберегти, потім запустіть їх.

git stash --keep-index

Наприклад, якщо ви хочете розділити стару комісію на декілька наборів змін, ви можете скористатися цією процедурою:

1. git rebase -i <last good commit>
2. Позначити деякі зміни як edit.
3. git reset HEAD^
4. git add <files you want to keep in this change>
5. git stash --keep-index
6. Виправте речі за потребою. Не забувайте про git addбудь-які зміни.
7. git commit
8. git stash pop
9. Повторіть, з №5, за необхідності.
10. git rebase --continue

Ви також можете використовувати git stash save -p "my commit message". Таким чином ви можете вибрати, які файли слід додати до сховища, також можна вибрати цілі файли.

Вам буде запропоновано виконати кілька дій для кожної частини:

   y - stash this hunk
   n - do not stash this hunk
   q - quit; do not stash this hunk or any of the remaining ones
   a - stash this hunk and all later hunks in the file
   d - do not stash this hunk or any of the later hunks in the file
   g - select a hunk to go to
   / - search for a hunk matching the given regex
   j - leave this hunk undecided, see next undecided hunk
   J - leave this hunk undecided, see next hunk
   k - leave this hunk undecided, see previous undecided hunk
   K - leave this hunk undecided, see previous hunk
   s - split the current hunk into smaller hunks
   e - manually edit the current hunk
   ? - print help

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

Насправді, оскільки Git 2.13 (Q2 2017), ви можете зберігати окремі файли, використовуючи git stash push:

git stash push [--] [<pathspec>...]

Коли pathspecзадано ' git stash push', новий сховище записує змінені стани лише для файлів, які відповідають шляху проспекту. Докладніше див. У статті " Сховання змін до конкретних файлів ".

Спрощений приклад:

 git stash push path/to/file

У тестовому випадку для цієї функції вимкнено ще кілька варіантів:

test_expect_success 'stash with multiple pathspec arguments' '
    >foo &&
    >bar &&
    >extra &&
    git add foo bar extra &&

    git stash push -- foo bar &&   

    test_path_is_missing bar &&
    test_path_is_missing foo &&
    test_path_is_file extra &&

    git stash pop &&
    test_path_is_file foo &&
    test_path_is_file bar &&
    test_path_is_file extra

Оригінальна відповідь (нижче, червень 2010 р.) Стосувалася вибору вручну того, що потрібно зберігати.

Коментарі Casebash :

Це ( stash --patchоригінальне рішення) приємно, але часто я змінював багато файлів, тому використання патча дратує

bukzor «s відповідь (upvoted, листопад 2011) пропонує більш практичне рішення, засноване на
git add+git stash --keep-index .
Іди подивись та підтверди його відповідь, яка повинна бути офіційною (замість моєї).

Щодо цього варіанту, chhh вказує альтернативний робочий процес у коментарях:

вам слід " git reset --soft" після такої скринінгу, щоб отримати чіткий показ сценарію:
Для того, щоб дійти до початкового стану - це чітка область постановки та лише з деякими вибраними нестадійними модифікаціями, можна м'яко скинути індекс, щоб отримати (без вчинив щось подібне до вас - букзор - зробив).

(Оригінальна відповідь червень 2010 року: приховування вручну)

Тим git stash save --patchне менш, може дозволити вам досягти часткового перегляду, який ви шукаєте:

За допомогою цього --patchви можете інтерактивно вибирати луки в різниці між ГОЛОВОЮ та робочим деревом, яке потрібно приховати.
Запис у сховищі побудований таким чином, що його стан індексу такий самий, як стан індексу вашого сховища, а його робоче дерево містить лише ті зміни, які ви вибрали інтерактивно. Вибрані зміни потім повертаються з робочого дерева.

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

git stash --patch --no-keep-index

може бути більш підходящим.

Якщо --patchне працює, ручний процес може:

Для одного або декількох файлів проміжним рішенням буде:

• скопіюйте їх поза Git repo
  (насправді, eleotlecram пропонує цікаву альтернативу )
• git stash
• скопіюйте їх назад
• git stash # цього часу зберігаються лише потрібні файли
• git stash pop stash@{1} # повторно застосувати всі свої модифікації файлів
• git checkout -- afile # скиньте файл до вмісту HEAD перед будь-якими локальними модифікаціями

В кінці цього досить громіздкого процесу у вас буде збережено лише один або кілька файлів.

Коли git stash -p(або git add -pз stash --keep-index) буде занадто громіздко, мені стало простіше у використанні diff, checkoutі apply:

Щоб "сховати" певний файл / dir:

git diff path/to/dir > stashed.diff
git checkout path/to/dir

Потім після цього

git apply stashed.diff

Використовуйте git stash pushтак:

git stash push [--] [<pathspec>...]

Наприклад:

git stash push -- my/file.sh

Це доступно з Git 2.13, випущеного навесні 2017 року.

Скажімо, у вас є 3 файли

a.rb
b.rb
c.rb

і ви хочете зберігати лише b.rb і c.rb, але не a.rb

ви можете зробити щось подібне

# commit the files temporarily you don't want to stash
git add a.rb
git commit -m "temp" 

# then stash the other files
git stash save "stash message"

# then undo the previous temp commit
git reset --soft HEAD^
git reset

І ви зробили! HTH.

Ще один спосіб зробити це:

# Save everything
git stash 

# Re-apply everything, but keep the stash
git stash apply

git checkout <"files you don't want in your stash">

# Save only the things you wanted saved
git stash

# Re-apply the original state and drop it from your stash
git stash apply stash@{1}
git stash drop stash@{1}

git checkout <"files you put in your stash">

Я придумав це після того, як я (ще раз) зайшов на цю сторінку і мені не сподобалися перші два відповіді (перша відповідь просто не відповідає на питання, і мені не дуже подобалось працювати з -pінтерактивним режимом).

Ідея така ж, як і @VonC запропонував використовувати файли поза сховищем, ви зберігаєте десь потрібні зміни, видаляєте зміни, які ви не хочете, у своєму сховищі, а потім повторно застосовуєте зміни, які ви перемістили з шляху. Однак я використав git stash як "десь" (і як результат, є ще один додатковий крок у кінці: вилучення cahnges, які ви помістили в копію, тому що ви також перемістили їх із шляху).

Оновлення (14.02.2015) - я трохи переписав сценарій, щоб краще впоратися із випадками конфліктів, які тепер мають бути подані як конфлікти, що не вмикаються, а не файли .rej.

Мені часто буває більш інтуїтивно зрозуміти зворотний підхід @ bukzor. Тобто провести деякі зміни, а потім сховати лише ті поетапні зміни.

На жаль, git не пропонує приховування git - тільки-індекс або подібне, тому я скопіював сценарій для цього.

#!/bin/sh

# first, go to the root of the git repo
cd `git rev-parse --show-toplevel`

# create a commit with only the stuff in staging
INDEXTREE=`git write-tree`
INDEXCOMMIT=`echo "" | git commit-tree $INDEXTREE -p HEAD`

# create a child commit with the changes in the working tree
git add -A
WORKINGTREE=`git write-tree`
WORKINGCOMMIT=`echo "" | git commit-tree $WORKINGTREE -p $INDEXCOMMIT`

# get back to a clean state with no changes, staged or otherwise
git reset -q --hard

# Cherry-pick the index changes back to the index, and stash.
# This cherry-pick is guaranteed to succeed
git cherry-pick -n $INDEXCOMMIT
git stash

# Now cherry-pick the working tree changes. This cherry-pick may fail
# due to conflicts
git cherry-pick -n $WORKINGCOMMIT

CONFLICTS=`git ls-files -u`
if test -z "$CONFLICTS"; then
    # If there are no conflicts, it's safe to reset, so that
    # any previously unstaged changes remain unstaged
    #
    # However, if there are conflicts, then we don't want to reset the files
    # and lose the merge/conflict info.
    git reset -q
fi

Ви можете зберегти вищезазначений скрипт як git-stash-indexдесь на своєму шляху, а потім можете викликати його як git stash-index

# <hack hack hack>
git add <files that you want to stash>
git stash-index

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

У деяких випадках зміни робочого дерева можуть залежати від змін індексу, тому коли ви зберігаєте зміни індексу, зміни робочого дерева мають конфлікт. У цьому випадку у вас вийдуть звичайні незмінені конфлікти, які ви можете вирішити за допомогою git merge / git mergetool / тощо.

Якщо ви не хочете вказувати повідомлення з прихованими змінами, передайте ім'я файлу після подвійного тире.

$ git stash -- filename.ext

Якщо це файл без відстеження / новий файл, вам доведеться спершу встановити його.

Цей метод працює у версіях git 2.13+

Оскільки створення гілок у Git тривіально, ви можете просто створити тимчасову гілку та перевірити в ній окремі файли.

Ви можете просто зробити це:

git stash push "filename"

або з додатковим повідомленням

git stash push -m "Some message" "filename"

Збережіть наступний код у файлі, наприклад, з ім'ям stash. Використання є stash <filename_regex>. Аргумент - регулярний вираз для повного шляху файлу. Наприклад, для зберігання a / b / c.txt stash a/b/c.txtабо stash .*/c.txtтощо

$ chmod +x stash
$ stash .*.xml
$ stash xyz.xml

Код для копіювання у файл:

#! /usr/bin/expect --
log_user 0
set filename_regexp [lindex $argv 0]

spawn git stash -p

for {} 1 {} {
  expect {
    -re "diff --git a/($filename_regexp) " {
      set filename $expect_out(1,string)
    }
    "diff --git a/" {
      set filename ""
    }
    "Stash this hunk " {
      if {$filename == ""} {
        send "n\n"
      } else {
        send "a\n"
        send_user "$filename\n"
      }
    }
    "Stash deletion " {
      send "n\n"
    }
    eof {
      exit
    }
  }
}

На всякий випадок, якщо ви дійсно маєте на увазі відмінити зміни кожного разу, коли ви користуєтесь git stash(і не використовуйте Git Stash, щоб тимчасово їх зберігати ), у такому випадку ви можете використовувати

git checkout -- <file>

[ ПРИМІТКА ]

Це git stashпросто швидша та проста альтернатива розгалуженню та роботі.

Проблема з «проміжним» рішенням VonC щодо копіювання файлів за межами Git repo полягає в тому, що ви втрачаєте інформацію про шлях, через що пізніше копіювати купу файлів можна дещо без проблем.

Знайдіть простіше використовувати tar (замість копії, можливо, подібні інструменти) замість копії:

• tar cvf /tmp/stash.tar шлях / до / деякий / шлях до файлу / до / деякий / інший / файл (... тощо)
• git checkout path / до / деякого / шляху до файлу / до / деякого / іншого / файлу
• git stash
• tar xvf /tmp/stash.tar
• тощо (див. "проміжну пропозицію" VonC)

Іноді я вносив незв'язані зміни до своєї гілки, перш ніж це здійснив, і хочу перенести її в іншу гілку і зробити її окремо (наприклад, головним). Я роблю це:

git stash
git checkout master
git stash pop
git add <files that you want to commit>
git commit -m 'Minor feature'
git stash
git checkout topic1
git stash pop
...<resume work>...

Зверніть увагу, що перші stashта stash popможуть бути усунені, ви можете перенести всі свої зміни у masterвідділення під час оформлення замовлення, але тільки якщо немає конфліктів. Крім того, якщо ви створюєте нову гілку для часткових змін, вам знадобиться скрипка.

Ви можете спростити його, якщо немає конфліктів та немає нової гілки:

git checkout master
git add <files that you want to commit>
git commit -m 'Minor feature'
git checkout topic1
...<resume work>...

Стек навіть не потрібен ...

Це легко зробити в 3 етапи за допомогою SourceTree.

1. Тимчасово виконайте все, що ви не хочете сховати
2. Git додайте все інше, а потім приберіть їх.
3. Розмістіть тимчасову фіксацію, виконавши скидання git, націлюючи її на тимчасовий.

Це все можна зробити за лічені секунди в SourceTree, де ви можете просто натиснути на файли (або навіть окремі рядки), які ви хочете додати. Після додавання просто докладіть їх до тимчасового. Далі встановіть прапорець, щоб додати всі зміни, а потім натисніть приховати, щоб усе приховати. Коли приховані зміни перешкоджають перегляду, перегляньте свій список фіксування та відзначте хеш для фіксації перед тимчасовою фіксацією, а потім запустіть "git reset hash_b4_temp_commit", що в основному нагадує "вискакування" комісії шляхом перезавантаження вашої гілки на вчинити прямо перед цим. Тепер вам залишаються лише речі, які ви не хотіли приховувати.

Я б користувався git stash save --patch. Я не вважаю інтерактивність прикрою, оскільки під час неї є варіанти застосувати потрібну операцію до всіх файлів.

Кожна відповідь тут така складна ...

Що з цього приводу "приховувати":

git diff /dir/to/file/file_to_stash > /tmp/stash.patch
git checkout -- /dir/to/file/file_to_stash

Це, щоб відкрити зміну файлу назад:

git apply /tmp/stash.patch

Точна поведінка, як зберігання одного файлу та вивільнення його назад.

Я переглянув відповіді та коментарі до цього та низку подібних тем. Майте на увазі, що жодна з наведених нижче команд не є правильною для того, щоб мати змогу зберігати будь-які конкретні відслідковувані / відслідковувані файли :

• git stash -p (--patch): вибирайте перемикання вручну, виключаючи незатребувані файли
• git stash -k (--keep-index): зберігайте всі відслідковані / відслідковувані файли та зберігайте їх у робочому каталозі
• git stash -u (--include-untracked): зберігає всі відстежені / відслідковувані файли
• git stash -p (--patch) -u (--include-untracked): недійсна команда

В даний час найбільш розумним методом, щоб можна було зберігати будь-які конкретні відслідковувані / відслідковувані файли, є:

• Тимчасово закріпіть файли, які ви не хочете зберігати
• Додайте та зберігайте
• Виконайте тимчасову комісію

Я написав простий скрипт для цієї процедури у відповідь на інше питання , і тут є кроки для виконання процедури в SourceTree .

Рішення

Місцеві зміни:

• file_A (модифікований) не інсценовано
• file_B (модифікований) не інсценовано
• file_C (модифікований) не інсценовано

Щоб створити скриньку "my_stash" лише із змінами у file_C :

1. git add file_C
2. git stash save --keep-index temp_stash
3. git stash save my_stash
4. git stash pop stash@#{1}

Зроблено.

Пояснення

1. додайте файл_C до області постановки
2. створити тимчасовий сховище з назвою "temp_stash" та зберегти зміни у file_C
3. створіть потрібний скрипт ("my_stash") лише із змінами у file_C
4. застосуйте зміни до "temp_stash" (file_A та file_B) у вашому локальному коді та видаліть скриньку

Ви можете використовувати статус git між кроками, щоб побачити, що відбувається.

Коли ви намагаєтесь перемикатися між двома гілками, така ситуація виникає.

Спробуйте додати файли за допомогою " git add filepath".

Пізніше виконати цей рядок

git stash --keep-index

Для зберігання одного файлу використовуйте git stash --patch [file].

Це буде карта: Stash this hunk [y,n,q,a,d,j,J,g,/,e,?]? ?. Просто введіть a(збережіть цю частину та всі пізніші записки у файлі), і ви все добре.

Схожа ситуація. Зробив і зрозумів, що це не нормально.

git commit -a -m "message"
git log -p

На основі відповідей це мені допомогло.

# revert to previous state, keeping the files changed
git reset HEAD~
#make sure it's ok
git diff
git status
#revert the file we don't want to be within the commit
git checkout specs/nagios/nagios.spec
#make sure it's ok
git status
git diff
#now go ahead with commit
git commit -a -m "same|new message"
#eventually push tu remote
git push

У цій ситуації я git add -p(інтерактивна), git commit -m blahа потім приховую те, що залишилося, якщо потрібно.

Я не знаю, як це зробити в командному рядку, лише використовуючи SourceTree. Скажімо, ви змінили файл A та маєте два файли змін у файлі B. Якщо ви хочете зберегти лише другу частину у файлі B, а все інше залишити недоторканим, зробіть це:

1. Поставити все
2. Виконайте зміни у своїй робочій копії, які скасують усі зміни у файлі А. (наприклад, запустіть зовнішній інструмент різниці та зрівняйте файли.)
3. Зробіть так, щоб файл B виглядав так, ніби до нього застосована лише друга зміна. (наприклад, запустіть зовнішній інструмент різниці та скасуйте першу зміну.)
4. Створіть скриньку, використовуючи "Зберігати поетапні зміни".
5. Нестабільне все
6. Готово!

git add .                           //stage all the files
git reset <pathToFileWillBeStashed> //unstage file which will be stashed
git stash                           //stash the file(s)
git reset .                         // unstage all staged files
git stash pop                       // unstash file(s)

Одним із складних способів було б спочатку зробити все:

git add -u
git commit // creates commit with sha-1 A

Скиньте назад до початкового комітету, але перевірте the_one_file з нового комітету:

git reset --hard HEAD^
git checkout A path/to/the_one_file

Тепер ви можете зберігати the_one_file:

git stash

Очищення, зберігаючи закріплений вміст у вашій файловій системі, скидаючи назад до початкового файлу:

git reset --hard A
git reset --soft HEAD^

Так, трохи незручно ...

Я не знайшов відповіді як те, що мені потрібно, і це так просто, як:

git add -A
git reset HEAD fileThatYouWantToStash
git commit -m "committing all but one file"
git stash

Це зберігає рівно один файл.

Швидкий відповідь

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

git checkout <branch-name> -- <file-path>

Ось фактичний приклад:

git checkout master -- battery_monitoring/msg_passing.py

Якщо ви хочете сховати деякі змінені файли, просто просто

Додайте файли, які не хочете зберігати, у " Етап" , а потім виконайтеgit stash save --keep-index

Він зберігає всі нестандартні змінені файли