git - Hoe verwijder ik niet-gestagede wijzigingen in Git?

Hoe verwijder ik wijzigingen in mijn werkkopie die niet in de index staan?

Antwoord 1, autoriteit 100%

Een andere snellere manier is:

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

Je hoeft --include-untrackedniet op te nemen als je er niet grondig over wilt zijn.

Daarna kun je die stash laten vallen met een git stash drop-opdracht als je wilt.

Antwoord 2, autoriteit 99%

Gebruik voor alle niet-gestagede bestanden in de huidige werkmap:

git checkout -- .

Voor een specifiek bestand gebruik:

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

--hier om dubbelzinnigheid te verwijderen (dit staat bekend als argument ondubbelzinnig maken).

Vanaf Git 2.23 kan men de meer specifieke gebruiken

git restore .

resp.

git restore path/to/file/to/revert

dat samen met git switchde overbelaste git checkoutvervangt (zie hier), en verwijdert dus de ondubbelzinnige argumentatie.

Antwoord 3, autoriteit 69%

Het lijkt erop dat de volledige oplossing is:

git clean -df
git checkout -- .

git cleanverwijdert alle niet-getrackte bestanden (waarschuwing: hoewel het genegeerde bestanden die direct in .gitignore worden genoemd niet verwijdert, het kan genegeerde bestanden die zich in mappen bevinden verwijderen) en git checkoutwist alle niet-gefaseerde wijzigingen.

Antwoord 4, autoriteit 12%

Dit controleert de huidige index voor de huidige map, waarbij alle wijzigingen in bestanden van de huidige map naar beneden worden weggegooid.

git checkout .

of dit dat alle bestanden uit de index uitcheckt, werkboombestanden overschrijft.

git checkout-index -a -f

Antwoord 5, autoriteit 9%

git clean -df

Reinigt de werkboom door recursief bestanden te verwijderen die niet onder versiebeheer staan, beginnend bij de huidige map.

-d: verwijder niet-bijgehouden mappen naast niet-bijgehouden bestanden

-f: Forceren (misschien niet nodig, afhankelijk van de instelling van clean.requireForce)

Voer git help cleanuit om de handleiding te zien

Antwoord 6, autoriteit 5%

2019-update

U kunt nu niet-gefaseerde wijzigingen in één bijgehouden bestandnegeren met:

git restore <file>

en in alle bijgehouden bestandenin de huidige map (recursief) met:

git restore .

Als u de laatste uitvoert vanuit de hoofdmap van de repository, worden niet-gefaseerde wijzigingen in alle bijgehouden bestanden in het project verwijderd.

Opmerkingen

git restoreis geïntroduceerd in juli 2019en uitgebracht in versie 2.23 als onderdeel van een splitsing van het git checkoutcommando in git restorevoor bestanden en git switchvoor branches.
git checkoutgedraagt zich nog steeds zoals vroeger en de oudere antwoorden blijven perfect geldig.
Bij het uitvoeren van git statusMet niet-gestudeerde veranderingen in de werkboom is dit nu wat Git nodig heeft om ze te gebruiken om ze weg te gooien (in plaats van git checkout -- <file>zoals vroeger vóór V2.23).
Zoals met git checkout -- ., deze verwijdert alleen wijzigingen in gevolgde bestanden. Dus Mariusz Nowak’s Answer is nog steeds van toepassing en als u alle niet-gestudeerde wijzigingen wilt weggooien, inclusief niet-uitgestreken bestanden, kunt u rennen, zoals hij Suggereert, een extra git clean -df.

7, Autoriteit 4%

Mijn favoriet is

git checkout -p

waarmee u chunks selectief kunt terugkeren.

Zie ook:

git add -p

8, Autoriteit 4%

Aangezien geen antwoord de exacte optie-combinatie suggereert die ik gebruik, hier is het:

git clean -dxn .  # dry-run to inspect the list of files-to-be-removed
git clean -dxf .  # REMOVE ignored/untracked files (in the current directory)
git checkout -- . # ERASE changes in tracked files (in the current directory)

Dit is de online Help-tekst voor de gebruikte git cleanOpties:

-d

Verwijder niet-gesraceerde directories naast niet-gesraceerde bestanden. Als een niet-gesraceerde map wordt beheerd door een andere GIT-repository, wordt deze standaard niet verwijderd. Gebruik tweemaal -fals u zo’n map echt wilt verwijderen.

-x

Gebruik niet de standaard negeerregels die worden gelezen uit .gitignore(per directory) en $GIT_DIR/info/exclude, maar gebruik nog steeds de negeerregels die worden gegeven bij -eopties. Hierdoor kunnen alle niet-getrackte bestanden worden verwijderd, inclusief buildproducten. Dit kan worden gebruikt (mogelijk in combinatie met git reset) om een onberispelijke werkmap te maken om een schone build te testen.

-n

Verwijder eigenlijk niets, laat alleen zien wat er zou gebeuren.

-f

Als de Git-configuratievariabele clean.requireForceniet is ingesteld op false, zal Git clean weigeren bestanden of mappen te verwijderen, tenzij -f, -nof -i. Git zal weigeren mappen te verwijderen binnen de .gitsubmap of bestand, tenzij een tweede -fwordt gegeven.

Antwoord 9, autoriteit 2%

Als je slechts wijzigingen in bestaande bestanden wilt verwijderen, gebruik dan checkout(hier gedocumenteerd).

git checkout -- .

Er is geen vertakking opgegeven, dus het controleert de huidige vertakking.
Het dubbele koppelteken (--) vertelt Git dat wat volgt moet worden opgevat als zijn tweede argument (pad), dat je de specificatie van een branch hebt overgeslagen.
De punt (.) geeft alle paden aan.

Als je bestanden wilt verwijderen die zijn toegevoegdsinds je laatste commit, gebruik dan clean(hier gedocumenteerd):

git clean -i

De optie -iinitieert een interactieve cleanom foutieve verwijderingen te voorkomen.
Er zijn een handvol andere opties beschikbaar voor een snellere uitvoering; zie de documentatie.

Als je wijzigingen wilt verplaatsen naar een bewaarruimte voor latere toegang, gebruik dan stash(hier gedocumenteerd):

git stash

Alle wijzigingen worden verplaatst naar Git’s Stash, voor eventuele latere toegang.
Er zijn een handvol opties beschikbaar voor meer genuanceerde opslag; zie de documentatie.

Antwoord 10, autoriteit 2%

Ik vond dit artikel echt nuttig om uit te leggen wanneer welk commando moet worden gebruikt: http://www.szakmeister.net/blog/2011/oct/12/reverting-changes-git/

Er zijn een paar verschillende gevallen:

Als je het bestand niet hebt gestaged, gebruik je git checkout. Afrekenen “werkt bestanden in de werkboom bij zodat ze overeenkomen met de versie in de index”. Als de bestanden niet gestaged zijn (ook wel toegevoegd aan de index)… zal dit commando de bestanden in wezen terugzetten naar wat je laatste commit was.

git checkout -- foo.txt
Als je het bestand hebt gestaged, gebruik dan git reset. Reset wijzigt de index zodat deze overeenkomt met een vastlegging.

git reset -- foo.txt

Ik vermoed dat het gebruik van git stasheen populaire keuze is omdat het iets minder gevaarlijk is. Je kunt er altijd naar teruggaan als je per ongeluk teveel wegblaast bij het gebruik van git reset. Resetten is standaard recursief.

Bekijk het bovenstaande artikel voor meer advies.

Antwoord 11, autoriteit 2%

De gemakkelijkste manier om dit te doen is door dit commando te gebruiken:

Dit commando wordt gebruikt om wijzigingen in de werkmap te negeren –

git checkout -- .

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

In het git-commando wordt stashing van niet-getrackte bestanden bereikt door het gebruik van:

git stash -u

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

Antwoord 12, autoriteit 2%

Als je niet geïnteresseerd bent in het behouden van de niet-gefaseerde wijzigingen (vooral als de gefaseerde wijzigingen nieuwe bestanden zijn), vond ik dit handig:

git diff | git apply --reverse

Antwoord 13, autoriteit 2%

Terwijl je git-status typt,
(gebruik “git checkout — …” om wijzigingen in de werkmap te negeren)
wordt weergegeven.

bijv. git checkout -- .

Antwoord 14

git checkout -f

man git-checkout:

-f, --force

Ga bij het wisselen van takken verder, zelfs als de index of de werkboom verschilt van HEAD. Dit wordt gebruikt om lokale wijzigingen weg te gooien.

Bij het uitchecken van paden uit de index, mag u niet falen bij niet-samengevoegde items; in plaats daarvan worden niet-samengevoegde items genegeerd.

Antwoord 15

Je kunt git stash gebruiken – als er iets misgaat, kun je nog steeds terugkeren uit de stash.
Vergelijkbaar met een ander antwoord hier, maar deze verwijdert ook alle niet-gestaged bestanden en ook alle niet-gestaged verwijderingen:

git add .
git stash

als je controleert of alles in orde is, gooi je de voorraad weg:

git stash drop

Het antwoord van Bilal Maqsood met git cleanwerkte ook voor mij, maar met de stash heb ik meer controle – als ik het per ongeluk doe, kan ik mijn wijzigingen nog steeds terugkrijgen

UPDATE

Ik denk dat er nog 1 verandering is (ik weet niet waarom dit eerder voor mij werkte):

git add . -Ain plaats van git add .

zonder de -Aworden de verwijderde bestanden niet gestaged

Antwoord 16

In plaats van wijzigingen ongedaan te maken, reset ik mijn afstandsbediening naar de oorsprong. Opmerking – deze methode is om uw map volledig te herstellen naar die van de repo.

Dus ik doe dit om ervoor te zorgen dat ze daar niet blijven zitten als ik git reset (later – sluit gitignores op de Origin/branchname uit)

OPMERKING: als je bestanden wilt bewaren die nog niet bijgehouden zijn, maar niet in GITIGNORE, kun je deze stap overslaan, omdat het deze niet-getrackte bestanden die niet in je externe repository zijn gevonden, zal wissen (bedankt @XtrmJosh).

git add --all

Dan ik

git fetch --all

Vervolgens reset ik naar de oorsprong

git reset --hard origin/branchname

Dat brengt het terug naar af. Net zoals het opnieuw klonen van de branch, terwijl ik al mijn gegitignoreerde bestanden lokaal en op hun plaats houd.

Bijgewerkt per gebruikerscommentaar hieronder:
Variatie om de huidige branch te resetten waarop de gebruiker zich bevindt.

git reset --hard @{u}

Antwoord 17

Alle bovenstaande oplossingen geprobeerd, maar nog steeds geen nieuwe, niet-gefaseerde bestanden kunnen verwijderen.

Gebruik git clean -fom die nieuwe bestanden te verwijderen – met de nodige voorzichtigheid!Let op de force-optie.

Antwoord 18

Een permanente verwijdering uitvoeren:
git reset --hard

Om wijzigingen voor later op te slaan:
git stash

Antwoord 19

Gebruik gewoon:

git stash -u

Gereed. Makkelijk.

Als je echtom je stash-stack geeft, kun je volgen met git stash drop. Maar op dat moment kun je beter (van Mariusz Nowak):

git checkout -- .
git clean -df

Desalniettemin vind ik git stash -uhet leukst omdat het alle bijgehouden en niet-bijgehouden wijzigingen in slechts één commando“verwerpt”. Maar git checkout -- .negeert alleen bijgehouden wijzigingen,
en git clean -dfnegeert alleen niet-bijgehouden wijzigingen… en het typen van beide commando’s is veelte veel werk 🙂

Antwoord 20

zeg gewoon

git stash

Het zal al uw lokale wijzigingen verwijderen. Je kunt later ook gebruiken door te zeggen

git stash apply

of
git stash pop

Antwoord 21

je hebt een heel eenvoudig git-commando git checkout .

Antwoord 22

Dit werkt zelfs in mappen die; buiten de normale git-rechten.

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

Is mij onlangs overkomen

Antwoord 23

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

Antwoord 24

Het maakt niet uit in welke staat je repo zich bevindt, je kunt altijd resetten naar een eerdere commit:

git reset --hard <commit hash>

Hiermee worden alle wijzigingen die na die commit zijn gemaakt, genegeerd.

25

Nog een manier om van nieuwe bestanden te verwijderen die specifieker is dan Git Clean -DF (waarmee u kunt ontdoen van sommige bestanden die niet noodzakelijkerwijs allemaal kunnen worden), is om eerst de nieuwe bestanden aan de index toe te voegen, dan stiekem laat dan de stash vallen.

Deze techniek is handig wanneer u om een of andere reden niet gemakkelijk alle niet-geralte bestanden kunt verwijderen door een gewone mechanisme (zoals RM).

26

Wat volgt is echt slechts een oplossing als u met een vork van een repository werkt waar u regelmatig synchroniseert (bijvoorbeeld Pull-aanvraag) met een andere repo. Kort antwoord: Delete Fork and Refork, maar Lees de waarschuwingen op GitHub .

Ik had een soortgelijk probleem, misschien niet identiek, en ik ben verdrietig om te zeggen dat mijn oplossing niet ideaal is, maar het is uiteindelijk effectief.

Ik heb vaak git-statusberichten zoals deze (betrokken op minstens 2/4 bestanden):

$ 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

Een scherp oog zal opmerken dat deze bestanden dubbelgangers hebben die uit één letter bestaan. Op de een of andere manier, en ik heb geen idee wat me op dit pad heeft gebracht om mee te beginnen (omdat ik zelf niet met deze bestanden werkte vanuit de upstream-repo), had ik deze bestanden gewisseld. Probeer de vele oplossingen die op deze pagina (en andere pagina’s) worden vermeld, niet lijken te helpen.

Ik heb het probleem kunnen oplossen door mijn gevorkte repository en alle lokale repositories te verwijderen en te reforken. Dit alleen was niet genoeg; upstream moest de betreffende bestanden hernoemen naar nieuwe bestandsnamen.Zolang je geen ongecommitteerd werk hebt, geen wiki’s en geen problemen die afwijken van de upstream-repository, zou het goed moeten komen. Stroomopwaarts is misschien niet erg blij met je, om het zachtjes uit te drukken. Wat mijn probleem betreft, het is ongetwijfeld een gebruikersfout omdat ik niet zo bedreven ben met git, maar het feit dat het verre van eenvoudig is om ook een probleem met git op te lossen.

Antwoord 27

Ik had een rare situatie waarin een bestand altijd niet gestaged is, dit helpt me om het op te lossen.

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

Antwoord 28

Als je een stash aan iemand anders wilt overdragen:

# 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

[bewerk] als commentaar, het is mogelijk om stashes een naam te geven. Nou, gebruik dit als je je voorraad wilt delen 😉

Antwoord 29

Je zou je eigen alias kunnen maken die beschrijft hoe je dit op een beschrijvende manier moet doen.

Ik gebruik de volgende alias om wijzigingen te negeren.

Wijzigingen in een (lijst van) bestand(en) in werkboomstructuur negeren

discard = checkout --

Dan kun je het gebruiken als volgende om alle wijzigingen te negeren:

discard .

Of gewoon een bestand:

discard filename

Anders, als je alle wijzigingen en ook de niet-bijgehouden bestanden wilt verwijderen, gebruik ik een combinatie van uitchecken en opschonen:

Opschonen en verwijderen van wijzigingen en niet-getrackte bestanden in de werkboom

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

Dus het gebruik is eenvoudig als volgt:

cleanout

Nu beschikbaar in de volgende Github-repo die veel aliassen bevat:

https://github.com/GitAlias/gitalias

Hoe verwijder ik niet-gestagede wijzigingen in Git?