Redefinir ou retornar um arquivo específico para uma revisão específica usando o Git?

Fiz algumas alterações no arquivo que foi transferido várias vezes como parte de um grupo de arquivos, mas agora quero redefinir / retornar as alterações para ele na versão anterior.

Fiz o git log juntamente com o git diff para encontrar a opção que precisava, mas não sei como recuperar o arquivo no passado.

3786
19 окт. conjunto Hates_ 19 de outubro . 2008-10-19 02:34 '08 at 2:34 am 2008-10-19 02:34
ответ 31 respostas
  • 1
  • 2

Assumindo que o hash de commit que você quer é c5f567 :

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

A página de manual do git checkout fornece mais informações.

Se você quiser retornar para commit para c5f567 , adicione ~1 (funciona com qualquer número):

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

Como nota, sempre me senti desconfortável com esse comando, porque ele era usado tanto para coisas comuns (alternando entre ramificações) quanto para coisas incomuns e destrutivas (excluindo as alterações no diretório de trabalho).

5117
19 окт. Resposta dada por Greg Hewgill 19 de outubro 2008-10-19 02:39 '08 às 2:39 2008-10-19 02:39

Você pode rever rapidamente as alterações feitas em um arquivo usando o comando diff:

 git diff <commit hash> <filename> 

Então, para retornar um arquivo específico para este fixador, use o comando reset:

 git reset <commit hash> <filename> 

Você pode ter que usar a opção --hard se tiver modificações locais.

border=0

Um bom fluxo de documentos para gerenciar seus waypoints é usar tags para manter os pontos em sua linha do tempo limpos. Não consigo entender sua última sentença, mas o que você pode precisar é da divergência do ramo em relação ao ponto anterior no tempo. Para fazer isso, use o comando de checkout conveniente:

 git checkout <commit hash> git checkout -b <new branch name> 

Em seguida, você pode reinstalá-lo em sua linha principal quando estiver pronto para mesclar essas alterações:

 git checkout <my branch> git rebase master git checkout master git merge <my branch> 
541
17 дек. Resposta dada por Chris Lloyd em 17 de dezembro 2008-12-17 09:59 '08 at 9:59 2008-12-17 09:59

Você pode usar qualquer link para git commit, incluindo SHA-1, se for mais conveniente. O fato é que a equipe se parece com isso:

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

319
08 апр. a resposta é dada foxxtrot 08 abr. 2009-04-08 00:48 '09 às 0:48 2009-04-08 00:48
 git checkout -- foo 

Este será um reset foo para HEAD. Você também pode:

 git checkout HEAD^ foo 

para uma revisão, etc.

256
29 авг. Resposta dada por Greg Hewgill em 29 ago 2008-08-29 23:56 '08 em 11:56 pm 2008-08-29 23:56

E para voltar à última versão completa, que é mais necessária, você pode usar esse comando mais simples.

 git checkout HEAD file/to/restore 
114
14 янв. a resposta é dada CDR 14 jan. 2012-01-14 09:15 '12 às 9:15 2012-01-14 09:15

Eu tive o mesmo problema agora, e achei essa resposta a mais fácil de entender ( commit-ref é o valor da mudança SHA no log que você deseja enviar de volta):

 git checkout [commit-ref] [filename] 

Isso coloca esta versão antiga em seu diretório de trabalho, e a partir daí você pode consertá-la se quiser.

102
27 мая '09 в 20:52 2009-05-27 20:52 a resposta é dada pelo bbrown em 27 de maio de 2009 às 20:52 2009-05-27 20:52

Se você sabe quantos commits você precisa devolver, você pode usar:

 git checkout master~5 image.png 

Supõe-se que você esteja no ramo master e a versão desejada seja 5.

88
07 апр. A resposta é dada por Ron DeVera 07 de abril 2009-04-07 17:03 '09 às 17:03 2009-04-07 17:03

Acho que encontrei ... de http://www-cs-students.stanford.edu/~blynn/gitmagic/ch02.html

Às vezes você só quer voltar e esquecer todas as mudanças por um certo ponto, porque elas estão todas erradas.

Comece com:

$ git log

que mostra uma lista de commits recentes e seu hash SHA1.

Em seguida, digite:

$ git reset --hard SHA1_HASH

para restaurar o estado de um determinado commit e apagar todas as novas entradas do registro para sempre.

78
17 дек. a resposta é dada jdee 17 dez. 2008-12-17 09:53 '08 at 9:53 2008-12-17 09:53

Funcionou para mim:

 git checkout <commit hash> file 

Em seguida, confirme a alteração:

 git commit -a 
61
26 авг. a resposta é dada v2k 26 ago. 2011-08-26 01:12 '11 às 1:12 2011-08-26 01:12

Você tem que ter cuidado quando você diz "reversão". Se você usou uma versão do arquivo em commit $ A, então fez duas alterações em duas commits separadas $ B e $ C (assim você vê, esta é a terceira iteração do arquivo), e se você disser "Eu quero voltar para a primeira", realmente quer dizer isso?

Se você quiser se livrar das mudanças nas segunda e terceira iterações, é muito simples:

 $ git checkout $A file 

e então você conserta o resultado. O comando pergunta "Quero verificar o arquivo do estado escrito pela confirmação $ A".

Por outro lado, o que você tinha em mente é livrar-se da segunda mudança de iteração (ou seja, fazer $ B), mantendo que você corrigiu o arquivo $ C no arquivo, você gostaria de retornar $ B

 $ git revert $B 

Nota: quem cometer $ B pode não ter sido muito disciplinado e pode fazer alterações completamente não relacionadas ao mesmo commit, e este retorno pode dizer respeito a arquivos diferentes do arquivo que você vê, mudanças ofensivas, então você pode verificar o resultado com cuidado depois disso.

54
11 янв. a resposta é dada por gitster 11 jan. 2009-01-11 11:13 '09 às 11:13 2009-01-11 11:13

Curiosamente, 'git checkout foo' não funcionará se a cópia de trabalho estiver em um diretório chamado foo; no entanto, como "w20> checkout HEAD foo" e "git checkout./foo" seria:

 $ pwd /Users/aaron/Documents/work/foo $ git checkout foo D foo Already on "foo" $ git checkout ./foo $ git checkout HEAD foo 
36
30 авг. a resposta é dada por Aaron Maenpaa 30 ago. 2008-08-30 00:26 '08 em 0:26 am 2008-08-30 00:26

Aqui rebase funciona:

 git checkout <my branch> git rebase master git checkout master git merge <my branch> 

Suponha que você tenha

 ---o----o----o----o master \---A----B <my branch> 

As duas primeiras equipes ... fazem um assistente de re-instalação git checkout git

... verifique a ramificação das alterações que você deseja aplicar ao ramo master . O comando rebase recebe commits de <my branch> (que não são encontrados no master ) e os rebase no cabeçalho master . Em outras palavras, o elemento pai da primeira confirmação em <my branch> não <my branch> mais o fixador anterior no histórico master , mas o cabeçalho master atual. Duas equipes são iguais a:

 git rebase master <my branch> 

Talvez seja mais fácil lembrar desse comando, já que as ramificações "base" e "modificar" são explícitas.

. O resultado final:

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

As duas últimas equipes ...

 git checkout master git merge <my branch> 

... execute uma mesclagem rápida para aplicar todas as alterações <my branch> ao master . Sem essa etapa, uma consolidação de rebase não é adicionada ao master . O resultado final:

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

master e <my branch> referências B' . Além disso, a partir deste ponto, você pode remover com segurança o link <my branch> .

 git branch -d <my branch> 
32
24 февр. A resposta é dada por cmcginty 24 fev 2009-02-24 12:43 '09 às 12:43 2009-02-24 12:43

git aliases, awk e shell functions para a salvação!

 git prevision <N> <filename> 

onde <N> é o número de correções de arquivo para reversão do arquivo <filename> .
Por exemplo, para verificar a revisão anterior imediata de um único arquivo x/y/zc , execute

 git prevision -1 x/y/zc 

Como a previsão do git funciona?

Adicione ao seu gitconfig

seguinte:
 [alias] prevision = "!f() { git checkout `git log --oneline $2 | awk -v commit="$1" 'FNR == -commit+1 {print $1}'` $2;} ;f" 

Equipe basicamente

  • executa git log no arquivo especificado e
  • seleciona o ID de confirmação correspondente no histórico de arquivos e
  • executa id de confirmação de git checkout para o arquivo especificado.

Essencialmente, tudo o que poderia ser feito manualmente nesta situação
envolto em um belo e eficaz git-alias - git-prevision

21
01 мая '15 в 4:46 2015-05-01 04:46 a resposta é dada por TheCodeArtist 01 mai '15 at 4:46 2015-05-01 04:46

Eu preciso conectar o EasyGit aqui, que é um wrapper para tornar o git mais acessível para iniciantes sem confundir usuários experientes. Uma das coisas que ele faz é dar mais valores de git revert . Nesse caso, você acabou de dizer:

eg revert foo/bar foo/baz

20
19 окт. a resposta é dada Aristóteles Pagaltzis 19 de outubro . 2008-10-19 03:16 '08 em 3:16 am 2008-10-19 03:16

Caso você queira devolver o arquivo ao commit anterior (e o arquivo que deseja retornar já está corrigido), você pode usar

 git checkout HEAD^1 path/to/file 

ou

 git checkout HEAD~1 path/to/file 

Em seguida, basta executar a etapa e corrigir a versão "nova".

Armado com o conhecimento de que, no caso de uma fusão, um commit pode ter dois pais, você deve saber que HEAD ^ 1 é o primeiro pai, e HEAD ~ 1 é o segundo pai.

Ou funcionará se houver apenas um pai na árvore.

20
11 янв. A resposta é dada por ModernIncantations 11 de janeiro. 2014-01-11 03:29 '14 às 3:29 2014-01-11 03:29

Primeira cabeça de redefinição para o arquivo de destino

 git reset HEAD path_to_file 

A segunda verificação desse arquivo

 git checkout -- path_to_file 
19
04 апр. a resposta é dada por Gulshan Maurya 04 abr. 2017-04-04 13:25 '17 às 1:25 pm 2017-04-04 13:25

Note que git checkout ./foo e git checkout HEAD ./foo não git checkout HEAD ./foo exatamente a mesma coisa; exemplo:

 $ 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 

(O segundo add processa o arquivo no índice, mas não é confirmado.)

git checkout ./foo significa retornar o caminho ./foo para o índice ; adicionar um HEAD instrui o Git a retornar este caminho de índice para seu HEAD antes disso.

19
31 авг. A resposta é dada por Damien Diederen em 31 de agosto. 2008-08-31 14:54 '08 às 2:54 pm 2008-08-31 14:54

Há muitas sugestões aqui, a maioria delas no espírito do git checkout $revision -- $file . Algumas alternativas obscuras:

 git show $revision:$file > $file 

E também, eu geralmente uso apenas para ver temporariamente uma versão específica:

 git show $revision:$file 

ou

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

(OBS: $file deve começar com o prefixo ./ se este for um caminho relativo para git show $revision:$file to work)

E ainda mais estranho

 git archive $revision $file | tar -x0 > $file 
14
08 янв. Resposta de Peter V. Mørch Jan 08 2016-01-08 01:19 '16 às 1:19 2016-01-08 01:19

Para ir para a versão anterior do arquivo de confirmação, obtenha o número de confirmação, digamos, eb917a1

 git checkout eb917a1 YourFileName 

Se você só precisa retornar para a última versão registrada.

 git reset HEAD YourFileName git checkout YourFileName 

Isso levará você ao último estado registrado do arquivo.

11
25 февр. a resposta é dada shah1988 25 de fevereiro 2014-02-25 17:01 '14 às 17:01 2014-02-25 17:01

Para mim, nenhuma resposta parecia muito clara e, portanto, eu gostaria de acrescentar a minha, que parece super simples.

Eu tenho um commit abc1 , e depois eu fiz vários (ou uma modificação) arquivo file.txt .

Agora me diga que eu estraguei algo no arquivo file.txt , e quero voltar para o commit anterior abc1 .

1. git checkout file.txt : isso removerá as alterações locais se você não precisar delas.

2. git checkout abc1 file.txt : isso levará seu arquivo para a versão desejada

3. git commit -m "Restored file.txt to version abc1" : isso causará sua reversão.

  1. git push : isso trará tudo para um repositório remoto

Entre os passos 2 e 3, é claro, você pode fazer o git status para entender o que está acontecendo. Normalmente você deve ver que file.txt já foi adicionado e, portanto, não há necessidade de git add .

10
23 марта '17 в 0:33 2017-03-23 00:33 a resposta é dada por kalmanIsAGameChanger em 23 de março '17 às 0:33 2017-03-23 ​​00:33

git checkout ref | commitHash - filePath

por exemplo.

 git checkout HEAD~5 -- foo.bar or git checkout 048ee28 -- foo.bar 
10
26 сент. A resposta é dada Amos Folarin 26 de setembro . 2013-09-26 20:04 '13 às 20:04 2013-09-26 20:04

Muitas das respostas aqui requerem que você use git reset ... <file> ou git checkout ... <file> , mas você perderá todas as mudanças para <file> que foram feitas após o commit que você deseja retornar.

Se você quiser descartar as alterações de apenas um commit para apenas um arquivo, como faria o git revert , mas apenas para um único arquivo (ou, digamos, um subconjunto dos arquivos commit), sugiro usar git diff e git apply desse git apply ( com <sha> = o hash do commit que você quer devolver):

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

Em princípio, ele primeiro gerará um patch correspondente às alterações que você deseja retornar e, em seguida, cancelará a aplicação do patch para descartar essas alterações.

É claro que não funciona se as linhas invertidas foram alteradas por qualquer commit entre <sha1> e HEAD (conflito).

8
07 дек. a resposta é dada Vince 07 dez. 2016-12-07 17:43 '16 às 17:43 2016-12-07 17:43

Use git log para obter a chave de hash para uma versão específica e, em seguida, use git checkout <hashkey>

Nota Não esqueça de digitar o hash antes do último. O último hash indica a posição atual (HEAD) e não altera nada.

8
05 дек. a resposta é dada mustafakyr 05 dez. 2011-12-05 23:09 '11 às 23:09 2011-12-05 23:09

Obviamente, alguém precisa escrever um livro claro sobre git ou git para melhor explicá-lo na documentação. Confrontado com o mesmo problema, imaginei que

 cd <working copy> git revert master 

inverte o último commit, o que parece estar fazendo.

Ian

7
16 дек. A resposta é dada por Ian Davis em 16 de dezembro. 2011-12-16 06:03 '11 às 6:03 2011-12-16 06:03

Se você fizer o arquivo errado em seus commits recentes, siga as instruções:

  1. árvore de código aberto, altere este commit

2019

23 авг. Resposta dada por sabre tabatabaee yazdi 23 ago. 2018-08-23 12:53 '18 às 12:53 2018-08-23 12:53

Você pode fazer isso em 4 etapas:

  1. cancelar todo o commit com o arquivo que você deseja cancelar especificamente - isso criará um novo commit no seu thread
  2. reinicialização suave que confirma - remove a confirmação e move as alterações para a área de trabalho
  3. selecione manualmente os arquivos para retornar e bloqueá-los
  4. Solte todos os outros arquivos em seu espaço de trabalho

O que você precisa para discar no seu terminal :

  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.

boa sorte

4
08 мая '18 в 13:26 2018-05-08 13:26 a resposta é dada por Nir M. May 08, '18 at 1:26 pm 2018-05-08 13:26
 git revert <hash> 

Retorna o commit especificado. Você parece pensar que git revert afeta apenas o último commit.

Isso não resolverá seu problema se você quiser desfazer a alteração em um arquivo específico e esse commit tiver alterado mais do que esse arquivo.

4
17 дек. Otto respondeu 17 de dezembro 2008-12-17 21:56 '08 em 9:56 pm 2008-12-17 21:56

Aqui está o meu caminho.

a) No Android Studio, abra o arquivo.

b) git → Mostrar histórico, encontrar o commit anterior para o qual eu quero retornar. Obtenha commit_id (por exemplo, Commit hash).

c) git checkout commit_id file_path

1
13 марта '17 в 11:10 2017-03-13 11:10 a resposta é dada por Francis Bacon 13 de março '17 às 11:10 2017-03-13 11:10

Se você usa Git Extensions e deseja retornar para o commit pai do arquivo, você pode selecionar o commit contendo as mudanças que você quer retornar, então selecione a aba "Diff" em detalhe, clique com o botão direito no arquivo que deseja retornar, então Reset the file to " .... ", depois" A "(pai)

1
26 сент. resposta dada por johnny 26 set. 2017-09-26 04:48 '17 às 4:48 2017-09-26 04:48

Este é um passo muito simples. Extraia o arquivo com o ID de confirmação que queremos, aqui está um ID de confirmação antes e, em seguida, basta executar o comando git commitmend e pronto.

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

Isso é muito conveniente. Se quisermos produzir qualquer arquivo com qualquer identificador do commit anterior no topo do commit, podemos facilmente fazê-lo.

1
24 янв. Resposta dada por Abhishek Dwivedi em 24 de janeiro 2019-01-24 20:21 19 às 8:21 pm 2019-01-24 20:21
  • 1
  • 2

Outras questões sobre tags de ou Ask a Question