I-reset o ibalik ang isang tukoy na file sa isang tukoy na rebisyon gamit ang Git?

Gumawa ako ng i>

git log ko ang git log kasama ang git diff upang mahanap ang opsyon na kai>

3786
19 окт. itakda ang Hates_ 19 Oktubre. 2008-10-19 02:34 '08 at 2:34 am 2008-10-19 02:34
ответ 31 sagot
  • 1
  • 2

Ipagpapalagay na ang hash na gusto mo ay c5f567 :

 git checkout c5f567 -- file1/to/restore file2/to/restore 

Ang manu-manong git checkout na pahina ay nagbibigay ng karagdagang impormasyon.

Kung nais mong bumalik upang gumawa sa c5f567 , idagdag ang ~1 (gumagana sa anumang numero):

 git checkout c5f567~1 -- file1/to/restore file2/to/restore 

Bi>

5117
19 окт. sagot na ibinigay ni Greg Hewgill Oktubre 19 2008-10-19 02:39 '08 at 2:39 2008-10-19 02:39

Maaari mong mabilis na suriin ang mga pagbabago na ginawa sa isang file gamit ang diff command:

 git diff <commit hash> <filename> 

Pagkatapos, upang ibalik ang isang tukoy na file sa tagaayos na ito, gamitin ang reset command:

 git reset <commit hash> <filename> 

Maaaring kai>--hard kung mayroon kang mga lokal na pagbabago.

border=0

Ang isang mahusay na daloy ng dokumento upang pamahalaan ang iyong mga waypoint ay ang paggamit ng mga tag upang mapanatili ang mga puntos sa iyong timeline malinis. Hindi ko maintindihan ang iyong huling pangungusap, ngunit ang maaaring kai>

 git checkout <commit hash> git checkout -b <new branch name> 

Pagkatapos ay maaari mong muling i-install ito laban sa iyong pangunahing linya kapag ikaw ay handa na upang pagsamahin ang mga pagbabagong ito:

 git checkout <my branch> git rebase master git checkout master git merge <my branch> 
541
17 дек. Sumagot na ibinigay ni Chris Lloyd noong Disyembre 17. 2008-12-17 09:59 '08 sa 9:59 2008-12-17 09:59

Maaari mong gamitin ang anumang link sa git commit, kabi>

git checkout [commit-ref] -- [filename]

319
08 апр. ang sagot ay ibinigay foxxtrot 08 apr. 2009-04-08 00:48 '09 sa 0:48 2009-04-08 00:48
 git checkout -- foo 

Ito ay isang pag-reset ng foo para sa HEAD. Maaari mo ring:

 git checkout HEAD^ foo 

para sa isang rebisyon, atbp.

256
29 авг. sagot na ibinigay ni Greg Hewgill Ago 29 2008-08-29 23:56 '08 at 11:56 pm 2008-08-29 23:56

At upang makabalik sa huling nakumpletong bersyon, na kung saan ay madalas na kai>

 git checkout HEAD file/to/restore 
114
14 янв. ang sagot ay ibinigay sa CDR 14 jan. 2012-01-14 09:15 '12 sa 9:15 2012-01-14 09:15

Nagkaroon din ako ng parehong problema ngayon, at nasumpungan ko ang sagot na ito na pinakamadaling maintindihan (ang commit-ref ay ang halaga ng pagbabago ng SHA sa log na nais mong ipadala pabalik):

 git checkout [commit-ref] [filename] 

Inilalagay nito ang lumang bersyon sa iyong nagtatrabaho na direktoryo, at mula roon ay maaari mong ayusin ito kung gusto mo.

102
27 мая '09 в 20:52 2009-05-27 20:52 ang sagot ay ibinigay sa pamamagitan ng bbrown sa May 27, 2009

Kung alam mo kung gaano karaming gumagawa ang kai>

 git checkout master~5 image.png 

Ipinapalagay na ikaw ay nasa master branch, at ang ninanais na bersyon ay 5.

88
07 апр. Ang sagot ay ibinigay ni Ron DeVera 07 Abr 2009-04-07 17:03 '09 sa 5:03 PM 2009-04-07 17:03

Sa tingin ko nakita ko ... mula sa http://www-cs-students.stanford.edu/~blynn/gitmagic/ch02.html

Kung minsan gusto mo lamang bumalik at kalimutan ang lahat ng mga pagbabago para sa isang tiyak na punto, dahil lahat sila ay mali.

Magsimula sa:

$ git log

na nagpapakita sa iyo ng isang listahan ng mga kamakai>

Pagkatapos ay ipasok ang:

$ git reset --hard SHA1_HASH

upang ibalik ang estado para sa isang binigay na gawain at burahin ang lahat ng mga bagong entry mula sa rekord magpakailanman.

78
17 дек. ang sagot ay ibinigay jdee 17 disyembre. 2008-12-17 09:53 '08 sa 9:53 2008-12-17 09:53

Nagtrabaho ito para sa akin:

 git checkout <commit hash> file 

Pagkatapos ay gawin ang pagbabago:

 git commit -a 
61
26 авг. ang sagot ay ibinigay v2k 26 aug. 2011-08-26 01:12 '11 sa 1:12 2011-08-26 01:12

Dapat kang maging maingat kapag sinabi mong "rollback". Kung ginamit mo ang isang bersyon ng file sa gumawa ng $ A, pagkatapos ay gumawa ng dalawang mga pagbabago sa dalawang hiwalay na mga gawain $ B at $ C (kaya nakikita mo, ito ang ikatlong pag-ulit ng file), at kung sasabihin mo "Gusto kong bumalik sa una", talagang ibig sabihin nito?

Kung nais mong mapupuksa ang mga pagbabago sa parehong ikalawa at ikatlong mga iteration, ito ay napaka-simple:

 $ git checkout $A file 

at pagkatapos ay ayusin mo ang resulta. Ang utos ay nagtanong "Gusto kong suriin ang file mula sa estado na isinulat ng $ A commit".

Sa kabi>

 $ git revert $B 

Tandaan: sinuman ang gumawa ng $ B ay maaaring hindi masyadong disiplinado at maaaring gumawa ng ganap na hindi nauugnay na mga pagbabago sa parehong gumawa, at ang pagbalik na ito ay maaaring pag-aalala ng mga file maliban sa file na nakikita mo, nakakasakit na mga pagbabago, kaya mo maingat na suriin ang resulta pagkatapos nito.

54
11 янв. ang sagot ay ibinigay sa pamamagitan ng gitster 11 jan. 2009-01-11 11:13 '09 sa 11:13 2009-01-11 11:13

Kapansin-pansin, ang 'git checkout foo' ay hindi gagana kung ang nagtatrabaho kopya ay nasa direktoryo na pinangalanang foo; gayunpaman, tulad ng "w20> checkout HEAD foo" at "git checkout./foo" ay magiging:

 $ pwd /Users/aaron/Documents/work/foo $ git checkout foo D foo Already on "foo" $ git checkout ./foo $ git checkout HEAD foo 
36
30 авг. ang sagot ay ibinigay ni Aaron Maenpaa 30 aug. 2008-08-30 00:26 '08 at 0:26 am 2008-08-30 00:26

Dito rebase gumagana:

 git checkout <my branch> git rebase master git checkout master git merge <my branch> 

Ipagpalagay na mayroon ka

 ---o----o----o----o master \---A----B <my branch> 

Ang unang dalawang koponan ... gumawa ng git checkout git re-install wizard

... tingnan ang branch ng mga pagbabago na nais mong ilapat sa master branch. Ang rebase command ay tumatagal mula sa <my branch> (na hindi matatagpuan sa master ) at muling rebase ito sa master header. Sa ibang salita, ang elementong magu><my branch> hindi na ang dating tagapag-ayos sa kasaysayan ng master , ngunit ang kasalukuyang master header. Ang dalawang koponan ay kapareho ng:

 git rebase master <my branch> 

Marahil ay mas madaling tandaan ang utos na ito, dahil ang "base" at "baguhin" na mga sangay ay malinaw.

. Ang resulta ng pagtatapos:

 ---o----o----o----o master \----A'----B' <my branch> 

Ang huling dalawang koponan ...

 git checkout master git merge <my branch> 

... magsagawa ng isang mabilis na pagsasama upang ilapat ang lahat ng <my branch> pagbabago upang master . Kung wala ang hakbang na ito, ang isang rebase ay hindi idinagdag sa master . Ang resulta ng pagtatapos:

 ---o----o----o----o----A'----B' master, <my branch> 

master at <my branch> parehong mga reference B' . Bi><my branch> .

 git branch -d <my branch> 
32
24 февр. Ang sagot ay ibinigay ng cmcginty 24 Peb. 2009-02-24 12:43 '09 sa 12:43 2009-02-24 12:43

git aliases, awk at shell function para sa kaligtasan!

 git prevision <N> <filename> 

kung saan ang <N> ay ang bi><filename> .
Halimbawa, upang suriin ang agarang nakaraang pagbabago ng isang solong x/y/zc file, patakbuhin

 git prevision -1 x/y/zc 

Paano gumagana ang git hula?

Idagdag sa iyong gitconfig

sumusunod:
 [alias] prevision = "!f() { git checkout `git log --oneline $2 | awk -v commit="$1" 'FNR == -commit+1 {print $1}'` $2;} ;f" 

Koponan talaga

  • executes git log sa tinukoy na file at
  • Pinipili ang katugmang ID ng commit sa kasaysayan ng file at
  • gumaganap git checkout commit id para sa tinukoy na file.

Mahalaga, ang lahat ng maaaring gawin nang manu-mano sa sitwasyong ito
balot sa isang magandang, epektibong git-alias - git-prevision

21
01 мая '15 в 4:46 2015-05-01 04:46 ang sagot ay ibinigay ng TheCodeArtist 01 Mayo '15 sa 4:46 2015-05-01 04:46

Kai>EasyGit dito, kung saan ay isang wrapper upang gawing mas mas madaling access ang mga newbies nang hindi nakalilito ang mga nakaranasang gumagamit. Ang isa sa mga bagay na ginagawa nito ay ang pagbibigay ng higit pang mga git revert halaga . Sa kasong ito, sasabihin mo lamang:

eg revert foo/bar foo/baz

20
19 окт. ang sagot ay ibinigay Aristotle Pagaltzis 19 Oktubre. 2008-10-19 03:16 '08 at 3:16 am 2008-10-19 03:16

Kung sakaling nais mong ibalik ang file sa nakaraang gumawa (at ang file na nais mong ibalik ay naayos na), maaari mong gamitin

 git checkout HEAD^1 path/to/file 

o

 git checkout HEAD~1 path/to/file 

Pagkatapos ay gawin lamang ang hakbang at ayusin ang "bagong" bersyon.

Gamit ang kaalaman na sa kaso ng isang pagsama-sama, ang isang magkasala ay maaaring magkaroon ng dalawang magu>

O magagawa ito kung may isang magu>

20
11 янв. Ang sagot ay ibinigay ng ModernIncantations Enero 11. 2014-01-11 03:29 '14 sa 3:29 2014-01-11 03:29

Unang I-reset ang Head para sa Target na File

 git reset HEAD path_to_file 

Ang ikalawang tseke ng file na ito

 git checkout -- path_to_file 
19
04 апр. ang sagot ay ibinigay ng Gulshan Maurya 04 apr. 2017-04-04 13:25 '17 sa 1:25 ng gabi 2017-04-04 13:25

Tandaan na ang git checkout ./foo at git checkout HEAD ./foo hindi eksakto ang parehong bagay; Halimbawa:

 $ echo A > foo $ git add foo $ git commit -m 'A' foo Created commit a1f085f: A 1 files changed, 1 insertions(+), 0 deletions(-) create mode 100644 foo $ echo B >> foo $ git add foo $ echo C >> foo $ cat foo A B C $ git checkout ./foo $ cat foo A B $ git checkout HEAD ./foo $ cat foo A 

(Ang ikalawang add proseso ang file sa indeks, ngunit hindi ito nakuha.)

git checkout ./foo nangangahulugang pagbabalik sa landas ./foo sa index ; ang pagdaragdag ng isang HEAD nagtuturo sa Git upang ibalik ang landas ng index sa HEAD bago nito.

19
31 авг. Ang sagot ay ibinigay ni Damien Diederen Agosto 31 2008-08-31 14:54 '08 at 2:54 pm 2008-08-31 14:54

Mayroong maraming mga suhestiyon dito, karamihan sa mga ito sa diwa ng git checkout $revision -- $file . Ang isang pares ng mga nakakubli na alternatibo:

 git show $revision:$file > $file 

At gayon din, madalas kong ginagamit ito upang pansamanta>

 git show $revision:$file 

o

 git show $revision:$file | vim -R - 

(OBS: $file dapat magsimula sa prefix ./ ito ay isang kamag-anak na landas para sa git show $revision:$file upang gumana)

At lahat ng mga mas kakaiba

 git archive $revision $file | tar -x0 > $file 
14
08 янв. Sumagot ni Peter V. Mørch Enero 08 2016-01-08 01:19 '16 sa 1:19 2016-01-08 01:19

Upang pumunta sa nakaraang bersyon ng file na gumawa, makuha ang numero ng gumawa, halimbawa, eb917a1 pagkatapos

 git checkout eb917a1 YourFileName 

Kung kai>

 git reset HEAD YourFileName git checkout YourFileName 

Dadalhin ka nito sa huling naitala na estado ng file.

11
25 февр. ang sagot ay ibinigay shah1988 25 Peb. 2014-02-25 17:01 '14 sa 17:01 2014-02-25 17:01

Para sa akin, wa>

Mayroon akong isang abc1 , at pagkatapos nito ay gumawa ako ng i>file.txt file.

Ngayon sabihin sa akin na nakapagkamali ako ng isang bagay sa file file.txt , at gusto kong bumalik sa nakaraang commit abc1 .

1. git checkout file.txt : aalisin nito ang mga lokal na pagbabago kung hindi mo ito kai>

2. git checkout abc1 file.txt : ito ay hahantong sa iyong file sa iyong ninanais na bersyon

3. git commit -m "Restored file.txt to version abc1" : ito ang magiging sanhi ng iyong pagbalik.

  1. git push : dadalhin nito ang lahat sa isang remote repository

Sa pagitan ng mga hakbang 2 at 3, siyempre, maaari mong gawin git status upang maunawaan kung ano ang nangyayari. Karaniwan dapat mong makita na file.txt ay naidagdag na, at samakatuwid ay hindi na kai>git add .

10
23 марта '17 в 0:33 2017-03-23 00:33 ang sagot ay ibinigay ng kalmanIsAGameChanger noong Marso 23 '17 sa 0:33 2017-03-23 ​​00:33

git checkout ref | commitHash - filePath

halimbawa.

 git checkout HEAD~5 -- foo.bar or git checkout 048ee28 -- foo.bar 
10
26 сент. Ang sagot ay ibinigay kay Amos Folarin 26 sep . 2013-09-26 20:04 '13 sa 20:04 2013-09-26 20:04

Karamihan sa mga sagot dito ay nangangai>git reset ... <file> o git checkout ... <file> , ngunit mawawalan ka ng lahat ng mga pagbabago sa <file> na ginawa pagkatapos ng commit na gusto mong ibalik.

Kung nais mong i-discard ang mga pagbabago mula sa isa lamang gumawa sa isa lamang na file, tulad ng git revert gagawin, ngunit lamang sa isang solong file (o, sabihin, isang subset ng mga file na gumawa), minumungkahi ko ang paggamit ng parehong git diff at git apply tulad nito ( may <sha> = ang hash ng commit na gusto mong ibalik):

 git diff <sha>^ <sha> path/to/file.ext | git apply -R 

Sa prinsipyo, ito ay unang bumuo ng isang patch na tumutugma sa mga pagbabago na nais mong bumalik, at pagkatapos ay kanselahin ang application ng patch upang itapon ang mga pagbabagong ito.

Siyempre, hindi ito gumagana kung ang mga baligtad na linya ay binago ng anumang gumawa sa pagitan ng <sha1> at HEAD (conflict).

8
07 дек. ang sagot ay ibinigay Vince 07 dec. 2016-12-07 17:43 '16 sa 5:43 ng 2016-12-07 17:43

Gamitin ang git log upang makuha ang hash key para sa isang tukoy na bersyon, at pagkatapos ay gamitin ang git checkout <hashkey>

Tandaan Huwag kalimutang ipasok ang hash bago ang huli. Ang huling hash ay nagpapahiwatig ng kasalukuyang posisyon (HEAD) at hindi nagbabago ng kahit ano.

8
05 дек. ang sagot ay ibinigay mustafakyr 05 dec. 2011-12-05 23:09 '11 sa 23:09 2011-12-05 23:09

Malinaw, ang isang tao ay kai>

 cd <working copy> git revert master 

reverses ang huling gumawa, na tila ginagawa.

Ian

7
16 дек. Ang sagot ay ibinigay ni Ian Davis noong Disyembre 16. 2011-12-16 06:03 '11 sa 6:03 2011-12-16 06:03

Kung gumawa ka ng maling file sa iyong mga kamakai>

  1. open source tree, baguhin ang commit na ito

2019

23 авг. sumagot na ibinigay ng saber tabatabaee yazdi 23 aug. 2018-08-23 12:53 '18 sa 12:53 2018-08-23 12:53

Magagawa mo ito sa 4 na hakbang:

  1. kanselahin ang buong gumawa gamit ang file na gusto mong i-cancel ang partikular na - ito ay lilikha ng isang bagong gumawa sa iyong thread
  2. soft reset na commit - aalisin ang commit at gumagalaw ang mga pagbabago sa workspace
  3. mano-manong piliin ang mga file upang bumalik at i-lock ang mga ito
  4. drop ang lahat ng iba pang mga file sa iyong workspace

Ano ang kai> :

  1. git revert <commit_hash>
  2. git reset HEAD~1
  3. git add <file_i_want_to_revert> git commit -m 'reverting file'
  4. git checkout.

good luck

4
08 мая '18 в 13:26 2018-05-08 13:26 ang sagot ay ibinigay ni Nir M. Mayo 08, '18 sa 1:26 pm 2018-05-08 13:26
 git revert <hash> 

Ibinabalik ang tinukoy na gumawa. Tila sa tingin mo na ang git revert nakakaapekto lamang sa huling gumawa.

Hindi nito malulutas ang iyong problema kung gusto mong i-undo ang pagbabago sa isang tukoy na file at ang komit ay nagbago ng higit sa file na ito.

4
17 дек. Sinagot ni Otto ang Disyembre 17. 2008-12-17 21:56 '08 at 9:56 pm 2008-12-17 21:56

Narito ang aking paraan.

a) Sa Android Studio, buksan ang file.

b) git → Ipakita ang kasaysayan, hanapin ang nakaraang commit na gusto kong ibalik. Kumuha ng commit_id (hal. Commit hash).

c) git checkout commit_id file_path

1
13 марта '17 в 11:10 2017-03-13 11:10 ang sagot ay ibinigay ni Francis Bacon Marso 13 '17 sa 11:10 2017-03-13 11:10

Kung gumagamit ka ng Mga Extension ng Git at nais mong bumalik sa magu>

1
26 сент. sumagot na ibinigay ng johnny 26 sept. 2017-09-26 04:48 '17 sa 4:48 2017-09-26 04:48

Ito ay isang napaka-simpleng hakbang. I-extract ang file gamit ang commit ID na gusto namin, narito ang isang ID ng gumawa bago, pagkatapos ay patakbuhin ang git commitmend command, at tapos ka na.

 # git checkout <previous commit_id> <file_name> # git commit --amend 

Ito ay maginhawa. Kung gusto naming magpalabas ng anumang file sa anumang tagatukoy ng nakaraang gumawa sa itaas ng gumawa, maaari naming madaling gawin ito.

1
24 янв. Sumagot na ibinigay ni Abhishek Dwivedi noong Enero 24 2019-01-24 20:21 '19 sa 8:21 ng gabi 2019-01-24 20:21
  • 1
  • 2

Iba pang mga katanungan tungkol sa mga tag na o Magtanong ng isang Tanong