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

Fiz algumas alterações em um arquivo que foi confirmado algumas vezes como parte de um grupo de arquivos, mas agora quero redefinir / reverter as alterações para uma versão anterior.

Eu fiz um git log junto com um git diff para encontrar a revisão que eu preciso, mas não tenho idéia de como recuperar o arquivo para o estado anterior no passado.

Assumindo que o hash do 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 reverter para o commit antes do c5f567 , acrescente ~1 (funciona com qualquer número):

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

Como uma nota lateral, eu sempre me senti desconfortável com este comando porque ele é usado tanto para coisas comuns (mudando entre ramificações) quanto para coisas incomuns e destrutivas (descartando mudanças no diretório de trabalho).

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

 git diff   

Então, para reverter um arquivo específico para o commit, use o comando reset:

 git reset   

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

Um bom stream de trabalho para gerenciar waypoints é usar tags para marcar pontos de forma clara em sua linha do tempo. Eu não consigo entender sua última frase, mas o que você pode querer é desviar um ramo de um ponto anterior no tempo. Para fazer isso, use o comando de checkout:

 git checkout  git checkout -b  

Você pode, então, rebaixar isso em sua linha principal quando estiver pronto para mesclar essas mudanças:

 git checkout  git rebase master git checkout master git merge  

Você pode usar qualquer referência a um commit git, incluindo o SHA-1, se for mais conveniente. O ponto é que o comando se parece com isso:

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

 git checkout -- foo 

Isso irá redefinir foo para HEAD. Você também pode:

 git checkout HEAD^ foo 

para uma revisão de volta, etc.

E para reverter para a última versão confirmada, que é mais frequentemente necessária, você pode usar esse comando mais simples.

 git checkout HEAD file/to/restore 

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

 git checkout [commit-ref] [filename] 

Isso colocará essa versão antiga em seu diretório de trabalho e, a partir daí, você poderá confirmá-la se quiser.

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

 git checkout master~5 image.png 

Isso pressupõe que você esteja no branch master , e a versão que você quer é 5 commits de volta.

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

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

Começar com:

$ git log

que mostra uma lista de commits recentes e seus hashes SHA1.

Em seguida, digite:

$ git reset --hard SHA1_HASH

para restaurar o estado para um determinado commit e apagar permanentemente todas as novas confirmações do registro.

Isso funcionou para mim:

 git checkout  file 

Em seguida, confirme a alteração:

 git commit -a 

Você tem que ter cuidado quando você diz “reversão”. Se você costumava ter uma versão de um arquivo em commit $ A, e depois fez duas alterações em duas commits separadas $ B e $ C (então o que você está vendo é a terceira iteração do arquivo), e se você disser ” Eu quero voltar para o primeiro “, você realmente quis dizer isso?

Se você quiser se livrar das mudanças tanto na segunda quanto na terceira iteração, é muito simples:

 $ git checkout $A file 

e então você confirma o resultado. O comando pergunta “Quero verificar o arquivo do estado registrado pelo commit $ A”.

Por outro lado, o que você quis dizer é livrar-se da mudança que a segunda iteração (ou seja, cometer $ B) trouxe, mantendo o que commit $ C fez para o arquivo, você iria querer reverter $ B

 $ git revert $B 

Observe que quem criou o commit $ B pode não ter sido muito disciplinado e pode ter feito uma alteração totalmente não relacionada no mesmo commit, e essa reversão pode tocar em arquivos diferentes do arquivo que você vê, se quiser fazer alterações assim.

Curiosamente, ‘git checkout foo’ não funcionará se a cópia de trabalho estiver em um diretório chamado foo; no entanto, tanto o ‘git checkout HEAD foo’ quanto o ‘git checkout ./foo’ irão:

 $ pwd /Users/aaron/Documents/work/foo $ git checkout foo D foo Already on "foo" $ git checkout ./foo $ git checkout HEAD foo 

Veja como o rebase funciona:

 git checkout  git rebase master git checkout master git merge  

Suponha que você tenha

 ---o----o----o----o master \---A----B  

Os dois primeiros comandos … commit git checkout git rebase master

… confira o ramo de mudanças que você deseja aplicar ao ramo master . O comando rebase recebe os commits de (que não são encontrados no master ) e os reaplica ao head of master . Em outras palavras, o pai do primeiro commit no não é mais um commit anterior no histórico master , mas o atual head of master . Os dois comandos são os mesmos:

 git rebase master  

Pode ser mais fácil lembrar desse comando, pois as ramificações “base” e “modificar” são explícitas.

. O resultado final da história é:

 ---o----o----o----o master \----A'----B'  

Os dois últimos comandos …

 git checkout master git merge  

… faça uma mesclagem fast-forward para aplicar todas as alterações no master . Sem essa etapa, o commit de rebase não é adicionado ao master . O resultado final é:

 ---o----o----o----o----A'----B' master,  

master e ambos referência B' . Além disso, a partir deste ponto, é seguro excluir a referência .

 git branch -d  

git-aliases, awk e shell-functions para o resgate!

 git prevision   

onde é o número de revisões do arquivo para reverter para o arquivo .
Por exemplo, para verificar a revisão anterior imediata de um único arquivo x/y/zc , execute

 git prevision -1 x/y/zc 

Como funciona a previsão git?

Adicione o seguinte ao seu gitconfig

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

O comando basicamente

  • executa um git log no arquivo especificado e
  • seleciona o id de confirmação apropriado no histórico do arquivo e
  • executa um git checkout para o commit-id do arquivo especificado.

Essencialmente, tudo o que faria manualmente nesta situação,
embrulhado em um belo e eficiente git-alias – git-prevision

Eu tenho que ligar o EasyGit aqui, que é um wrapper para tornar o git mais acessível aos novatos sem confundir usuários experientes. Uma das coisas que faz é dar mais significados para git revert . Nesse caso, você simplesmente diria:

eg revert foo/bar foo/baz

Caso você queira reverter um arquivo para uma confirmação anterior (e o arquivo que deseja reverter já confirmado), você pode usar

 git checkout HEAD^1 path/to/file 

ou

 git checkout HEAD~1 path/to/file 

Em seguida, basta encenar e confirmar a “nova” versão.

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

Ou funcionará se houver apenas um pai na tree.

Note, no entanto, que git checkout ./foo e git checkout HEAD ./foo não são exatamente a mesma coisa; caso em questão:

 $ 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 coloca o arquivo no índice, mas não é confirmado.)

Git checkout ./foo significa reverter o caminho ./foo do índice ; A adição de HEAD instrui o Git a reverter esse caminho no índice para sua revisão HEAD antes de fazer isso.

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

 git reset HEAD path_to_file 

Segunda verificação desse arquivo

 git checkout -- path_to_file 

Muitas sugestões aqui, mais ao longo das linhas de git checkout $revision -- $file . Algumas alternativas obscuras:

 git show $revision:$file > $file 

E também, eu uso muito isso apenas para ver uma versão particular temporariamente:

 git show $revision:$file 

ou

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

(OBS: $file precisa ser prefixado com ./ se for um caminho relativo para git show $revision:$file to work)

E o mais estranho ainda:

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

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

 git checkout eb917a1 YourFileName 

Se você só precisa voltar para a última versão confirmada

 git reset HEAD YourFileName git checkout YourFileName 

Isso simplesmente levará você ao último estado comprometido do arquivo

git checkout ref | commitHash – filePath

por exemplo

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

Para mim, nenhuma resposta me pareceu clara e, portanto, gostaria de acrescentar a minha, que parece super fácil.

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

Agora digamos que eu estraguei algo no arquivo file.txt e quero voltar para um 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 trará o seu arquivo para a sua versão desejada

3. git commit -m "Restored file.txt to version abc1" : isto irá confirmar sua reversão.

  1. git push : isso vai empurrar tudo no repository remoto

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

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

Nota: Não esqueça de digitar o hash antes do último. Último hash aponta sua posição atual (HEAD) e não muda nada.

Obviamente, alguém precisa escrever um livro inteligível sobre o git, ou o git precisa ser melhor explicado na documentação. Diante desse mesmo problema, imaginei que

 cd  git revert master 

iria desfazer o último commit que parece fazer.

Ian

Muitas respostas aqui afirmam usar git reset ... ou git checkout ... mas ao fazê-lo, você perderá todas as modificações em cometidas após o commit que você deseja reverter.

Se você quiser reverter as alterações de um commit em um único arquivo, assim como o git revert faria, mas apenas para um arquivo (ou digamos um subconjunto dos arquivos commit), sugiro usar git diff e git apply like that ( com = o hash do commit que você quer reverter):

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

Basicamente, ele primeiro gerará um patch correspondente às alterações que você deseja reverter e aplicará o patch reversamente para descartar essas alterações.

É claro que não funcionará se as linhas revertidas tiverem sido modificadas por qualquer confirmação entre e HEAD (conflito).

 git revert  

Irá reverter um determinado commit. Parece que você acha que o git revert afeta apenas o commit mais recente.

Isso não resolve o seu problema, se você quiser reverter uma mudança em um arquivo específico e que o commit mudou mais do que esse arquivo.

Você pode fazer isso em 4 etapas:

  1. reverter todo o commit com o arquivo que você deseja reverter especificamente – ele criará um novo commit no seu branch
  2. reboot suave que confirma – remove o commit e move as alterações para a área de trabalho
  3. escolha os arquivos para reverter e comprometê-los
  4. Solte todos os outros arquivos em sua área de trabalho

O que você precisa digitar no seu terminal :

  1. git revert
  2. git reset HEAD~1
  3. git add && git commit -m 'reverting file'
  4. git checkout .

boa sorte

se você cometer um arquivo errado em seus últimos commits, siga as instruções:

  1. tree de código aberto, mude para este commit

árvore de código aberto

  1. mudar as linhas e encontrar o seu commit que o arquivo errado enviado como commit

insira a descrição da imagem aqui

  1. você pode ver a lista de suas alterações nesse commit lista de arquivos na árvore de origem
  2. selecione-o e depois clique em … botões do lado direito … clique no arquivo reverso
  3. então você pode vê-lo na aba de status do arquivo na parte inferior esquerda e clicar em unstage:

guia de status do arquivo

  1. abra o código do seu estúdio visual e reverta, confirmando seus arquivos removidos
  2. depois de todos eles, você pode ver os resultados em seu último commit na tree de fonts

insira a descrição da imagem aqui

Aqui está o meu caminho.

a) No Android Studio, abra o arquivo.

b) git -> Show History, encontre o commit anterior para o qual desejo reverter. Obtenha o commit_id (ou seja, commit hash).

c) git checkout commit_id file_path

Se você estiver usando Git Extensions e desejar reverter somente para a confirmação pai do arquivo, poderá selecionar a confirmação que contém as alterações que deseja reverter e, em seguida, selecionar a guia ‘Diff’ no painel de detalhes, clique com o botão direito do mouse o arquivo que você deseja reverter e, em seguida, “Redefinir arquivo (s) para ‘….’, depois ‘A’ (o pai)