Hogyan állíthatsz vissza egy korábbi verziót a GitHubon?

Képzeld el a helyzetet: órákat töltöttél a kódolással, lelkesen fejlesztettél egy új funkciót, vagy éppen javítottál egy hibát. Nyomkodtad a `git add`, `git commit`, `git push` parancsokat, aztán hirtelen rájössz… valami nem stimmel. A legutóbbi változtatások teljesen tönkretettek valamit, vagy egyszerűen rossz irányba vitte a projektet. Pánik? Nem kell! A jó hír az, hogy a verziókezelés, különösen a Git és a GitHub, pont az ilyen helyzetekre lett kitalálva. Nem veszhet el semmi örökre!

Ebben a részletes útmutatóban lépésről lépésre végigvezetünk azon, hogyan állíthatod vissza a kódodat egy korábbi, működő állapotba a GitHubon. Megismerkedünk a különböző módszerekkel, megértjük, mikor melyiket érdemes használni, és eloszlatunk minden félelmet a változások visszavonásával kapcsolatban.

Miért van szükség a verzióvisszaállításra?

Még a legtapasztaltabb fejlesztőkkel is előfordul, hogy szükség van a GitHub visszaállítás funkciójára. Néhány gyakori forgatókönyv:

Hibás funkció: Egy új funkció fejlesztése során hibát követtél el, ami instabillá teszi az alkalmazást.
Visszamenőleges hibajavítás: Egy régi hiba újra felmerül, és rájössz, hogy egy korábbi commit javította, amit azóta felülírtál.
Téves commit: Elköteleztél (commit-oltál) egy olyan kódrészletet, aminek mégsem kellett volna bekerülnie.
Félresikerült merge: Összeolvasztottál két ágat, de az eredmény katasztrofális lett.
Titkos adatok közzététele: Véletlenül jelszavakat, API kulcsokat tartalmazó fájl került a repositoryba. (Ez esetben a visszaállítás csak az első lépés, utána azonnal cseréld a kulcsokat!)

A lényeg, hogy a Git rendkívül rugalmas. Szinte bármilyen hibát orvosolhatsz, feltéve, hogy tudod, melyik eszközt használd.

Git vs. GitHub: A Különbség megértése

Mielőtt belemerülnénk a technikai részletekbe, tisztázzuk a Git és a GitHub közötti különbséget:

Git: Egy elosztott verziókezelő rendszer, ami a helyi gépeden fut. Ez kezeli a kódot, a változások nyomon követését és a különböző verziók közötti váltást.
GitHub: Egy felhőalapú platform, amely a Git repository-k tárolására, megosztására és együttműködésre szolgál. Ez a Git „központja” a csapatod számára, de maga a verziókezelés logikája a Gitben van.

Amikor korábbi verzió visszaállításáról beszélünk, általában Git parancsokat használunk, majd a változtatásokat feltöltjük (push-oljuk) a GitHubra. Bizonyos esetekben a GitHub felületén is tudunk „visszavonni” változásokat, de ez általában a háttérben futó Git parancsokra épül.

Az Arany Szabály: Működj Együtt és Légy Tudatos!

Mielőtt bármilyen visszaállítást végeznél, különösen, ha már megosztottad a kódot a GitHubon, gondolj erre:

Helyi változtatások: Ha a változtatások még csak a te gépeden vannak, és nem pusholtad fel a GitHubra, sokkal rugalmasabban kezelheted őket.
Megosztott változtatások: Ha már felkerültek a változtatások a GitHubra (vagy bármely más távoli repository-ra), akkor a történelem átírása problémákat okozhat más csapattagoknak. Ilyenkor a „biztonságos” módszereket kell előnyben részesíteni.

Mindig kommunikálj a csapatoddal, mielőtt drasztikus lépéseket tennél, különösen, ha a fő ágon (pl. `main` vagy `master`) dolgozol!

Módszer 1: `git revert` – A Biztonságos Visszavonás (Megosztott Történelemre)

A git revert a leggyakrabban javasolt és legbiztonságosabb módszer a változások visszavonására, különösen, ha a kód már felkerült a GitHubra és mások is letöltötték. Miért biztonságos? Mert a git revert nem írja át a történetet, hanem egy *új* commitot hoz létre, ami a kiválasztott commit változtatásait vonja vissza.

Hogyan működik a `git revert`?

Képzeld el, hogy elkövettél egy commitot (Commit B), ami egy hibát vezetett be. A git revert Commit B parancs egy Commit C-t hoz létre, ami *ugyanazokat a fájlokat* módosítja, mint Commit B, de *pontosan az ellenkező* irányba. Így a történelem megmarad, és a hibás Commit B továbbra is látható lesz, de az általa okozott változások érvénytelenítve lesznek az új Commit C által.

Mikor használd a `git revert`-et?

Amikor a változtatások már felkerültek a GitHubra, és mások is lehúzták azokat.
Amikor nem szeretnél történelmet átírni.
Amikor nyilvános repository-ban dolgozol.
Egy konkrét commit változásait szeretnéd visszavonni, de az azt követő commitokat meg akarod tartani.

Lépésről lépésre: `git revert` használata

Keresd meg a visszaállítani kívánt commit hash-ét:
Használd a git log parancsot a commit történet megtekintéséhez. Minden commitnak van egy egyedi azonosítója (hash), ami egy hosszú hexadecimális karakterlánc. Keresd meg annak a commitnak a hash-ét, amit vissza szeretnél állítani.
```
git log --oneline
```
Például, ha látod ezt:
```
abcdef1 Új funkció hozzáadása (hibás)
        1234567 Régi funkció javítása
```
És az `abcdef1` a hibás commit.
Futtasd a git revert parancsot:
Add meg a kiválasztott commit hash-ét. Ha csak az első néhány karakterét adod meg (általában 7-10 karakter), az is elegendő, ha egyértelműen azonosítja a commitot.
```
git revert abcdef1
```
Ez megnyit egy szövegszerkesztőt (pl. Vim vagy Nano), ahol lehetőséged van módosítani a revert commit üzenetét. A Git automatikusan generál egyet, ami általában teljesen elfogadható („Revert „Új funkció hozzáadása (hibás)””). Mentsd el és zárd be a szerkesztőt.
Pushold fel a változásokat a GitHubra:
Mivel egy új commitot hoztál létre, azt fel kell tölteni a távoli repository-ra.
```
git push origin <ág_neve>
```
Ahol <ág_neve> általában main vagy master.

Több commit visszaállítása

Ha több egymást követő commitot szeretnél visszaállítani, megadhatsz egy tartományt:

git revert HEAD~3..HEAD

Ez visszaállítja az utolsó három commitot. A HEAD~3 a harmadik commitot jelenti visszafelé a HEAD-től, a HEAD pedig a legutolsó commit. Fontos megjegyezni, hogy a git revert parancs ebben az esetben fordított sorrendben hajtja végre a visszaállítást (a legújabb komittól a legrégebbi felé). Alapértelmezetten minden commitra külön üzenetszerkesztő nyílik meg, de a --no-edit flag-gel kihagyhatod ezt, és az alapértelmezett üzeneteket használhatod.

git revert -n HEAD~3..HEAD # -n vagy --no-commit: csak a változásokat vonja vissza, de nem commitolja
git commit -m "Visszaállítottam az utolsó 3 commitot" # Majd commitold egyben

Ez utóbbi opció akkor hasznos, ha egyetlen commitba szeretnéd csoportosítani a revertált változásokat.

Módszer 2: `git reset` – A Történelem Átírása (Helyi Változtatásokra)

A git reset egy erőteljes parancs, amely képes *átírni* a repository történetét. Ez azt jelenti, hogy eltávolíthat commitokat, és megváltoztathatja a HEAD mutatót, ami a jelenlegi commitra mutat. Ezt a parancsot csak akkor használd, ha a változtatások még nincsenek feltöltve a GitHubra, vagy ha *tudod*, mit csinálsz, és koordináltad a csapatoddal!

Hogyan működik a `git reset`?

A git reset alapvetően a HEAD pointert mozgatja egy korábbi commitra, és a megadott mód szerint módosítja a munkakönyvtárat és a staging területet. Három fő módja van:

--soft:
Ez a legkevésbé romboló. A HEAD pointert a megadott commitra mozgatja, de a változtatásokat a staging területen hagyja (mintha `git add` parancsot adtál volna ki). A munkakönyvtárad érintetlen marad.
```
git reset --soft <commit_hash>
```
Hasznos, ha elkövettél néhány commitot, amiket egyetlen, jobb üzenetű commitba szeretnél összevonni.
--mixed (Alapértelmezett):
A HEAD pointert a megadott commitra mozgatja, és a változtatásokat a munkakönyvtárban hagyja, de eltávolítja őket a staging területről. A munkakönyvtárad érintetlen marad, de minden korábbi változtatás „unstaged” állapotba kerül.
```
git reset --mixed <commit_hash>
```
Ez az alapértelmezett mód, ha nem adsz meg semmit (`git reset `). Hasznos, ha vissza akarsz menni egy korábbi állapotba, de meg akarod tartani a fájlokon végzett változtatásokat, hogy újra átnézhesd és commitolhasd őket.
--hard:
Ez a legrombolóbb! A HEAD pointert a megadott commitra mozgatja, *és minden változást eldob* a munkakönyvtárból és a staging területről is, ami a kiválasztott commit után történt. Mintha sosem léteztek volna. Ezt óvatosan használd, mert adatvesztéssel járhat!
```
git reset --hard <commit_hash>
```
Hasznos, ha elkövettél egy commitot (vagy többet), amit még nem pusholtál fel, és teljesen meg akarod semmisíteni azokat a változásokat.

Mikor használd a `git reset`-et?

Amikor a változtatások még csak a helyi gépeden vannak, és nem pusholtad fel a GitHubra.
Amikor teljesen át akarod írni a helyi történelmet.
Amikor biztos vagy benne, hogy senki más nem dolgozik azon az ágon, amit visszaállítasz.

Lépésről lépésre: `git reset` használata (Példa `--hard` móddal)

Ellenőrizd a jelenlegi állapotot:
```
git status
```
Győződj meg róla, hogy nincsenek el nem kötelezett (uncommitted) változtatások, amiket nem akarsz elveszíteni!
Keresd meg a cél commit hash-ét:
Azon commit hash-ét, *amelyikre* vissza szeretnél állni. (Tehát a „jó” commitot, nem a „rosszat”.)
```
git log --oneline
```
Például, ha ez a történeted:
```
abcdef1 Rossz commit, amit törölni akarok
        1234567 Jó commit, ide akarok visszatérni
        fedcba9 Kezdeti beállítás
```
A cél hash `1234567`.
Futtasd a git reset --hard parancsot:
```
git reset --hard 1234567
```
Ezzel a HEAD pointer az `1234567` commitra mutat majd, és az `abcdef1` commit által bevezetett változások (és maga az `abcdef1` commit is) törlődnek a helyi repositorydból. A munkakönyvtárad is visszaáll az `1234567` commit állapotára.
(Opcionális, de KOCKÁZATOS) Force Push a GitHubra:
Ha már felpusholtad a törölt commitot a GitHubra, és *nagyon* muszáj átírni a távoli történelmet, akkor egy „force push”-ra lesz szükséged. Ezt csak akkor tedd, ha biztos vagy benne, hogy senki sem húzta le az adott commitot, vagy ha koordináltad a csapatoddal!
```
git push --force origin <ág_neve>
```
A --force-with-lease opció biztonságosabb, mert ellenőrzi, hogy a távoli ág nem tartalmaz-e olyan commitokat, amik a helyi ágon nincsenek meg, ezzel csökkentve a véletlen felülírás kockázatát.
```
git push --force-with-lease origin <ág_neve>
```
Ismétlem: force push-t csak rendkívül körültekintően használj!

Mi van, ha elrontottam a `git reset --hard` parancsot?

Ne ess pánikba! A Git egy nagyon megbocsátó eszköz. Még a git reset --hard után is van esélyed a recoveryre a git reflog parancs segítségével. A reflog (reference log) minden egyes alkalommal rögzíti, amikor a HEAD pointer megváltozik. Ez magában foglalja a commitokat, reselteket, mergeléseket stb.

git reflog

Ez megmutatja a HEAD mozgását. Keresd meg azt az állapotot, amire vissza szeretnél térni (keresd meg a commit hash-ét, ami a *reset előtt* volt), majd futtasd:

git reset --hard <reflog_bejegyzés_hash>

Például, ha a reflogban látod, hogy `HEAD@{2}: commit: Rossz commit`, és vissza akarsz állni a `HEAD@{3}: commit: Jó commit` állapotra, akkor a `git reset –hard HEAD@{3}` parancsot használd.

Módszer 3: Visszavonás Közvetlenül a GitHubon (Pull Requestek)

Néhány speciális esetben a GitHub felülete is kínál lehetőséget a változások visszavonására, különösen pull requestek (PR-ek) esetében.

Pull Request Visszavonása

Ha egy pull requestet már összeolvasztottak (merged) a fő ágba, és rájössz, hogy problémás, a GitHub felületén egyszerűen visszaállíthatod:

Navigálj a repository-dhoz a GitHubon.
Kattints a „Pull requests” fülre.
Keresd meg az összeolvasztott (merged) pull requestet, amit vissza szeretnél állítani, és kattints rá.
A PR oldalán, a leírás alatt általában találni fogsz egy „Revert” gombot. Kattints rá!
A GitHub automatikusan létrehoz egy új pull requestet, amely visszaállítja az eredeti PR által bevezetett változásokat (tehát a git revert parancsot hajtja végre a háttérben).
Nézd át az új PR-t, és ha minden rendben van, olvaszd össze (merge) azt is.

Ez a módszer is egy új commitot hoz létre, így nem írja át a történelmet, és biztonságos a megosztott repositorykban.

Melyik módszert mikor használd? – Gyors Összefoglalás

git revert:
- Mikor? Amikor a commitok már felkerültek a távoli repository-ra (GitHubra), és mások is lehúzták azokat.
- Miért? Mert egy *új commitot* hoz létre, nem írja át a történelmet, így nem okoz problémát a csapattagoknak.
git reset:
- Mikor? Amikor a commitok még csak a helyi repository-dban vannak, és még nem pusholtad fel a GitHubra.
- Miért? Átírja a helyi történelmet, eltávolítja a commitokat, és tisztább állapotot eredményezhet.
- Módok:
  - --soft: A változások a staging area-ban maradnak.
  - --mixed (alapértelmezett): A változások a munkakönyvtárban maradnak (unstaged).
  - --hard: Minden változás elveszik. HASZNÁLD EXTRÉM ÓVATOSAN!
GitHub Pull Request Revert:
- Mikor? Egy összeolvasztott (merged) pull requestet szeretnél visszaállítani.
- Miért? A GitHub felülete egyszerűsíti a folyamatot, szintén git revert-re épül.

Gyakorlati Tanácsok és Legjobb Gyakorlatok

Kommunikáció a csapattal: Ha megosztott repositoryban dolgozol, mindig tájékoztasd a csapattársaidat, ha visszaállítást tervezel, különösen, ha az átírja a történelmet (git reset és --force push).
Használj feature branch-eket: Soha ne dolgozz közvetlenül a main (vagy master) ágon. Hozz létre külön ágakat az új funkciókhoz vagy hibajavításokhoz. Így könnyebben visszaállíthatod a rossz commitokat anélkül, hogy a fő ágat befolyásolnád.
Gyakori commitolás: A gyakori, kisebb commitok segítenek, hogy könnyebben megtaláld a hibás pontot, és célzottabban állíthass vissza.
git status és git log: Gyakran használd ezeket a parancsokat, hogy tisztában legyél a repositoryd aktuális állapotával és a commit történettel.
Ne ess pánikba: A Git egy rendkívül rugalmas eszköz. Szinte mindent vissza lehet állítani, ha tudod, hogyan.

Összefoglalás

A GitHub korábbi verzióra való visszaállítása nem egy ijesztő, hanem egy alapvető készség a modern szoftverfejlesztésben. A git revert és a git reset parancsok (valamint a GitHub UI lehetőségei) rendkívül hatékony eszközök a kezedben, hogy kezelhesd a hibákat, visszavonhasd a nem kívánt változásokat, és megőrizd a projekt integritását.

A legfontosabb, hogy megértsd a különbséget a két fő parancs között, és tudd, mikor melyiket használd – különös tekintettel arra, hogy a változtatások megosztottak-e már, vagy csak helyileg léteznek. Ha ezt megérted, magabiztosan navigálhatsz a Git verziókezelő rendszer labirintusában, és mindig megtalálhatod a helyes utat vissza a működő kódhoz. Sok sikert a verziókezelés GitHubon történő elsajátításához!