Come posso eliminare le modifiche non messe in scena in Git?

Come posso eliminare le modifiche nella mia copia di lavoro che non sono nell'indice?

Un altro modo più veloce è:

git stash save --keep-index --include-untracked

Non è necessario includere --include-untrackedse non si desidera essere accurati al riguardo.

Dopodiché, puoi rilasciare quella scorta con un git stash dropcomando se vuoi.

Per tutti i file non gestiti nella directory di lavoro corrente utilizzare:

git checkout -- .

Per un file specifico utilizzare:

git checkout -- path/to/file/to/revert

--qui per rimuovere l' ambiguazione dell'argomento .

Sembra che la soluzione completa sia:

git clean -df
git checkout -- .

git cleanrimuove tutti i file non monitorati ( avviso : sebbene non elimini i file ignorati menzionati direttamente in .gitignore, può eliminare i file ignorati che risiedono nelle cartelle ) e git checkoutcancella tutte le modifiche non messe in scena.

Questo verifica l'indice corrente per la directory corrente, eliminando tutte le modifiche ai file dalla directory corrente verso il basso.

git checkout .

o questo che estrae tutti i file dall'indice, sovrascrivendo i file dell'albero di lavoro.

git checkout-index -a -f

git clean -df

Pulisce l'albero di lavoro rimuovendo in modo ricorsivo i file che non sono sotto il controllo della versione, a partire dalla directory corrente.

-d: Rimuove le directory non tracciate oltre ai file non tracciati

-f: Force (potrebbe non essere necessario in base clean.requireForceall'impostazione)

Corri git help cleanper vedere il manuale

Il mio preferito è

git checkout -p

Ciò ti consente di ripristinare selettivamente i blocchi.

Guarda anche:

git add -p

Poiché nessuna risposta suggerisce l'esatta combinazione di opzioni che utilizzo, eccola qui:

git clean -dfx
git checkout .

Questo è il testo della guida in linea per le git cleanopzioni utilizzate :

-d

Rimuovere le directory non tracciate oltre ai file non tracciati. Se una directory non tracciata è gestita da un diverso repository Git, non viene rimossa per impostazione predefinita. Utilizzare l' -fopzione due volte se si desidera veramente rimuovere tale directory.

-f

Se la variabile di configurazione Git clean.requireForcenon è impostata false, Git pulito si rifiuterà di eliminare i file o directory a meno che determinato -f, -no -i. Git rifiuterà di eliminare le directory all'interno della .gitsottodirectory o del file, a meno che non -fvenga fornito un secondo .

-x

Non utilizzare le regole di ignore da .gitignore(per directory) e $GIT_DIR/info/exclude, ma comunque utilizzare le regole di ignore fornite con le -eopzioni. Ciò consente di rimuovere tutti i file non tracciati, inclusi i prodotti di compilazione. Questo può essere usato (possibilmente in combinazione con git reset) per creare una directory di lavoro incontaminata per testare una build pulita.

Inoltre, git checkout .deve essere eseguito nella radice del repository.

Se si desidera semplicemente rimuovere le modifiche ai file esistenti , utilizzare checkout( documentato qui ).

git checkout -- .

• Non è stato specificato alcun ramo, quindi verifica il ramo corrente.
• Il doppio trattino ( --) dice a Git che ciò che segue dovrebbe essere preso come secondo argomento (percorso), che hai ignorato la specifica di un ramo.
• Il punto ( .) indica tutti i percorsi.

Se si desidera rimuovere i file aggiunti dall'ultimo commit, utilizzare clean( documentato qui ):

git clean -i 

• L' -iopzione avvia un interattivo clean, per evitare cancellazioni errate.
• Una manciata di altre opzioni sono disponibili per un'esecuzione più rapida; vedi la documentazione.

Se si desidera spostare le modifiche in uno spazio di attesa per un accesso successivo , utilizzare stash( documentato qui ):

git stash

• Tutte le modifiche verranno spostate in Git's Stash, per un possibile accesso successivo.
• Una manciata di opzioni sono disponibili per uno stashing più sfumato; vedi la documentazione.

Ho davvero trovato utile questo articolo per spiegare quando usare quale comando: http://www.szakmeister.net/blog/2011/oct/12/reverting-changes-git/

Ci sono un paio di casi diversi:

1. Se non hai messo in scena il file, allora lo usi git checkout. Acquista "aggiorna i file nella struttura di lavoro in modo che corrispondano alla versione nell'indice". Se i file non sono stati messi in scena (ovvero aggiunti all'indice) ... questo comando ripristinerà essenzialmente i file con l'ultimo commit.

   git checkout -- foo.txt

2. Se il file è stato messo in scena, utilizzare git reset. Ripristina cambia l'indice in modo che corrisponda a un commit.

   git reset -- foo.txt

Sospetto che l'utilizzo git stashsia una scelta popolare poiché è un po 'meno pericoloso. Puoi sempre tornare indietro se accidentalmente soffi troppo lontano quando usi git reset. Il ripristino è ricorsivo per impostazione predefinita.

Dai un'occhiata all'articolo sopra per ulteriori consigli.

Il modo più semplice per farlo è usando questo comando:

Questo comando viene utilizzato per annullare le modifiche nella directory di lavoro -

git checkout -- .

https://git-scm.com/docs/git-checkout

Nel comando git, lo stash di file non tracciati si ottiene usando:

git stash -u

http://git-scm.com/docs/git-stash

Se non sei interessato a mantenere le modifiche non messe in scena (specialmente se le modifiche messe in scena sono nuovi file), l'ho trovato utile:

git diff | git apply --reverse

git checkout -f

man git-checkout:

-f, --force

Quando si cambiano rami, procedere anche se l'indice o l'albero di lavoro differisce da HEAD. Viene utilizzato per eliminare le modifiche locali.

Quando si estraggono percorsi dall'indice, non fallire su voci non unite; invece, le voci non unite vengono ignorate.

Mentre digiti lo stato git, viene mostrato (usa "git checkout - ..." per scartare le modifiche nella directory di lavoro) .

per esempio git checkout -- .

Puoi usare git stash - se qualcosa va storto, puoi comunque tornare dalla scorta. Simile ad un'altra risposta qui, ma questa rimuove anche tutti i file non messi in scena e anche tutte le eliminazioni non messe in scena:

git add .
git stash

se controlli che tutto sia OK, getta via la scorta:

git stash drop

Anche la risposta di Bilal Maqsood git cleanha funzionato per me, ma con la scorta ho un maggiore controllo - se lo faccio accidentalmente, posso ancora ottenere le mie modifiche

AGGIORNARE

Penso che ci sia 1 altro cambiamento (non so perché questo ha funzionato per me prima):

git add . -A invece di git add .

senza i -Afile rimossi non verranno messi in scena

Aggiornamento 2019:

Dal luglio 2019 , v'è stato un nuovo comando, che fa esattamente questo: git restore.

In git status, ora Git consiglia di utilizzare questo comando anziché git checkoutcome una volta.

Mentre questo comando può anche essere utilizzato per ripristinare l'albero di lavoro su un commit specifico o per ripristinare il contenuto dell'indice, per impostazione predefinita, l'albero di lavoro viene ripristinato allo stato nell'indice (cosa viene richiesto qui).

Quindi, per ripristinare i file corrispondenti a un pathspec (eliminando le loro modifiche non messe in scena), dovresti:

git restore <pathspec>

Ad esempio, per ripristinare tutte le modifiche non messe in scena nella directory corrente, è possibile eseguire:

git restore .

Se lo esegui dalla radice del progetto, ripristinerà tutte le modifiche non messe in scena nell'intero repository.

Si noti che, come nel caso di git checkout -- .(come sottolineato da Mariusz Nowak), questo annullerà solo le modifiche ai file tracciati da Git e non eliminerà alcun nuovo file non tracciato. Se si desidera annullare eventuali modifiche non organizzate, inclusi i nuovi file non monitorati, è possibile eseguire un ulteriore:

git clean -df

Presta molta attenzione con questo comando successivo, poiché potresti scartare i file di cui non hai intenzione di sbarazzarti.

Nota su git restore: poiché si tratta di un nuovo comando, la sua pagina man fornisce un avviso:

Questo comando è sperimentale. Il comportamento potrebbe cambiare.

Quindi è possibile che questa risposta possa diventare obsoleta se il comportamento dovesse cambiare in futuro. Potrebbe quindi essere saggio eseguire un veloce man git-restoreprima di usarlo.

Invece di annullare le modifiche, ripristino l'origine del telecomando. Nota: questo metodo consente di ripristinare completamente la cartella in quella del repository.

Quindi faccio questo per assicurarmi che non siedano lì quando reimposta git (in seguito - esclude gitignores sul nome di origine / ramo)

NOTA: se si desidera mantenere i file non ancora tracciati, ma non in GITIGNORE, è possibile saltare questo passaggio, poiché verranno cancellati questi file non tracciati non trovati sul repository remoto (grazie @XtrmJosh).

git add --all

Quindi io

git fetch --all

Quindi ho ripristinato l'origine

git reset --hard origin/branchname

Ciò lo riporterà al punto di partenza. Proprio come ri-clonare il ramo, MENTRE mantenendo tutti i miei file gitignored localmente e sul posto.

Aggiornamento per commento utente di seguito: Variazione per reimpostare il ramo corrente su cui si trova l'utente.

git reset --hard @{u}

Ho provato tutte le soluzioni sopra ma ancora non riuscivo a liberarmi di nuovi file non messi in scena.

Utilizzare git clean -fper rimuovere quei nuovi file - con cautela però! Nota l'opzione forza.

dì semplicemente

git stash

Rimuoverà tutte le modifiche locali. Puoi anche usarlo in seguito dicendo

git stash apply 

o git stash pop

Usa solo:

git stash -u

Fatto. Facile.

Se ti interessa davvero il tuo stack, puoi seguirlo git stash drop. Ma a quel punto stai meglio usando (da Mariusz Nowak):

git checkout -- .
git clean -df

Tuttavia, mi piace git stash -uil meglio perché "elimina" tutte le modifiche tracciate e non tracciate in un solo comando . Eppure, git checkout -- .solo scarti rintracciato modifiche e git clean -dfcambiamenti solo scarti non monitorate ... e digitando entrambi i comandi è di gran lunga troppo lavoro :)

Per eseguire uno scarto permanente: git reset --hard

Per salvare le modifiche per dopo: git stash

Funziona anche in directory che lo sono; al di fuori delle normali autorizzazioni git.

sudo chmod -R 664 ./* && git checkout -- . && git clean -dfx

Mi è successo di recente

hai un comando git molto semplice git checkout .

cd path_to_project_folder  # take you to your project folder/working directory 
git checkout .             # removes all unstaged changes in working directory

Secondo me,

git clean -df

dovrebbe fare il trucco. Come da documentazione Git su git clean

git-clean - Rimuove i file non tracciati dall'albero di lavoro

Descrizione

Pulisce l'albero di lavoro rimuovendo in modo ricorsivo i file che non sono sotto il controllo della versione, a partire dalla directory corrente.

Normalmente, vengono rimossi solo i file sconosciuti a Git, ma se viene specificata l'opzione -x, vengono rimossi anche i file ignorati. Questo può, ad esempio, essere utile per rimuovere tutti i prodotti di compilazione.

Se vengono forniti argomenti facoltativi, vengono interessati solo quei percorsi.

Opzioni

-d Elimina le directory non tracciate oltre ai file non tracciati. Se una directory non tracciata è gestita da un diverso repository Git, non viene rimossa per impostazione predefinita. Utilizzare l'opzione -f due volte se si desidera veramente rimuovere tale directory.

-f --force Se la variabile di configurazione Git clean.requireForce non è impostata su false, git clean rifiuterà l'esecuzione a meno che non sia dato -f, -n o -i.

Indipendentemente dallo stato in cui si trova il tuo repository, puoi sempre ripristinare qualsiasi commit precedente:

git reset --hard <commit hash>

Ciò eliminerà tutte le modifiche apportate dopo tale commit.

Un altro modo per sbarazzarsi di nuovi file che è più specifico di git clean -df (ti consentirà di sbarazzarti di alcuni file non necessariamente tutti), è quello di aggiungere prima i nuovi file all'indice, quindi stash, quindi rilasciare il scorta.

Questa tecnica è utile quando, per qualche motivo, non è possibile eliminare facilmente tutti i file non monitorati da un meccanismo ordinario (come rm).

Quella che segue è davvero solo una soluzione se stai lavorando con un fork di un repository in cui ti sincronizzi regolarmente (ad es. Richiesta pull) con un altro repository. Risposta breve: elimina fork e refork, ma leggi gli avvisi su github .

Ho avuto un problema simile, forse non identico, e sono triste a dire che la mia soluzione non è l'ideale, ma alla fine è efficace.

Avrei spesso messaggi di stato git come questo (che coinvolgono almeno 2/4 file):

$ git status
# Not currently on any branch.
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       modified:   doc/PROJECT/MEDIUM/ATS-constraint/constraint_s2var.dats
#       modified:   doc/PROJECT/MEDIUM/ATS-constraint/parsing/parsing_s2var.dats
#
# Changes not staged for commit:
#   (use "git add <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#       modified:   doc/PROJECT/MEDIUM/ATS-constraint/constraint_s2Var.dats
#       modified:   doc/PROJECT/MEDIUM/ATS-constraint/parsing/parsing_s2Var.dats

Un occhio attento noterà che questi file hanno doppleganger che sono una singola lettera nel caso in cui siano spenti. In qualche modo, e non ho idea di cosa mi abbia portato in questo percorso per iniziare (dato che non stavo lavorando con questi file dal repository upstream), avevo cambiato questi file. Prova le molte soluzioni elencate in questa pagina (e in altre pagine) non sembra essere d'aiuto.

Sono stato in grado di risolvere il problema eliminando il mio repository biforcuto e tutti i repository locali e ripristinando. Questo da solo non era abbastanza; upstream ha dovuto rinominare i file in questione con nuovi nomi di file. Fintanto che non hai alcun lavoro senza impegno, nessun wiki e nessun problema che diverge dal repository a monte, dovresti andare bene. A monte potrebbe non essere molto felice con te, per non dire altro. Per quanto riguarda il mio problema, è senza dubbio un errore dell'utente in quanto non sono così abile con Git, ma il fatto che sia tutt'altro che facile risolvere punti su un problema con Git.

Quando vuoi trasferire una scorta a qualcun altro:

# add files
git add .  
# diff all the changes to a file
git diff --staged > ~/mijn-fix.diff
# remove local changes 
git reset && git checkout .
# (later you can re-apply the diff:)
git apply ~/mijn-fix.diff

[modifica] come commentato, è possibile nominare gli stash. Bene, usa questo se vuoi condividere la tua scorta;)

Potresti creare il tuo alias che descrive come farlo in modo descrittivo.

Uso l'alias successivo per annullare le modifiche.

Elimina le modifiche in un (elenco di) file nella struttura ad albero di lavoro

discard = checkout --

Quindi puoi usarlo come accanto per annullare tutte le modifiche:

discard .

O solo un file:

discard filename

Altrimenti, se vuoi annullare tutte le modifiche e anche i file non tracciati, utilizzo un mix di checkout e clean:

Pulisci ed elimina le modifiche e i file non tracciati nell'albero di lavoro

cleanout = !git clean -df && git checkout -- .

Quindi l'uso è semplice come il prossimo:

cleanout

Ora è disponibile nel prossimo repository Github che contiene molti alias:

• https://github.com/GitAlias/gitalias

Ho avuto una strana situazione in cui un file è sempre non messo in scena, questo mi aiuta a risolvere.

git rm .gitattributes
git add -A
git reset --hard