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

StackOverflow https://stackoverflow.com/questions/215718

Вопрос

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

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

Это было полезно?

Решение

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

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

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

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

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

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

Другие советы

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

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 (так что вы видите третью итерацию файла), и если вы скажете < !> quot; я хочу вернуться к первому ", вы действительно это имеете в виду?

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

$ git checkout $A file

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

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

$ git revert $B

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

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

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

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

git branch -d <my branch>

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

git reset HEAD path_to_file

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

git checkout -- path_to_file

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

git prevision <N> <filename>

где <N> это количество ревизий файла для отката для file <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-предвидение

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

например, вернуться foo/бар foo/база

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

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 вернуть этот путь в индексе к его <=> доработка перед этим.

Здесь много предложений, большинство из которых касаются 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

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

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

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

1. git commit -m "Restored file.txt to version abc1": это удалит локальные изменения, если они вам не нужны

2. git push: это приведет ваш файл к вашей требуемой версии

3. git status: это совершит ваш возврат.

  1. git add: это подтолкнет все в удаленном хранилище

    2. Между шагами 2 и 3, конечно, вы можете сделать <=>, чтобы понять, что происходит. Обычно вы должны видеть <=> уже добавленный, и поэтому нет необходимости в <=>.

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

git checkout eb917a1 YourFileName

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

git reset HEAD YourFileName
git checkout YourFileName

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

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

например , 

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

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

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

Многие ответы здесь утверждают, что используют 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 (конфликт).

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

cd <working copy>
git revert master

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

Йен

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

<Ол>
  • дерево с открытым исходным кодом, измените этот коммит

    • дерево с открытым исходным кодом

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

      2. введите описание изображения здесь

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

        4. вкладка статуса файла

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

          3. введите описание изображения здесь

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

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

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

    <Ол>
  • Git возвращает файл к определенному коммиту
    •   

    git checkout Last_Stable_commit_Number - fileName

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

    git checkout branchName_Which_Has_stable_Commit fileName

    git revert <hash>

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

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

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

    <Ол>
  • отменить весь коммит с помощью файла, который вы хотите специально отменить - он создаст новый коммит в вашей ветви
  • программный сброс, который фиксирует - удаляет фиксацию и перемещает изменения в рабочую область
  • вручную выберите файлы, чтобы восстановить и зафиксировать их
  • удалите все остальные файлы в вашей рабочей области

    • Что нужно набрать в своем терминале :

    <Ол> <Литий> git revert <commit_hash> <Литий> git reset HEAD~1
  • git add <file_i_want_to_revert> & amp; & amp; git commit -m 'reverting file'
    • <Литий> git checkout .

    удачи

    Вот мой путь.

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

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

    c) git checkout commit_id file_path

    Лицензировано под: CC-BY-SA с атрибуция
    Не связан с StackOverflow
    scroll top