Come posso eliminare le modifiche non graduali in Git?

https://stackoverflow.com/questions/52704

09-06-2019
|

Domanda

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

Soluzione

Un altro modo più rapido è:

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

Non è necessario includere --include-untracked se non vuoi essere approfondito.

Dopodiché, puoi rilasciare quella scorta con a git stash drop comanda se vuoi.

Altri suggerimenti

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

git checkout -- .

Per un utilizzo di file specifico:

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

-- qui per rimuovere ambigua argomentazione.

Sembra che la soluzione completa sia:

git clean -df
git checkout -- .

git clean rimuove tutti i file non tracciati (avvertimento:mentre non eliminerà i file ignorati menzionati direttamente in .gitignore, potrebbe eliminare i file ignorati che risiedono nelle cartelle) E git checkout cancella tutte le modifiche non graduali.

Questo controlla l'indice corrente per la directory corrente, eliminando tutte le modifiche nei 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 ricorsivamente i file che non sono sotto il controllo della versione, a partire dalla directory corrente.

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

-f:Forza (potrebbe non essere necessaria a seconda clean.requireForce collocamento)

Correre git help clean per 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 l'usato git clean opzioni:

-d

Rimuovi le directory non tracciate oltre ai file non tracciati.Se una directory non tracciata è gestita da un repository Git diverso, non viene rimossa per impostazione predefinita.Utilizzo -f opzione due volte se vuoi davvero rimuovere tale directory.

-f

Se la variabile di configurazione Git clean.requireForce non è impostato su false, Git clean rifiuterà di eliminare file o directory se non specificato -f, -n, O -i.Git si rifiuterà di eliminare le directory all'interno del file .git sottodirectory o file, a meno che un secondo -f viene data.

-x

Non utilizzare le regole di ignora da .gitignore (per directory) e $GIT_DIR/info/exclude, ma utilizza comunque le regole di ignoranza fornite con -e opzioni.Ciò consente di rimuovere tutti i file non tracciati, inclusi i prodotti di build.Questo può essere utilizzato (possibilmente insieme a git reset) per creare una directory di lavoro incontaminata per testare una build pulita.

Anche, git checkout . deve essere fatto nella radice del repository.

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

Ci sono un paio di casi diversi:

Se non hai messo in scena il file, allora usi git checkout.Checkout "aggiorna i file nell'albero di lavoro in modo che corrispondano alla versione nell'indice".Se i file non sono stati messi in stage (ovvero aggiunti all'indice)...questo comando ripristinerà essenzialmente i file al tuo ultimo commit.

git checkout -- foo.txt
Se hai messo in stage il file, usa git reset.Reset modifica l'indice in modo che corrisponda a un commit.

git reset -- foo.txt

Sospetto che l'utilizzo git stash è una scelta popolare poiché è un po' meno pericolosa.Puoi sempre tornarci se accidentalmente ne soffi via troppo quando usi git reset.Il ripristino è ricorsivo per impostazione predefinita.

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

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

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

git checkout -- .

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

Nel comando git, lo stoccaggio dei file non tracciati viene ottenuto utilizzando:

git stash -u

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

Se semplicemente lo desideri per rimuovere le modifiche ai file esistenti, utilizzo checkout (documentato qui).

git checkout -- .

Non è specificato alcun ramo, quindi controlla il ramo corrente.
Il doppio trattino (--) dice a Git che quanto segue dovrebbe essere preso come secondo argomento (percorso), ovvero che hai saltato la specifica di un ramo.
Il periodo (.) indica tutti i percorsi.

Se vuoi per rimuovere i file aggiunti dal tuo ultimo commit, usa clean (documentato qui):

git clean -i

IL -i l'opzione avvia un interattivo clean, per evitare cancellazioni errate.
Sono disponibili alcune altre opzioni per un'esecuzione più rapida;vedere la documentazione.

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

git stash

Tutte le modifiche verranno spostate in Git's Stash, per un possibile accesso successivo.
Sono disponibili una manciata di opzioni per un deposito più sfumato;vedere la documentazione.

Se non sei interessato a mantenere le modifiche non graduali (soprattutto se le modifiche graduali sono nuovi file), ho trovato utile questo:

git diff | git apply --reverse

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

per esempio. git checkout -- .

git checkout -f

man git-checkout:

-f, --force

Quando si cambia ramo, procedere anche se l'indice o l'albero di lavoro è diverso da HEAD.Questo viene utilizzato per eliminare le modifiche locali.

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

Puoi usare git stash: se qualcosa va storto, puoi comunque ripristinare lo stash.Simile a qualche altra risposta qui, ma questa rimuove anche tutti i file non organizzati e anche tutte le eliminazioni non organizzate:

git add .
git stash

se controlli che sia tutto a posto, butta via la scorta:

git stash drop

La risposta di Bilal Maqsood con git clean ha funzionato anche per me, ma con la scorta ho più controllo: se faccio qualcosa per sbaglio, posso comunque ripristinare le modifiche apportate

AGGIORNAMENTO

Penso che ci sia un altro cambiamento (non so perché abbia funzionato per me prima):

git add . -A invece di git add .

senza il -A i file rimossi non verranno sottoposti a stage

Invece di scartare le modifiche, ho ripristinato il telecomando all'origine.Nota: questo metodo consiste nel ripristinare completamente la cartella in quella del repository.

Quindi lo faccio per assicurarmi che non si siedano lì quando eseguo git reset (più tardi - esclude gitignores su Origin/branchname)

NOTA:Se vuoi mantenere i file non ancora tracciati, ma non in GITIGNORE, potresti saltare questo passaggio, poiché cancellerà questi file non tracciati non trovati nel tuo repository remoto (grazie @XtrmJosh).

git add --all

Quindi io

git fetch --all

Quindi ho ripristinato l'origine

git reset --hard origin/branchname

Ciò riporterà tutto al punto di partenza.Proprio come clonare nuovamente il ramo, mantenendo tutti i miei file gitignorati localmente e al loro posto.

Aggiornato per commento utente qui sotto:Variazione per ripristinare il ramo corrente su cui si trova l'utente.

git reset --hard @{u}

Ho provato tutte le soluzioni di cui sopra ma non sono ancora riuscito a eliminare i file nuovi e non organizzati.

Utilizzo git clean -f per rimuovere quei nuovi file - con cautela però! Nota l'opzione di forzatura.

semplicemente dillo

git stash

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

git stash apply

o git stash pop

Basta usare:

git stash -u

Fatto.Facile.

Se tu Veramente prenditi cura della tua pila di scorte, quindi puoi seguirla git stash drop.Ma a quel punto è meglio usare (da Mariusz Nowak):

git checkout -- .
git clean -df

Tuttavia, mi piace git stash -u il migliore perché "scarta" tutte le modifiche tracciate e non tracciate in just un comando.Ancora git checkout -- . scarta solo i cambiamenti tracciati e git clean -df scarta solo le modifiche non tracciate...e digitare entrambi i comandi è lontano troppo lavoro :)

Funziona anche nelle directory che sono;al di fuori dei normali permessi git.

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

Mi è successo di recente

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

Non importa in quale stato 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 eliminare nuovi file che è più specifico di git clean -df (ti permetterà di eliminare alcuni file non necessariamente tutti), è aggiungere prima i nuovi file all'indice, quindi metterli nello spazio, quindi rilasciare il file scorta.

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

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 ricorsivamente i file che non sono sotto il controllo della versione, a partire dalla directory corrente.

Normalmente, solo i file sconosciuti a GIT vengono rimossi, 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 costruzione.

Se qualche facoltativo...Vengono forniti argomenti, solo quei percorsi sono interessati.

Opzioni

-d Rimuove le directory non tracciate oltre ai file non tracciati.Se una directory non rintracciata è gestita da un diverso repository Git, non viene rimossa per impostazione predefinita.Usa l'opzione -f due volte se vuoi davvero rimuovere una directory del genere.

-f - -forza Se la variabile di configurazione Git pulita. Requireforce non è impostato su falso, Git Clean si rifiuterà di eseguire a meno che non viene dato -f, -n o -i.

Ciò che segue è in realtà solo una soluzione se stai lavorando con un fork di un repository in cui sincronizzi regolarmente (ad es.pull request) con un altro repository.Risposta breve:elimina fork e refork, ma leggere gli avvisi su github.

Ho avuto un problema simile, forse non identico, e mi dispiace 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 dei doppleganger che sono una singola lettera maiuscola.In qualche modo, e non ho idea di cosa mi abbia portato su questo percorso per iniziare (poiché non stavo lavorando personalmente con questi file dal repository upstream), avevo cambiato questi file.Provare le numerose 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 biforcato e tutti i repository locali ed effettuando nuovamente il fork.Questo da solo non era sufficiente;a monte ha dovuto rinominare i file in questione con nuovi nomi di file. Finché non hai lavoro non impegnativo, wiki e problemi che divergono dal repository upstream, dovresti stare bene.Upstream potrebbe non essere molto contento di te, per usare un eufemismo.Per quanto riguarda il mio problema, si tratta senza dubbio di un errore dell'utente poiché non sono molto esperto con Git, ma il fatto che sia tutt'altro che facile risolverlo indica un problema anche 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 le scorte.Bene, usa questo se vuoi condividere la tua scorta ;)

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

Utilizzo l'alias successivo per ignorare le modifiche.

Scarta le modifiche in un (elenco di) file nell'albero di lavoro

discard = checkout --

Quindi puoi usarlo come accanto per scartare tutte le modifiche:

discard .

O semplicemente un file:

discard filename

Altrimenti, se vuoi eliminare 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 seguente:

cleanout

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

https://github.com/GitAlias/gitalias

Se tutti i file in stage sono stati effettivamente impegnati, il ramo può essere semplicemente ripristinato, ad es.dalla GUI con circa tre clic del mouse: Ramo, Ripristina, SÌ!

Quindi quello che faccio spesso in pratica per annullare le modifiche locali indesiderate è eseguire il commit di tutte le cose buone e quindi reimpostare il ramo.

Se le cose buone vengono impegnate in un singolo commit, puoi utilizzare "modifica ultimo commit" per riportarle allo stato di stage o non stage se alla fine desideri impegnarle in modo leggermente diverso.

Questa potrebbe non essere la soluzione tecnica che stai cercando per il tuo problema, ma la trovo una soluzione molto pratica.Ti consente di scartare selettivamente le modifiche non graduali, reimpostando le modifiche che non ti piacciono e mantenendo quelle che fai.

Quindi, in sintesi, lo faccio semplicemente commettere, ripristino del ramo, E modificare l'ultimo commit.

Se ti trovi in caso di sottomodulo e nessun'altra soluzione funziona, prova:

Per verificare qual è il problema (magari un caso "sporco") utilizzare:

git diff
Per rimuovere la scorta

git submodule update

Ho avuto una strana situazione in cui un file è sempre senza stage, questo mi aiuta a risolverlo.

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

Se è quasi impossibile escludere modifiche ai file, hai considerato di ignorarle?Se questa affermazione è corretta e non toccheresti quei file durante lo sviluppo, questo comando potrebbe essere utile:

git update-index --assume-unchanged file_to_ignore

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow