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




installer git windows (20)

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

git prevision <N> <filename>

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

git prevision -1 x/y/z.c

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

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.


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.


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 de 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).


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 fusão, você deve saber que HEAD ^ 1 é o primeiro pai e HEAD ~ 1 é o segundo pai.

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


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

git checkout HEAD file/to/restore

Este é um passo muito simples. Arquivo de check-out para o ID de confirmação que queremos, aqui um cometer id antes e, em seguida, apenas git confirmar emendar e estamos a fazer.

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

Isso é muito útil. Se quisermos trazer qualquer arquivo para qualquer ID de commit anterior no topo do commit, podemos facilmente fazer isso.


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 desejar.


Isso funcionou para mim:

git checkout <commit hash> file

Em seguida, confirme a alteração:

git commit -a

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 específica 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

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 ele não é confirmado.)

Git checkout ./foo significa reverter 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.


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


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

Eu tenho um commit abc1 e depois disso 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 : isto 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 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 o file.txt já adicionado e é por isso que não há necessidade de um git add .


Se você estiver usando o Git Extensions e desejar reverter 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, em seguida, 'Redefinir arquivo (s) para' ...., depois 'A' (pai)


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.


Veja como o 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>

Os dois primeiros comandos ... commit git checkout git rebase master

... confira o ramo das mudanças que você deseja aplicar ao ramo master . O comando rebase recebe os commits de <my branch> (que não são encontrados no master ) e os reaplica ao chefe do master . Em outras palavras, o pai do primeiro commit no <my branch> 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 <my branch>

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'  <my branch>

Os dois últimos comandos ...

git checkout master
git merge <my branch>

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

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

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

git branch -d <my branch>

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

git diff <commit hash> <filename>

Então, para reverter um arquivo específico para essa confirmação, use o comando reset:

git reset <commit hash> <filename>

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

Um bom fluxo 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 <commit hash>
git checkout -b <new branch name>

Você pode, então, rebase-lo contra sua linha principal quando estiver pronto para mesclar essas mudanças:

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

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

Se você quer 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 mudança totalmente não relacionada no mesmo commit, e essa reversão pode tocar em arquivos diferentes do arquivo que você vê, se desejar, verifique cuidadosamente o resultado depois de fazer assim.


git checkout ref | commitHash - filePath

por exemplo

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

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. reinicialização 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 <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


git checkout -- foo

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

git checkout HEAD^ foo

para uma revisão de volta, etc.





git-checkout