ការកែកំហុស (Undo)

មាតិកា

1. ច្បាប់តែមួយ
2. បោះចោលការផ្លាស់ប្តូរដែលអ្នកមិនទាន់ Commit
3. Unstage File មួយ
4. កែ Commit ចុងក្រោយរបស់អ្នក
5. Undo Commit មួយដោយសុវត្ថិភាព៖ git revert
6. ត្រឡប់ទៅអតីតកាលវិញ៖ git reset
7. យកកំណែចាស់នៃ File មួយ
8. សំណាញ់សុវត្ថិភាព៖ git reflog
9. តើខ្ញុំត្រូវការ Undo មួយណា?
10. សាកល្បងដោយខ្លួនឯង

1. ច្បាប់តែមួយ

Git មានវិធីជាច្រើនដើម្បី undo អ្វីៗ ហើយវាចែកជាពីរក្រុម៖

• undo ដែលមានសុវត្ថិភាព បន្ថែមអ្វីមួយថ្មីទៅក្នុង history ដូចជា commit មួយដែលបញ្ច្រាស commit ចាស់មួយ។ គ្មានអ្វីនៅក្នុងអតីតកាលត្រូវបានផ្លាស់ប្តូរទេ។
• undo ដែលសរសេរឡើងវិញ (rewrite) ផ្លាស់ប្តូរ ឬលុប commit ដែលមានស្រាប់។ វាផ្តល់ឲ្យអ្នកនូវ history ដែលស្អាតជាង ប៉ុន្តែអ្នកណាដែលមានច្បាប់ចម្លងនៃ commit ចាស់ទាំងនោះរួចហើយ នឹងជួបបញ្ហា។

ដូច្នេះច្បាប់គឺ៖

សរសេរឡើងវិញតែអ្វីដែលអ្នកមិនទាន់ចែករំលែកប៉ុណ្ណោះ។ មុនពេលអ្នក push commit ទៅ GitHub (ជំពូកទី 8) អ្នកអាចកែវាតាមរបៀបណាក៏បាន។ បន្ទាប់ពីអ្នក push រួច សូមប្រើ undo ដែលមានសុវត្ថិភាព — git revert។

អ្វីៗទាំងអស់នៅក្នុងជំពូកនេះកើតឡើងនៅលើកុំព្យូទ័ររបស់អ្នកផ្ទាល់ ដូច្នេះអ្នកអាចសាកល្បងវាទាំងអស់ដោយសេរី។

2. បោះចោលការផ្លាស់ប្តូរដែលអ្នកមិនទាន់ Commit

អ្នកបានកែ index.html វាខូចទាំងស្រុង ហើយអ្នកគ្រាន់តែចង់បានវាវិញដូចនៅ commit ចុងក្រោយ។ សាកល្បងវា — ធ្វើឲ្យវារញ៉េរញ៉ៃសិន៖

    <h1>asdfasdf BROKEN</h1>

រក្សាទុក។ git status ថែមទាំងណែនាំវិធីជួសជុលទៀតផង៖

  (use "git restore <file>..." to discard changes in working directory)
	modified:   index.html

ដូច្នេះ៖

git restore index.html

file នោះត្រឡប់ទៅកំណែដែលបាន commit ចុងក្រោយវិញហើយ។ ដើម្បីបោះចោល គ្រប់ ការផ្លាស់ប្តូរដែលមិនទាន់ commit នៅក្នុង project សូមប្រើ git restore .។

ប្រយ័ត្ន៖ នេះជារឿងមួយក្នុងចំណោមរឿងតិចតួចដែល Git មិនអាច undo បាន។ ការផ្លាស់ប្តូរដែលអ្នកបោះចោល មិនដែលត្រូវបាន commit ទេ ដូច្នេះ Git មិនដែលរក្សាទុកវាឡើយ។ សូមប្រើ git diff ជាមុនសិន បើអ្នកមិនប្រាកដថាអ្នកជិតបាត់បង់អ្វីខ្លះ។

git restore ក៏អាចយក file ដែលអ្នកលុបដោយចៃដន្យមកវិញបានដែរ ដរាបណាវាមាននៅក្នុង commit ចុងក្រោយ។

3. Unstage File មួយ

អ្នកបានរត់ git add . ហើយ stage file មួយដែលអ្នកមិនចង់ដាក់បញ្ចូល។ យកវាចេញពី staging area — ដោយមិនបាត់បង់ការកែប្រែរបស់អ្នក — ដោយប្រើ៖

git restore --staged index.html

ការផ្លាស់ប្តូរនៅតែមាននៅក្នុង file ដដែល គ្រាន់តែវាលែងនៅក្នុង «ប្រអប់វេចខ្ចប់» ទៀតហើយ។ ម្តងទៀត git status ប្រាប់អ្នកពី command នេះរាល់ពេលដែលអ្នកមានការផ្លាស់ប្តូរដែលបាន stage។

4. កែ Commit ចុងក្រោយរបស់អ្នក

កំហុសទូទៅបំផុតពីរ តែងតែកើតឡើងភ្លាមៗបន្ទាប់ពី commit៖

សរសេរខុសអក្ខរាវិរុទ្ធនៅក្នុង message៖

git commit -m "Add favrite food"     # oops
git commit --amend -m "Add favorite food"

អ្នកភ្លេច file មួយ៖

git add style.css
git commit --amend --no-edit

--amend ជំនួស commit ចុងក្រោយដោយ commit ថ្មីមួយ ដែលរួមបញ្ចូលអ្វីដែលបាន stage ទាំងអស់ បូកនឹង message ថ្មី (ឬ message ចាស់ បើប្រើ --no-edit)។ សូមពិនិត្យ git log --oneline មុន និងក្រោយ៖ hash ផ្លាស់ប្តូរ ព្រោះវាជា commit ថ្មីទាំងស្រុង។

នោះធ្វើឲ្យ --amend ជា undo ដែលសរសេរឡើងវិញ។ ប្រើវាដោយសេរីលើ commit ដែលអ្នកមិនទាន់ push — ហើយកុំប្រើបន្ទាប់ពី push រួច។

5. Undo Commit មួយដោយសុវត្ថិភាព៖ git revert

ឧបមាថាអ្នកសម្រេចចិត្តថា commit "Add favorite food" ពីជំពូកមុន មិនគួរនៅទីនោះទេ។ រក hash របស់វា៖

git log --oneline

d9a4f21 (HEAD -> main) Make heading friendlier
6e3b8c0 Add favorite food
8b1e4d0 Add .gitignore
c47a2e9 Add where I live
3f2a1c9 Add home page

បន្ទាប់មក revert វា៖

git revert 6e3b8c0

Git គណនារកអ្វីដែលផ្ទុយពី commit នោះ — នៅទីនេះគឺការលុបបន្ទាត់អំពីម្ហូប — ហើយធ្វើវាជា commit ថ្មី មួយ។ editor របស់អ្នកបើកឡើងជាមួយ message ដែលរៀបចំរួចស្រេច Revert "Add favorite food"។ រក្សាទុក ហើយបិទវា (ឬបន្ថែម --no-edit ទៅ command ដើម្បីរំលង editor)។

git log --oneline

1c7e5a2 (HEAD -> main) Revert "Add favorite food"
d9a4f21 Make heading friendlier
6e3b8c0 Add favorite food
8b1e4d0 Add .gitignore
...

commit ដើមនៅតែមាននៅក្នុង history — អ្នកគ្រាន់តែបានបន្ថែម commit មួយដែលលុបចោលឥទ្ធិពលរបស់វា។ គ្មានអ្វីត្រូវបានសរសេរឡើងវិញទេ ដូច្នេះវាមានសុវត្ថិភាព សូម្បីតែសម្រាប់ commit ដែលក្រុមទាំងមូលមានរួចហើយ។ សូមកត់សម្គាល់ផងដែរថា អ្នកអាច revert commit ចាស់ជាង មួយ ដោយមិនប៉ះពាល់ដល់ commit ថ្មីៗដែលនៅបន្ទាប់ពីវា។

6. ត្រឡប់ទៅអតីតកាលវិញ៖ git reset

git reset ផ្លាស់ទី branch របស់អ្នកថយក្រោយទៅ commit មុនមួយ ហាក់ដូចជា commit ក្រោយៗមិនដែលកើតឡើងសោះ។ វាជា undo ដែលសរសេរឡើងវិញ ដូច្នេះប្រើវាតែលើ commit ដែលអ្នកមិនទាន់ push ប៉ុណ្ណោះ។

វាមានបីកម្រិត។ នៅក្នុងឧទាហរណ៍នីមួយៗ HEAD~1 មានន័យថា «ថយក្រោយមួយ commit»៖

git reset --soft HEAD~1   # undo the commit, keep the changes staged
git reset HEAD~1          # undo the commit, keep the changes unstaged
git reset --hard HEAD~1   # undo the commit and DELETE its changes

ពីរដំបូងគឺស្រាលៗ។ វាមានប្រយោជន៍នៅពេលអ្នក commit លឿនពេក ហើយចង់ធ្វើ commit នោះឡើងវិញខុសពីមុន — ប្រហែលជាបំបែកវាជាពីរ។

--hard គឺជាមួយដែលគ្រោះថ្នាក់។ វាក៏បោះចោលការផ្លាស់ប្តូរដែលមិនទាន់ commit ទាំងអស់នៅក្នុង file របស់អ្នកដែរ ដូចគ្នានឹង git restore . ដែរ។ មុនពេលអ្នករត់វា សូមរត់ git status ហើយធ្វើឲ្យប្រាកដថាគ្មានអ្វីដែលអ្នកចង់រក្សាទុកទេ។

7. យកកំណែចាស់នៃ File មួយ

ពេលខ្លះ អ្នកមិនចង់ undo commit ទាំងមូលទេ — អ្នកគ្រាន់តែចង់បាន file មួយដូចដែលវាធ្លាប់មាននៅពេលណាមួយក្នុងអតីតកាល៖

git restore --source=3f2a1c9 index.html

ឥឡូវ index.html នៅក្នុង working directory របស់អ្នកដូចគ្នានឹង commit ដំបូងបង្អស់។ file ផ្សេងទៀតទាំងអស់នៅដដែល។ បើអ្នកពេញចិត្តនឹងលទ្ធផល សូម commit វា។ បើមិនពេញចិត្តទេ git restore index.html នាំអ្នកត្រឡប់ទៅកំណែចុងក្រោយវិញ។

8. សំណាញ់សុវត្ថិភាព៖ git reflog

ចុះបើអ្នករត់ git reset --hard ហើយបន្ទាប់មកទើបដឹងថាអ្នកត្រូវការ commit ទាំងនោះ? វាមិនទាន់បាត់ទេ។ Git រក្សាកំណត់ហេតុឯកជនមួយនៃគ្រប់កន្លែងដែល HEAD ធ្លាប់ទៅ ដែលហៅថា reflog៖

git reflog

8b1e4d0 (HEAD -> main) HEAD@{0}: reset: moving to HEAD~3
1c7e5a2 HEAD@{1}: revert: Revert "Add favorite food"
d9a4f21 HEAD@{2}: commit: Make heading friendlier
6e3b8c0 HEAD@{3}: commit: Add favorite food
...

រក commit ដែលអ្នកនៅមុនពេលធ្វើកំហុស — នៅទីនេះគឺ 1c7e5a2 — ហើយ reset ត្រឡប់ទៅវាវិញ៖

git reset --hard 1c7e5a2

អ្វីៗទាំងអស់ត្រឡប់មកវិញហើយ។ reflog មានតែនៅលើកុំព្យូទ័ររបស់អ្នកប៉ុណ្ណោះ ហើយ Git សម្អាតវាចោលបន្ទាប់ពីពីរបីខែ ប៉ុន្តែសម្រាប់គ្រោះថ្នាក់ប្រចាំថ្ងៃ វាជួយសង្គ្រោះអ្នកបាន។

មេរៀនគឺ៖ នៅពេលអ្វីមួយត្រូវបាន commit ហើយ វាពិបាកណាស់ក្នុងការបាត់បង់វាពិតប្រាកដ។ ការងារតែមួយគត់ដែល Git មិនអាចជួយបាន គឺការងារដែលអ្នកមិនដែល commit។ នេះជាមូលហេតុមួយទៀតដែលគួរ commit ឲ្យបានញឹកញាប់។

9. តើខ្ញុំត្រូវការ Undo មួយណា?

10. សាកល្បងដោយខ្លួនឯង

1. បោះចោលការផ្លាស់ប្តូរ។ ធ្វើឲ្យ <h1> របស់អ្នកខូច ពិនិត្យ git diff បន្ទាប់មក git restore index.html។
2. Unstage។ កែ file មួយ git add . បន្ទាប់មក git restore --staged វា។ រត់ git status បន្ទាប់ពីជំហាននីមួយៗ។
3. Amend។ ធ្វើ commit មួយដែលមាន message សរសេរខុស បន្ទាប់មកកែវាដោយប្រើ --amend។ ប្រៀបធៀប hash មុន និងក្រោយ។
4. Revert។ revert commit "Add favorite food" របស់អ្នក ហើយពិនិត្យថាបន្ទាត់នោះបាត់ពី index.html ហើយ commit ថ្មីមួយលេចឡើងនៅក្នុង git log --oneline។
5. Reset ហើយសង្គ្រោះ។ រត់ git reset --hard HEAD~2។ មើល git log --oneline — commit ពីរបាត់។ ឥឡូវប្រើ git reflog ដើម្បីរកកន្លែងដែលអ្នកធ្លាប់នៅ ហើយ git reset --hard ត្រឡប់ទៅវាវិញ។ អ្វីៗទាំងអស់ត្រឡប់មកវិញ។

ឥឡូវនេះ អ្នកអាចពិសោធន៍បានដោយមិនខ្លាច។ បន្ទាប់មកទៀត យើងនឹងធ្វើឲ្យការពិសោធន៍កាន់តែមានសុវត្ថិភាពថែមទៀតជាមួយ branch។