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

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

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

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

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

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

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

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

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

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

git diff <commit hash> <filename>

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

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>

Вы можете использовать любую ссылку на коммит 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

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

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

$ git checkout $A file

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

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

$ git revert $B

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

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

Вот как это 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 git rebase master

... проверить ветку изменений, которые вы хотите применить к 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. Без этого шага коммит ребаз не будет добавлен в master. Окончательный результат:

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

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

git branch -d <my branch>

Начиная с git v2.23.0, существует новый метод восстановления git, который должен принимать на себя часть 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

Первая головка сброса для целевого файла

git reset HEAD path_to_file

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

git checkout -- path_to_file

git-aliases, 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 $2 |  awk -v commit="$1" 'FNR == -commit+1 {print $1}'` $2;} ;f"

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

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

По сути, все, что можно было бы сделать вручную в этой ситуации,
заключить в один красивый, эффективный псевдоним - 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 $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

Обратите внимание, однако, что 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ревизии, прежде чем сделать это.

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

У меня есть коммит 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".: это совершит ваше возвращение.

4. git push : это будет толкать все в удаленном хранилище

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

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

git checkout Last_Stable_commit_Number -- fileName

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

git checkout branchName_Which_Has_stable_Commit fileName

Чтобы перейти к предыдущей версии коммита, получите номер коммита, скажем 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

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

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

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

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

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

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

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

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

cd <working copy>
git revert master

отменяет последний коммит, который, кажется, делает.

Ян

Вы можете сделать это в 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 .

удачи

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

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

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

git revert <hash>

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

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

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

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

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

3. вы можете увидеть список ваших изменений в этом коммите
4. выберите его, а затем нажмите на ... кнопки справа ... щелкните обратный файл
5. затем вы можете увидеть его на вкладке статуса файла внизу слева и нажать кнопку «untage»:

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