Сброс или возврат определенного файла к определенной ревизии с помощью Git?


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

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

29   3591   2008-10-19 03:34:02

29 ответов:

предполагая, что хэш фиксации вы хотите c5f567:

git checkout c5f567 -- file1/to/restore file2/to/restore

The git checkout man страница дает дополнительную информацию.

если вы хотите вернуться к фиксации перед c5f567 добавить ~1 (работает с любого номера):

git checkout c5f567~1 -- file1/to/restore file2/to/restore

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

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

git diff <commit hash> <filename>

затем, чтобы вернуть определенный файл к этой фиксации, используйте команду reset:

git reset <commit hash> <filename>

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

хорошим рабочим процессом для управления путевыми точками является использование тегов для четкого обозначения точек на временной шкале. Я не совсем понимаю ваше последнее предложение, но то, что вы можете захотеть, это отклонить ветку от предыдущей момент времени. Для этого воспользуйтесь удобной командой checkout:

git checkout <commit hash>
git checkout -b <new branch name>

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

git checkout <my branch>
git rebase master
git checkout master
git merge <my branch>

вы можете использовать любую ссылку на фиксацию git, включая SHA-1, если это наиболее удобно. Дело в том, что команда выглядит так:

git checkout [commit-ref] -- [filename]

git checkout -- foo

это сбросит foo головы. Вы также можете:

git checkout HEAD^ foo

для одного пересмотра назад и т. д.

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

git checkout HEAD file/to/restore

у меня была такая же проблема только сейчас, и я нашел ответ проще всего понять (commit-ref - это значение SHA изменения в журнале, к которому вы хотите вернуться):

git checkout [commit-ref] [filename]

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

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

git checkout master~5 image.png

это предполагает, что вы на master ветвь, и версия, которую вы хотите, - это 5 коммитов назад.

Я думаю, что нашел его....от http://www-cs-students.stanford.edu / ~blynn/gitmagic/ch02.html

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

начать с:

$ git log

который показывает вам список последних коммитов и их хэши SHA1.

далее, типа:

$ git reset --hard SHA1_HASH

для восстановления состояния до заданной фиксации и стереть все новые коммиты из записи навсегда.

это сработало для меня:

git checkout <commit hash> file

зафиксировать изменения:

git commit -a

вы должны быть осторожны, когда вы говорите "откат". Если раньше у вас была одна версия файла в commit $A, а затем вы сделали два изменения в двух отдельных коммитах $B и $C (так что вы видите третью итерацию файла), и если вы говорите "Я хочу вернуться к первому", вы действительно это имеете в виду?

Если вы хотите избавиться от изменений как второй, так и третьей итерации, это очень просто:

$ git checkout $A file

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

С другой стороны, вы имели в виду, чтобы избавиться от изменения, внесенного второй итерацией (т. е. commit $B), сохраняя при этом то, что commit $C сделал с файлом, вы хотели бы вернуть $B

$ git revert $B

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

забавно, 'git checkout foo 'не будет работать, если рабочая копия находится в каталоге с именем foo; однако, как' git checkout HEAD foo', так и ' git checkout ./foo ' will:

$ pwd
/Users/aaron/Documents/work/foo
$ git checkout foo
D   foo
Already on "foo"
$ git checkout ./foo
$ git checkout HEAD foo

вот как rebase работает:

git checkout <my branch>
git rebase master
git checkout master
git merge <my branch>

предположим, что у вас есть

---o----o----o----o  master
    \---A----B       <my branch>

первые две команды ... совершать git checkout ГИТ перебазирования мастер

... проверьте ветку изменений, которые вы хотите применить к master филиала. Элемент rebase команда принимает коммиты от <my branch> (которые не нашли в master) и вновь прикладывает их к голове master. Другими словами, родитель первый коммит в <my branch> больше не является предыдущим коммитом в master история, но нынешний глава master. Две команды такие же, как и:

git rebase master <my branch>

было бы проще запомнить эту команду, поскольку ветви "base" и "modify" являются явными.

. Окончательный результат истории:

---o----o----o----o   master
                   \----A'----B'  <my branch>

последние две команды ...

git checkout master
git merge <my branch>

... выполните быстрое слияние, чтобы применить все <my branch> изменения на master. Без этого шага фиксация rebase не добавляется в master. Конечный результат:

---o----o----o----o----A'----B'  master, <my branch>

master и <my branch> и B'. Кроме того, с этого момента можно безопасно удалить <my branch> ссылка.

git branch -d <my branch>

git-псевдонимы, awk и shell-функции на помощь!

git prevision <N> <filename>

здесь <N> - это количество ревизий файла для отката для файла <filename>.
Например, чтобы проверить непосредственную предыдущую ревизию одного файла x/y/z.c, используя

git prevision -1 x/y/z.c

как работает Git prevision?

добавить следующий код gitconfig

[alias]
        prevision = "!f() { git checkout `git log --oneline  |  awk -v commit="" 'FNR == -commit+1 {print }'` ;} ;f"

команда в основном

  • выполняет git log на указанный файл и
  • выбирает соответствующий commit-id в истории файла и
  • выполняет a git checkout к commit-id для указанного файла.

по сути, все, что можно было бы сделать вручную в этой ситуации,
завернутый в один красивый, эффективный git-псевдоним - git-prevision

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

eg revert foo/bar foo/baz

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

git checkout HEAD^1 path/to/file

или

git checkout HEAD~1 path/to/file

затем просто этап и зафиксировать "новую" версию.

вооружившись знанием, что фиксация может иметь два родителя в случае слияния, вы должны знать, что HEAD^1 является первым родителем, а HEAD~1-вторым родителем.

либо будет работать, если есть только один родитель в дерево.

обратите внимание, однако, что git checkout ./foo и git checkout HEAD ./foo это не ровно то же самое; пример:

$ echo A > foo
$ git add foo
$ git commit -m 'A' foo
Created commit a1f085f: A
1 files changed, 1 insertions(+), 0 deletions(-)
create mode 100644 foo
$ echo B >> foo
$ git add foo
$ echo C >> foo
$ cat foo
A
B
C
$ git checkout ./foo
$ cat foo
A
B
$ git checkout HEAD ./foo
$ cat foo
A

(вторая add помещает файл в индекс, но он делает не вам привержен.)

Git checkout ./foo значит, восстановить путь ./foo С индекс; добавление HEAD поручает Git вернуть этот путь в индексе к своему HEAD пересмотр перед этим.

Первый Сброс Головки Для Целевого Файла

git reset HEAD path_to_file

Вторая Проверка Этого Файла

git checkout -- path_to_file

многие предложения здесь, большинство по линии git checkout $revision -- $file. Несколько неясных альтернатив:

git show $revision:$file > $file

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

git show $revision:$file

или

git show $revision:$file | vim -R -

(OBS:$file должен иметь префикс ./ если это относительный путь для git show $revision:$file для работы)

и еще более странно:

git archive $revision $file | tar -x0 > $file

чтобы перейти к предыдущей версии фиксации файла, получите номер фиксации, скажем eb917a1 тогда

git checkout eb917a1 YourFileName

Если вам просто нужно вернуться к последней совершенной версии

git reset HEAD YourFileName
git checkout YourFileName

Это просто приведет вас к последнему зафиксированному состоянию файла

git checkout ref / commitHash -- filePath

например

git checkout HEAD~5 -- foo.bar
or 
git checkout 048ee28 -- foo.bar

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

у меня есть совершения abc1 и после этого я сделал несколько (или одну модификацию) в файл file.txt.

теперь скажите, что я что-то перепутал в файле file.txt и я хочу вернуться к предыдущей фиксации abc1.

1.git checkout file.txt : это позволит удалить локальные изменения, если вам не нужно их

2.git checkout abc1 file.txt: это приведет ваш файл к вашему хотел версия

3.git commit -m "Restored file.txt to version abc1" : это совершит ваш возврат.

  1. git push : это будет толкать все на удаленный репозиторий

между шагом 2 и 3 Конечно, вы можете сделать git status чтобы понять, что происходит. Обычно вы должны увидеть file.txt уже добавлено и именно поэтому нет необходимости в git add.

использовать git log чтобы получить хэш-ключ для конкретной версии, а затем использовать git checkout <hashkey>

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

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

cd <working copy>
git revert master

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

Иэн

многие ответы здесь утверждают, что используют git reset ... <file> или git checkout ... <file> но при этом вы потеряете все модификации <file> committed после фиксации вы хотите вернуться.

если вы хотите отменить изменения из одной фиксации только в одном файле, так же, как git revert будет делать, но только для одного файла (или сказать подмножество файлов фиксации), я предлагаю использовать оба git diff и git apply<sha> = хэш коммита, который вы хотите восстановить) :

git diff <sha>^ <sha> path/to/file.ext | git apply -R

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

конечно, он не будет работать, если возвращенные строки были изменены любой фиксацией между <sha1> и HEAD (конфликта).

git revert <hash>

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

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

Если вы зафиксировали неправильный файл в вашем последнем коммите следуйте инструкциям:

  1. дерево с открытым исходным кодом, перейдите к этой фиксации

open source tree

  1. измените строки и найдите фиксацию, что неправильный файл отправлен как commit

enter image description here

  1. вы можете увидеть список ваших изменений в этой фиксации list of files in the source tree
  2. выберите и нажмите на. .. кнопки справа ... нажмите кнопку реверс файлом
  3. затем вы можете увидеть его на вкладке состояния файла в нижней левой части нажмите кнопку Отменить добавление:

file status tab

  1. откройте код visual studio и вернитесь назад, зафиксировав удаленные файлы
  2. после них все, вы можете увидеть результаты в вашей последней фиксации в исходном дереве

enter image description here

вы можете сделать это в 4 шага:

  1. верните всю фиксацию с файлом, который вы хотите конкретно вернуть - он создаст новую фиксацию в вашей ветке
  2. soft reset that commit-удаляет фиксацию и перемещает изменения в рабочую область
  3. handpick файлы, чтобы вернуться и зафиксировать их
  4. отбросьте все остальные файлы в рабочей области

что вам нужно ввести в свой терминал:

  1. git revert <commit_hash>
  2. git reset HEAD~1
  3. git add <file_i_want_to_revert> &&git commit -m 'reverting file'
  4. git checkout .

удачи

вот мой путь.

a) в Android Studio откройте файл.

b) git -> показать историю, найти предыдущую фиксацию, к которой я хочу вернуться. Получите commit_id (т. е. хэш фиксации).

c)git checkout commit_id file_path

Если вы используете расширения Git и хотите вернуться только к родительской фиксации для файла, вы можете выбрать фиксацию, содержащую изменения, которые вы хотите вернуть, затем выберите вкладку "Diff" в области сведений, щелкните правой кнопкой мыши файл, который вы хотите вернуть, а затем "сбросить файлы"...., то 'A '(родитель)