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

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

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

29 ответов


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

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

на 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>

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

хорошего рабочего процесса на managaging точек-использовать теги, чтобы чисто отметиться набранными очками в ваш график. Я не совсем понимаю ваше последнее предложение, но то, что вы можете захотеть, это отклонить ветку от предыдущей момент времени. Для этого воспользуйтесь удобной командой 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".

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

$ git revert $B

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


забавно, "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>

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

... проверьте ветку изменений, которые вы хотите применить к master филиала. The 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>

... выполните быстрое слияние, чтобы применить all <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 на указанный файл и
  • выбирает соответствующий идентификатор фиксации в истории файла и
  • выполняет 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

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

git reset HEAD YourFileName
git checkout YourFileName

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


git checkout ref / commitHash -- filePath

например

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

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

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

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

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

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>

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


очевидно, кто-то должен написать понятную книгу о 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. дерево с открытым исходным кодом, измените на этот commit

open source tree

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

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. мягкий сброс, который фиксирует-удаляет фиксацию и перемещает изменения в рабочую область
  3. выберите файлы для возврата и фиксации их
  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' (родитель)