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


8965

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?


22
A partire da Git v1.8.4, tutte le risposte sottostanti che utilizzano HEADo headpossono ora utilizzare @al posto di HEAD. Vedi questa risposta (ultima sezione) per sapere perché puoi farlo.

3
Ho fatto un po 'estiva che mostra tutti i modi di unstage un file: stackoverflow.com/questions/6919121/...
Daniel Alder

5
Perché non git checkout?
Erik Reppen,

13
@ErikReppen git checkoutnon rimuove le modifiche organizzate dall'indice di commit. Ripristina solo le modifiche non messe in scena all'ultima revisione impegnata - che tra l'altro non è nemmeno quello che voglio, voglio quelle modifiche, le voglio solo in un commit successivo.
paxos1977,

4
Se usi Eclipse, è semplice come deselezionare i file nella finestra di dialogo di commit
Hamzahfrq,

Risposte:


10372

È 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).


92
Naturalmente, questo non è un vero annullamento, perché se l'errore ha git addsovrascritto una versione precedente non messa in scena, non è possibile recuperarlo. Ho cercato di chiarire questo nella mia risposta di seguito.
leonbloy,

7
git reset HEAD *.extdove extsono i file dell'estensione data che si desidera annullare l'aggiunta. Per me era *.bmp&*.zip
boulder_ruby il

18
@Jonny, l'indice (noto anche come area di gestione temporanea) contiene tutti i file, non solo i file modificati. "Avvia la vita" (quando si esegue il checkout di un commit o si clona un repository) come una copia di tutti i file nel commit a cui punta HEAD. Quindi se rimuovi un file dall'indice ( git rm --cached) significa che stai preparando un commit che cancella quel file. git reset HEAD <filename>d'altra parte copierà il file da HEAD all'indice, in modo che il prossimo commit non mostrerà alcuna modifica apportata a quel file.
Wildcard

11
Ho appena scoperto che esiste un git reset -plike git add -p. Questo è bellissimo!
donquixote,

10
In realtà è possibile recuperare modifiche sovrascritte in precedenza ma non vincolate, ma non in modo intuitivo e non sicuro al 100% (almeno nessuna delle quali ho trovato): vai a .git / oggetti, cerca i file creati al momento in git addcui desideri ripristinare ( 61/3AF3...- > id oggetto 613AF3...), quindi git cat-file -p <object-id>(potrebbe valerne la pena recuperare diverse ore di lavoro ma anche una lezione da impegnare più spesso ...)
Peter Schneider,

2151

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).


15
Hah. Ho seguito lo stesso processo. Tranne che ho rinunciato e detto rm -rf .git, git initperché non mi fidavo git rm --cacheddi conservare la mia copia di lavoro. Dice un po 'di come Git sia ancora eccessivamente complesso in alcuni punti. git unstagedovrebbe essere solo un comando standard, non mi interessa se posso aggiungerlo come alias.
Adrian Macneil,

5
Per me git dicegit reset HEAD <File>...
drahnr,

16
git rm --cached <file> è in realtà la risposta corretta, se è l'importazione iniziale di <file> nel repository. Se stai cercando di annullare la modifica di un file, git reset è la risposta corretta. Le persone che affermano che questa risposta è sbagliata pensano a una domanda diversa.
Barry Kelly,

14
Funzionerà effettivamente, ma solo al primo commit, in cui il file non esisteva prima o in cui il git addcomando ha aggiunto nuovi file, ma non modifiche ai file esistenti.
naught101

4
va solo a dimostrare quanto sia git non intuitivo e contorto. invece di avere comandi "Annulla" paralleli, devi scoprire come annullarli. Come cercare di liberare la gamba in sabbia veloce, quindi bloccare il braccio, quindi bloccare l'altro braccio ... ogni comando dovrebbe essere eseguito tramite la GUI, con voci di menu a discesa per le opzioni ... Pensa a tutta l'interfaccia utente, abbiamo ottenuto guadagni di produttività, ma abbiamo questo casino di un'interfaccia a riga di comando retrò. Non è come se i programmi GUI di Git lo rendessero più intuitivo.
ahnbizcad,

532

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)

19
Il messaggio sarà diverso a seconda che il addfile ed fosse già stato tracciato (l' addunica ha salvato una nuova versione nella cache - qui mostrerà il tuo messaggio). Altrove, se il file non è stato precedentemente messo in scena, verrà visualizzatouse "git rm --cached <file>..." to unstage
leonbloy

Grande! L' git reset HEAD <file>unico è l'unico che funzionerà nel caso in cui si desideri annullare la messa in scena dell'eliminazione di un file
skerit

2
La mia versione 2.14.3 di git dice git reset HEADdi non mettere in scena.
SilverWolf - Ripristina Monica il

246

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 unstagegit 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

3
"si sposta"? Ciò indicherebbe che è passato dalla directory di lavoro. Non è così.
Thomas Weller,

4
Perché è ovvio?
Lenar Hoyt,

In realtà, git stageè l'alias di git add, che è il comando storico, sia su Git che su altri SCM. È stato aggiunto a dicembre 2008 con commit 11920d28da nel "repository git's git", se posso dire.
Obsidian,

1
Questo potrebbe non essere correlato, ma ho trovato la convalida del file prima ancora di aggiungerlo per essere un'idea utile, qualcosa come check-command nomefile &&git aggiungi nomefile, ho sostituito git con una g più corta nella mia macchina, e finora ha funzionato ok per me: github.com/dataf3l/g , non so se questo sarà utile a qualcuno, ma lo metterò qui nella speranza che risparmi il tempo di alcune persone.
Felipe Valdes,

167

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)


4
A rigor di termini c'è un modo per recuperare un file già in scena che è stato sostituito con git add. Come accennato, git add crea un oggetto git per quel file che diventerà un oggetto sciolto non solo quando si rimuove completamente il file, ma anche quando viene sovrascritto con nuovo contenuto. Ma non esiste alcun comando per ripristinarlo automaticamente. Invece il file deve essere identificato ed estratto manualmente o con strumenti scritti solo per questo caso (libgit2 lo consentirà). Ma questo pagherà solo se il file è molto importante e grande e non può essere ricostruito modificando la versione precedente.
Johannes Matokic,

2
Per correggermi: una volta trovato il file di oggetti sciolto (usare metadati come la data / ora di creazione) git cat-filepotrebbe essere usato per recuperare il suo contenuto.
Johannes Matokic,

2
Un altro modo per recuperare le modifiche che sono state messe in scena ma che non sono state sottoposte a commit e che sono state sovrascritte ad esempio da un altro git addè tramite un git fsck --unreachableelenco di tutti gli oggetti irraggiungibili, che è quindi possibile ispezionare da git show SHA-1_IDo git fsck --lost-foundche> Scriveranno oggetti penzolanti in .git/lost-found/commit/o .git/lost-found/other/, a seconda del tipo. Vedi anchegit fsck --help
iolsmit il

110

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 resetta il file HEAD


Immagine: "Il comando aggiunge ...""Il comando aggiunge ..." ( presente semplice, terza persona )
Peter Mortensen,

Immagine: vuoivuoi (qui non c'è bisogno di usare il gergo)
Peter Mortensen,

92
git rm --cached . -r

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


3
Non volevo annullare l'aggiunta di tutto, solo UN file specifico.
paxos1977,

3
Utile anche se non hai alcun commit precedente. In assenza di un precedente impegno, git reset HEAD <file>direbbefatal: Failed to resolve 'HEAD' as a valid ref.
Priya Ranjan Singh,

6
No, questo aggiunge una cancellazione di tutto nella directory corrente. Molto diverso dalle modifiche non in scena.
Mark Amery,

88

Correre

git gui

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


1
Sì, lo capisco. Volevo solo suggerire implicitamente che tu lo indichi nella tua risposta come "Puoi usare git-gui...." :)
Alexander Suraphel

1
Dice "git-gui: comando non trovato". Non sono sicuro che funzioni.
Parinda Rajapaksha,

Caspita, è molto semplice fare linee di comando che non hai capito. Questo è sicuramente consigliato per un principiante come me. Grazie per averlo scritto!
Irfandy Jip,

Grazie. Non volevo rischiare, quindi ho dovuto usare la GUI.
Sagar Khatri,

83

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>
    

1
Non riesco a capire la differenza di 'git reset head <file>' e 'git rm --cached <file>. Potresti spiegarlo?
Gesù

6
I file @jeswang sono o 'conosciuti' da git (le loro modifiche vengono monitorate.) oppure non sono 'versionati'. reset headannulla le tue attuali modifiche, ma il file è ancora monitorato da Git. rm --cachedelimina il file dal controllo delle versioni, quindi git non controlla più le modifiche (e rimuove anche eventuali modifiche indicizzate, comunicate a git dal precedente add), ma il file modificato verrà conservato nella copia di lavoro, ovvero nella cartella dei file sull'HDD.
sabato

3
La differenza è git reset HEAD <file>temporanea: il comando verrà applicato solo al prossimo commit, ma git rm --cached <file>verrà disattivato fino a quando non verrà aggiunto nuovamente git add <file>. Inoltre, git rm --cached <file>significa che se si spinge quel ramo sul telecomando, chiunque tiri il ramo otterrà il file REALMENTE cancellato dalla propria cartella.
Estratto il

80

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

7
+1. Un numero straordinario di risposte e commenti altamente votati in questa pagina sono semplicemente sbagliati sul comportamento di git rm --cached somefile. Spero che questa risposta salga sulla pagina in una posizione di rilievo in cui possa proteggere i neofiti dall'inganno da tutte le false affermazioni.
Mark Amery,

una delle migliori risposte qui, purtroppo è abbastanza in basso nella lista
Creos

64

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


5
Un consiglio è quello di copiare il file .git / config se hai aggiunto origine remota, prima di eliminare la cartella.
Tiago,

4
Il commento di @ChrisJohnsen è perfetto. A volte, vuoi eseguire il commit di tutti i file tranne uno: git add -A && git rm --cached EXCLUDEFILE && git commit -m 'awesome commit' (Questo funziona anche quando non ci sono commit precedenti, ri Failed to resolve 'HEAD'problema)

57

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

45

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)
$

42

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

git help rm

9
Non rimuoverà del tutto il file?
Willa,

8
git rm --cached ...rimuoverà i file da un repository git. Esisteranno ancora sul tuo computer, ma questo è MOLTO diverso dalle modifiche non in scena di un file. Per chiunque inciampare su questo, non è una risposta valida alla domanda.
Addison,

38

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.

1
Confermato! Ho provato un reset git dopo un'aggiunta git. e git si lamentava di HEAD corrotto. Seguendo il tuo consiglio, potrei aggiungere e ripristinare avanti e indietro senza problemi :)
Kounavi,

1
La seconda parte funziona, ma è un po 'goffa. Come vengono gestite le terminazioni di riga, dipende dal autocrlfvalore ... Questo non funzionerà in tutti i progetti, a seconda delle impostazioni.
sabato

1
Questa risposta era ragionevole al momento della pubblicazione, ma ora è obsoleta; git reset somefileed git resetentrambi funzionano prima di effettuare il primo commit, ora. Questo è stato il caso da quando diverse versioni di Git sono tornate.
Mark Amery,

@MarkAmery, potresti avere ragione (sarebbe bello se tu avessi pubblicato una fonte per la tua affermazione), ma c'è ancora valore nell'avviare il tuo repository con un commit pulito o due.
Ryan Lundy,

34

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.


2
Certo, ma poi hai la domanda di seguito su come si dovrebbe annullare l'aggiunta di uno dei due (o più) file aggiunti. Il manuale "git reset" menziona che "git reset <paths>" è l'opposto di "git add <paths>", tuttavia.
Alex North-Keys,

34

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)


2
Ho provato git reset <path>e funziona benissimo senza un separatore. Sto anche usando git 1.9.0. Forse non funziona nelle versioni precedenti?

31

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.


4
Ricorda che qui --cachedè una parte davvero importante.
Takeshin,

1
-1; no, questo non annulla la messa in scena del file, ma mette in scena una cancellazione del file (senza eliminarlo effettivamente dall'albero di lavoro).
Mark Amery,

25

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

git reset *

4
In realtà, questo non reimposta tutti i file perché * utilizza l'espansione della shell e ignora i dotfile (e le dot-directory).
Luc,

Puoi correre git statusper vedere tutto ciò che rimane e ripristinarlo manualmente, ad es git reset file.
Zorayr,

25

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

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

eccetera.


3
Ricorda che * di solito non includerà dotfile o 'dot-directory' a meno che non specifichi esplicitamente .*o.*.prj
Luc

23

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


Come succede, c'è stato un ultimo commit ... ma stavo chiedendo in particolare di rimuovere un singolo file dal commit, non tutti i file dal commit.
paxos1977,

20

Supponiamo di creare un nuovo file newFile.txt,:

Inserisci qui la descrizione dell'immagine

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

Inserisci qui la descrizione dell'immagine

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

Inserisci qui la descrizione dell'immagine


Supponiamo che io sia alla prima immagine che significa che non ho nemmeno fatto "git.add". Inoltre, non voglio affatto tutto questo cambiamento. Voglio dire quando faccio lo stato git, non dovrebbe mostrare alcun file rosso. Voglio dire, dovrebbe essere sincronizzato come se non ci fosse un singolo file alterato dall'ultima git push. come raggiungerlo.
Infrangibile il

Quindi supponiamo che tu sia solo al primo passo. E vuoi sbarazzarti di tutte le modifiche che hai fatto che sta facendo diventare "newFile.txt" rosso.
Infrangibile il

Quando faccio lo stato git. Non dovrei vedere alcun cambiamento. Tutti i file rossi dovrebbero essere ripristinati.
Infrangibile il

Ciao, penso che la tua domanda sia come rimuovere i file non tracciati dall'albero corrente. Per questo, puoi usare "git clean -f -d". Ciò rimuoverà anche le directory non tracciate.
Vidura Mudalige,

Se non vuoi eliminare i file non tracciati, ignora semplicemente il flag "-f".
Vidura Mudalige,

19

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.


3
Spiegare la differenza tra git reset <file>e git checkout <file>.
Trento,

1
reset non modifica il file, basta metterlo via dallo stage (= indice, dove è stato messo da git add)
franc

checkout cambia i codici nel file e passa all'ultimo stato aggiornato. reset non modifica i codici ma reimposta l'intestazione. Ad esempio, reimpostare l'uso per il ripristino dei file aggiunti o impegnati prima del push e del checkout per tornare all'ultima fase aggiornata / impegnata prima di git add.
Hasib Kamal,

1
reset = rimuove il file dallo stage, tuttavia le modifiche saranno ancora presenti. checkout = ottiene il file aggiornato dal repository e sovrascrive il file corrente
Imam Bux,

14

Questo comando annullerà le modifiche:

git reset HEAD filename.txt

Puoi anche usare

git add -p 

per aggiungere parti di file.


14

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


"Sono sorpreso che nessuno menzioni la modalità interattiva" - hanno fatto: stackoverflow.com/a/10209776/1709587
Mark Amery,


10
git reset filename.txt

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


10

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.


9

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.


Sì, la stessa tecnica può essere utilizzata con TortoiseGit , ottenendo i comandi Git per i casi d'uso comuni.
Peter Mortensen,

8
git reset filename.txt  

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


git reset [nome file] es: git reset src / main / java / com / dao / ImportCsvDataDaoImpl.java
Rohit Chaurasiya
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.