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

Предполагая, что хеш фиксации, который вы хотите, равен 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

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

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

ЭТА КОМАНДА ЯВЛЯЕТСЯ ЭКСПЕРИМЕНТАЛЬНОЙ. ПОВЕДЕНИЕ МОЖЕТ ИЗМЕНИТЬСЯ.

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

git diff <commit hash> <filename>

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

git reset <commit hash> <filename>

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

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

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 в HEAD. Вы также можете:

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

Начиная с 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

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

Первые две команды ... commit 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>

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

git checkout Last_Stable_commit_Number -- fileName

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

git checkout branchName_Which_Has_stable_Commit fileName

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

git reset HEAD path_to_file

Вторая выписка из этого файла

git checkout -- path_to_file

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

git checkout HEAD^1 path/to/file

or

git checkout HEAD~1 path/to/file

Затем просто подготовьте и зафиксируйте «новую» версию.

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

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

На помощь приходят 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-псевдоним - git-prevision

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

git show $revision:$file > $file

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

git show $revision:$file

or

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

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

И что еще более странно:

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

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

eg revert foo/bar foo/baz

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

Во многих ответах здесь говорится об использовании 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 (конфликт).

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

git checkout eb917a1 YourFileName

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

git reset HEAD YourFileName
git checkout YourFileName

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

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

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

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

git checkout ref | commitHash - путь к файлу

e.g.

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

Используйте 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 revert <hash>

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

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

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

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

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

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

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

Вот мой путь.

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

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

c) git checkout commit_id file_path

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

• Выполните следующую команду, которая выполняет мягкий сброс, и изменения поступают на ваш локальный компьютер.

git reset --soft HEAD^1

• Просматривайте статус ранее зафиксированных файлов, который поступает на ваш локальный компьютер, а затем вносите изменения.

 git status

• Зафиксируйте и отправьте файл после внесения изменений.

• Предыдущая история фиксации неверно зафиксированных файлов не будет отображаться