Commit solo una parte di un file in Git

Question

Quando faccio modifiche a un file in Git, come posso commettere solo alcune delle modifiche?

Per esempio, come potrei commettere solo 15 linee su 30 linee che sono stati modificati in un file?

Answer 1

È possibile utilizzare git add --patch <filename> (o -p in breve), e git inizierà ad abbattere il file in quello che pensa siano sensibili "Hunk" (parti del file). Sarà quindi si chiederà con questa domanda:

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

Ecco una descrizione di ciascuna opzione:

• y fase questo pezzo per il prossimo commit
• n non mettere in scena questo pezzo per il prossimo commit
• q quit; non mettere in scena questo pezzo o uno qualsiasi dei rimanenti fusti
• a in scena questo pezzo e tutti Hunk successive nel file
• d non mettere in scena questo pezzo o una qualsiasi delle hunk più avanti nel file
• g selezionare un pezzo di andare a
• / cercare un pezzo corrispondente al dato regex
• j lasciare questo pezzo indeciso, vedi pezzo successivo indecisi
• J lasciare questo pezzo indeciso, vedi il prossimo pezzo
• k lasciare questo pezzo indeciso, vedi precedente pezzo indecisi
• K lasciare questo pezzo indeciso, vedi pezzo precedente
• s dividere il pezzo corrente in blocchi più piccoli
• e modificare manualmente il pezzo corrente
• ? stampa pezzo help

Se il file non è nel repository, puoi prima fare git add -N <filename>. Poi si può andare avanti con git add -p <filename>.

In seguito, è possibile utilizzare:

• git diff --staged per verificare che si messo in scena le modifiche corrette
• git reset -p a unstage Hunk erroneamente aggiunto
• git commit -v per visualizzare l'commettere mentre si modifica il messaggio di commit.

Nota: questo è molto diverso da quello del comando git format-patch, il cui scopo è di analizzare commettere i dati in un file .patch.

Riferimento per i futuri: Git Strumenti - messa in scena interattiva

Answer 2

È possibile utilizzare git add --interactive o git add -p <file>, e quindi git commit ( non git commit -a); vedi modalità interattiva git-add pagina di manuale, o semplicemente seguire istruzioni.

Moderno Git ha anche git commit --interactive (e git commit --patch, che è scorciatoia per rattoppare opzione interattivo commit).

Se si preferisce farlo da GUI, è possibile utilizzare git-gui . Si può semplicemente marcare pezzi quali si desidera avere incluso nel commettere. Personalmente trovo più facile che usare git add -i. Altre interfacce grafiche git, come qgit o GitX, potrebbe anche avere questa funzionalità pure.

Answer 3

git gui fornisce questa funzionalità sotto la vista diff. Basta fare clic destro sulla linea (s) che ti interessa e si dovrebbe vedere un "palcoscenico questa linea di commettere" voce di menu.

Answer 4

Credo che git add -e myfile è il modo più semplice (la mia preferenza almeno) dal momento che apre semplicemente un editor di testo e permette di scegliere quale linea si vuole mettere in scena e quale linea non lo fai. Per quanto riguarda i comandi di modifica:

contenuto aggiunto:

  

contenuto aggiunto è rappresentato da linee che iniziano con "+". È possibile impedire in scena tutte le linee da aggiungere cancellandoli.

contenuti rimossi:

  

Rimosso contenuto è rappresentato da linee che iniziano con "-". È possibile impedire in scena la loro rimozione dalla conversione del "-". Ad un "" (spazio)

contenuto modificato:

  

contenuto modificato è rappresentata da "-" linee (rimuovendo il vecchio contenuto), seguita da "+" linee (aggiungendo il contenuto di sostituzione). È possibile impedire in scena la modifica convertendo "-" linee a "", e la rimozione di "+"              Linee. Da notare che modificando solo metà della coppia possa introdurre modifiche confusi all'indice.

Ogni dettaglio circa git add sono disponibili su git --help add

Answer 5

Se si sta utilizzando vim, si consiglia di provare l'ottimo plugin chiamato latitante .

Si può vedere il diff di un file tra copia di lavoro e indice con :Gdiff, e quindi aggiungere linee o Hunk all'indice utilizzando classici comandi diff vim come dp. Salvare le modifiche nell'indice e impegnarsi con :Gcommit, e il gioco è fatto.

Molto buono screencast introduttivo qui (vedi spec. parte 2 ).

Answer 6

Vorrei raccomandare vivamente di utilizzare SourceTree da Atlassian. (È libero.) Fa questo banale. È possibile mettere in scena i singoli grossi pezzi di codice o singole righe di codice rapidamente e facilmente.

Answer 7

Da notare che per usare git add --patch per un nuovo file è necessario aggiungere prima il file indice con git add --intent-to-add:

git add -N file
git add -p file

Answer 8

Quando ho un sacco di cambiamenti, e finirà per creare un paio impegna dai cambiamenti, allora voglio salvare il mio punto di partenza temporaneamente prima messa in scena le cose.

In questo modo:

$ 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

La risposta di Whymarrh è quello che faccio di solito, tranne che a volte ci sono un sacco di cambiamenti e posso dire che potrei fare un errore durante la messa in scena le cose, e voglio uno stato impegnato posso ripiegare su per un secondo passaggio.

Answer 9

Se si utilizza Emacs, dare un'occhiata a Magit , che fornisce un'interfaccia git per Emacs. Supporta messa in scena fusti (parti di file) abbastanza bene.

Answer 10

IntelliJ IDEA (e credo che tutti gli altri prodotti della serie) ha un supporto incorporato per parziale impegna dal v2018.1

Answer 11

Un po 'come la risposta di jdsumsion è anche possibile riporre il vostro lavoro attuale, ma poi usare un difftool come fusione di tirare modifiche selezionate dalla scorta. In questo modo si può anche modificare il Hunk manualmente molto semplice, che è un po 'di dolore quando in git add -p:

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

Utilizzando il metodo scorta ti dà l'opportunità di testare, se il codice funziona ancora, prima di impegnarsi esso.

Answer 12

Per chi usa Estensioni Git :

Nella finestra Commit, selezionare il file che si vuole impegnare in parte, quindi selezionare il testo che si desidera impegnarsi nel riquadro di destra, quindi fare clic destro sulla selezione e scegliere 'stadio selezionato linee' dal menu contestuale.

Answer 13

vim-gitgutter plug può organizzare grossi pezzi senza lasciare l'editor vim usando

:GitGutterStageHunk

Oltre a questo, fornisce altre funzioni interessanti come una colonna diff segno come in alcuni IDE moderno

Se solo una parte del pezzo deve essere messo in scena vim-fuggitivo

:Gdiff

permette la selezione del campo visivo quindi :'<,'>diffput o :'<,'>diffget alla fase / ripristinare le singole modifiche riga.

Answer 14

Provato git add -p filename.x, ma su un Mac, ho trovato GitX ( http://gitx.frim.nl/ o https://github.com/pieter/gitx ) ad essere molto più facile commettere esattamente la linee ho voluto.

Answer 15

Con TortoiseGit:

  

tasto destro del mouse sul file e utilizzare Context Menu → Restore after commit. Questo creerà una copia del file così com'è. Quindi è possibile modificare il file, ad esempio, in TortoiseGitMerge e annullare tutte le modifiche non si vuole impegnare. Dopo aver salvato le modifiche si può commettere il file.

Answer 16

L'aggiunta di una risposta precedente, se si preferisce usare la linea di comando, entrando git add -e myfile vi dà la scelta di scegliere riga per riga ciò che si desidera impegnarsi perché questo comando si aprirà un editor con le differenze, in questo modo:

Come si può linee noti che iniziano con + sono addtions, le linee che iniziano con - sono eliminazioni. Quindi:

• non mettere in scena un'aggiunta basta cancellare quella linea.
• non mettere in scena una delezione basta sostituire - con spazio .

Questo è ciò che dice git add -h sull'aggiunta di file in questo modo (i file di patch):

  

ha aggiunto contenuti              il contenuto aggiunto è rappresentato da linee che iniziano con "+". Puoi              prevenire mettendo in scena tutte le linee da aggiungere cancellandoli.

     

contenuti rimossi:              Rimosso contenuto è rappresentato da linee che iniziano con "-". Puoi              evitare che in scena la loro rimozione dalla conversione del "-" ad un ""              (Spazio).

     

contenuto modificato:              contenuto modificato è rappresentata da "-" linee (la rimozione del vecchio              contenuto) seguito da "+" linee (aggiungendo il contenuto di sostituzione).              È possibile impedire in scena la modifica convertendo "-" linee a              "", e la rimozione di "+" linee. Attenzione che modificando solo la metà della              coppia è probabile di introdurre cambiamenti confusi per l'indice.

Attenzione: non cambiano il contenuto del file, questo non è un buon posto per farlo. Basta cambiare i gestori di linee cancellati o aggiunti.

Answer 17

Atom utenti , il pacchetto github comprende messa in scena interattiva, nello stile di git gui. Per i collegamenti vedere .

Utilizzando Atom permette di lavorare con un tema che ha sfondo scuro (per impostazione predefinita, git gui ha uno sfondo bianco).

Answer 18

E 'stato 10 anni da quando questa domanda è stato chiesto. E spero che questa risposta possa essere utile a qualcuno. Come accennato nella risposta qui , dove GUI non è un'opzione, di Andrew Shadura estensione crecord aiuta a portare una finestra ncurses in cui possiamo selezionare le linee di impegnarsi.

Impostare l'estensione come segue:

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

CD al repo git e invocare come segue:

git crecord

Questo porterebbe l'interfaccia ncurses che può essere utilizzato come illustrato di seguito. Premendo i seguenti tasti nella finestra ncurses farà determinate azioni:

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 che mostra un esempio dell'uso

Answer 19

Per emacs c'è anche gitsum

Answer 20

git-fusione-index - citando il sito web:

git-fusione-index corre fusione - o qualsiasi altro difftool git (KDiff3, diffusa, ecc.) - per consentire di mettere in scena in modo interattivo le modifiche al dell'indice git (noto anche come l'area di sosta git)

Questo è simile alla funzionalità di git add -p, e git add --interactive. In alcuni casi si fondono è più facile / più veloce da usare rispetto git add -p. Questo perché fusione consente, ad esempio, a:

• vedere di più di contesto
• vedi diff intra-linea
• modifica a mano e vedere 'dal vivo' gli aggiornamenti del diff (aggiornato dopo ogni pressione del tasto)
• passare a un cambiamento senza dire 'N' per ogni cambiamento che vuoi ignorare

Utilizzo

In un repository git, eseguire:

git meld-index

Vedrai fusione (o il vostro difftool git configurato) pop-up con:

SINISTRA : directory contining file temporanei copiati dal vostro albero di lavoro

e : directory temporanea con il contenuto dell'indice. Questo include anche i file che non sono ancora nell'indice, ma sono modificati o non tracciata nella copia di lavoro -. In questo caso si vedrà il contenuto del file da HEAD

Modifica l'indice (lato destro) fino felice. Ricordati di salvare in caso di necessità.

Quando hai finito, chiudere fusione, e git-fusione-indice aggiornare l'indice per abbinare il contenuto della directory temporanea sul lato destro della fusione che appena modificato.

Answer 21

una risposta spettacoli di cui sopra, è possibile utilizzare git add --patch filename.txt

o in forma abbreviata git add -p filename.txt

... ma per i file già in te repository, non v'è, in s sono molto meglio usare la bandiera --patch sul comando commit direttamente (se si utilizza una versione abbastanza recente di Git): git commit --patch filename.txt

... o, ancora, la forma abbreviata git commit -p filename.txt

... e poi con i tasti citati, (S / N, ecc), per la scelta di linee da includere nel commettere.

Answer 22

Se è su piattaforma Windows, a mio parere git gui è molto buono strumento per stage / commit poche righe da file unstaged

1. Hunk saggio:

• Selezionare il file dalla sezione unstagged Changes
• Fare clic destro pezzo di codice che deve essere messo in scena
• Seleziona Stage Hunk for commit

2. Linea saggio:

• Selezionare il file dalla sezione unstagged Changes
• Selezionare la riga / righe in scena
• Fare clic destro e selezionare Stage Lines for commit

3. Se si vuole mettere in scena il file completo eccetto paio di righe:

• Selezionare il file dalla sezione unstagged Changes
• Premere Ctrl+T (Stage file to commit)
• Il file selezionato si sposta ora a Staged Changes Sezione
• Selezionare la linea / linee in scena
• Fare clic destro e selezionare UnStage Lines for commit

Answer 23

git-cola è una grande interfaccia grafica e ha anche questa funzione built-in. Basta selezionare le linee di fase e premere S . Se non viene effettuata alcuna selezione, il pezzo completo è messa in scena.