"3.95.131.208 - 3.95.131.208"

Как я могу сбросить или вернуть файл к определенной ревизии?

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

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

+4165
источник поделиться
32 ответа
  • 1
  • 2

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

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

Страница руководства git checkout дает больше информации.

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

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

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

+5653
источник

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

git diff <commit hash> <filename>

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

git reset <commit hash> <filename>

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

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

Связанные вопросы


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

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

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

+346
источник
git checkout -- foo

Это будет reset foo для HEAD. Вы также можете:

git checkout HEAD^ foo

для одной ревизии и т.д.

+268
источник

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

git checkout HEAD file/to/restore
+120
источник

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

git checkout [commit-ref] [filename]

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

+103
источник

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

git checkout master~5 image.png

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

+89
источник

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

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

Начните с:

$ git log

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

Затем введите:

$ git reset --hard SHA1_HASH

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

+80
источник

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

git checkout <commit hash> file

Затем зафиксируйте изменение:

git commit -a
+61
источник

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

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

$ git checkout $A file

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

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

$ git revert $B

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

+54
источник

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

$ pwd
/Users/aaron/Documents/work/foo
$ git checkout foo
D   foo
Already on "foo"
$ git checkout ./foo
$ git checkout HEAD foo
+36
источник

Здесь 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 выписка   git мастер переустановки

... проверьте ветвь изменений, которые вы хотите применить к ветки 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>
+32
источник

Первая Reset Голова для целевого файла

git reset HEAD path_to_file

Вторая проверка этого файла

git checkout -- path_to_file
+23
источник

git -алиасы, awk и функции оболочки для спасения!

git prevision <N> <filename>

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

git prevision -1 x/y/z.c

Как работает git предикция?

Добавьте в свой gitconfig

следующее:
[alias]
        prevision = "!f() { git checkout `git log --oneline $2 |  awk -v commit="$1" 'FNR == -commit+1 {print $1}'` $2;} ;f"

Команда в основном

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

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

+21
источник

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

eg revert foo/bar foo/baz

+20
источник

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

git checkout HEAD^1 path/to/file

или

git checkout HEAD~1 path/to/file

Затем просто выполните этап и зафиксируйте "новую" версию.

Вооружившись знаниями о том, что в случае слияния commit может иметь двух родителей, вы должны знать, что HEAD ^ 1 является первым родителем, а HEAD ~ 1 является вторым родителем.

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

+20
источник

Обратите внимание, что 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 до этого.

+18
источник

Здесь много предложений, большинство из них в духе 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 to work)

И тем более странно

git archive $revision $file | tar -x0 > $file
+17
источник

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

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

Теперь скажите, что я что-то испортил в файле file.txt, и я хочу вернуться к предыдущему commit 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.

+14
источник

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

git checkout eb917a1 YourFileName

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

git reset HEAD YourFileName
git checkout YourFileName

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

+11
источник

git checkout ref | commitHash - filePath

например.

git checkout HEAD~5 -- foo.bar
or 
git checkout 048ee28 -- foo.bar
+10
источник

Многие ответы здесь требуют использовать git reset ... <file> или git checkout ... <file>, но при этом вы потеряете все изменения в <file>, совершенные после коммита, который вы хотите вернуть.

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

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

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

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

+9
источник
  1. Git вернуть файл к определенной фиксации

git checkout Last_Stable_commit_Number - fileName

2.Git вернуть файл в определенную ветку

git checkout branchName_Which_Has_stable_Commit fileName
+9
источник

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

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

+8
источник

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

cd <working copy>
git revert master

отменяет последнее совершение, которое, как представляется, делает.

Ян

+7
источник

Вы можете сделать это в 4 этапа:

  1. отменить весь коммит с файлом, который вы хотите специально отменить - это создаст новый коммит в вашей ветке
  2. soft reset that commit - удаляет коммит и перемещает изменения в рабочую область
  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.

удачи

+6
источник

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

  1. дерево с открытым исходным кодом, измените этот коммит

open source tree

  1. измените строки и найдите ваш коммит, который неверный файл отправил как коммит

enter image description here

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

file status tab

  1. откройте код Visual Studio и вернитесь обратно, зафиксировав удаленные файлы
  2. после всех них вы можете увидеть результаты вашего последнего коммита в исходном дереве

enter image description here

+5
источник

Это очень простой шаг. Извлеките файл с идентификатором фиксации, который мы хотим, здесь один идентификатор фиксации ранее, а затем просто выполните команду git commitmend, и все готово.

# git checkout <previous commit_id> <file_name>
# git commit --amend

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

+5
источник
git revert <hash>

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

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

+4
источник

Начиная с git v2.23.0 появился новый метод git restore, который должен предполагать, что часть того, за что был ответственен git checkout (даже в принятом ответе упоминается, что git checkout довольно запутанно). Просмотрите основные изменения в блоге github.

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

Таким образом, основываясь на ответе Грега Хьюгилла (при условии, что хеш коммита равен c5f567), команда будет выглядеть следующим образом:

git restore --source=c5f567 file1/to/restore file2/to/restore

Или, если вы хотите восстановить содержимое одного коммита до c5f567:

git restore --source=c5f567~1 file1/to/restore file2/to/restore
+2
источник
  • 1
  • 2

Посмотрите другие вопросы по меткам или Задайте вопрос