Come annullare 'git add' prima di eseguire il commit?

Ho erroneamente aggiunto file a Git usando il comando:

git add myfile.txt

Non ho ancora corso git commit. C'è un modo per annullare ciò, quindi questi file non saranno inclusi nel commit?

È possibile annullare git addprima di impegnarsi con

git reset <file>

che lo rimuoverà dall'indice corrente (l'elenco "sta per essere impegnato") senza cambiare nient'altro.

Puoi usare

git reset

senza alcun nome di file per mettere in scena tutte le modifiche dovute. Questo può tornare utile quando ci sono troppi file per essere elencati uno per uno in un ragionevole lasso di tempo.

Nelle vecchie versioni di Git, i comandi precedenti sono equivalenti git reset HEAD <file>e git reset HEADrispettivamente, e falliranno se HEADnon sono definiti (perché non hai ancora effettuato alcun commit nel tuo repository) o ambigui (perché hai creato un ramo chiamato HEAD, che è una cosa stupida che non dovresti fare). Ciò è stato modificato in Git 1.8.2 , tuttavia, quindi nelle versioni moderne di Git è possibile utilizzare i comandi sopra anche prima di effettuare il primo commit:

"git reset" (senza opzioni o parametri) usato per errori quando non ci sono commit nella tua cronologia, ma ora ti dà un indice vuoto (per abbinare i commit inesistenti non sei nemmeno su).

Tu vuoi:

git rm --cached <added_file_to_undo>

Ragionamento:

Quando ero nuovo, ho provato per la prima volta

git reset .

(per annullare l'intera aggiunta iniziale), solo per ottenere questo (non così) messaggio utile:

fatal: Failed to resolve 'HEAD' as a valid ref.

Si scopre che ciò è dovuto al fatto che il riferimento HEAD (branch?) Non esiste fino a dopo il primo commit. Cioè, incontrerai lo stesso problema del mio principiante se il tuo flusso di lavoro, come il mio, fosse qualcosa del tipo:

1. cd nella mia fantastica nuova directory di progetto per provare Git, il nuovo hotness
2. git init
3. git add .

4. git status

   ... tante pergamene di ...

   => Accidenti, non volevo aggiungere tutto questo.

5. google "annulla aggiunta git"

   => trova Stack Overflow - yay

6. git reset .

   => fatale: impossibile risolvere "HEAD" come riferimento valido.

Si scopre inoltre che nella mailing list c'è un bug registrato contro la scarsità di ciò.

E che la soluzione corretta era proprio lì nell'output dello stato di Git (che, sì, ho lucidato come 'schifo)

...
# Changes to be committed:
#   (use "git rm --cached <file>..." to unstage)
...

E la soluzione è davvero da usare git rm --cached FILE.

Nota gli avvisi qui altrove: git rmelimina la copia di lavoro locale del file, ma non se si utilizza --cached . Ecco il risultato di git help rm:

--cached Utilizzare questa opzione per rimuovere la scena e rimuovere i percorsi solo dall'indice. I file dell'albero di lavoro, modificati o meno, verranno lasciati.

Procedo all'utilizzo

git rm --cached .

per rimuovere tutto e ricominciare. Non ha funzionato però, perché mentre add .è ricorsivo, risulta che rmbisogna -rricorrere. Sospiro.

git rm -r --cached .

Bene, ora sono tornato da dove ho iniziato. La prossima volta userò -nper fare una corsa a secco e vedere cosa verrà aggiunto:

git add -n .

Ho zippato tutto in un posto sicuro prima di fidarmi git help rmdel --cachednon distruggere nulla (e cosa succederebbe se lo scrivessi male).

Se digiti:

git status

Git ti dirà cosa viene messo in scena, ecc., Comprese le istruzioni su come rimuovere la scena:

use "git reset HEAD <file>..." to unstage

Trovo che Git faccia un buon lavoro spingendomi a fare la cosa giusta in situazioni come questa.

Nota: le versioni recenti di Git (1.8.4.x) hanno modificato questo messaggio:

(use "git rm --cached <file>..." to unstage)

Per chiarire: git addsposta le modifiche dalla directory di lavoro corrente all'area di gestione temporanea (indice).

Questo processo è chiamato stadiazione . Quindi il comando più naturale per mettere in scena le modifiche (file modificati) è quello ovvio:

git stage

git add è solo un alias più facile da digitare git stage

Peccato che non ci siano git unstagené git unaddcomandi. Quello rilevante è più difficile da indovinare o ricordare, ma è abbastanza ovvio:

git reset HEAD --

Possiamo facilmente creare un alias per questo:

git config --global alias.unadd 'reset HEAD --'
git config --global alias.unstage 'reset HEAD --'

E infine, abbiamo nuovi comandi:

git add file1
git stage file2
git unadd file2
git unstage file1

Personalmente uso alias anche più brevi:

git a # For staging
git u # For unstaging

Un'aggiunta alla risposta accettata, se il tuo file aggiunto per errore era enorme, probabilmente noterai che, anche dopo averlo rimosso dall'indice con ' git reset', sembra ancora occupare spazio nella .gitdirectory.

Questo non è nulla di cui preoccuparsi; il file è effettivamente ancora nel repository, ma solo come "oggetto sciolto". Non verrà copiato in altri repository (tramite clone, push) e lo spazio verrà infine recuperato, anche se forse non molto presto. Se sei ansioso, puoi eseguire:

git gc --prune=now

Aggiornamento (quello che segue è il mio tentativo di eliminare un po 'di confusione che può derivare dalle risposte più votate):

Quindi, qual è il vero annullamento di git add?

git reset HEAD <file> ?

o

git rm --cached <file>?

A rigor di termini, e se non sbaglio: nessuno .

git add non può essere annullato - sicuro, in generale.

Ricordiamo innanzitutto cosa git add <file>fa effettivamente:

1. Se non<file> è stato precedentemente monitorato , lo git add aggiunge alla cache , con il suo contenuto corrente.

2. Se <file>è già stato monitorato , git add salva il contenuto corrente (istantanea, versione) nella cache. In Git, questa azione è ancora chiamata add , (non semplice aggiornamento ), perché due diverse versioni (istantanee) di un file sono considerate come due elementi diversi: quindi, stiamo davvero aggiungendo un nuovo elemento nella cache, per essere infine commesso più tardi.

Alla luce di ciò, la domanda è leggermente ambigua:

Ho erroneamente aggiunto file usando il comando ...

Lo scenario dell'OP sembra essere il primo (file non tracciato), vogliamo che "annulla" rimuova il file (non solo il contenuto corrente) dagli elementi tracciati. Se questo è il caso, allora è ok per l'esecuzione git rm --cached <file>.

E potremmo anche correre git reset HEAD <file>. Questo è generalmente preferibile, perché funziona in entrambi gli scenari: fa anche l'annullamento quando abbiamo erroneamente aggiunto una versione di un elemento già tracciato.

Ma ci sono due avvertimenti.

Primo: esiste (come sottolineato nella risposta) un solo scenario in cui git reset HEADnon funziona, ma git rm --cachedfunziona: un nuovo repository (nessun commit). Ma, davvero, questo è un caso praticamente irrilevante.

Secondo: tenere presente che git reset HEAD non è possibile ripristinare magicamente il contenuto del file precedentemente memorizzato nella cache, ma lo risincronizza da HEAD. Se la nostra guida errata ha git addsovrascritto una versione non messa in scena precedente, non possiamo recuperarla. Ecco perché, a rigore, non possiamo annullare [*].

Esempio:

$ git init
$ echo "version 1" > file.txt
$ git add file.txt   # First add of file.txt
$ git commit -m 'first commit'
$ echo "version 2" > file.txt
$ git add  file.txt   # Stage (don't commit) "version 2" of file.txt
$ git diff --cached file.txt
-version 1
+version 2
$ echo "version 3" > file.txt
$ git diff  file.txt
-version 2
+version 3
$ git add  file.txt    # Oops we didn't mean this
$ git reset HEAD file.txt  # Undo?
$ git diff --cached file.txt  # No dif, of course. stage == HEAD
$ git diff file.txt   # We have irrevocably lost "version 2"
-version 1
+version 3

Naturalmente, questo non è molto critico se seguiamo il solito flusso di lavoro pigro di fare 'git add' solo per aggiungere nuovi file (caso 1) e aggiorniamo nuovi contenuti tramite il git commit -acomando commit .

^{* (Modifica: quanto sopra è praticamente corretto, ma possono esserci ancora alcuni modi leggermente hacker / contorti per recuperare le modifiche messe in scena, ma non impegnate e poi sovrascritte - vedi i commenti di Johannes Matokic e iolsmit)}

Annullare un file che è già stato aggiunto è abbastanza facile usando Git. Per il ripristino myfile.txt, che sono già stati aggiunti, utilizzare:

git reset HEAD myfile.txt

Spiegazione:

Dopo aver messo in scena i file indesiderati, per annullare, puoi farlo git reset. Headè il capo del tuo file in locale e l'ultimo parametro è il nome del tuo file.

Ho creato i passaggi nell'immagine seguente per maggiori dettagli, inclusi tutti i passaggi che possono verificarsi in questi casi:

git rm --cached . -r

"annulla" in modo ricorsivo tutto ciò che hai aggiunto dalla tua directory corrente

Correre

git gui

e rimuovere tutti i file manualmente o selezionandoli tutti e facendo clic sul pulsante Unstage dal commit .

Git ha i comandi per ogni azione immaginabile, ma ha bisogno di una conoscenza approfondita per ottenere le cose giuste e per questo è contro-intuitivo nella migliore delle ipotesi ...

Cosa hai fatto prima:

• Modificato un file e usato git add ., o git add <file>.

Ciò che vuoi:

• Rimuovi il file dall'indice, ma mantienilo aggiornato e lasciato con modifiche senza commit nella copia di lavoro:

  git reset head <file>
  

• Ripristina il file all'ultimo stato da HEAD, annullando le modifiche e rimuovendole dall'indice:

  # Think `svn revert <file>` IIRC.
  git reset HEAD <file>
  git checkout <file>
  
  # If you have a `<branch>` named like `<file>`, use:
  git checkout -- <file>

  Ciò è necessario poiché git reset --hard HEADnon funziona con file singoli.

• Rimuovi <file>dall'indice e dal controllo delle versioni, mantenendo il file non aggiornato con modifiche nella copia di lavoro:

  git rm --cached <file>
  

• Rimuovi <file>dalla copia di lavoro e dal controllo delle versioni completamente:

  git rm <file>
  

La domanda non è chiaramente posta. Il motivo è che git addha due significati:

1. aggiungendo un nuovo file all'area di gestione temporanea, quindi annullare con git rm --cached file.
2. aggiungendo un file modificato all'area di gestione temporanea, quindi annullare con git reset HEAD file.

In caso di dubbio, utilizzare

git reset HEAD file

Perché fa la cosa prevista in entrambi i casi.

Attenzione: se lo fai git rm --cached filesu un file che è stato modificato (un file che esisteva prima nel repository), il file verrà rimosso git commit! Esisterà ancora nel tuo file system, ma se qualcun altro tira il tuo commit, il file verrà eliminato dal suo albero di lavoro.

git statusti dirà se il file era un nuovo file o modificato :

On branch master
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

    new file:   my_new_file.txt
    modified:   my_modified_file.txt

Se stai eseguendo il commit iniziale e non puoi utilizzarlo git reset, dichiara semplicemente "Git bankruptcy", elimina la .gitcartella e ricomincia da capo

Come per molte altre risposte, puoi usare git reset

MA:

Ho trovato questo piccolo post che in realtà aggiunge il comando Git (beh, un alias) per git unadd: vedi git unadd per i dettagli o ..

Semplicemente,

git config --global alias.unadd "reset HEAD"

Ora puoi

git unadd foo.txt bar.txt

Utilizzare git add -iper rimuovere i file appena aggiunti dal prossimo commit. Esempio:

Aggiunta del file non desiderato:

$ git add foo
$ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       new file:   foo
#
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
# [...]#

Passare all'aggiunta interattiva per annullare l'aggiunta (i comandi digitati in git qui sono "r" (ripristina), "1" (la prima voce dell'elenco mostra ripristina), "return" per uscire dalla modalità di ripristino e "q" (smettere):

$ git add -i
           staged     unstaged path
  1:        +1/-0      nothing foo

*** Commands ***
  1: [s]tatus     2: [u]pdate     3: [r]evert     4: [a]dd untracked
  5: [p]atch      6: [d]iff       7: [q]uit       8: [h]elp
What now> r
           staged     unstaged path
  1:        +1/-0      nothing [f]oo
Revert>> 1
           staged     unstaged path
* 1:        +1/-0      nothing [f]oo
Revert>> 
note: foo is untracked now.
reverted one path

*** Commands ***
  1: [s]tatus     2: [u]pdate     3: [r]evert     4: [a]dd untracked
  5: [p]atch      6: [d]iff       7: [q]uit       8: [h]elp
What now> q
Bye.
$

Questo è tutto! Ecco la tua prova, dimostrando che "pippo" è tornato nell'elenco non tracciato:

$ git status
# On branch master
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
# [...]
#       foo
nothing added to commit but untracked files present (use "git add" to track)
$

git removeo git rmpuò essere usato per questo, con la --cachedbandiera. Provare:

git help rm

Ecco un modo per evitare questo fastidioso problema quando si avvia un nuovo progetto:

• Crea la directory principale per il tuo nuovo progetto.
• Corri git init.
• Ora crea un file .gitignore (anche se è vuoto).
• Salva il tuo file .gitignore.

Git rende davvero difficile farlo git resetse non hai alcun commit. Se crei un piccolo commit iniziale solo per il gusto di averne uno, puoi farlo git add -Ae git resettutte le volte che vuoi per ottenere tutto nel modo giusto.

Un altro vantaggio di questo metodo è che se si verificano problemi di fine riga in seguito e è necessario aggiornare tutti i file, è facile:

• Dai un'occhiata a quel commit iniziale. Questo rimuoverà tutti i tuoi file.
• Quindi controlla nuovamente il commit più recente. Questo recupererà nuove copie dei tuoi file, usando le tue attuali impostazioni di fine riga.

Forse Git si è evoluto da quando hai pubblicato la tua domanda.

$> git --version
git version 1.6.2.1

Ora puoi provare:

git reset HEAD .

Questo dovrebbe essere quello che stai cercando.

Se non si riesce a specificare una revisione, è necessario includere un separatore. Esempio dalla mia console:

git reset <path_to_file>
fatal: ambiguous argument '<path_to_file>': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions

git reset -- <path_to_file>
Unstaged changes after reset:
M    <path_to_file>

(Versione Git 1.7.5.4)

Per rimuovere nuovi file dall'area di gestione temporanea (e solo nel caso di un nuovo file), come suggerito sopra:

git rm --cached FILE

Usa rm --cached solo per i nuovi file aggiunti accidentalmente.

Per ripristinare tutti i file in una determinata cartella (e le sue sottocartelle), è possibile utilizzare il comando seguente:

git reset *

Utilizzare il *comando per gestire più file alla volta:

git reset HEAD *.prj
git reset HEAD *.bmp
git reset HEAD *gdb*

eccetera.

Basta digitare git resettornerà indietro ed è come se non avessi mai digitato git add .dal tuo ultimo commit. Assicurati di esserti impegnato prima.

Supponiamo di creare un nuovo file newFile.txt,:

Supponiamo di aggiungere il file per sbaglio git add newFile.txt:

Ora voglio annullare questa aggiunta, prima di eseguire il commit git reset newFile.txt:

Per un file specifico:

• git ripristina my_file.txt
• git checkout my_file.txt

Per tutti i file aggiunti:

• git reset.
• git checkout.

Nota: il checkout modifica il codice nei file e passa all'ultimo stato (commit) aggiornato. reset non modifica i codici; ripristina semplicemente l'intestazione.

Questo comando annullerà le modifiche:

git reset HEAD filename.txt

Puoi anche usare

git add -p 

per aggiungere parti di file.

C'è anche la modalità interattiva:

git add -i

Scegli l'opzione 3 per annullare l'aggiunta dei file. Nel mio caso desidero spesso aggiungere più di un file e con la modalità interattiva è possibile utilizzare numeri come questo per aggiungere file. Ci vorranno tutti tranne 4: 1, 2, 3 e 5

Per scegliere una sequenza, digita 1-5 per prendere tutto da 1 a 5.

Git file di gestione temporanea

Per annullare git add, utilizzare:

git reset filename

git reset filename.txt

Rimuoverà un file chiamato nomefile.txt dall'indice corrente, l'area "sta per essere impegnato", senza cambiare nient'altro.

git add myfile.txt # Questo aggiungerà il tuo file nell'elenco da impegnare

Al contrario di questo comando è,

git reset HEAD myfile.txt  # This will undo it.

quindi, sarai nello stato precedente. Specificato sarà di nuovo nell'elenco non tracciato (stato precedente).

Resetterà la tua testa con quel file specificato. quindi, se la tua testa non lo ha, significa semplicemente ripristinarlo.

In Sourcetree puoi farlo facilmente tramite la GUI. Puoi controllare quale comando utilizza Sourcetree per annullare la messa in scena di un file.

Ho creato un nuovo file e l'ho aggiunto a Git. Quindi l'ho messo in scena utilizzando la GUI di Sourcetree. Questo è il risultato:

File non di scena [08/12/15 10:43] git -c diff.mnemonicprefix = false -c core.quotepath = false -c credential.helper = sourcetree reset -q - percorso / to / file / nomefile.java

Sourcetree utilizza resetper annullare la messa in scena di nuovi file.

git reset filename.txt  

Rimuoverà un file chiamato nomefile.txt dall'indice corrente, l'area "sta per essere impegnato", senza cambiare nient'altro.