මට මේ ආකාරයට පෙනෙන git ගබඩාවක් ඇත:

A -> B -> C -> D -> HEAD

මට ශාඛාවේ හිස A වෙතට යොමු කිරීමට අවශ්‍යයි, එනම් මට B, C, D, සහ HEAD අතුරුදහන් වීමට අවශ්‍යයි. හිස A සමඟ සමපාත වීමට මට අවශ්‍යයි.

මට නැවත ප්‍රතිස්ථාපනය කිරීමට උත්සාහ කළ හැකි බවක් පෙනේ (අදාළ නොවේ, මම අතර වෙනස්කම් තල්ලු කර ඇති බැවින්), හෝ ආපසු හරවන්න. නමුත් මම බහු කොමිස් ආපසු හරවන්නේ කෙසේද? මම වරකට එකක් ආපසු හරවනවාද? ඇණවුම වැදගත් ද?

අදහස් දැක්වීමක මා ලියා ඇති දේ පුළුල් කිරීම

සාමාන්‍ය රීතිය නම්, ඔබ ප්‍රකාශයට පත් කළ ඉතිහාසය නැවත ලිවීම (වෙනස් කිරීම) නොකළ යුතුය, මන්ද යමෙකු ඔවුන්ගේ කෘති ඒ මත පදනම් කර ගෙන ඇති බැවිනි. ඔබ ඉතිහාසය නැවත ලිවීම (වෙනස් කිරීම) කරන්නේ නම්, ඒවායේ වෙනස්කම් ඒකාබද්ධ කිරීම සහ ඒවා යාවත්කාලීන කිරීම සමඟ ඔබ ගැටලු ඇති කරයි.

විසඳුම නිර්මාණය සඳහා, එසේ සිදු නව වන වෙනස්කම් එළඹීම ඔබ ඉවත් කිරීමට අවශ්ය බව. Git revert විධානය භාවිතයෙන් ඔබට මෙය කළ හැකිය .

ඔබට පහත තත්වය ඇත:

A <- B <- C <- D <- master <- HEAD

(මෙහි ඊතල මඟින් යොමුකරන්නාගේ දිශාවට යොමු වේ: කොමිස් සම්බන්ධයෙන් "මව්" යොමුව, ශාඛා ප්‍රධානියාගේ ඉහළම ශාඛාව (ශාඛා යොමු කිරීම) සහ හෙඩ් යොමු කිරීමේදී ශාඛාවේ නම).

ඔබ නිර්මාණය කළ යුතු දේ පහත දැක්වේ:

A <- B <- C <- D <- [(BCD) ^ - 1] <- මාස්ටර් <- HEAD

මෙහි "[(BCD) ^ - 1]" යන්නෙන් අදහස් කරන්නේ B, C, D වල වෙනස්වීම් ආපසු හරවන කැපවීමයි. ගණිතය අපට පවසන්නේ (BCD) ^ - 1 = D ^ -1 C ^ -1 B ^ -1, එබැවින් පහත දැක්වෙන විධානයන් භාවිතයෙන් ඔබට අවශ්‍ය තත්වය ලබා ගත හැකිය:

$ git revert --no-commit D
$ git revert --no-commit C
$ git revert --no-commit B
$ git commit -m "the commit message"

විකල්ප විසඳුමක් වනු ඇත ලොව පුරාවටම අන්තර්ගතයන් ඒ සිදු වන අතර, මෙම රාජ්ය සිදු:

$ git checkout -f A -- .
$ git commit -a

එවිට ඔබට පහත තත්වය ඇත:

A <- B <- C <- D <- A '<- master <- HEAD

බැඳීම A 'හි A හි අන්තර්ගතයට සමාන අන්තර්ගතයන් ඇත, නමුත් එය වෙනස් කැපවීමකි (පණිවිඩය, දෙමව්පියන්, කැපවීමේ දිනය).

මෙම චාල්ස් බේලි විසින් වෙනස් කරන ජෙෆ් Ferland විසින් විසඳුමක්, ඒ හා සමාන අදහස් මත, ඇල්ම, නමුත් භාවිතා GIT යළි පිහිටුවීමේ :

$ git reset --hard A
$ git reset --soft @{1}  # (or ORIG_HEAD), which is D
$ git commit

මට ප්‍රයෝජනවත් වූ පිරිසිදු ක්‍රමය

git revert --no-commit HEAD~3..

මෙම විධානය අවසන් වර්‍ග 3 ආපසු හරවන්නේ එක් බැඳීමක් පමණි.

ඉතිහාසය නැවත ලියන්නේද නැත.

එසේ කිරීම සඳහා ඔබට ආපසු හැරවීමේ විධානය භාවිතා කළ යුතුය.

ඔබේ උදාහරණය සැලකිල්ලට ගනිමින්, ඔබට මෙය කිරීමට සිදුවේ (ඔබ ශාඛාවේ 'මාස්ටර්' යැයි උපකල්පනය කරමින්):

git revert master~3..master

මෙය B, C සහ D වල ප්‍රතිලෝම කැපවීම සමඟ ඔබේ දේශීයව නව බැඳීමක් ඇති කරයි (මෙයින් අදහස් කරන්නේ මෙම කොමිස් විසින් හඳුන්වා දුන් වෙනස්කම් අහෝසි කරනු ඇති බවයි):

A <- B <- C <- D <- BCD' <- HEAD

ජකූබ්ගේ පිළිතුරට සමානව, ආපසු හැරවීම සඳහා අඛණ්ඩ කොමිස් පහසුවෙන් තෝරා ගැනීමට මෙය ඔබට ඉඩ සලසයි.

# revert all commits from B to HEAD, inclusively
$ git revert --no-commit B..HEAD  
$ git commit -m 'message'

git reset --hard a
git reset --mixed d
git commit

එය ඔවුන් සියල්ලන්ටම එකවර ආපසු හැරවීමක් ලෙස ක්‍රියා කරනු ඇත. හොඳ කැපවීමේ පණිවිඩයක් දෙන්න.

ඔබේ වැඩ කරන පිටපත වෙනස් කර නොමැති බවට පළමුව වග බලා ගන්න. ඉන්පසු:

git diff HEAD commit_sha_you_want_to_revert_to | git apply

ඉන්පසු කැප වන්න. ආපසු හැරවීමට හේතුව කුමක්දැයි ලේඛනගත කිරීමට අමතක නොකරන්න.

මෙම ප්‍රශ්නයට පිළිතුරු දිය නොහැකි තරමට මම කලකිරී සිටිමි. අනෙක් සෑම ප්‍රශ්නයක්ම නිවැරදිව ආපසු හරවා ඉතිහාසය ආරක්ෂා කරන්නේ කෙසේද යන්නට අදාළ වේ. මෙම ප්‍රශ්නය පවසන්නේ "මට ශාඛාවේ ප්‍රධානියා A වෙත යොමු කිරීමට අවශ්‍යයි, එනම් මට B, C, D, සහ HEAD අතුරුදහන් වීමට අවශ්‍යයි. හිස A සමඟ සමපාත වීමට මට අවශ්‍යයි."

git checkout <branch_name>
git reset --hard <commit Hash for A>
git push -f

මම ජකුබ්ගේ පෝස්ට් කියවීමට බොහෝ දේ ඉගෙන ගත්තෙමි, නමුත් සමාගමේ සමහර පුද්ගලයෙක් (පුල්-ඉල්ලීමකින් තොරව අපගේ "පරීක්ෂණ" ශාඛාවට තල්ලු කිරීමට ප්‍රවේශය ඇති) ඔහු කළ වැරදි 5 ක් මෙන් තල්ලු කර ඔහු කළ වැරැද්ද නිවැරදි කිරීමට සහ නිවැරදි කිරීමට උත්සාහ කරයි. එපමණක් නොව, අදින්න නරක ඉල්ලීම් එකක් හෝ දෙකක් පිළිගනු ලැබීය. එබැවින් එය අමතක කරන්න, මම අවසාන හොඳ කැපවීම (abc1234) සොයාගෙන මූලික පිටපත ධාවනය කළෙමි:

git checkout testing
git reset --hard abc1234
git push -f

මෙම repo හි සේවය කරන අනෙක් පුද්ගලයින් 5 දෙනාට මම කියා සිටියේ ඔවුන් පසුගිය පැය කිහිපය තුළ ඔවුන්ගේ වෙනස්කම් සටහන් කර ගැනීම සහ නවතම පරීක්ෂණයෙන් පිසදමන්න / නැවත ශාඛාව අතුගා දැමීමයි. කතාවේ අවසානය.

මෙය ජකුබ්ගේ පිළිතුරේ දක්වා ඇති එක් විසඳුමක ව්‍යාප්තියකි

ආපසු හැරවීමට මට අවශ්‍ය වූ කොමිස් තරමක් සංකීර්ණ වූ අතර, කොමිස් කිහිපයක් ඒකාබද්ධ කිරීමේ කොමිස් වන අතර, ඉතිහාසය නැවත ලිවීමෙන් වැළකී සිටීමට මට අවශ්‍ය විය. මට git revertවිධාන මාලාවක් භාවිතා කිරීමට නොහැකි වූයේ අවසානයේදී එකතු කරන ලද ආපසු හැරවීමේ වෙනස්කම් අතර ගැටුම්වලට මා මුහුණ දුන් බැවිනි. මම පහත පියවරයන් භාවිතා කළෙමි.

පළමුව, ශාඛාවේ කෙළවරේ HEAD අතහැර යන විට ඉලක්කගත බැඳීම්වල අන්තර්ගතය පරීක්ෂා කරන්න:

$ git checkout -f <target-commit> -- .

(- - <target-commit>ගොනුවකට වඩා බැඳීමක් ලෙස අර්ථ නිරූපණය කර ඇති බව සහතික කරයි ; වර්තමාන නාමාවලියට යොමු වේ.)

පසුව, ආපසු හරවන ලද කොමිස් වල එකතු කරන ලද ලිපිගොනු මොනවාදැයි තීරණය කරන්න, එබැවින් මකා දැමිය යුතුය:

$ git diff --name-status --cached <target-commit>

එකතු කරන ලද ලිපිගොනු පේළියේ ආරම්භයේ දී "A" සමඟ පෙන්විය යුතු අතර වෙනත් වෙනස්කම් නොතිබිය යුතුය. දැන්, කිසියම් ලිපිගොනු ඉවත් කිරීමට අවශ්‍ය නම්, මෙම ගොනු ඉවත් කිරීම සඳහා වේදිකා ගත කරන්න:

$ git rm <filespec>[ <filespec> ...]

අවසාන වශයෙන්, ආපසු හැරවීම සිදු කරන්න:

$ git commit -m 'revert to <target-commit>'

අවශ්‍ය නම්, අප නැවත අපේක්ෂිත තත්වයට පැමිණ ඇති බවට වග බලා ගන්න:

$git diff <target-commit> <current-commit>

වෙනස්කම් තිබිය යුතු නැත.

හවුල් ගබඩාවක (මිනිසුන් භාවිතා කරන සහ ඔබට ඉතිහාසය සුරැකීමට අවශ්‍ය) කොමිස් සමූහයක් ආපසු හැරවීමට පහසුම ක්‍රමය වන්නේ git revertgit සමඟ භාවිතා කිරීමයි rev-list. දෙවැන්න ඔබට කොමිස් ලැයිස්තුවක් ලබා දෙනු ඇත, හිටපු තැනැත්තා ආපසු හැරවීමම කරයි.

ඒ සඳහා ක්‍රම දෙකක් තිබේ. ඔබට අවශ්‍ය නම් තනි කැපවීමකදී බහු කොමිස් ආපසු හරවන්න:

for i in `git rev-list <first-commit-sha>^..<last-commit-sha>`; do git revert -n $i; done

මෙය ඔබට අවශ්‍ය කැපවීම් සමූහයක් ආපසු හරවනු ඇත, නමුත් ඔබගේ වැඩ කරන ගසෙහි සියලු වෙනස්කම් තබන්න, ඔබ ඒවා සියල්ල සුපුරුදු පරිදි කළ යුතුය.

ආපසු හැරවීමේ වෙනසකට තනි කැපවීමක් තිබීම තවත් විකල්පයකි:

for i in `git rev-list <first-commit-sha>^..<last-commit-sha>`; do git revert --no-edit -s $i; done

නිදසුනක් වශයෙන්, ඔබ වැනි කැපවීමේ ගසක් තිබේ නම්

 o---o---o---o---o---o--->    
fff eee ddd ccc bbb aaa

eee සිට bbb දක්වා වෙනස් කිරීමට , ධාවනය කරන්න

for i in `git rev-list eee^..bbb`; do git revert --no-edit -s $i; done

ඒ කිසිවක් මා වෙනුවෙන් වැඩ නොකළ නිසා ආපසු හැරවීමට මට කොමිස් තුනක් තිබුණි (අවසාන කොමිස් තුන), එබැවින් මම එසේ කළෙමි:

git revert HEAD
git revert HEAD~2
git revert HEAD~4
git rebase -i HEAD~3 # pick, squash, squash

චාම් එකක් වගේ වැඩ කළා :)

මගේ මතය අනුව ඉතා පහසු හා පිරිසිදු ක්‍රමයක් විය හැකිය:

නැවත A වෙත යන්න

git checkout -f A

මාස්ටර්ගේ හිස වත්මන් තත්වයට යොමු කරන්න

git symbolic-ref HEAD refs/heads/master

සුරකින්න

git commit

දෘ hard යළි පිහිටුවීම් වලක්වා ගැනීමට මට සැබවින්ම අවශ්‍ය විය, මෙය මා විසින් ඉදිරිපත් කරන ලද්දකි.

A -> B -> C -> D -> HEAD

A වෙත ආපසු යාමට (එය පියවර 4 ක් පසුපසට):

git pull                  # Get latest changes
git reset --soft HEAD~4   # Set back 4 steps
git stash                 # Stash the reset
git pull                  # Go back to head
git stash pop             # Pop the reset 
git commit -m "Revert"    # Commit the changes

ඔබට අංගයක කොමිස් තාවකාලිකව ආපසු හැරවීමට අවශ්‍ය නම්, ඔබට පහත දැක්වෙන විධාන මාලාව භාවිතා කළ හැකිය.

මෙන්න එය ක්‍රියාත්මක වන ආකාරයයි

git log --pretty = ඔන්ලයින් | grep 'feature_name' | cut -d '' -f1 | xargs -n1 git revert --no-edit