Commit apenas parte de um arquivo no Git

Question

Quando faço alterações em um arquivo no Git, como posso cometer apenas algumas das alterações?

Por exemplo, como eu poderia cometer apenas 15 linhas de 30 linhas que foram alteradas em um arquivo?

Answer 1

Você pode usar git add --patch <filename> (ou -p para o short), e git vai começar a quebrar o seu arquivo para que ele pensa que são sensatas "nacos" (partes do arquivo). Ele irá então pedir-lhe esta pergunta:

Stage this hunk [y,n,q,a,d,/,j,J,g,s,e,?]?

Aqui está uma descrição de cada opção:

• y encenar esse pedaço para o próximo commit
• n não encenar esse pedaço para o próximo commit
• q quit; não encenar este pedaço ou qualquer um dos pedaços restantes
• a encenar esse pedaço e todos os pedaços posteriores no arquivo
• d não encenar este pedaço ou qualquer um dos pedaços mais tarde no arquivo
• g selecione um pedaço de ir para
• / procurar um pedaço correspondente ao dado regex
• j deixar este pedaço indecisos, veja o próximo pedaço indecisos
• J deixar este pedaço indecisos, veja o próximo pedaço
• k deixar este pedaço indecisos, consulte pedaço indecisos anterior
• K deixar este pedaço indecisos, consulte pedaço anterior
• s dividir o pedaço de corrente em pedaços menores
• e manualmente editar o galã atual
• ? imprimir ajuda pedaço

Se o arquivo não está no repositório ainda, você pode primeiro fazer git add -N <filename>. Depois disso, você pode ir em frente com git add -p <filename>.

Depois, você pode usar:

• git diff --staged para verificar se você encenou as alterações corretas
• git reset -p para unstage pedaços erroneamente acrescentado
• git commit -v para ver o seu cometer enquanto você editar a mensagem de confirmação.

Note que este é muito diferente do que o comando git format-patch, cujo objetivo é analisar comprometer dados em um arquivos .patch.

Referência para o futuro: Git Ferramentas - Staging Interativo

Answer 2

Você pode usar git add --interactive ou git add -p <file>, e depois git commit ( não git commit -a); veja Modo Interativo em git-adicionar manpage, ou simplesmente seguir instruções.

Modern GIT tem também git commit --interactive (e git commit --patch, que é atalho opção remendo em cometer interactiva a).

Se você preferir fazê-lo a partir de GUI, você pode usar git-gui . Você pode simplesmente marcar pedaços que você deseja ter incluído em cometer. Eu, pessoalmente, acho mais fácil do que usar git add -i. Outros GUIs git, como QGit ou gitx, também pode ter essa funcionalidade também.

Answer 3

git gui proporciona essa funcionalidade sob o ponto de vista dif. Basta clicar o botão direito na linha (s) que você está interessado e você deve ver uma "fase desta linha de cometer" item de menu.

Answer 4

Eu acredito que git add -e myfile é a maneira mais fácil (a minha preferência, pelo menos) uma vez que simplesmente abre um editor de texto e permite escolher qual linha você quer palco e qual linha você não. Em relação comandos de edição:

conteúdo adicionado:

conteúdo adicionado é representado por linhas que começam com "+". Você pode evitar encenar todas as linhas de adição de excluí-los.

conteúdo removido:

conteúdo removido é representado por linhas que começam com "-". Você pode evitar encenar a sua remoção através da conversão do "-". A um "" (espaço)

conteúdo modificado:

conteúdo modificado é representado por "-" linhas (removendo o conteúdo antigo), seguida por linhas de "+" (adicionando o conteúdo de substituição). Você pode evitar encenar a modificação através da conversão "-" linhas "", e remoção de "+" linhas. Tenha em atenção que modificando-se apenas a metade do par é susceptível de introduzir confundindo alterações no índice.

Todos os detalhes sobre git add estão disponíveis no git --help add

Answer 5

Se você estiver usando o vim, você pode querer experimentar o excelente plugin chamado fugitivo .

Você pode ver o diff de um arquivo entre cópia de trabalho e índice com :Gdiff, e depois adicionar linhas ou blocos sobre o índice usando comandos clássicos vim diff como dp. Guardar as modificações no índice e se comprometer com :Gcommit, e você está feito.

Muito bom screencasts introdutórios aqui (ver esp. parte 2 ).

Answer 6

Eu recomendaria fortemente usando SourceTree da Atlassian. (É grátis.) Ele faz isso trivial. Você pode organizar pedaços individuais de código ou linhas individuais de código de forma rápida e facilmente.

Answer 7

Vale notar que a utilização git add --patch para um novo arquivo você precisa primeiro adicionar o arquivo de índice com git add --intent-to-add:

git add -N file
git add -p file

Answer 8

Quando eu tenho um monte de mudanças, e vai acabar criando alguns commits das mudanças, então eu quero salvar meu ponto de partida temporariamente, antes de encenar as coisas.

Como esta:

$ git stash -u
Saved working directory and index state WIP on master: 47a1413 ...
$ git checkout -p stash
... step through patch hunks
$ git commit -m "message for 1st commit"
$ git checkout -p stash
... step through patch hunks
$ git commit -m "message for 2nd commit"
$ git stash pop

A resposta de Whymarrh é o que eu costumo fazer, exceto às vezes há muitas mudanças e eu posso dizer que eu poderia cometer um erro ao encenar as coisas, e eu quero um estado comprometido posso voltar a cair para uma segunda passagem.

Answer 9

Se você usa o emacs, dê uma olhada magit , que fornece uma interface git para o Emacs. Ele suporta encenar Hunks (partes de arquivos) muito bem.

Answer 10

IntelliJ IDEA (e eu acho que todos os outros produtos da série) tem suporte embutido para parcial commits desde v2018.1

Answer 11

Assim como a resposta de jdsumsion você também pode esconder o seu trabalho atual, mas, em seguida, usar um difftool como fusão de puxar alterações selecionadas a partir do esconderijo. Dessa forma, você pode até mesmo editar os blocos manualmente muito fácil, que é um pouco de dor quando em git add -p:

$ git stash -u
$ git difftool -d -t meld stash
$ git commit -a -m "some message"
$ git stash pop

Usando o método de estoque dá-lhe a oportunidade de teste, se o seu código ainda funciona, antes de cometê-lo.

Answer 12

Para aqueles que usam Git extensões :

Na janela Commit, selecione o arquivo que deseja comprometer parcialmente, em seguida, selecione o texto que você quer se comprometer no painel da direita, clique com o botão direito na seleção e escolha 'Stage linhas selecionadas' no menu de contexto.

Answer 13

vim-gitgutter plugin pode encenar pedaços sem deixar editor vim usando

:GitGutterStageHunk

Além disso, ele fornece outros recursos interessantes, como uma coluna de sinal diff como em alguns IDEs modernos

Se apenas parte pedaço deve ser encenado vim-fugitivo

:Gdiff

permite a selecção do alcance visual, em seguida, :'<,'>diffput ou :'<,'>diffget a fase / reversão mudanças de linha individuais.

Answer 14

Tentou-git add -p filename.x, mas em um Mac, eu achei gitx ( http://gitx.frim.nl/ ou https://github.com/pieter/gitx ) ser muito mais fácil para cometer exactamente o linhas que eu queria.

Answer 15

Com TortoiseGit:

clique direito sobre o Context Menu → Restore after commit processo e utilização. Isto irá criar uma cópia do arquivo como ele é. Em seguida, você pode editar o arquivo, por exemplo, em TortoiseGitMerge e desfazer todas as mudanças que você não quer se comprometer. Depois de salvar as alterações que você pode cometer o arquivo.

Answer 16

Adicionando em uma resposta anterior, se você preferir usar a linha de comando, entrando git add -e myfile dá-lhe a opção de escolher linha por linha o que você quer se comprometer, porque este comando irá abrir um editor com as diferenças, assim:

Como você pode linhas conhecidas que começam com + são addtions, linhas que começam com - são exclusões. Assim:

• Para não encenar uma adição simplesmente apagar essa linha.
• Para não encenar uma eliminação apenas substituir - com espaço.

Isto é o que git add -h diz sobre como adicionar arquivos desta forma (arquivos patching):

conteúdo adicionado conteúdo adicionado é representado por linhas que começam com "+". Você pode Prevenir encenar todas as linhas de adição de excluí-los.

conteúdo removido: conteúdo removido é representado por linhas que começam com "-". Você pode Prevenir encenar a sua remoção através da conversão do "-" para um "" (Espaço).

conteúdo modificado: conteúdo modificado é representado por "-" linhas (de remover o antigo teor) seguido por linhas "+" (adicionando o conteúdo de substituição). Você pode evitar encenar a modificação através da conversão "-" linhas para "", e removendo "+" linhas. Tenha em atenção que modificando-se apenas a metade da par é susceptível de introduzir confundindo alterações ao índice.

Atenção: não altere o conteúdo do arquivo, este não é um bom lugar para fazê-lo. Basta alterar os operadores de linhas excluídas ou adicionadas.

Answer 17

Para Atom usuários, o pacote github inclui encenação interativa, no estilo de git gui. Para que os atalhos ver do pacote documentação .

Usando o Atom permite trabalhar com um tema que tem fundo escuro (por padrão, git gui tem um fundo branco).

Answer 18

Tem sido 10 anos desde que esta pergunta foi perguntado. E espero que esta resposta será útil para alguém. Como mencionado na resposta aqui , onde GUI não é uma opção, de Andrew Shadura extensão crecord ajuda a trazer uma janela ncurses em que podemos selecionar as linhas a cometer.

Defina a extensão da seguinte forma:

git clone https://github.com/andrewshadura/git-crecord
cd git-crecord
./setup.py install
ln -s $PWD/git-crecord ~/.local/bin/git-crecord

cd para o seu repositório git e invocá-lo da seguinte forma:

git crecord

Isso traria a interface ncurses que pode ser usado como mostrado abaixo. Pressionando as teclas a seguir na janela de ncurses vai fazer algumas ações:

f       hunk toggle fold (arrow keys can also be used)
space   toggle hunk selection
a       toggle commit or amend
c       confirm and open commit window

Screencast mostrando um uso de amostra

Answer 19

Para emacs há também gitsum

Answer 20

git-fusão-index - citando o site:

git-fusão-índice corridas fundir - ou qualquer outro difftool git (kdiff3, difuso, etc.) - para permitir a mudanças de estágio de forma interativa para o índice git (também conhecida como a área de teste git)

Este é semelhante à funcionalidade de -p add git e git add --interactive. Em alguns casos fusão é mais fácil / mais rápido de usar do que -p add git. Isso porque fusão permite, por exemplo, para:

• ver mais contexto
• ver diffs intra-line
• Editar com a mão e ver as atualizações diff 'ao vivo' (atualizado depois de cada tecla pressionada)
• Navegue para uma mudança sem dizer 'n' a cada mudança que você quer pular

Uso

Em um repositório git, execute:

git meld-index

Você verá fusão (ou o seu configurado git difftool) aparecer com:

esquerdo : arquivos do diretório contining temporários copiados de sua árvore de trabalho

DIREITO : Diretório temporário com o conteúdo do índice. Isso também inclui arquivos que ainda não estão no índice, mas são modificados ou untracked na cópia de trabalho -. Neste caso você verá o conteúdo do arquivo a partir da HEAD

Edit (lado direito) o índice até feliz. Lembre-se de salvar quando necessário.

Quando estiver pronto, perto MELD, e git-fusão-index irá atualizar o índice para coincidir com o conteúdo do diretório temporário no lado direito da fusão que você acabou de editar.

Answer 21

Como um resposta acima mostra, você pode usar git add --patch filename.txt

ou a forma curta git add -p filename.txt

... mas para arquivos já em você repositório, existe, em s são muito melhor fora de usar a bandeira --patch no comando comprometer diretamente (se você estiver usando uma versão recente bastante de git): git commit --patch filename.txt

... ou, mais uma vez, o Short-Form git commit -p filename.txt

... e, em seguida, usando as teclas mencionadas, (y / n etc), para a escolha de linhas a serem incluídas no cometer.

Answer 22

Se é na plataforma Windows, na minha opinião git gui é muito boa ferramenta para stage / commit algumas linhas a partir do arquivo unstaged

1. Hunk sábio:

• Selecione o arquivo da seção unstagged Changes
• Clique pedaço Direito de código que precisa ser encenado
• Selecionar Stage Hunk for commit

2. Linha sábio:

• Selecione o arquivo da seção unstagged Changes
• Selecione a linha / linhas a ser encenado
• Botão direito do mouse e selecione Stage Lines for commit

3. Se você quiser organizar o arquivo completo, exceto par de linhas:

• Selecione o arquivo da seção unstagged Changes
• Pressione Ctrl+T (Stage file to commit)
• arquivo agora se desloca para a Seção Staged Changes selecionado
• Selecione a linha / linhas de ser encenado
• Botão direito do mouse e selecione UnStage Lines for commit

Answer 23

git-cola é uma ótima GUI e também tem esse recurso embutido. Basta selecionar as linhas ao palco e pressione S . Se nenhuma seleção for feita, o galã completa é encenado.