Felhasználói eszközök

Eszközök a webhelyen


oktatas:programozas:verziokontroll:git:a_git_hasznalata

< Git

A Git használata

  • Szerző: Sallai András
  • Copyright © Sallai András, 2014, 2015, 2016, 2019, 2020
  • Licenc: GNU Free Documentation License 1.3

Bevezetés

A Gitről

A Git egy elosztott verziókövető rendszer. Angolul Decentralized Version Control System, röviden DVCS, de Distributed Version Control System rövidítésének is tartják. Ez azt jelenti, hogy a felhasználó nem csak az aktuális verziót tartja a gépén, hanem az egész tároló (repository) tartalmát, ellentétben a központosított rendszerekkel. Ennek az az előnye, hogy hálózat nélkül is tudunk dolgozni (offline).

Az SVN és más hasonló verziókövető rendszerek központosított verziókövető rendszerek. Angolul Centralized Version Control Systems, röviden CVCS. A CVCS alapú rendszerek a commitokat a rendszerbekerüléshez viszonyítják. A Git esetén ez nem így működik. A Git pillanatnyi állapotokat (snapshot) tárol.

A Gitet eredetileg a Linux projekt számára hozta létre Linus Torvalds. Alkalmas nagy projektek használatára. A Gittel parancssorban dolgozunk, de rendelkezésre áll néhány grafikus felületű program is.

A git és a gtihub használatáról Linux alatt a következő helyen találunk leírást. A git szerver telepítéséről pedig itt.

Összehasonlítás más verziókövetőkkel

A Git rendszer eltér más verziókövető rendszerek működésétől, mint amilyen a Subversion vagy a Perforce.

A legfőbb különbség a Git és más verziókövető rendszerek között az adatok kezelésében van. Más verziókövető rendszerek minden állományról készítenek egy mentést. A Git ezzel szemben, ha egy állomány nem változott, akkor azt nem tárolja el. Csak egy mutatót hoz létre az előző verzióra.

Vannak rendszerek, amelyek az állományok egy részéről készítenek csak másolatot. A Git csak a változtatott állományról, de az adott állomány egész részéről.

Telepítés

Debian alapú Linuxon:

apt-get install git

Windowsra innen lehet letölteni:

Grafikus kliens:

apt-get install git-cola

vagy:

vagy ncurses alapú kliens Linuxra:

apt-get install tig

Szervertelepítés Linuxra az oktatás:linux:git szerver lapon.

Telepítés Windowsra Git Windowsra lapon olvasható.

Commit nézegető:

apt install gitk

Működés

Helyi működés

A gitben, amikor fájlokon és más erőforrásokon dolgozunk, minden helyben történik, nincs szükség hálózati kapcsolatra. Így a munkánk gyors és offline lehet. A munkánkat bármikor szinkronizálhatjuk egy központi tárolóval.

Fogalmak

Kommit

A kommit, a fájlokról elmentett pillanatkép. Érdemes úgy megválasztani a kommitjainkat, hogy az logikailag összetartozó egységeket együtt kommitoljuk. A git rendszerben commit alparanccsal használjuk. A kommit a legelemibb tárolandó egység. Érdemes minél sűrűbben kommitolni.

Branch

Fejlesztés egy ága. Amikor készítünk egy projektet és azt a Git-be helyezzük, lesz egy fő (master) baranch-ünk. Ebből újabb branchokat hozhatunk létre. A háttérben egy branch létrehozása egy mutató az utolsó állapotra. Egy branch tulajdonképpen kommitok összessége.

Clone

Távoli gépről másolatot készíthetünk egy branch-ről.

Checkout

A branchek közötti váltásra használható.

Push

Ha kiadok egy commit parancsot, akkor az csak helyben történik – nem úgy mint az SVN-ben. A központi szerverrel való szinkronizáláshoz szükségünk van a Push műveletre a push paranccsal.

Egy mutató, ami a munkánk során az aktuális branch-ra mutat.

Munkakönyvtár

A munkakönyvtár az a könyvtár, amelyben létrehozzuk a forrásállományainkat, és ahol dolgozunk rajtuk. Ez tulajdonképpen a projekt könyvtára.

Stage

A stage egy átmeneti hely. Azokat az állományokat, amelyeket most hoztunk létre vagy módosítottuk a stage helyre kell tenni, ha szeretnénk követett állapotba tenni.

Repository

Tároló, ahol a fájlok tárolásra kerülnek. A helyi gépen a tároló valójában a .git könyvtárban van. A távolig szerveren, egy .git kiterjesztésű könyvtár a szokásos tárolási hely.

Helyi tároló

A helyi tároló a munkakönyvtár, a stage hely és a repository helyek együttese.

upstream

A távoli tároló, ahova mindenki feltölt.

downstream

A helye tároló ahol dolgozol.

Kliens-szerver felépítés

A git szerver-kliens alapú, de használható szerver nélkül is, mivel kliens oldalon is tárolódik az összes állomány. Alapvetően egy helyi tárolóban dolgozunk, a szerverre egy push művelettel töltjük fel az adatainkat.

A letöltés, clone, pull és fecth műveletekkel lehetséges.

Fájlok állapota

A fájlok a munkakönyvtárunkban alapvetően két állapota lehet:

  • untracked - nem követett
  • tracked - követett
    • modified - módosult a commit óta
    • unmodified - a commit óta nem módosult
    • staged - a legközelebbi commit esetén tárolásra kerül

Pillanatképek

A git segítségével a munkánkról pillanatfelvételeket készítünk. Minden felvétel kap egy azonosítót.

Amikor elindítjuk a fejlesztések pillanatfelvételeit egy úgynevezett master ágat, vagy angolosan branch-et hozunk létre. Később más ágakat is fogunk használni, és mindig a HEAD mondja meg éppen melyik ággal dolgozunk.

Minden pillanatkép tartalmaz egy mutatót az előző pillanatképre.

Kezdő lépések

Bemutatkozás a Git számára

A git számára meg kell adni egy teljes nevet, és egy e-mail címet. Ez a név és cím fog megjelenni, minden kommitban.

git config --global user.name "Keresztnév Vezetéknév"
git config --global user.email "joska@zold.and"

Ezek az adatok a ~/.gitconfig nevű fájlban kerülnek tárolásra, vagyis az adott felhasználónak globális lesz, vagyis minden projekthez ezt fogja használni.

Állítsuk be a kedvenc szövegszerkesztőnket.

git config --global core.editor mcedit

Állítsuk be színes kiíratás is:

git config --global color.ui true

Lekérdezés:

git config user.name

Beállítások lekérdezése:

git config --list

A lehetséges kimenete:

user.email=joska@zold.and
user.name=Nagy Jozsef
giggle.main-window-maximized=false
giggle.main-window-geometry=700x550+1192+459
giggle.main-window-view=FileView
push.default=simple
core.repositoryformatversion=0
core.filemode=true
core.bare=false
core.logallrefupdates=true
remote.origin.url=https://github.com/joska/myprojekt
remote.origin.fetch=+refs/heads/*:refs/remotes/origin/*
branch.master.remote=origin
branch.master.merge=refs/heads/master

Kérdezzük le, hol tárolja a git ezeket az adatokat:

git config --list --show-origin

Helyi munka

Új projekt

mkdir TesztProjekt
cd TesztProjekt
git init

A git init parancs létrehoz a TesztProjekt könyvtárban egy .git könyvtárat. Ez tulajdonképpen egy helyi adatbázis, ami eltárolja a projektünk verzióit, és minden azzal kapcsolatos információt.

Azt is mondhatjuk, hogy a projektünk, most már a Git része.

Használat

Kérdezzük le a fájlok státuszát:

git status

Most hozzunk létre egy állományt:

touch readme.txt

Kérdezzük le újból a státuszt:

git status

A git add paranccsal a stage helyre tesszük a fájlokat, majd a commit paranccsal elkészítjük a pillanatképet.

Tegyük követett állapotba a readme.txt fájlt:

git add readme.txt

Innentől kezdve commit esetén ez az állomány is tárolásra kerül.

Most nézzük meg újra a státuszt:

git status
# On branch master
#
# Initial commit
#
# Changes to be committed:
#   (use "git rm --cached <file>..." to unstage)
#
#	new file:   readme.txt
#

A Changes to bi commited után felsorolt állományok staged állapotban vannak.

Változtassuk meg a readme.txt állományt:

echo "egy" > readme.txt

Ellenőrizzük a státuszt:

git status
# On branch master
#
# Initial commit
#
# Changes to be committed:
#   (use "git rm --cached <file>..." to unstage)
#
#	new file:   readme.txt
#
# Changes not staged for commit:
#   (use "git add <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#	modified:   readme.txt
#

Adjuk hozzá újra readme.txt fájlt:

git add readme.txt

Nézzük meg a státuszt:

git status
# On branch master
#
# Initial commit
#
# Changes to be committed:
#   (use "git rm --cached <file>..." to unstage)
#
#	new file:   readme.txt
#

Fűzzünk megint valamit readme.txt fájlhoz:

echo "ketto" >> readme.txt

Nézzük meg a változásokat a diff paranccsal:

git diff

A diff parancs csak akkor fog látni egy állományt ha az nincs staged állapotba.

Ha a staged állapotú állományokat is szeretnéd látni:

git diff --cached

Commit

A staged állapotú állományok tárolásra kerülnek.

git commit

A git megnyitja egy szövegszerkesztőt a megjegyzés leírásához.

A szövegszerkesztő beállítása:

git config --global core.editor mcedit

Persze mi magunk is megadhatjuk a parancssorban a megjegyzéseket:

get commit -m "Egy és kettő hozzáadása"

A kommit módosítása:

git commit --amend

Ha szeretnénk a commit tulajdonosát és/vagy e-mail címét megváltoztatni:

git commit --amend --author="Vezetéknév Keresztnév <felhasznalonev@tartomanynev.hu>"

Ügyeljünk arra, hogy a beállított szövegszerkesztővel meg fog nyílni, a commit szövege. Az alapértelmezett szövegszerkesztő pedig Windowson is a vim. Állítsuk be a jegyzettömböt, ha nem megy a vim használata. Ha megnyílt a commit és azt nem akarjuk szerkeszteni (csak a nevet és az e-mail címet akartuk változtatni), akkor csak simán lépjünk ki belőle. Kilépés vimből mentés nélkül:

<Esc>:q!<Enter>

A név és az e-mail cím megváltozik.

Tegyük fel, hogy korábbi commitot szeretnénk változtatni. A következő commitok vannak:

  • egy
  • ketto
  • harom
  • negy
  • ot
  • hat

A HEAD a „hat” commitra mutat, mi pedig szeretnénk megváltoztatni a „harom” és a „negy” commitot. A következőket tegyük:

Adjuk meg, hogy a „ketto” után szeretnénk javítani:

git rebase -i ketto

A megadott szövegszerkesztőben a commitokat látjuk felsorolva. Jelöljük meg az „harom” és a „negy” kommitokat szerkesztésre az „edit” szóval. Mentsünk, lépjünk ki a szerkesztőből. Végezzük el a változtatást:

git commit --amend --author="Vezetéknév Keresztnév <felhasznalonev@tartomanynev.hu>"

Lépjünk tovább:

git rebase --continue

Most a „negy” commitnál vagyunk. Végezzük el a változtatásokat:

git commit --amend --author="Vezetéknév Keresztnév <felhasznalonev@tartomanynev.hu>"
git rebase --continue

Elkészült.

A commit paranccsal a helyi tárolóba kerültek a fájlok. Nézzük meg mik vannak tárolva:

git ls-files

Esetleg:

git ls-tree --full-tree -r HEAD

A státusz rövidítése:

git status -s

Automatikus stage állapotba:

git commit -a -m 'Valami'
git commit --all --message 'Valami'

Próba:

git commit --dry-run

Napló

git log

A commit-ok adatait tekinthetjük meg.

git log --abbrev-commit
git log --oneline
git log --no-notes
git log --pretty="format:%h %s %d"

A kimenet hasonló lehet:

5345711 Első sor beírva  (HEAD, master)
d78adf3 Kezdés

Kimenet díszítve, ágak mutatása:

git log --oneline --decorate --graph --all

Fájlok törlése

git rm readme.txt

Ezzel a paranccsal töröljük fizikailag az állományt, töröljük a stage-ről és a tracedek közül.

Ha nem szeretnénk törölni a stage-ről és a tracedek közül, akkor használjuk a --cached kapcsolót.

git rm --cached readme.txt

Utolsó két commit:

git log -2

Commit-ok közötti különbségek:

git log -p

Fájlok, könyvtárak átnevezése

Úgy szeretnénk átnevezni, hogy az verziókezelve legyen. Az mv parancsot nem szükséges önmagában használni, a git mv parancs megoldja a fizikai átnevezést is. A git rm után csak egy commit szükséges:

git mv eredetiNev ujNev
git commit -m "Átnevezve"

Fájlok kizárása a Gitből

Néhány állományt szeretnénk majd kizárni a Git tárolónkból. Ez úgy tehetjük meg, ha felvesszük a következő állományba:

.gitignore

Ezek nem jelölhetők meg untraced állapotúként és nem lehetnek commitólni sem.

Példa:

.gitignore
*.class
 
# Csomagfájlok #
*.jar
*.war
*.ear
 
*.old

Linux alatt több információ:

man gitignore

A .gitignore állományt adjuk hozzá a tárolóhoz.

git add .gitignore

Módosítás különbségei

Nézzük meg az utolsó és az utolsó előtti kommit különbségét. Kommit után már csak a kommitok azonosítójának megadásával tudjuk megtenni.

git log -2
git diff 2343..3432

Ha még nem volt kommit, akkor elég a git diff:

git add fajlnev.txt
git diff

Ha csak egy behúzás volt a módosítása, de soron belül egyébként semmi nem változott, akkor is változásnak fogja fel:

-eredeti sor
+     eredeti sor

A -w kapcsolóval, kizárhatjuk a whitespace karakterek figyelését:

git diff -w 2343..3432

Két külön ág közötti különbség:

git diff master..devel-1

Ki változtatott

Lekérdezhetjük, az adott fájlban adott sort ki változtatta meg. Ezt a blame alparanccsal tehetjük meg.

git blame readme.txt

Néhány kapcsoló:

git blame -w  # whitespace elutasítása
git blame -M  # szöveg mozgatás elutasítása
git blame -C  # szöveg mozgatása másik fájlba elutasítva

Visszaállítás

Unstaged local changes (before you commit)

Nézzük, hogyan tudunk visszaállni az utolsó commit állapotába. Még commit előtt vagyunk és a fájlok még nincsennek a staged állapotban.

Kérdezzünk le egy státuszt:

git status

Így láthatjuk milyen fájlokról lehet szó, pontos útvonallal.

Egy fájl visszaállítása:

git checkout -- <fájl>

Az összes változtatás visszaállítása (még nem volt git add):

git reset --hard

Az összes változás visszaállítása, a jelenlegi mentésével, későbbi felhasználás esetére.

git stash

Ha már volt git add, vagyis staged helyen van, akkor a visszavonás:

git reset --hard HEAD

Az összes verzió mutatása, ami már nem szerepel commitként, azt is:

git log --reflog

Munka a távoli szerverrel

Helyi változat létrehozása

A clone parancsot akkor használjuk, ha olyan tárolóval szeretnénk dolgozni, amelyik nem áll rendelkezésre a helyi gépünkön.

Ha szeretnénk dolgozni projekt1.git projekten, akkor a clone paranccsal töltsük le:

git clone 192.168.5.103:/home/git/projekt1.git

A javításokat visszatölthetjük, a push paranccsal.

A felhasználó a saját könyvtárára így is hivatkozhat:

git clone ssh://usernev@servernev/~/projekt1.git
git clone usernev@servernev:/~/projekt1.git

Név URL összerendelés

Ahhoz, hogy a távoli gépre fel tudjunk tölteni létre kell hoznunk egy nevet és egy hozzátartozó URL-t.

Az elsődleges név szokásosan az „origin” szokott lenni.

Hogy milyen összerendelések vannak, a következő képen kérdezhetjük le:

git remote

A következőben egy ilyen hozzárendelést látunk:

git remote add origin ssh://usernev@servernev/~/repo/projekt1.git

Most megint nézzük meg, milyen összerendelések vannak:

git remote

Ha használjuk a -v kapcsolót is, akkor azt is kiírja milyen URL tartozik az adott névhez.

Ha szeretnénk megváltoztatni egy nevet akkor a „rename” alparancs segít:

git remote rename origin masiknev

Törlés:

git remote rm masiknev

URL javítása:

git remote set-url origin ssh://usernev@servernev/~/repo/projekt1.git

Az URL változtatása másként:

git remote set-url origin git@192.168.5.103:/home/git/zold.git

Tartalom frissítése

Szeretnénk egy távoli tárolóból frissíteni a munkakönyvtárunkat.

Lépjünk a munkakönyvtárba:

cd c:\tervek\zold

Feltételezzük, hogy be van állítva a távoli tároló:

Leszedjük a tároló tartalmát:

git pull origin master

A pull parancsot, akkor szoktuk használni, ha rendelkezésünkre áll egy .git könyvtár. Ha nincs .git könyvtárunk, vagyis nincs munkaanyagunk, akkor git clone parancsot használjuk. A git pull parancs felülírja a helyi állományokat.

Tartalom letöltése megtekintésre

A git fetch paranccsal úgy tölthetjük le az állományokat, hogy nem írja felül a helyi állományokat. Egy külön branchként töltődik le.

Letöltés:

git fetch origin master

Ezek után lesz egy remote/origin/master branch-önk, ha erre váltunk, megnézhetjük a szerverről letöltött frissítést. Ilyenkor változás a másik branch-re:

git checkout remotes/origin/master

A git diff paranccsal megnézhetjük a különbséget:

git diff master..origin/master

Ha szerverről leszedett állományok megfelelnek, akkor összeolvaszthatjuk a helyi állományokkal:

git merge master origin/master

Feltöltés

Ha git clone paranccsal szedtük le a munkaanyagot, akkor elég a git push parancs:

git push

Teljes példa:

git push origin master

A --tags kapcsolóval, a címkék is feltöltésre kerülnek, ha vannak.

git push --tags origin master

Egyszerre két branch is feltölthető:

git push origin master devel

Távoli tárolóból szeretnénk dolgozni

Ha nincs meg git adatbázis, klónozzunk:

git clone usernev@valahol.hu:projektnev

Mit tartalmaz a távoli tároló?

A show parancs közbeiktatásával azt is megtudhatjuk mit tud rólunk a távoli szerver.

git remote show origin

Távoli tároló utolsó commit

git rev-parse origin/master

Például:

$ git rev-parse origin/master
817c888d15575a0fedfa78280bdc42a18f956168

gitk

A gitk egy git tároló böngésző.

Megmutatja a tárolóban történt változásokat, a kiválasztott kommitokat. A gitk ezeket vizuálisan is megjeleníti, miközben megmutatja a kommitok kapcsolatát.

Egyik gyakran használt kapcsolója a --all, amely az összes változat megmutatására utasít. Ha ezt nem használjuk, akkor csak az aktuális változat, például a master ágat mutatja.

Távoli elágazások

git branch -a

Kezdőpont ez legyen:

git checkout -b fejlesztes remotes/origin/fejlesztes

Helyben is létrejön és aktív is lesz.

Elágazás

Elágazás létrehozása

Az elágazás a Git-ben a branch. A branch alparanccsal tudunk egy külön elágazás létrehozni. Amikor létrehozunk egy git projektet, a főágban dolgozunk, aminek a neve „master”. Az újabb elágazásnak, egy új nevet kell adnunk. Az elágazás létrehozása:

git branch <ujagneve>

Példa

git branch devel1

Ezek után egy külön ágon is fejleszhetünk:

A parancs, csak létrehozza a branch-et, de a HEAD nem áll át. Ha szeretnénk átállni a devel1 ágra, használjuk git checkout parancsot:

git checkout devel1

Egy másik példa kedvéért legyen egy projekt, amely három állományból áll, A1, B1 és C1. Lásd az ábrán:

A továbbfejlesztés eredményeként, létrejön a A2, B2 és C2, megint továbbfejlesztve A3, B3 és C3. Ha létrehozok egy branchet, akkor egy külön ágon másolat jön létre a három állományból. A képen az első kommit után egy branchet is készítettünk, amely egy külön ágat alkot.

A létező branchek listázásához írjuk a parancssorba:

git branch

Ha létrehoztunk egy devel-1 branchet, akkor ehhez hasonlót kell lássunk a kimenetben:

  devel-1
* master

A * karakter mutatja az aktív branchet.

Átállás másik elágazásra

Másik branch-re – elágazásra – átállás a checkout alparanccsal lehetséges:

git checkout <ujagneve>

A kiadott parancsok ez után a ujagneve nevű branch-on hajtódnak végre.

Helyi és távoli branch

Alapértelmezetten csak a helyi brancheket láthatjuk. A helyi és távoli branchet a -a vagy --all kapcsolókkal tekinthetjük meg:

git branch -a

Branch példa

Hozzunk létre egy devel-1 branchet:

git branch devel-1

Branch név általános példák:

  • devel-1
  • feature-1
  • ficsor-1
  • kiserlet-1
  • fejlesztes-1
  • sajatossag-1
  • jokod

Álljunk át a devel-1 elágazásra:

git checkout devel-1

Álljunk vissza a főágra:

git checkout master

A -b azonnal létre hozza a devel-2 ágat, ha az nem létezik:

git checkout -b devel-2

Branch példa ábrákkal

Tegyük fel, hogy van egy master águnk, ahol már volt 3 commit, vagyis van három pillanatképünk. Készítünk egy devel1 nevű ágat, a git branch devel1 paranccsal. A HEAD ettől nem áll át automatikusan.

Ha átállunk a git checkout devel1 utasítással a devel1 ágra, akkor a HEAD át áll, vagyis innentől kezdve a devel1 ágra mutat.

Fejlesztünk a devel1 ágon, majd a commit paranccsal elkészítjük a pillanatképet.

Most visszaállunk a master ágra.

A master ágon is fejlesztünk, majd a commit paranccsal elkészítjük a pillanatképet.

Branch törlése

Töröljük a branchet:

git branch -d devel-01

A nyomai megmaradnak.

Nyomtalanul törlés:

git checkout master
git branch -D devel-01

A -D esetén nem ellenőrzi, hogy volt-e merge, ezért óvatosan.

Branch átnevezése

git branch -m devel-01 ficsor-01

Branchek összefésülése

Adott a master és a fejlesztes branch. Szeretnénk a masterbe fésülni a fejlesztes branchet. Átváltok a master ágra, majd összefésülök:

git checkout master
git merge fejlesztes
gitk

A fast forward az jelenti problémamentesen össze lett fésülve. Ilyenkor a gitk-ban látszik hogy a két branch azonos.

Konfliktus esetén szerkesszük a fájlt és töröljük a >>>>, =====, >>>>> sorokat. Majd kommit.

Segítség

A git help parancs önmagában is segít. Kiírja milyen alparancsai vannak a gitnek:

git help

Ezek után már könnyű megnézni egy alparancsról mit kell tudni:

git help <parancs>

Néhány alternatíva:

git <parancs> --help
man git-<parancs>

Például:

git help config

Az alparancsokról kézikönyvet a Debian GNU/Linux rendszereken így is kérhetünk:

man git <alparancs>

git gui

A git rendelkezik egy gui nevű alparanccsal is. Ekkor beindul egy grafikus felület, ahol git műveleteket kattintgatva tudjuk végrehajtani.

Egyszerűen írjuk be parancssorba:

git gui

Linux alatt külön telepszik:

apt install git-gui

Egyéb beállítások

Ékezetes fájlnevek:

git config --global core.quotepath false

Automatikus színezés:

git config --global color.ui auto

Álnevek létrehozása:

git config --global alias.co checkout
git config --global alias.ci commit
git config --global alias.gl "git log"

CR cseréje CRLF-re:

git config core.autocrlf true

Értéke true, false vagy input lehet.

core.autcrlf=true

       repo
      /    \
     /      \
crlf > lf   lf>crlf



core.autcrlf=input

       repo
      /    \
     /      \
crlf > lf    \



core.autcrlf=false

       repo
      /    \
     /      \
    /        \

Címkézés

Az egyes kommitok azonosítói elég barátságtalanok egy átlagember számára. Lehetőségünk van az egyes kommitokhoz egy címkét rendelni, így az azonosító szám helyett, használhatjuk ezt a címként. Címkét a már végrehajtott kommithoz rendelhetünk. A kommit után csak írjuk be:

git tag cimke01

Ellenőrizzük a gitk paranccsal:

gitk

A használatban lévő címkéket lekérdezhetjük ha a tag alparancsnak nem adok meg paramétert:

git tag

Újabb kommit után a címke az előző kommithoz fog tartozni. Például:

echo "új sor" >> vmi.txt
git add vmi.txt
git commit
gitk

A címkék lehetővé teszik a könnyebb állapotváltást. Például:

git checkout cimke01
gitk

Itt még visszaválthatok az előző kommitra:

git checkout master

Az újabb commithoz adjunk egy újabb címkét.

git tag cimke02
gitk

A diff parancs is könnyebben használható címkékkel:

git diff cimk01..cimke02

A címke a törölhető a következő módon:

git tag -d cimke02

Kommitok eldobása

Ha még nem volt commit, de a változásokat szeretném eldobni:

git reset --hard

Az utolsó kommit óta eltelt minden változat eldobva.

git status

A fájlból is eltünik.

A hash azonosítóra hivatkozva, bármely kommit eldobható.

Megnézem a naplót:

git log

Kikeresem azt az utolsó kommitot amit még szeretnék megtartani.

git reset --hard 3483fg34

A HEAD ezentúl ide fog mutatni.

A kommit szövegének cseréje

git commit --amend

Az alapértelmezett szövegszerkesztőben megnyílik és javíthatjuk.

Átmeneti mentés

git status
touch ujfajl.txt
git add ujfal.txt
git commit

Módosítom a fájlt:

echo körte > ujfajl.txt
git status

Ezt a fájlt szeretnénk ideiglenesen eltenni:

git stash save "változat egy"
git status

Újra a régivel folytatom.

echo szilva > ujfajl.txt
git stash save "változat kettő"
git status

Két fájl átmeneti tárolóba került. Listázzuk ezeket a fájlokat:

git stash list

A kimenet ehhez hasonló lesz:

stash@{0}: On master: változat egy
stash@{1}: On master: változat kettő

Részletesebb információ:

git stash show

Esetleg a -p paraméterrel a különbségek is megjelennek.

git stash show -p stash@\{0}

A másik fájl:

git stash show -p stash@\{1}

Módosítás alkalmazása:

git stash apply

A legutoljára elmentett kommitot alkalmazza.

git stash list

Fájl tartalmának ürítése:

git reset --hard
git stash list

Utoljára elmentett kommitot törli és alkalmazza:

git stash pop

Megadhatjuk melyik kommit legyen:

git stash pop stash@\{0}
git stash list
git status

Nézzünk bele a fájlba. Ott van.

Átmeneti tárolóból törlés:

git stash drop

Így, paraméter nélkül, az utolsót törli.

Archívum készítés

A munkakönyvtárról készíthetünk archívumot, adott formátumban. A hozzáférhető formátumok a -l vagy --list kapcsolóval kérdezhetők le.

git archive -l

LinuxMint rendszeren nálam a következő lehetőségeket kapom:

tar
tgz
tar.gz
zip

Tar csomag készítése

git archive HEAD > ../csomag.tar

Vagy tömörítve:

git archive HEAD | gzip > ../csomag.tar.gz

Esetleg adjuk meg a formátumot:

git archive HEAD --format=tar.gz > ../csomag.tar.gz

Utolsó commit

Az utolsó előtti és az utolsó commit közötti keletkezett könyvtárak és fájlok archiválása:

git archive -o ../utolso.zip HEAD $(git diff --name-only --diff-filter=d HEAD^..HEAD)
  • git diff --name-only --diff-filter=d HEAD^..HEAD
    • Az utasítás megadja az utolsó előtti és az utolsó commit könyvtárakat és fájlokat.
    • --name-only
      • a fájlokat tartalmak nélkül, mutatja.
    • --diff-filter=d
      • A törölt fájlokat nem szeretnénk.
    • HEAD^..HEAD
      • ez mondja meg mely fájlokról van szó
      • Az utolsó HEAD elhagyható: HEAD^..HEAD

Ha az utolsó előtti, előtti commit-tól szeretnénk:

HEAD-2..

Használhatjuk a tar parancsot is:

tar -czf utolso.tar.gz $(git diff --name-only --diff-filter=d HEAD^..HEAD

Takarítás

Ellenőrizzük, hogy sérültek-e az adatok:

git fsck
Checking object directories: 100% (256/256), done.

Ellenőrizzük le, mennyi adatot foglal egy .git könyvtárunk:

du -sb .git

Ekkor bájtban megadva láthatjuk az eredményt. Például:

81706	.git

Ha Kibibájtban szeretnénk:

du -sh .git

Az eredmény ehhez hasonló:

160K

Ha felesleges objektumok vannak, egy egyszerűen tömöríteni kellene, akkor használjuk a git gc parancsot:

git gc

A futás után egy lehetséges kimenet:

git gc
Counting objects: 3, done.
Writing objects: 100% (3/3), done.
Total 3 (delta 0), reused 0 (delta 0)

Ezek után ellenőrizzük újra a könyvtár méretét:

du -sb .git
70834	.git
du -sh .git
148K	.git

Összefésülés

merge

Legyen egy háromszög kerület, területszámító program, amelyet eddig fejlesztünk:

Program01.java
class Program01 {
	public static void szamitHaromszog() {
		int 3 + 4 + 5;
	}
	public static void main(String[] args) {
		System.out.println("Hi");
	}
}

Ekkor csinálunk rá egy elágazást. Legyen a neve: devel.

git branch devel

Ezt az ágat azonban nem fejlesztjük tovább. A master ágat azonban tovább fejlesztjük. Lesz egy jegy() metódus, majd kommit. Lesz egy ertek() metódus, majd kommit.

Program01.java
class Program01 {
	public static void szamitHaromszog() {
		int 3 + 4 + 5;
	}
	public static void jegy() {
		System.out.println("Nevem jön ide");
	}
	public static void ertek() {
		System.out.println("Értéke ez.");
	}
	public static void main(String[] args) {
		System.out.println("Hi");
	}
}

Rájövünk, hogy nem is így kellett volna. Áttérünk a devel változatra:

git checkout devel

Először írunk egy getTriangleRange() metódust. Majd írunk egy getTriangleArea() metódust.

Program01.java
class Program01 {
	public static double getTriangleRange(double a, double b, double c) {
		return a + b + c;
	}
	public static doubel getTriangleArea() {
		double s = (a + b + c) /2;
		return Math.sqrt(s*(s-a)*(s-b)*(s-c));
	}
	public static void main(String[] args) {
		System.out.println("Hi");
	}
}

Ellenőrizzük a gitk paranccsal hol tartunk:

gitk --all

A devel ág kódja teljesen jó. A master ág kódja viszont teljesen rossz amióta lett egy új branch. Átváltunk a master ágra:

git checkout master

Majd a merge paranccsal összefésülést kezdeményezünk:

git merge devel

A kimeneten kiíródik a konfliktus ténye:

Auto-merging Program01.java
CONFLICT (content): Merge conflict in Program01.java
Automatic merge failed; fix conflicts and then commit the result.

Az egyik megoldás lehet kézi javítás.

Ha most megnyitjuk a Program01.java állományt, akkor ezt látjuk:

Program01.java
class Program01 {
<<<<<<< HEAD
	public static void szamitHaromszog() {
		int 3 + 4 + 5;
	}
	public static void jegy() {
		System.out.println("Nevem jön ide");
	}
	public static void ertek() {
		System.out.println("Értéke ez.");
=======
	public static double getTriangleRange(double a, double b, double c) {
		return a + b + c;
	}
	public static doubel getTriangleArea() {
		double s = (a + b + c) /2;
		return Math.sqrt(s*(s-a)*(s-b)*(s-c));
>>>>>>> devel
	}
	public static void main(String[] args) {
		System.out.println("Hi");
	}
}

Kitöröljük ettől: «««< HEAD az egyenlőség jelekig, majd a végéről töröljük a »»»> devel sort. Elkészült.

A második, hogy visszavonjuk az összefésülést:

git merge --abort

A harmadik lehetőség, hogy átvegyük a develágból az összes módosítást:

git checkout MERGE_HEAD -- .

Ez után jöhet a kommit:

git commit

Ellenőrizzük a gitk paranccsal hol tartunk:

gitk

Majd törölhetjük a devel ágat:

git checkout master
git reset --hard devel

Ellenőrizzük a gitk paranccsal hol tartunk:

gitk

Ezen a ponton a devel és a master ág megegyezik.

rebase

A példa kedvéért vegyünk egy egyszerű példát: Feladatunk egy szamok.txt állomány fejlesztése, amely soronként tartalmaz a számokat. Az első sor egyeseket, a következő ketteseket, stb.

Indulás

echo 11111 > szamok.txt
git init
git add szamok.txt
git commit -m "Kezdés"
echo 222222 >> szamok.txt
git add szamok.txt
git commit -m "Kettesek"

Elágaztatunk, és a devel-1-et fejlesztjük tovább:

git branch devel-1
git checkout devel-1
echo "III III III III III" >> szamok.txt
git add szamok.txt
git commit -m "Hármasok"
echo "IV IV IV IV IV" >> szamok.txt
git add szamok.txt
git commit -m "Négyesek"

Egyesítjük a master és a devel-1 ágat:

git checkout master
git rebase devel-1

Linkek

oktatas/programozas/verziokontroll/git/a_git_hasznalata.txt · Utolsó módosítás: 2021/02/26 20:23 szerkesztette: admin