როგორ აღადგინებთ დაკარგულ commitებს git reflog-ით?

Question

Accepted Answer

**git reflog** აფიქსირებს თქვენი ბრანჩის HEAD-ის ისტორიას — თითოეულ commit-ს, checkout-ს, reset-ს, rebase-ს და ა.შ. ეს არის უსაფრთხოების ქსელი **დაკარგულ commitებზე** (ცუდი reset-ის, rebase-ის ან ბრანჩის წაშლის შემდეგ) გამოსაყენებლად, რომლებიც სულ დაკარგულ ჩანან, მაგრამ აღადგინებადი არიან.

## რა არის reflog

```text
The REFLOG logs every movement of HEAD (and branch tips) in YOUR local repo:
  → every commit, checkout, reset, rebase, merge, etc. is recorded with a reference
  → it's LOCAL and includes commits not reachable from any branch (the "lost" ones)
→ Even if you reset/rebase away commits, reflog remembers where they were.
```

## დაკარგული სამუშაოს აღდგენა

```bash
git reflog                     # show the history of HEAD movements
# example output:
#   abc123 HEAD@{0}: reset: moving to HEAD~3
#   def456 HEAD@{1}: commit: Important work    ← the "lost" commit!
#   ...

# recover: the lost commit is def456 — get it back
git checkout def456            # inspect it
git branch recovered def456    # create a branch at it (save it)
# or reset back to it:
git reset --hard def456        # restore HEAD to that commit
```

როდესაც commits დაკარგული ჩანს (`reset --hard`-ის, ცუდი rebase-ის ან ბრანჩის წაშლის შემდეგ), `git reflog` აჩვენებს სად იყო HEAD, და თქვენ შეგიძლიათ commit აღადგინოთ მისი hash-ის მიხედვით (მისკენ checkout გაკეთება, ბრანჩის შექმნა ან მის მიერ reset-ი).

## აღდგენის ქვემოთ მოცემული სიტუაციები

```text
✓ After git reset --hard (discarded commits) → find them in reflog, reset back
✓ After a bad rebase (rewrote/lost commits) → reflog has the pre-rebase state
✓ After deleting a branch → its last commit is in reflog → recreate the branch
✓ "Detached HEAD" commits that seem orphaned → reflog finds them
→ As long as commits existed locally, reflog usually can recover them (until GC, ~weeks).
```

## რატომ არის მნიშვნელოვანი

`git reflog`-ის გაგება ღირებული **უსაფრთხოების ქსელი დაკარგული სამუშაოს აღდგენისთვის**, ამიტომ ეს მნიშვნელოვანი პრაქტიკული ცოდნაა, რომელიც შეგიძლიათ გამოიყენოთ უმეცარი შეცდომებისგან დაზღვევის კოდიდან.

Git ოპერაციები, რომლებიც ხელახლა აწერენ ისტორიას ან გადაადგილებენ HEAD-ს — `reset --hard`, წაბლული rebases, ბრანჩების წაშლა — შეიძლება commits **დაკარგული გამოიყურებოდეს**, რაც აღმაშფოვნებელი და უხელი აღმოჩნდება.

მნიშვნელოვანი ფაქტი ის არის, რომ ეს commits ჩვეულებრივ **სულ არ არის დაკარგული**: `git reflog` აფიქსირებს HEAD-ის თითოეულ მოძრაობას ადგილობრივად (თითოეულ commit-ს, checkout-ს, reset-ს, rebase-ს), მათ შორის commits, რომელიც აღარ მისაწვდომელი არსებობენ რაიმე ბრანჩიდან, ამიტომ იგი ახსოვს სად იყვნენ "დაკარგული" commits.

ეს reflog-ს გამძლე **აღდგენის ხელსაწყოფ** აქცევს — როდესაც სამუშაო დაკარგული ჩანს ცუდი reset-ის, წაბლული rebase-ის ან წაშლილი ბრანჩის შემდეგ, თქვენ შეგიძლიათ გამოიყენოთ `git reflog` commit-ის hash-ის მოსაძებნად და ის აღადგინოთ (მისკენ checkout გაკეთება, ბრანჩის შექმნა ან მის მიერ reset-ი).

**აღდგენის ქვემოთ მოცემული სიტუაციების** გაგება (`reset --hard`-ის შემდეგ აღდგენა, ცუდი rebases, ბრანჩის წაშლა და orphaned detached-HEAD commits) და რომ აღდგენა მუშაობს მანამ სამში, რამდენადაც commits უკიდურესად ჯერ კიდევ გარკვევილია (garbage collection-მდე, ჩვეულებრივ კვირების შემდეგ) ღირებული პრაქტიკული ცოდნაა.

ეს უსაფრთხოების ქსელი დამაკმაყოფილებელი და ნამდვილად გამოსადეგი — ეს ნიშნავს, რომ ბევრი "ჩემი სამუშაო დავკარგე!" სიტუაცია აღადგინებადია, რაც აშორებს დიდ ფიქრს Git-ის ისტორია-ხელახლა დაწერილი ოპერაციების გარშემო.

მას შემდეგ, რაც შეცდომები, რომლებიც commits დაკარგულად ჩანან, ხშირია (განსაკუთრებით სწავლისას ან reset და rebase-ის მსგავსი მძლე ბრძანებების გამოყენებისას), და მას შემდეგ, რაც reflog არის ხელსაწყო, რომელიც მათი აღდგენა (ხშირად პანიკა სწრაფი დასწორებაში აქცევს), `git reflog`-ის გაგება — რა აფიქსირებს ის, როგორ აღადგინებთ დაკარგულ commits-ებს, და აღდგენის ქვემოთ მოცემული სიტუაციები — ღირებული, პრაქტიკულად შესაბამისი Git ცოდნა, როგორც აუცილებელი უსაფრთხოების ქსელი, ხელსაწყო, რომელიც იძლევა ნდობას გამოიყენო Git-ის მძლე ფუნქციები იმის ცოდნით, რომ დაკარგული სამუშაო ჩვეულებრივ აღადგინებადი არის, და ნამდვილად დამაკმაყოფილებელი ცოდნა ნებისმიერი დეველოპერისთვის.