Como modificar existente, unpushed cometer mensagens?

https://stackoverflow.com/questions/179123

05-07-2019
|

Pergunta

Eu escrevi a coisa errada em uma mensagem de confirmação.

Como posso alterar a mensagem? O commit ainda não foi empurrado.

Solução

rectificativo o mais recente mensagem de commit

git commit --amend

irá abrir o seu editor, que lhe permite alterar a mensagem de commit do mais recente cometer. Além disso, você pode definir a mensagem comprometer diretamente na linha de comando com:

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

... no entanto, isso pode fazer multi-linha cometer mensagens ou pequenas correções mais complicados para entrar.

Certifique-se de que você não tem quaisquer alterações cópia de trabalho encenado antes de fazer isso ou eles vão ficar comprometida também. ( Unstaged mudanças não vai ficar comprometida.)

Alterar a mensagem de um commit que você já tenha empurrado para a sua filial remota

Se você já empurrou seu comprometer-se à sua filial remota, então você vai precisa empurrar vigor a cometer com:

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

Aviso: força empurrando irá substituir o ramo remoto com o seu estado de um local, . Se houver commits no ramo remoto que você não tem em sua filial local, você irá perder os commits.

Aviso:. Ser cauteloso sobre que altera commits que você já tenha compartilhado com outras pessoas rectificativo compromete essencialmente regravações que eles tenham diferentes SHA IDs, o que coloca um problema se outras pessoas têm cópias do velho comprometer que você reescrito. Qualquer um que tem uma cópia do antigo commit precisará sincronizar seu trabalho com o seu recém-re-escrito cometer, que por vezes pode ser difícil, por isso certifique-se de coordenar com os outros ao tentar reescrever compartilhada cometer história, ou apenas evitar reescrever commits compartilhados por completo.

Use rebase interativo

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

Para fazer uma polpa de git, 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

Uma vez que você esmagar seus commits - escolher o e/r para editar a mensagem

Nota importante sobre Interativo rebase

Quando você usa o git rebase -i HEAD~X pode haver mais que X commits. Git "Collect" todos os commits nos commits última X e se havia um lugar fusão entre esse intervalo você vai ver todos os commits, bem assim o resultado será X +.

Boa dica:

Se você tem que fazê-lo por mais de um único ramo e você pode enfrentar conflitos quando altera o conteúdo, configurar git rerere e deixe determinação git esses conflitos automaticamente para você.

Documentação

Outras dicas

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

Se a cometer você quiser correção não é o mais recente:

git rebase --interactive $parent_of_flawed_commit

Se você quiser corrigir vários commits falhos, passe o pai do mais antigo deles.
Um editor vai vir para cima, com uma lista de todos os commits desde o que você deu.
1. Alterar pick para reword (ou em versões antigas do Git, a edit) na frente de nenhum commit você deseja corrigir.
2. Uma vez que você salvar, Git irá reproduzir os commits listados.
Para cada commit você quiser reformular , Git vai deixá-lo para trás em seu editor. Para cada commit você quiser editar , Git você cai no shell. Se você estiver no shell:
1. Alterar a comprometer de qualquer forma você gosta.
2. git commit --amend
3. git rebase --continue

A maior parte desta sequência será explicado a você pela saída dos vários comandos que você vá. É muito fácil, você não precisa memorizá-lo -. Basta lembrar que git rebase --interactive permite fazer commits corretas não importa quanto tempo atrás eles eram

Note que você não vai querer commits mudança que você já tenha empurrado. Ou talvez você faz, mas, nesse caso, você terá que tomar muito cuidado para se comunicar com todos que podem ter puxado seus commits e trabalho feito em cima deles. Como faço para recuperar / resynchronise depois que alguém empurra um rebase ou um reset a um ramo publicado?

Para alterar cometer o anterior, faça as alterações desejadas e encenar essas mudanças, e depois executar

git commit --amend

Isto irá abrir um arquivo em seu editor de texto que representa a sua nova mensagem de commit. Ele começa preenchida com o texto de sua antiga mensagem de commit. Alterar a mensagem de commit como você quer, salve o arquivo e sair do seu editor ao fim.

Para alterar cometer o anterior e manter a mesma mensagem de log, execute

git commit --amend -C HEAD

Para corrigir cometer o anterior, suprimindo-lo inteiramente, execute

git reset --hard HEAD^

Se você quiser editar mais do que uma mensagem de confirmação, run

git rebase -i HEAD~commit_count

(Substituir COMMIT_COUNT com o número de commits que você quer editar.) Esse comando inicia o seu editor. Marcar o primeiro commit (o que você quer mudar) como “editar” em vez de “pegar”, em seguida, salvar e sair do seu editor. Faça a mudança que você quer se comprometer e execute

git commit --amend
git rebase --continue

Nota: Você pode "fazer a mudança que você quer", também do editor aberto por git commit --amend

Como já mencionado, git commit --amend é o caminho para substituir o último commit. Uma nota: se você gostaria de também substituir os arquivos , o comando seria

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

Você também pode usar git filter-branch para isso.

git filter-branch -f --msg-filter "sed 's/errror/error/'" $flawed_commit..HEAD

Não é tão fácil como um git commit --amend trivial, mas é especialmente útil, se você já tem algumas fusões após a sua mensagem de submissão errônea.

Note que este vai tentar reescrever cada commit entre HEAD eo falho cometer, por isso você deve escolher o seu comando msg-filter muito sábio; -)

Eu prefiro desta forma.

git commit --amend -c <commit ID>

Caso contrário, haverá uma nova comprometer com um novo commit ID

Se você estiver usando a ferramenta Git GUI, existe um botão chamado alterar último commit. Clique no botão que e, em seguida, ele irá exibir seu último commit arquivos e mensagens. Basta editar essa mensagem e você pode cometê-lo com a nova mensagem de confirmação.

Ou use este comando a partir de um console / terminal:

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

Você pode usar Git rebasing . Por exemplo, se você deseja modificar voltar a cometer bbc643cd, run

$ git rebase bbc643cd^ --interactive

No editor padrão, modifique 'pick' para 'editar' na linha cuja cometer você deseja modificar. Faça as alterações e, em seguida, organizar-los com

$ git add <filepattern>

Agora você pode usar

$ git commit --amend

para modificar a cometer, e depois disso

$ git rebase --continue

para voltar à cabeça submissão anterior.

Se você só deseja modificar sua última mensagem de commit, então faça:
```
git commit --amend
```
Isso vai deixá-lo em seu Exitor texto e permitem que você altere a última mensagem de confirmação.
Se você quiser alterar o último 3 cometer mensagens ou qualquer um dos mensagens de commit até aquele momento, a oferta HEAD~3 ao comando git rebase -i:
```
git rebase -i HEAD~3
```

Se você tem que mudar um velho cometer mensagem através de várias ramificações (isto é, a comprometer com a mensagem errônea está presente em vários ramos), você pode querer usar:

git filter-branch -f --msg-filter \
'sed "s/<old message>/<new message>/g"' -- --all

Git irá criar um diretório temporário para reescrever e referências antigas adicionalmente de backup em refs/original/.

-f irá impor a execução da operação. Isso é necessário se o diretório temporário já está presente ou se já existem referências armazenadas sob refs/original. Se isso não for o caso, você pode soltar esta bandeira.
-- separa opções filter-branch de opções de revisão.
--all irá certificar-se que todos os ramos e marcas são reescritas.

Devido ao apoio de seus antigos referências, você pode facilmente voltar ao estado antes de executar o comando.

Diga, você quer recuperar o seu mestre e acessá-lo em old_master ramo:

git checkout -b old_master refs/original/refs/heads/master

Use

git commit --amend

Para compreendê-la em detalhe, um excelente post é 4. Reescrita Git História . Ele também fala sobre Quando não usar git commit --amend.

Alterar

Você tem um par de opções aqui. Você pode fazer

git commit --amend

contanto que é a sua última confirmação.

Interativo rebase

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

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

Então, dentro do rebase interativo basta adicionar edição para que cometeu. Quando surge fazer um git commit --amend e modificar a mensagem de commit. Se você quiser reverter antes que cometem ponto, você também pode usar git reflog e apenas excluir que cometeu. Então você acabou de fazer um git commit novamente.

Se você estiver usando o Git GUI, você pode alterar a última confirmação que não tem sido empurrado com:

Commit/Amend Last Commit

Se é a sua última operação, apenas alterar o commit:

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

(usando o -o (--only) flag para se certificar de que você alterar apenas a mensagem de commit)

Se é uma enterrado cometer, utilize o rebase interativo incrível :

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

Encontre o cometer quiser, mudança pick para r (reword), e salvar e fechar o arquivo. Feito!

Miniature tutorial vim (ou, como rebase com apenas 8 teclas digitadas 3j cw r Esc ZZ ) :

Executar 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 lances bem conseguidos 3 linhas
i para entrar modo de inserção - texto digitado aparecerá no arquivo
Esc ou Ctrl c para sair modo de inserção e voltar 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 ( "puxão") uma linha, palavra ou letra, respectivamente
p ou P para colar após, ou antes de posição actual, respectivamente
:w Enter para salvar (gravar) um arquivo
:q! Enter para sair sem salvar
:wq Enter ou ZZ para salvar e sair

Se você editar texto muito, então mudar para o layout de teclado Dvorak, aprender a tocar tipo, e aprender vim. Valerá a pena o esforço? Sim.

Protip ™: Não tenha medo de experimentar com os comandos "perigosos" que a história reescrita * - Git não exclui os commits durante 90 dias por padrão; você pode encontrá-los no reflog:

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

* Cuidado com as opções como --hard e --force embora -. Eles podem descartar dados
* Além disso, não reescrever a história em todos os ramos que você está colaborando em.

Eu uso o Git GUI tanto quanto eu puder, e que lhe dá a opção de alterar o último commit:

Tick que a caixa

Além disso, git rebase -i origin/masteris um mantra agradável que sempre irá apresentar-lhe os commits que você tem feito em cima do mestre, e dar-lhe a opção de alterar, apagar, reordenar ou squash. Não há necessidade de se apossar do que de hash em primeiro lugar.

Uau, então há uma série de maneiras de fazer isso.

No entanto, outra maneira de fazer isso é excluir o último commit, mas manter suas alterações para que você não vai perder o seu trabalho. Você pode então fazer outra comprometer com a mensagem corrigida. Isso seria algo parecido com isto:

git reset --soft HEAD~1
git commit -m 'New and corrected commit message'

Eu sempre fazer isso se eu esquecer de adicionar um arquivo ou fazer uma mudança.

Lembre-se para especificar --soft vez de --hard, senão você perde que cometem inteiramente.

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

SourceTree rebase interativo ??

Para commits que ainda não foram empurrados para um controle remoto:

Certifique-se de que você tenha cometido ou escondido todas as mudanças atuais (ou seja, para que não haja arquivos listados na guia "Arquivo Status") -. Não vai funcionar de outra forma
Na guia "Log / História", clique direito sobre a entrada com uma linha adjacente no gráfico abaixo o commit (s) que deseja editar e selecione "crianças REBASE de interativamente ... "
Selecione a linha inteira para uma mensagem de confirmação que você deseja mudar ( i. Clicar na coluna "Mensagem" ).
Clique no botão "Editar".
Editar a mensagem como desejado na caixa de diálogo que aparece e clique em OK.
Repita os passos 3-4 se não houver outra cometer mensagens para mudança.
Clique em OK: Rebasing começará. Se tudo estiver bem, a saída vai acabar "concluída com êxito". NOTA: Eu vi recentemente que falhar com Unable to create 'project_path/.git/index.lock': File exists. ao tentar modificar vários cometer mensagens ao mesmo tempo. Não tenho certeza exatamente qual é o problema, ou se ele será corrigido em uma versão futura do SourceTree mas se isso acontecer recomendaria rebasing-los um de cada vez (mais lento, mas parece mais confiável).

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

Siga as etapas no esta resposta , que são semelhantes às acima, mas exigir uma nova comando a ser executado a partir do comando linha de força de empurrar o ramo - leia tudo e aplicar a cautela necessária

Se você quiser apenas para editar a última cometer uso:

git commit --amend

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

Mas se você quiser editar várias submissões em uma linha você deve usar rebasing vez:

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

git rebase edição

Em um arquivo como o descrito acima gravação editar / e ou um dos outros opção e bateu salvar e sair.

Agora você vai estar no primeiro errado cometer. Fazer alterações nos arquivos, e eles vão ser automaticamente encenado para você. Tipo

git commit --amend

Save and Exit que e tipo

git rebase --continue

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

Note que essas coisas mudam todos os seus hashes SHA depois que determinado cometer.

Se você só quer mudar sua última mensagem que você deve usar o sinalizador --only ou seu -o atalho com commit --amend:

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

Isso garante que você não possa melhorar a sua comprometer com coisas encenado. É claro que é melhor ter uma configuração $EDITOR adequada. Depois, você pode deixar o -m opção, e git irá pré-preencher a mensagem de confirmação com o antigo. Desta forma, ele pode ser facilmente editadas.

Atualize seu último errado cometer mensagem com nova mensagem de commit em uma linha:

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

Ou, tente redefinir git 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 commits divididos em pequenos commits

git reset pode ajudá-lo a quebrar um commit em vários commits demasiado:

# 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 o seu último commit em duas commits.

Sobre esta questão, há uma série de respostas, mas nenhuma delas explica em detalhe super como alterar mais velho cometer mensagens usando VIM. Eu estava preso tentando fazer isso sozinho, então aqui eu vou escrever em detalhes como eu fiz este especialmente para pessoas que não têm experiência em VIM!

Eu queria mudar meus cinco últimos commits que eu já empurrado para o servidor. Isto é bastante causa 'perigoso' se alguém já puxou a partir desta você pode baralhar as coisas mudando as mensagens cometer. No entanto, quando você está trabalhando em seu próprio pequeno ramo e são certeza de que ninguém puxou-o você pode alterá-lo como este:

Vamos dizer que você quer mudar seus cinco últimos commits, então você digite isso no terminal:

git rebase -i HEAD~5 * Onde 5 é o número de mensagens de confirmação que você deseja alterar. (Por isso, se você deseja alterar os dias 10 e último commit você digita 10)

Este comando vai chegar em VIM lá você pode ‘editar’ o seu histórico de commits. Você vai ver os seus últimos 5 commits no topo como este:

pick <commit hash> commit message

Em vez de pick você precisa escrever reword. Você pode fazer isso no VIM, digitando i, que faz você ir para inserir-mode. (Você vê que você está no modo de inserção pela palavra INSERIR na parte inferior) Para os commits você deseja digitar mudança na reword vez de pick

Então você precisa para salvar e sair desta tela, você fazer isso indo primeiro para ‘modo de comando’, premindo o botão esc. (Você pode verificar se você está no modo de comando se o Word insira na parte inferior desapareceu) Então você pode digitar um comando por : digitação, o comando para salvar e sair é wq. Então, se você digitar :wq você está ont ele caminho certo.

Em seguida, VIM wil passar por cima de cada commit mensagem que pretende reformular, aqui você pode realmente mudar a mensagens de cometer. Você vai fazer isso indo em INSERIR-mode, mudando a mensagem de registro, entrar em modo de comando e salvar e sair. Faça isso 5 vezes e você está fora de VIM!

Então, se você já empurrou seus commits erradas, você precisa git push --force para substituí-los. Lembre-se que git push --force é uma coisa muito perigosa de se fazer, para se certificar de que ninguém puxou a partir do servidor desde que você empurrou seus commits erradas!

Agora você tiver alterado as cometem mensagens!

(Como você vê eu não sou tão experiente em VIM por isso, se eu usei errado 'linguagem' para explicar o que está acontecendo, sinta-se livre para me corrigir!)

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

$ vim ~/.gitconfig

[alias]

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

Você pode usar git-rebase-reformular

Ele é projetado para editar qualquer commit (não apenas passado) mesma forma que commit --amend

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

É nomeado após a ação na rebase interativo para alterar um commit: "reformular". Consulte este post e homem -section modo interativo -

Exemplos:

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

eu percebi que eu tinha empurrado um commit com um erro de digitação na mesma. A fim de desfazer, eu fiz o seguinte:

git commit --amend -m "T-1000, advanced prototype"
git push --force

Aviso: força empurrando as alterações irá substituir o ramo remoto com o seu um local. Certifique-se de que você não vai estar substituindo qualquer coisa que você deseja manter. Também ser cauteloso sobre força empurrando um alterada (reescrito) comprometer-se alguém ações então o ramo com você, porque eles vão precisar reescrever sua própria história, se eles têm a cópia antiga do commit que você acabou de reescrita.

Eu gosto de usar o seguinte:

git status
git add --all
git commit -am "message goes here about the change"
git pull <origin master>
git push <origin master>

Se você não empurrou o código para a sua filial remota ( GitHub / Bitbucket ) você pode mudar a mensagem de log na linha de comando como abaixo.

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

Se você está trabalhando em um ramo específico fazer isso:

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

Se você já empurrou o código com a mensagem errada, e você precisa ter cuidado ao alterar a mensagem. Ou seja, depois de alterar a mensagem de confirmação e tentar empurrá-lo novamente, você acabar com tendo problemas. Para torná-lo suave, siga estes passos.

Por favor, leia minha resposta inteira antes de fazê-lo.

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 impulso força diretamente você pode acabar com problemas de código que outros desenvolvedores estão trabalhando no mesmo ramo. Então, para evitar esses conflitos, você precisa puxar o código do seu ramo antes de fazer a empurrão força :

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

Esta é a melhor prática quando se muda a mensagem de commit, se ele já foi empurrado.

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow