Ik heb enkele wijzigingen aangebracht in een bestand dat een paar keer is vastgelegd als onderdeel van een groep bestanden, maar wil nu de wijzigingen erin terugzetten naar een vorige versie.
Ik heb een git logsamen met een git diffgedaan om de revisie te vinden die ik nodig heb, maar ik heb gewoon geen idee hoe ik het bestand terug kan krijgen naar zijn vroegere staat in het verleden.
Antwoord 1, autoriteit 100%
Ervan uitgaande dat de hash van de gewenste commit c5f567is:
git checkout c5f567 -- file1/to/restore file2/to/restore
De git checkoutman-pagina geeft meer informatie.
Als je wilt terugkeren naar de commit vóór c5f567, voeg dan ~1toe (waarbij 1 het aantal commits is dat je terug wilt gaan, het kan van alles zijn) :
git checkout c5f567~1 -- file1/to/restore file2/to/restore
Terzijde: ik heb me altijd ongemakkelijk gevoeld bij dit commando, omdat het wordt gebruikt voor zowel gewone dingen (wisselen tussen branches) als ongebruikelijke, destructieve dingen (wijzigingen in de werkdirectory negeren).
Er is ook een nieuw git restorecommando dat is speciaal ontworpen voor het herstellen van gewijzigde werkkopiebestanden. Als je git nieuw genoeg is, kun je dit commando gebruiken, maar de documentatie bevat een waarschuwing:
DEZE OPDRACHT IS EXPERIMENTEEL. HET GEDRAG KAN VERANDEREN.
Antwoord 2, autoriteit 10%
U kunt de wijzigingen die in een bestand zijn aangebracht snel bekijken met het diff-commando:
git diff <commit hash> <filename>
Gebruik vervolgens een specifiek bestand naar die commit, gebruik de opdracht Reset:
git reset <commit hash> <filename>
Mogelijk moet u de --hardgebruiken als u lokale wijzigingen hebt.
Een goede workflow voor het beheer van waypoints is om tags te gebruiken om punten in uw tijdlijn netjes te markeren. Ik kan je laatste zin niet helemaal begrijpen, maar wat je misschien wilt, is een tak uit een vorig moment in de tijd divergeren. Om dit te doen, gebruikt u de handige uitcheckopdracht:
git checkout <commit hash>
git checkout -b <new branch name>
U kunt dan weerleggen tegen uw hoofdlijn wanneer u klaar bent om die wijzigingen samen te voegen:
git checkout <my branch>
git rebase master
git checkout master
git merge <my branch>
3, Autoriteit 6%
U kunt elke verwijzing naar een GIT-commit gebruiken, inclusief de SHA-1 als dat het meest handig is. Het punt is dat de opdracht eruit ziet:
git checkout [commit-ref] -- [filename]
4, Autoriteit 5%
git checkout -- foo
die wordt ingesteld foonaar kop. U kunt ook:
git checkout HEAD^ foo
voor één revisie terug, enz.
5, Autoriteit 2%
en om terug te keren naar de laatste toegewijde versie, die het vaakst nodig is, kunt u deze eenvoudigere opdracht gebruiken.
git checkout HEAD file/to/restore
6, Autoriteit 2%
Ik had net nu hetzelfde probleem en ik vond Dit antwoord het gemakkelijkst te begrijpen (commit-refis de SHA-waarde van de verandering in het logboek dat u wilt teruggaan naar):
git checkout [commit-ref] [filename]
Dit zal die oude versie in je werkmap plaatsen en van daaruit kun je het vastleggen als je wilt.
Antwoord 7
Als je weet hoeveel commits je nodig hebt om terug te gaan, kun je het volgende gebruiken:
git checkout master~5 image.png
Dit veronderstelt dat je in de masterbranch zit, en de versie die je wilt is 5 commits terug.
Antwoord 8
Ik denk dat ik het heb gevonden….van http ://www-cs-students.stanford.edu/~blynn/gitmagic/ch02.html
Soms wil je gewoon teruggaan en elke wijziging na een bepaald punt vergeten, omdat ze allemaal verkeerd zijn.
Begin met:
$ git log
die je een lijst toont met recente commits en hun SHA1-hashes.
Typ vervolgens:
$ git reset --hard SHA1_HASH
om de status te herstellen naar een bepaalde commit en alle nieuwere commits permanent uit de record te wissen.
Antwoord 9
Dit werkte voor mij:
git checkout <commit hash> file
Bevestig vervolgens de wijziging:
git commit -a
Antwoord 10
Je moet voorzichtig zijn als je ‘terugdraaien’ zegt. Als je vroeger één versie van een bestand had in commit $A, en later twee wijzigingen aanbracht in twee aparte commits $B en $C (dus wat je ziet is de derde iteratie van het bestand), en als je zegt ” Ik wil terug naar de eerste”, meen je het echt?
Als je de wijzigingen wilt verwijderen, zowel de tweede als de derde iteratie, is dat heel eenvoudig:
$ git checkout $A file
en dan commit je het resultaat. Het commando vraagt “Ik wil het bestand uitchecken vanuit de staat die is vastgelegd door de commit $A”.
Aan de andere kant, wat u bedoelt, is om de wijziging van de tweede iteratie af te komen (dwz commit $ b) ingebracht, terwijl u bij het vasthouden van $ C het bestand heeft gedaan, zou u $ B
$ git revert $B
Houd er rekening mee dat degene die committed $ b is gemaakt, niet erg gedisciplineerd is en mogelijk volledig niet-gerelateerde verandering in dezelfde commit heeft gepleegd en deze terugkerende bestanden kunnen aanraken andere dan bestand die u beledigt, dus Misschien wilt u het resultaat zorgvuldig controleren nadat u dit hebt gedaan.
11
Vanaf Git v2.23.0 is er een nieuwe git herstel methode Dat moet aannemen dat een deel van wat git checkoutwas verantwoordelijk voor (zelfs het geaccepteerde antwoord vermeldt dat git checkoutbehoorlijk verwarrend is). Zie hoogtepunten van wijzigingen op GitHub blog .
Het standaardgedrag van deze opdracht is om de status van een werkboom te herstellen met de inhoud van de sourceparameter (die in uw geval een commit heeft).
Dus gebaseerd op het antwoord van Greg Hewgill (aannemen van de CITE HASH is c5f567) De opdracht zou er als volgt uitzien:
git restore --source=c5f567 file1/to/restore file2/to/restore
of als u wilt herstellen naar de inhoud van één commit vóór C5F567:
git restore --source=c5f567~1 file1/to/restore file2/to/restore
12
Verminderlijk, git checkout foowerkt niet als de werkkopie in een map is met de naam foo; Echter, zowel git checkout HEAD fooen git checkout ./fooWill:
$ pwd
/Users/aaron/Documents/work/foo
$ git checkout foo
D foo
Already on "foo"
$ git checkout ./foo
$ git checkout HEAD foo
Antwoord 13
Zo werkt rebase:
git checkout <my branch> git rebase master git checkout master git merge <my branch>
Stel dat je hebt
---o----o----o----o master \---A----B <my branch>
De eerste twee opdrachten …
verbinden
git kassa
git rebase master
… bekijk de branch met wijzigingen die je wilt toepassen op de masterbranch. Het rebasecommando neemt de commits van <my branch>(die niet gevonden worden in master) en past ze opnieuw toe op de head van master. Met andere woorden, de ouder van de eerste commit in <my branch>is niet langer een eerdere commit in de mastergeschiedenis, maar het huidige hoofd van master. De twee commando’s zijn hetzelfde als:
git rebase master <my branch>
Het is misschien makkelijker om dit commando te onthouden, aangezien zowel de “base” als de “modify” vertakkingen expliciet zijn.
. Het uiteindelijke resultaat van de geschiedenis is:
---o----o----o----o master \----A'----B' <my branch>
De laatste twee commando’s …
git checkout master
git merge <my branch>
… voer een fast-forward merge uit om alle <my branch>wijzigingen toe te passen op master. Zonder deze stap wordt de rebase-commit niet toegevoegd aan master. Het eindresultaat is:
---o----o----o----o----A'----B' master, <my branch>
masteren <my branch>verwijzen beide naar B'. Vanaf dit punt is het ook veilig om de verwijzing <my branch>te verwijderen.
git branch -d <my branch>
Antwoord 14
- Git zet bestand terug naar een specifieke vastlegging
git checkout Last_Stable_commit_Number -- fileName
2.Git-bestand terugzetten naar een specifieke branch
git checkout branchName_Which_Has_stable_Commit fileName
Antwoord 15
Eerste resetkop voor doelbestand
git reset HEAD path_to_file
Tweede checkout dat bestand
git checkout -- path_to_file
Antwoord 16
In het geval dat je een bestand wilt terugzetten naar een eerdere vastlegging (en het bestand dat je al vast wilt zetten), kun je gebruik maken van
git checkout HEAD^1 path/to/file
of
git checkout HEAD~1 path/to/file
En stage en commit de “nieuwe” versie.
Gewapend met de wetenschap dat een commit twee ouders kan hebben in het geval van een merge, zou je moeten weten dat HEAD^1 de eerste ouder is en HEAD~1 de tweede ouder.
Beide werken als er maar één ouder in de stamboom is.
Antwoord 17
git-aliassen, awk en shell-functies te hulp!
git prevision <N> <filename>
waarbij <N>het aantal revisies is van het bestand dat moet worden teruggedraaid voor bestand <filename>.
Als u bijvoorbeeld de onmiddellijke vorige revisie van een enkel bestand x/y/z.cwilt uitchecken, voert u
git prevision -1 x/y/z.c
Hoe werkt git prevision?
Voeg het volgende toe aan je gitconfig
[alias]
prevision = "!f() { git checkout `git log --oneline $2 | awk -v commit="$1" 'FNR == -commit+1 {print $1}'` $2;} ;f"
Het commando eigenlijk
- voert een
git loguit op het opgegeven bestand en- kies de juiste commit-id in de geschiedenis van het bestand en
- voert een
git checkoutuit naar de commit-id voor het opgegeven bestand.
In wezen alles wat men in deze situatie handmatig zou doen,
verpakt in één mooie, efficiënte git-alias – git-prevision
Antwoord 18
Veel suggesties hier, de meeste in de trant van git checkout $revision -- $file. Een paar obscure alternatieven:
git show $revision:$file > $file
En ik gebruik dit ook veel om tijdelijk een bepaalde versie te zien:
git show $revision:$file
of
git show $revision:$file | vim -R -
(OBS: $filemoet worden voorafgegaan door ./als het een relatief pad is voor git show $revision:$filewerken)
En nog vreemder:
git archive $revision $file | tar -x0 > $file
Antwoord 19
Ik moet easygit hier, dat is een wrapper om git meer aan te benaderbaar te maken naar novices zonder in verwarring gebrachte gebruikers. Een van de dingen die het doet is Geef meer betekenissen voor git revert. In dit geval zou je gewoon zeggen:
eg revertfoo/bar foo/baz
Antwoord 20
Veel antwoorden hier beweren git reset ... <file>of git checkout ... <file>te gebruiken, maar door dit te doen, verlies je elke wijziging op <file>vastgelegd na de commit die je wilt terugdraaien.
Als je wijzigingen van één commit op slechts een enkel bestand wilt terugdraaien, net zoals git revertzou doen, maar alleen voor één bestand (of zeg maar een subset van de commit-bestanden), raad ik aan om gebruik zowel git diffals git applyop die manier (met <sha>= de hash van de commit die je wilt terugzetten) :
git diff <sha>^ <sha> path/to/file.ext | git apply -R
In principe zal het eerst een patch genereren die overeenkomt met de wijzigingen die u wilt terugdraaien, en vervolgens de patch omgekeerd toepassen om die wijzigingen te verwijderen.
Het zal natuurlijk niet werken als teruggekeerde regels zijn gewijzigd door een commit tussen <sha1>en HEAD(conflict).
Antwoord 21
Om naar een eerdere commit-versie van het bestand te gaan, moet je het commit-nummer krijgen, zeg eb917a1
dan
git checkout eb917a1 YourFileName
Als je gewoon terug moet naar de laatst vastgelegde versie
git reset HEAD YourFileName
git checkout YourFileName
Hiermee gaat u gewoon naar de laatste vastgelegde status van het bestand
Antwoord 22
Dit is een heel eenvoudige stap. Checkout-bestand naar de commit-ID die we willen, hier één commit-ID ervoor, en dan gewoon commit wijzigen en we zijn klaar.
# git checkout <previous commit_id> <file_name>
# git commit --amend
Dit is erg handig. Als we een bestand naar een eerdere commit-ID bovenaan de commit willen brengen, kunnen we dat gemakkelijk doen.
Antwoord 23
git checkout ref|commitHash — filePath
bijv.
git checkout HEAD~5 -- foo.bar
or
git checkout 048ee28 -- foo.bar
Antwoord 24
Gebruik git logom de hash-sleutel voor een specifieke versie te verkrijgen en gebruik vervolgens git checkout <hashkey>
Opmerking: vergeet niet de hash voor de laatste te typen. De laatste hash verwijst naar uw huidige positie (HEAD) en verandert niets.
Antwoord 25
Het is duidelijk dat iemand een begrijpelijk boek over git moet schrijven, of dat git beter moet worden uitgelegd in de documentatie. Geconfronteerd met hetzelfde probleem vermoedde ik dat
cd <working copy>
git revert master
zou de laatste commit ongedaan maken die het leek te doen.
Ian
Antwoord 26
Je kunt het in 4 stappen doen:
- draai de hele commit terug met het bestand dat je specifiek wilt terugzetten – het zal een nieuwe commit maken op je branch
- zachte reset die commit – verwijdert de commit en verplaatst de wijzigingen naar het werkgebied
- kies de bestanden handmatig om ze terug te zetten en vast te leggen
- zet alle andere bestanden neer in uw werkgebied
Wat u in uw terminal moet typen:
git revert <commit_hash>git reset HEAD~1git add <file_i_want_to_revert>&&git commit -m 'reverting file'git checkout .
veel succes
Antwoord 27
git revert <hash>
Zal een bepaalde commit terugdraaien. Het klinkt alsof je denkt dat git revertalleen de meest recente commit beïnvloedt.
Dat lost je probleem niet op, als je een wijziging in een specifiek bestand wilt terugdraaien en die commit meer is gewijzigd dan dat bestand.
Antwoord 28
als je een verkeerd bestand hebt gecommit in je laatste commits, volg dan de instructie :
- open source tree, verander naar deze commit
- verander de regels en vind je commit dat het verkeerde bestand is verzonden als commit
- je kunt de lijst met je wijzigingen in die commit zien
- selecteer het en klik vervolgens op … knoppen aan de rechterkant … klik op bestand omkeren
- dan kun je het zien op het tabblad Bestandsstatus linksonder
klik vervolgens op unstage:
- open je Visual Studio-code en keer terug door je verwijderde bestanden te committen
- Na hen, kunt u resultaten zien in uw laatste commit in de Bronstructuur
