git tag Como modificar commits existentes e não processados?




git tag by commit (18)

Emendando a mensagem de commit mais recente

git commit --amend

irá abrir o seu editor, permitindo que você altere a mensagem de commit do commit mais recente. Além disso, você pode definir a mensagem de confirmação diretamente na linha de comando com:

git commit --amend -m "New commit message"

… No entanto, isso pode fazer com que mensagens de confirmação de várias linhas ou pequenas correções sejam mais complicadas de serem inseridas.

Certifique-se de que você não tenha nenhuma alteração na cópia de trabalho preparada antes de fazer isso ou eles também serão confirmados. (Alterações não organizadas não serão confirmadas.)

Alterando a mensagem de uma confirmação que você já enviou para sua ramificação remota

Se você já enviou sua confirmação para o seu ramo remoto, você precisará forçar o commit a:

git push <remote> <branch> --force
# Or
git push <remote> <branch> -f

Aviso: o envio forçado sobrescreve o ramo remoto com o estado do seu local . Se houver commits no branch remoto que você não tem em seu branch local, você perderá os commits.

Aviso: tenha cuidado ao alterar os commits que você já compartilhou com outras pessoas. Emendar os commits essencialmente os reescreve para ter diferentes IDs de SHA , o que representa um problema se outras pessoas tiverem cópias do commit antigo que você tenha reescrito. Qualquer um que tenha uma cópia do commit antigo precisará sincronizar seu trabalho com o commit recém-reescrito, o que às vezes pode ser difícil, então certifique-se de coordenar com os outros ao tentar reescrever o histórico de commits compartilhado, ou apenas reescrever commits compartilhados completamente.

Use rebase interativo

Outra opção é usar o rebase interativo.
Isso permite editar qualquer mensagem que você queira atualizar, mesmo que não seja a última mensagem.

Para fazer um git squash, siga estes passos:

// X is the number of commits to the last commit you want to be able to edit
git rebase -i HEAD~X

Depois de esmagar seus commits - escolha o e/r para editar a mensagem

Nota importante sobre rebas interativo

Quando você usa a git rebase -i HEAD~X , pode haver mais de X commits. O Git irá "coletar" todos os commits nos últimos X commits e se houver uma mesclagem em algum lugar entre esse range, você verá todos os commits também, então o resultado será X +.

Boa dica:

Se você tiver que fazer isso para mais de uma única ramificação e você puder enfrentar conflitos ao alterar o conteúdo, configure o git rerere e deixe o git resolver esses conflitos automaticamente para você.

🔥 Hot-tip

Você também pode escrever uma pequena função bash para corrigir a última mensagem de commit do git e empurrá-la para o controle remoto. Me ajuda o tempo todo. Aqui está a função; coloque-o em seu arquivo .bashrc ou similar .zshrc e recarregue seu shell.

# Amend the last commit message
# Push the changes to remote by force
# USAGE: gamend "Your New Commit Msg"
function gamend() {
    git commit --amend -m "[email protected]"
    git push --force
}

Documentação

https://code.i-harness.com

Eu escrevi a coisa errada em uma mensagem de commit. Como alternativa, esqueci de incluir alguns arquivos.

Como posso alterar a mensagem / arquivos de commit? O commit ainda não foi enviado.


Alterar

Você tem algumas opções aqui. Você pode fazer

git commit --amend

contanto que seja seu último commit.

Rebase interativo

Caso contrário, se não for o seu último commit, você pode fazer um rebase interativo,

git rebase -i [branched_from] [hash before commit]

Então, dentro do rebase interativo, você simplesmente adiciona edit a esse commit. Quando isso acontecer, faça um git commit --amend e modifique a mensagem de commit. Se você quiser reverter antes desse ponto de commit você também pode usar o git reflog e deletar o commit. Então você acabou de fazer um git commit novamente.


Atualize sua última mensagem de commit errada com uma nova mensagem de commit em uma linha:

git commit --amend -m "your new commit message"

Ou tente git reset como abaixo:

# You can reset your head to n number of commit
# NOT a good idea for changing last commit message
# but you can get an idea to split commit into multiple commits
git reset --soft HEAD^

# it will reset you last commit. Now, you
# can re-commit it with new commit message.

Usando reset para dividir commits em commits menores

git reset pode ajudá-lo a quebrar um commit em múltiplos commits também:

# reset your head. I am resetting to last commits:
git reset --soft HEAD^
# (you can reset multiple commit by doing HEAD~2(no. of commits)

# Now, reset your head for splitting it to multiple commits
git reset HEAD

# add and commit your files seperately to make multiple commits: e.g
git add app/
git commit -m "add all files in app directory"

git add config/
git commit -m "add all files in config directory"

Aqui você quebrou com sucesso seu último commit em dois commits.


Como já foi mencionado, git commit --amend é a maneira de sobrescrever o último commit. Uma nota: se você quiser também sobrescrever os arquivos , o comando será

git commit -a --amend -m "My new commit message"

Eu uso o Git GUI o máximo que posso, e isso te dá a opção de alterar o último commit:

Além disso, git rebase -i origin/master é um bom mantra que sempre lhe apresentará os commits que você fez em cima do master, e lhe dará a opção de alterar, deletar, reordenar ou squash. Não há necessidade de se apossar desse hash primeiro.


Nesta questão, há muitas respostas, mas nenhuma delas explica detalhadamente como alterar mensagens de confirmação mais antigas usando o VIM. Eu estava preso tentando fazer isso sozinho, então aqui eu vou escrever em detalhes como eu fiz isso especialmente para pessoas que não têm experiência em VIM!

Eu queria mudar meus cinco últimos commits que eu já enviei para o servidor. Isso é muito 'perigoso' porque se alguém já tirou isso, você pode atrapalhar as coisas mudando as mensagens de commit. No entanto, quando você está trabalhando em seu próprio galho e tem certeza de que ninguém o puxou, você pode mudá-lo assim:

Digamos que você queira alterar seus cinco últimos commits e, em seguida, digite isso no terminal:

git rebase -i HEAD~5 * Onde 5 é o número de mensagens de confirmação que você deseja alterar. (então se você quiser mudar o 10º para o último commit você digita 10)

Este comando irá levá-lo para o VIM, onde você pode editar seu histórico de commit. Você verá seus últimos 5 commits no topo assim:

pick <commit hash> commit message

Em vez de pick você precisa escrever um novo reword . Você pode fazer isso no VIM digitando i , que faz você entrar no modo INSERT. (Você vê que você está no modo de inserção pela palavra INSERT na parte inferior) Para as confirmações que você deseja alterar digite reword em vez de pick

Então você precisa salvar e sair desta tela, você faz isso primeiro entrando no 'modo de comando' pressionando o botão esc. (você pode verificar se está no modo de comando se a palavra INSERT na parte inferior desaparecer). Em seguida, você pode digitar um comando digitando:, o comando para salvar e sair é wq . Então, se você digitar :wq você está no caminho certo.

Então o VIM vai passar por cima de cada mensagem de commit que você quer reformular, aqui você pode realmente mudar as mensagens de commit. Você fará isso entrando no modo INSERT, alterando a mensagem de confirmação, entrando no modo de comando e salvando e encerrando. Faça isso 5 vezes e você está fora do VIM!

Então, se você já enviou seus commits errados, você precisa git push --force para sobrescrevê-los. Lembre-se que o git push --force é uma coisa bastante perigosa para se fazer, então certifique-se de que ninguém tenha saído do servidor desde que você enviou seus commits errados!

Agora você mudou suas mensagens de commit!

(Como você vê, eu não sou tão experiente no VIM, então se eu usei o jargão errado para explicar o que está acontecendo, fique à vontade para me corrigir!)


Para quem procura uma GUI do Windows / Mac para ajudar na edição de mensagens antigas (ou seja, não apenas a mensagem mais recente), eu recomendo o SourceTree . Os passos a seguir estão abaixo.

Para confirmações que ainda não foram enviadas para um controle remoto:

  1. Certifique-se de ter confirmado ou armazenado todas as alterações atuais (ou seja, para que não haja arquivos listados na guia "Status do arquivo") - isso não funcionará de outra forma.
  2. Na aba "Log / Histórico", clique com o botão direito do mouse na entrada com uma linha adjacente no gráfico um abaixo do (s) commit (s) que você deseja editar e selecione "Rebase children of <commit ref> interativamente ..."
  3. Selecione a linha inteira da mensagem de commit que você deseja alterar ( isto é, clique na coluna "Message" ).
  4. Clique no botão "Editar mensagem".
  5. Edite a mensagem como desejado na caixa de diálogo que aparece e clique em OK.
  6. Repita as etapas 3 a 4 se houver outras mensagens de confirmação a serem alteradas.
  7. Clique em OK: o re-lançamento começará. Se tudo estiver bem, a saída terminará "Concluído com sucesso".

... Ou ... para commits que já foram enviados:

Siga os passos nesta resposta , que são semelhantes aos acima, mas requerem um comando adicional para ser executado a partir da linha de comando para forçar o ramo a ser lido - leia tudo e aplique o cuidado necessário!


Se é o seu último commit, apenas altere o commit:

git commit --amend -o -m "New commit message"

(usando o --only -o ( --only ) para garantir que você altere apenas a mensagem de confirmação)


Se é um commit enterrado, use o ótimo repositório interativo :

git rebase -i @~9   # Show the last 9 commits in a text editor

Encontre o commit desejado, altere pick para r ( reword ) e salve e feche o arquivo. Feito!


Tutorial de vim em miniatura (ou, como rebase com apenas 8 pressionamentos de tecla 3j cw r Esc ZZ ):

  • Corra vimtutor se você tiver tempo
  • h j k l correspondem às teclas de movimento
  • Todos os comandos podem ser prefixados com um "intervalo", por exemplo, 3j se move para baixo 3 linhas
  • i para entrar no modo de inserção - o texto digitado aparecerá no arquivo
  • Esc ou Ctrl c para sair do modo de inserção e retornar ao modo "normal"
  • u para desfazer
  • Ctrl r para refazer
  • dd , dw , dl para excluir uma linha, palavra ou letra, respectivamente
  • cc , cw , cl para alterar uma linha, palavra ou letra, respectivamente (o mesmo que dd i )
  • yy , yw , yl para copiar ("yank") uma linha, palavra ou letra, respectivamente
  • p ou P para colar depois ou antes da posição atual, respectivamente
  • :w Enter para salvar (gravar) um arquivo
  • :q! Entre para sair sem salvar
  • :wq Enter ou ZZ para salvar e sair

Se você editar bastante o texto, mude para o layout do teclado Dvorak, aprenda a digitar e aprenda o vim. Vale a pena o esforço? Sim.


ProTip ™: Não tenha medo de experimentar comandos "perigosos" que reescrevem o histórico * - o Git não exclui seus commits por 90 dias por padrão; você pode encontrá-los no reflog:

$ git reset @~3   # go back 3 commits
$ git reflog
c4f708b [email protected]{0}: reset: moving to @~3
2c52489 [email protected]{1}: commit: more changes
4a5246d [email protected]{2}: commit: make important changes
e8571e4 [email protected]{3}: commit: make some changes
... earlier commits ...
$ git reset 2c52489
... and you're back where you started

* Cuidado com opções como --hard e --force - eles podem descartar dados.
* Além disso, não reescreva o histórico em nenhum ramo em que você esteja colaborando.


Se você estiver usando a GUI do Git, você pode alterar o último commit que não foi enviado:

Commit/Amend Last Commit

Se você estiver usando a ferramenta Git GUI, existe um botão denominado emendar último commit. Clique nesse botão e, em seguida, ele exibirá seus últimos arquivos e mensagens de confirmação. Apenas edite essa mensagem e você poderá confirmá-la com uma nova mensagem de confirmação.

Ou use este comando em um console / terminal:

git commit -a --amend -m "My new commit message"

Se você quiser apenas alterar sua última mensagem, use a sinalização --only ou seu atalho -o com commit --amend :

git commit --amend -o -m "New commit message"

Isso garante que você não aprimore acidentalmente seu commit com material preparado. Claro que é melhor ter uma configuração adequada do $EDITOR . Então você pode deixar a opção -m fora e o git preencherá previamente a mensagem de commit com a antiga. Desta forma, pode ser facilmente editado.


Se você quiser apenas editar o último uso de commit:

git commit --amend

ou

git commit --amend -m 'one line message'

Mas se você quiser editar vários commits seguidos, você deve usar o rebasing em vez disso:

git rebase -i <hash of one commit before the wrong commit>

Em um arquivo como o acima, escreva edit / e ou uma das outras opções e pressione salvar e sair.

Agora você estará no primeiro commit errado. Faça alterações nos arquivos e eles serão organizados automaticamente para você. Tipo

git commit --amend

salvar e sair disso e digite

git rebase --continue 

para ir para a próxima seleção até terminar com todas as suas seleções.

Note que estas coisas mudam todos os seus hashes SHA após aquele commit em particular.


Usar

git commit --amend

Para entender em detalhes, um excelente post é 4. Reescrevendo a História do Git . Ele também fala sobre quando não usar o git commit --amend .


Você pode usar o rebase do Git . Por exemplo, se você quiser modificar de volta para confirmar bbc643cd, execute

$ git rebase bbc643cd^ --interactive

No editor padrão, modifique 'pick' para 'edit' na linha cujo commit você deseja modificar. Faça suas alterações e, em seguida, organize-as com

$ git add <filepattern>

Agora você pode usar

$ git commit --amend

para modificar o commit, e depois disso

$ git rebase --continue

para voltar ao commit anterior.


Eu gosto de usar o seguinte:

  1. git status
  2. git add --all
  3. git commit -am "message goes here about the change"
  4. git pull <origin master>
  5. git push <origin master>

Eu adicionei o alias de reci, recmpara recommit (amend)isso, agora eu posso fazer isso com git recmou git recm -m.

$ vim ~/.gitconfig

[alias]

    ......
    cm = commit
    reci = commit --amend
    recm = commit --amend
    ......

Se você não empurrou o código para sua ramificação remota ( GitHub / Bitbucket ), você pode alterar a mensagem de confirmação na linha de comando, conforme abaixo.

 git commit --amend -m "Your new message"

Se você está trabalhando em um ramo específico, faça isso:

git commit --amend -m "BRANCH-NAME: new message"

Se você já enviou o código com a mensagem errada e precisa ser cuidadoso ao alterar a mensagem. Ou seja, depois de alterar a mensagem de confirmação e tentar empurrá-la novamente, você acaba tendo problemas. Para facilitar, siga estas etapas.

Por favor, leia minha resposta inteira antes de fazer isso.

git commit --amend -m "BRANCH-NAME : your new message"

git push -f origin BRANCH-NAME                # Not a best practice. Read below why?

Nota importante: Quando você usa o force push diretamente, pode acabar com problemas de código que outros desenvolvedores estão trabalhando na mesma ramificação. Então, para evitar esses conflitos, você precisa puxar o código do seu ramo antes de fazer o push force :

 git commit --amend -m "BRANCH-NAME : your new message"
 git pull origin BRANCH-NAME
 git push -f origin BRANCH-NAME

Essa é a melhor prática ao alterar a mensagem de confirmação, se já foi enviada.


Você pode usar o git-rebase-reword

Ele é projetado para editar qualquer commit (não apenas o último) da mesma maneira que commit --amend

$ git rebase-reword <commit-or-refname>

É nomeado após a ação no rebase interativo para alterar um commit: "reword". Veja este post e man interactive mode-seção

Exemplos:

$ git rebase-reword b68f560
$ git rebase-reword HEAD^




amend