විශේෂිත සංශෝධනයකට ගොනුවක් නැවත සැකසීමට හෝ ආපසු හැරවීමට මට හැක්කේ කෙසේද?

ලිපිගොනු සමූහයක කොටසක් ලෙස කිහිප වතාවක් සිදු කර ඇති ගොනුවක මම යම් යම් වෙනස්කම් සිදු කර ඇත, නමුත් දැන් එහි ඇති වෙනස්කම් පෙර අනුවාදයකට නැවත සැකසීමට / ආපසු හැරවීමට අවශ්‍යය.

මට අවශ්‍ය සංශෝධනය සොයා ගැනීම සඳහා මම git logයම්කිසි git diffදෙයක් කර ඇත, නමුත් අතීතයේ දී ගොනුව නැවත එහි පැරණි තත්වයට ගෙන යන්නේ කෙසේදැයි නොදැන සිටිමි.

ඔබට අවශ්‍ය කැපවීමේ හැෂ් උපකල්පනය කිරීම c5f567:

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

මෙම GIT ලොව පුරාවටම වැඩි විස්තර man පිටුව ලබා දෙයි.

ඔබට පෙර බැඳීමට ආපසු යාමට අවශ්‍ය නම් c5f567, එකතු කරන්න ~1(මෙහි 1 යනු ඔබට ආපසු යාමට අවශ්‍ය කොමිස් ගණන, එය ඕනෑම දෙයක් විය හැකිය):

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

පැති සටහනක් ලෙස, මම සෑම විටම මෙම විධානය සමඟ අපහසුතාවයට පත්ව ඇත්තේ එය සාමාන්‍ය දේවල් (අතු අතර වෙනස් වීම) සහ අසාමාන්‍ය, විනාශකාරී දේවල් (වැඩ කරන නාමාවලියෙහි වෙනස්කම් ඉවතලීම) යන දෙකටම භාවිතා කර ඇති බැවිනි.

Diff විධානය භාවිතා කර ගොනුවක සිදුකරන ලද වෙනස්කම් ඔබට ඉක්මනින් සමාලෝචනය කළ හැකිය:

git diff <commit hash> <filename>

නිශ්චිත ගොනුවක් එම කැපවීමට ආපසු හැරවීමට යළි පිහිටුවීමේ විධානය භාවිතා කරන්න:

git reset <commit hash> <filename>

ඔබට --hardදේශීය වෙනස් කිරීම් තිබේ නම් ඔබට විකල්පය භාවිතා කිරීමට අවශ්‍ය විය හැකිය .

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

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

එම වෙනස්කම් ඒකාබද්ධ කිරීමට ඔබ සුදානම් වන විට ඔබේ ප්‍රධාන පෙළට එරෙහිව එය නැවත ප්‍රතිස්ථාපනය කළ හැකිය:

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

ඔබට වඩාත් පහසු නම් SHA-1 ද ඇතුළුව git commit සඳහා ඕනෑම සඳහනක් භාවිතා කළ හැකිය. කාරණය වන්නේ විධානය මේ ආකාරයට පෙනේ:

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

git checkout -- foo

එය fooHEAD වෙත නැවත සැකසෙනු ඇත. ඔබට ද කළ හැකිය:

git checkout HEAD^ foo

එක් සංශෝධනයක් සඳහා යනාදිය.

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

git checkout HEAD file/to/restore

මට දැන් එම ප්‍රශ්නයම ඇති අතර මෙම පිළිතුර තේරුම් ගැනීමට පහසු බව මට පෙනී ගියේය ( commit-refඔබට ආපසු යාමට අවශ්‍ය ලොගයේ වෙනසෙහි SHA අගයද):

git checkout [commit-ref] [filename]

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

ඔබට ආපසු යාමට කොපමණ කොමිස් ප්‍රමාණයක් අවශ්‍ය දැයි ඔබ දන්නේ නම්, ඔබට මෙය භාවිතා කළ හැකිය:

git checkout master~5 image.png

මෙය ඔබ masterශාඛාවේ සිටින බව උපකල්පනය කරන අතර ඔබට අවශ්‍ය අනුවාදය 5 ක් ආපසු ලබා දේ.

මම හිතන්නේ මම එය සොයා ගත්තා .... http://www-cs-students.stanford.edu/~blynn/gitmagic/ch02.html වෙතින්

සමහර විට ඔබට අවශ්‍ය වන්නේ ආපසු හැරී එක්තරා ස්ථානයක් පසු කළ සෑම වෙනස්කමක්ම අමතක කර දැමීමයි.

ආරම්භ කරන්න:

$ git log

එමඟින් ඔබට මෑත කාලීන කොමිස් ලැයිස්තුවක් සහ ඒවායේ SHA1 හැෂ් පෙන්වයි.

ඊළඟට, ටයිප් කරන්න:

$ git reset --hard SHA1_HASH

ලබා දී ඇති බැඳීමකට රාජ්‍යය යථා තත්වයට පත් කිරීම සහ වාර්තාවෙන් සියලු නව කොමිස් ස්ථිරවම මකා දැමීම.

මෙය මට ප්‍රයෝජනවත් විය:

git checkout <commit hash> file

ඉන්පසු වෙනස සිදු කරන්න:

git commit -a

ඔබ "රෝල්බැක්" යැයි පවසන විට ප්‍රවේශම් විය යුතුය. ඔබ ගොනුවේ එක් අනුවාදයක් $ A හි භාවිතා කර, පසුව වෙනම කොමිස් දෙකකින් වෙනස්කම් දෙකක් සිදු කර ඇත්නම් $ B සහ $ C (එබැවින් ඔබ දකින්නේ ගොනුවේ තුන්වන ක්‍රියාවලියයි), සහ ඔබ කියන්නේ නම් " මට පළමු එකට ආපසු යාමට අවශ්‍යයි ", ඔබ එය ඇත්තටම අදහස් කරනවාද?

දෙවන හා තෙවන පුනරාවර්තන දෙකම ඉවත් කිරීමට ඔබට අවශ්ය නම්, එය ඉතා සරල ය:

$ git checkout $A file

එවිට ඔබ ප්‍රති .ලය ඉටු කරයි. විධානය අසයි "මට කැපවූ $ A විසින් පටිගත කරන ලද ගොනුව පරීක්ෂා කිරීමට අවශ්‍යයි".

අනෙක් අතට, ඔබ අදහස් කළේ දෙවන ක්‍රියාවලිය (එනම් කැපවීම $ බී) ගෙන එන ලද වෙනස ඉවත් කිරීම ය, ගොනුවට කළ කැපවීම තබා ගනිමින්, ඔබට ආපසු හැරවීමට අවශ්‍ය වනු ඇත $ බී

$ git revert $B

බැඳීම $ B නිර්මාණය කළ අය ඉතා විනයගරුක නොවූ අතර එකම කැපවීම තුළ මුළුමනින්ම සම්බන්ධයක් නැති වෙනසක් සිදු කර ඇති අතර, මෙම ප්‍රතිවර්තනය මඟින් ඔබ සිත් රිදවන වෙනස්කම් දකින ගොනුව හැර වෙනත් ලිපිගොනු ස්පර්ශ කළ හැකි බව සලකන්න. ඒ නිසා.

විනෝදජනක ලෙස, git checkout fooවැඩ කරන පිටපත නම් නාමාවලියක තිබේ නම් ක්‍රියා නොකරනු ඇත foo; කෙසේ වෙතත්, දෙකම git checkout HEAD fooසහ git checkout ./fooකැමැත්ත:

$ pwd
/Users/aaron/Documents/work/foo
$ git checkout foo
D   foo
Already on "foo"
$ git checkout ./foo
$ git checkout HEAD foo

rebaseක්‍රියා කරන ආකාරය මෙන්න :

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

ඔබ සතුව ඇතැයි උපකල්පනය කරන්න

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

පළමු විධාන දෙක ... git checkout git rebase master කරන්න

... ඔබට masterශාඛාවට අයදුම් කිරීමට අවශ්‍ය වෙනස්කම් පිළිබඳ ශාඛාව බලන්න. මෙම rebaseවිධානය අනාචාරයේ ගනී <my branch>(දී සොයාගත නොහැකි බව master) සහ හිසට reapplies ඔවුන් master. වෙනත් වචන වලින් කිවහොත්, පළමු කැපවීමේ මවුපියන් <my branch>තවදුරටත් masterඉතිහාසයේ පෙර කැපවීමක් නොව වර්තමාන ප්‍රධානියා වේ master. විධාන දෙක සමාන වේ:

git rebase master <my branch>

"පාදම" සහ "වෙනස් කිරීම" යන ශාඛා දෙකම පැහැදිලි බැවින් මෙම විධානය මතක තබා ගැනීම පහසු විය හැකිය.

. අවසාන ඉතිහාස ප්‍රති result ලය:

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

අවසාන විධාන දෙක ...

git checkout master
git merge <my branch>

... සියලු <my branch>වෙනස්කම් යෙදීම සඳහා වේගයෙන් ඉදිරියට ඒකාබද්ධ කිරීමක් කරන්න master. මෙම පියවර නොමැතිව, නැවත ගෙවීමේ බැඳීම එකතු නොවේ master. අවසාන ප්‍රති result ලය:

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

masterසහ <my branch>යොමු දෙකම B'. එසේම, මෙතැන් සිට යොමු කිරීම මකා දැමීම ආරක්ෂිත වේ <my branch>.

git branch -d <my branch>

Git v2.23.0 වන විට වගකිව යුතු දෙයින් කොටසක් උපකල්පනය කළ යුතු නව git ප්‍රතිස්ථාපන ක්‍රමයක් git checkoutඇත (පිළිගත් පිළිතුරෙහි පවා git checkoutතරමක් අවුල් සහගතය). ගිතබ් බ්ලොග් අඩවියේ වෙනස්කම් වල විශේෂ අවස්ථා බලන්න .

මෙම විධානයේ පෙරනිමි හැසිරීම වන්නේ වැඩ කරන ගසක තත්වය යථා තත්වයට පත් කිරීමයි source පරාමිතියෙන් (ඔබේ නඩුවේ එය කැපවීමේ හැෂ් එකක් වනු ඇත).

එබැවින් ග්‍රෙග් හෙව්ගිල්ගේ පිළිතුර මත පදනම්ව (කැපවීමේ හැෂ් යැයි උපකල්පනය කර c5f567) විධානය මේ ආකාරයෙන් පෙනෙනු ඇත:

git restore --source=c5f567 file1/to/restore file2/to/restore

නැතහොත් c5f567 ට පෙර එක් බැඳීමක අන්තර්ගතයට යථා තත්වයට පත් කිරීමට ඔබට අවශ්‍ය නම්:

git restore --source=c5f567~1 file1/to/restore file2/to/restore

ඉලක්ක ගොනුව සඳහා පළමු යළි පිහිටුවීම

git reset HEAD path_to_file

දෙවන ගොනුව එම ගොනුව

git checkout -- path_to_file

git-aliases, awk සහ shell-functions ගලවා ගැනීම සඳහා!

git prevision <N> <filename>

එහිදී <N>ගොනුව සඳහා වරදක්ද ගොනුව සංශෝධන සංඛ්යාව වේ <filename>.
උදාහරණයක් ලෙස, එක් ගොනුවක පෙර පෙර සංශෝධනය පරීක්ෂා කර බැලීමට x/y/z.c, ධාවනය කරන්න

git prevision -1 x/y/z.c

Git prevision ක්‍රියාත්මක වන්නේ කෙසේද?

ඔබගේ පහත සඳහන් දෑ එකතු කරන්න gitconfig

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

විධානය මූලික වශයෙන්

• a git logනිශ්චිත ගොනුවේ
• ගොනුවේ ඉතිහාසයේ සුදුසු කැපවීමේ හැඳුනුම්පත තෝරා ගනී
• git checkoutනිශ්චිත ගොනුව සඳහා commit-id වෙත a ක්‍රියාත්මක කරයි .

අත්යවශ්යයෙන්ම, මෙම තත්වය තුළ යමෙකු අතින් කළ යුතු සියල්ල,
එක් ලස්සන, කාර්යක්ෂම git-alias - git-prevision වලින් ඔතා.

පළපුරුදු පරිශීලකයින් ව්‍යාකූල නොකර නවකතාවන්ට වඩාත් පහසුවෙන් ළඟා විය හැකි වන පරිදි එසිජිට් මට මෙහි ඇතුළත් කළ යුතුය. එය කරන එක් දෙයක් නම් ඊට වැඩි අර්ථයක් ලබා දීමයිgit revert . මෙම අවස්ථාවේදී, ඔබ සරලව කියන්නේ:

eg revert foo/bar foo/baz

ඔබට පෙර ගොනුවකට ගොනුවක් ආපසු හැරවීමට අවශ්‍ය නම් (සහ දැනටමත් සිදු කර ඇති ගොනුව ආපසු හැරවීමට අවශ්‍ය ගොනුව) ඔබට භාවිතා කළ හැකිය

git checkout HEAD^1 path/to/file

හෝ

git checkout HEAD~1 path/to/file

ඉන්පසු "නව" අනුවාදය වේදිකා ගත කරන්න.

ඒකාබද්ධ කිරීමකදී කැපවීමකට දෙමව්පියන් දෙදෙනෙකු සිටිය හැකි බව දැන ගැනීමෙන් සන්නද්ධව සිටින ඔබ, හෙඩ් ^ 1 පළමු මවුපියන් බවත්, හෙඩ් ~ 1 දෙවන දෙමව්පියන් බවත් දැන සිටිය යුතුය.

ගසෙහි එක් දෙමාපියෙකු පමණක් සිටී නම් එක්කෝ වැඩ කරනු ඇත.

මෙහි බොහෝ යෝජනා, බොහෝ දුරට git checkout $revision -- $file. අපැහැදිලි විකල්ප කිහිපයක්:

git show $revision:$file > $file

විශේෂිත අනුවාදයක් තාවකාලිකව බැලීමට මම මෙය බොහෝ දේ භාවිතා කරමි:

git show $revision:$file

හෝ

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

(OBS: එය වැඩ කිරීමට සාපේක්ෂ මාර්ගයක් නම් එය $fileපෙර සැකසිය යුතුය )./git show $revision:$file

ඊටත් වඩා අමුතු:

git archive $revision $file | tar -x0 > $file

සටහන, කෙසේ වෙතත්, ඒ git checkout ./fooහා git checkout HEAD ./foo නොවේ හරියටම එකම දෙයකි; කාරණය අනුව:

$ 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

(දෙවන addඅදියර ගොනුව දර්ශකයේ ඇත, නමුත් එය බැඳී නොමැත .)

Git checkout ./fooඅදහස් වන්න යා ./fooසිට දර්ශකය ; එකතු HEADකිරීම මඟින් එය HEADකිරීමට පෙර දර්ශකයේ එම මාර්ගය එහි සංශෝධනයට හරවන ලෙස Git ට උපදෙස් දෙයි .

මට කිසිදු පිළිතුරක් සැබවින්ම පැහැදිලිව පෙනෙන්නට නොතිබූ අතර ඒ නිසා මම ඉතා පහසු යැයි පෙනෙන මගේ එකතු කිරීමට කැමැත්තෙමි.

මට බැඳීමක් ඇති abc1අතර ඉන් පසුව මම ගොනුවකට කිහිපයක් (හෝ එක් වෙනස් කිරීමක්) කර ඇත file.txt.

දැන් කියන්න මම ගොනුවේ යම් දෙයක් අවුල් කළ බවත් මට file.txtපෙර කැපවීමකට යාමට අවශ්‍ය බවත් abc1.

1.git checkout file.txt : ඔබට අවශ්‍ය නැතිනම් මෙය දේශීය වෙනස්කම් ඉවත් කරයි

2 . git checkout abc1 file.txt: මෙය ඔබගේ ගොනුව ඔබට අවශ්‍ය අනුවාදයට ගෙන එනු ඇත

3 . git commit -m "Restored file.txt to version abc1": මෙය ඔබගේ ආපසු හැරවීම සිදු කරයි.

4. git push : මෙය දුරස්ථ ගබඩාවේ ඇති සියල්ල තල්ලු කරයි

පියවර 2 සහ 3 අතර ඇත්ත වශයෙන්ම ඔබට git statusසිදුවන්නේ කුමක්ද යන්න තේරුම් ගැනීමට කළ හැකිය . සාමාන්‍යයෙන් ඔබ file.txtදැනටමත් එකතු කර ඇති දේ දැකිය යුතු අතර ඒ නිසා a හි අවශ්‍යතාවයක් නොමැත git add.

1. ගොනුව ආපසු හරවන්න නිශ්චිත බැඳීමකට

git checkout Last_Stable_commit_Number -- fileName

2. ගොනුව විශේෂිත ශාඛාවකට යොමු කරන්න

git checkout branchName_Which_Has_stable_Commit fileName

ගොනුවේ පෙර බැඳීම් අනුවාදයකට යාමට, බැඳීම් අංකය ලබා ගන්න, එවිට eb917a1 කියන්න

git checkout eb917a1 YourFileName

ඔබට අවසන් කැපවූ අනුවාදය වෙත ආපසු යාමට අවශ්‍ය නම්

git reset HEAD YourFileName
git checkout YourFileName

මෙය හුදෙක් ගොනුවේ අවසාන කැපවූ තත්වයට ඔබව ගෙන යනු ඇත

git checkout ref | commitHash - filePath

උදා

git checkout HEAD~5 -- foo.bar
or 
git checkout 048ee28 -- foo.bar

මෙහි බොහෝ පිළිතුරු භාවිතා කිරීමට කියා git reset ... <file>හෝ git checkout ... <file>නොව එසේ කිරීමෙන්, ඔබ සෑම වෙනස් කිරීම් හා ඉන්ධන සපයන්නේ <file>ඔබ වෙත පවරා ගැනීමට අවශ්ය සිදු පසුව සිදු.

ඔබට එක් ගොනුවකින් පමණක් එක් ගොනුවක වෙනස්කම් ආපසු හැරවීමට අවශ්‍ය නම්, එය කළ git revertහැකි නමුත් එක් ගොනුවක් සඳහා පමණි (හෝ බැඳීම් ලිපිගොනු වල උප කුලකයක් කියන්න), මම යෝජනා කරන්නේ ඒ දෙකම භාවිතා කිරීමට git diffසහ ඒ හා git applyසමානව ( <sha>= = හෑෂ් සමඟ) ඔබට ආපසු හැරවීමට අවශ්‍ය කැපවීම):

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

මූලික වශයෙන්, එය මුලින්ම ඔබට ආපසු හැරවීමට අවශ්‍ය වෙනස්කම් වලට අනුරූප පැච් එකක් ජනනය කරනු ඇති අතර, එම වෙනස්කම් අතහැර දැමීමට පැච් එක ආපසු හරවන්න.

ඇත්ත වශයෙන්ම, ආපසු හැරවූ රේඛා <sha1>සහ HEAD(ගැටුම්) අතර කිසියම් බැඳීමක් මගින් වෙනස් කර ඇත්නම් එය ක්‍රියා නොකරනු ඇත .

git logවිශේෂිත අනුවාදය සඳහා හැෂ් යතුර ලබා ගැනීමට භාවිතා කර පසුව භාවිතා කරන්නgit checkout <hashkey>

සටහන: අන්තිම එකට පෙර හැෂ් ටයිප් කිරීමට අමතක නොකරන්න. අන්තිම හැෂ් මඟින් ඔබගේ වත්මන් පිහිටීම (HEAD) පෙන්වා කිසිවක් වෙනස් නොකරයි.

නිසැකවම යමෙකුට git පිළිබඳ බුද්ධිමත් පොතක් ලිවීමට අවශ්‍ය වේ, නැතහොත් ප්‍රලේඛනය තුළ git වඩා හොඳින් පැහැදිලි කළ යුතුය. මෙම ගැටලුවටම මුහුණ දුන් මම එය අනුමාන කළෙමි

cd <working copy>
git revert master

කළ යුතු යැයි පෙනෙන අවසාන කැපවීම අහෝසි කරනු ඇත.

ඉයන්

ඔබට එය පියවර 4 කින් කළ හැකිය:

1. ඔබට විශේෂයෙන් ආපසු හැරවීමට අවශ්‍ය ගොනුව සමඟ සම්පූර්ණ බැඳීම ආපසු හරවන්න - එය ඔබේ ශාඛාවේ නව බැඳීමක් ඇති කරයි
2. මෘදු යළි පිහිටුවීම - බැඳීම ඉවත් කර වෙනස්කම් වැඩ කරන ප්‍රදේශයට ගෙන යයි
3. ලිපිගොනු ආපසු හැරවීමට හා ඒවා කැපීමට හසුරුවන්න
4. ඔබගේ සේවා ස්ථානයේ අනෙක් සියලුම ලිපිගොනු අතහරින්න

ඔබේ පර්යන්තය තුළ ටයිප් කිරීමට අවශ්‍ය දේ :

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 .

වාසනාව

මෙය ඉතා සරල පියවරකි. අපට අවශ්‍ය බැඳීම් හැඳුනුම්පත වෙත ගොනුව පිරික්සන්න, මෙහි එක් හැඳුනුම්පතක් මීට පෙර සිදු කරන්න, ඉන්පසු git commit සංශෝධනය කර අප අවසන් කර ඇත.

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

මෙය ඉතා පහසුය. ඕනෑම ගොනුවක් කැපවීමේ ඉහළින් ඇති ඕනෑම පූර්ව කැපවීමේ හැඳුනුම්පතකට ගෙන ඒමට අපට අවශ්‍ය නම්, අපට පහසුවෙන් කළ හැකිය.

git revert <hash>

දී ඇති බැඳීමක් ආපසු ලබා දෙනු ඇත. එය නවීනතම git revertකැපවීමට පමණක් බලපාන බව ඔබ සිතන බවක් පෙනේ .

ඔබට විශේෂිත ගොනුවක වෙනසක් ආපසු හැරවීමට අවශ්‍ය නම් සහ එම ගොනුවට වඩා එම බැඳීම වෙනස් වුවහොත් එය ඔබගේ ගැටළුව විසඳන්නේ නැත.

ඔබ අවසන් වරට වැරදි ගොනුවක් කළහොත් උපදෙස් අනුගමනය කරන්න:

1. විවෘත මූලාශ්‍ර ගස, මෙම කැපවීමට වෙනස් කරන්න

2. රේඛා වෙනස් කර වැරදි ගොනුවක් බැඳීමක් ලෙස යවා ඇති බවට ඔබේ බැඳීම සොයා ගන්න

3. එම කැපවීමේදී ඔබ කළ වෙනස්කම් ලැයිස්තුව ඔබට දැක ගත හැකිය
4. එය තෝරා ඉන්පසු දකුණු පස ඇති බොත්තම් මත ක්ලික් කරන්න ... ප්‍රතිලෝම ගොනුව ක්ලික් කරන්න
5. එවිට ඔබට එය පහළ වම්පස ඇති ගොනු තත්ව පටිත්තෙහි දැකගත හැකිය, පසුව වේදිකාව මත ක්ලික් කරන්න:

6. ඔබගේ දෘශ්‍ය චිත්‍රාගාර කේතය විවෘත කර ඔබ ඉවත් කළ ලිපිගොනු නැවත සකස් කරන්න
7. ඒ සියල්ලට පසු, මූලාශ්‍ර වෘක්ෂයේ ඔබගේ අවසන් කැපවීමේ ප්‍රති results ල ඔබට දැක ගත හැකිය