Leírja a GIT használatának gyakorlati részét - telepítése és regisztrálása a Github.com szerveren.

A Github.com olyan szolgáltatás, amely a kód és az adatok tárolását kínálja a verzióvezérlő rendszer segítségével. Git.. A Github ingyenes vámtámogatást nyújt 300 MB-os adat tárolására a nyílt formában. Ez azt jelenti, hogy bármely internet-felhasználó letöltheti az adatokat. A Githubon más tárhelyre helyezhető és zárva lehet, havonta 7 dollárt fizet. A szabad Github fiókban alapértelmezés szerint senki sem változtathatja meg adatait (csak olvasható). De ragaszkodhatsz, hogy ki a Github rendszer felhasználóinak joga van rögzíteni.

A cikk részletesen ismerteti, hogyan lehet a git beállítást a Windows és a Linux operációs rendszerben.

GIT telepítése Linux alatt

Linux felhasználók, azt hiszem, nincs értelme megmagyarázni, hogyan kell telepíteni a gitot - ez különböző módon történik. A Debian rendszerben (amit velem érdemes), a git telepítéséhez használhatja a parancsot:

apt-get install git

GIT telepítése a Windows alatt

Megyünk a Hivatalos Git oldalra http://git-scm.com, kattintson a Letöltés Windows. A megnyíló ablakban kattintson a Tovább gombra Teljes telepítő a hivatalos git számára. Futtassa az exe-shniket.

A telepítés folyamatában ezt a kérdést megkérdezik:

Azt javaslom, hogy a "Git futtatása a Windows parancssorból". Minden más lehetőség alapértelmezés szerint maradhat. A GIT telepítése után újra kell indítania, vagy befejeznie kell a felhasználói munkamenetet, és jelentkezzen be az útvonalrendszer változó módosításainak használatához.

Ha információt kap a verzióról, akkor a GIT telepítve van és fut. Ha megkapjuk az információt, hogy a GIT program nem található, megértjük, mit tettek rosszul.

Ssh billentyűbeállítás

Mielőtt regisztrálnánk a Github-szal, először létrehoznia kell az SSH kulcsfontosságú titkosítást. Ez a kulcs szükséges, gyorsan telepíthető a kapcsolatot a GitHub, a jelszó megadása nélkül. Anélkül, hogy ilyen Github kulcs lenne, akkor nem lesz könnyű dolgozni.

Figyelem!

A kulcsfontosságú generáció idején a jelszó kérték. Ez a jelszó hozzáférést biztosít a zárt kulcshoz, amely csak az autójában és bárhol máshol tárolódik. Ez a jelszó a maximális értékpapírok esetében van beállítva, bár nélküle is. Tudnia kell, hogy jelszó beállítása egy privát kulcsra, meg kell adnia ezt a jelszót minden egyes github kiszolgálóval. Így a jelszó megadásakor a titkosítási kulcsok használatának minden kényelme eltűnik.

MyTetra felhasználói: A parancssorral való együttműködés interfésze, amelyet a szinkronizálás során a git hívására használ, nem tud dolgozni a karakterek bevitelével. Ezért, ha megadja a jelszót, a szinkronizálás nem fog működni.

SSH kulcsok beállítása Linuxban

A Linux operációs rendszerben először meg kell vizsgálnia a ~ / .ssh könyvtárba. Ha vannak ID_RSA fájlok és ID_RSA.Pub, akkor ez az SSH kulcsok. Ha nincs ilyen könyvtár vagy ilyen fájlok, akkor a kulcsokat generálni kell. Hagyja a csapatot:

Helyette [E-mail védett] Meg kell adnia az e-mailt. A kulcsfontosságú folyamat során megkérdezi, hogy hol helyezze el a fájlokat, egyszerűen nyomja meg az ENTER gombot. Jelszó kérése esetén egyszerűen nyomja meg az ENTER gombot. A generálás után az ID_RSA és az ID_RSA.pub fájlokat a ~ / .ssh könyvtárban kell megjeleníteni, akkor későbbiek lesznek.

SSH billentyűk konfigurálása a Windows rendszerben

A Windows operációs rendszerben az SSH kulcsgenerátor szerepel a GIT csomagban. A kulcsok létrehozásához futtatnia kell a fájl végrehajtásához C: programfájlok \\ git \\ git bash.vbs. Elindítható, mint egy rendes exe-shnik. Megnyílik a Git konzol program. Meg kell adni egy csapatot:

ssh-keygen -t rsa -c " [E-mail védett]"

Legyen óvatos, ebben a konzolban a COP-múlt észre fogja venni, egyszerűen írja be a parancsot kézzel. E-mailként adja meg a postafiókját. Kérésre " Adja meg a fájlt, amelybe mentheti a kulcsot„Csak nyomja meg az ENTER gombot. Ha a jelszó kérése” Összetett jelszó megadása „és az” ENTER ugyanazt a jelszót újra „egyszerűen nyomja meg az ENTER-t. A folyamat során a kulcsok generálására a konzol, hozzávetőleg a következő információk kerülnek ki:

A nyilvános / magán RSA kulcspár létrehozása.
Adja meg a fájlt, amelyben mentse a kulcsot (/ C / Dokumentumok és beállítások / Felhasználónév / .ssh / ID_RSA)
Adja meg a jelszót (üres hiba esetén):
Írja be újra a jelszót:
Az Ön azonosítása mentésre került a / c / dokumentumok és beállítások / felhasználónév / .ssh / id_rsa.
A nyilvános kulcsot a / c / dokumentumok és beállítások / felhasználónév / .ssh / id_rsa.pub.
A legfontosabb ujjlenyomat:
51: DB: 73: E9: 31: 9F: 51: A6: 7A: C5: 3D: DA: 9C: 35: 8F: 95 [E-mail védett]

A program végrehajtása után a katalógusban C: Dokumentumok és beállítások \\ felhasználónév \\ .ssh ID_RSA és ID_RSA.pub fájlok lesznek, akkor hasznosak lesznek számunkra később.

Regisztráció a Github.com-on.

Most minden készen áll a regisztrációra. Menjen a Github.com kezdőlapjára. Az interfész egy kicsit zavaros, ezért adok egy pár képernyőképet, ahol az, amit megnyomnak. A tervezés és az elrendezés bármikor megváltoztatható, ezért a cselekvés logikáját írom le.

A felső menüben megtalálja az elemet " Árképzés és feliratkozás."És kattints rá:

Megnyílik a tarifális terv kiválasztási oldala. Válasszon egy ingyenes fiókot " Hozzon létre egy ingyenes fiókot":

SSH kulcs telepítése a githubba

Közvetlenül a regisztráció után, szükség van-e regisztrálni a nyilvános kulcsú titkosítási kulcsot a Guthub rendszer (nyitott SSH kulcs). A kulcs hozzáadásához kattintson a jobb felső sarokban. " Fiók beállítások":

A megnyíló ablakban kattintson a menüelemre " SSH nyilvános kulcsok.", és kattintson a" Adjon hozzá egy másik nyilvános kulcsot". Két mező jelenik meg - a kulcsnév ( Cím) és a legfontosabb tartalom ( Kulcs).

Területen Cím Írja be a számítógép nevét, amelyen a nyilvános kulcs keletkezik. Írhatsz oroszul.

Területen Kulcs Be kell illesztenie az ID_RSA.PUB fájl tartalmát. Ne feledje, hogy melyik katalógusban vannak? Menj a könyvtárba, nyitott bármilyen szövegszerkesztővel ID_RSA.PUB (ez a .pub kiterjesztése, ne tévesszük össze). Kiemeljük az összes szöveget, másolatot és beillesztést a Github oldalon a mezőben Kulcs.

A kulcs hozzáadása után a számítógép csatlakozhat a githubhoz a GIT programon keresztül, és nem kell hibát bekapcsolni.

A REPOSORITÁS létrehozása a Githubon

Most itt az ideje, hogy megteremtse az első tárhelyet a Githubon. A tároló egyszerűen olyan könyvtárként tekinthető meg, amelyben a szinkronizált fájlok és alkönyvtárak hazudnak. Be kell, hogy hozzon létre egy tároló a GitHub webes felület, és akkor már töltse fel a fájlokat, és dolgozni vele a GIT programot a számítógépen.

A tároló létrehozásához kattintson a jobb felső sarokban " Irányítópult.". A megnyíló ablakban látható az elem" Hozzon létre egy adattárat.":

Szóval nincs szükségünk erre az elemre! Ez a tétel nem a repository létrehozása párbeszédablakot és a súgó oldalt megnyitja. Ahelyett, hogy rákattintunk erre az elemre, az alábbiakban az oldalon találjuk a valószínűtlen linket " Hozzon létre egy adattárat.". Megnyitja a párbeszédablakot, hogy új tárhelyet adjon hozzá.

Egy új tároló párbeszédablak hozzáadásával ki kell töltenie legalább a projekt neve mezőt " Projekt neve."A projekt nevében jobb, ha ne használjon cirillist, mivel a projekt neve a könyvtár neve. A problémák elkerülése érdekében a projekt neve csak latinot tartalmaz. A gomb megnyomása után. Hozzon létre adattárat.", a tároló létrejön.

A Github rendszer tárolójára való működési hivatkozás alakul ki. Ha a névfelhasználónév alatt regisztrált, és az adattárát reponame-nak hívják, akkor a következő linkeket használhatja az adattárhoz való hozzáféréshez:

A GIT szintaxisban:

[E-mail védett]: felhasználónév / reponame.git

A HTTPS szintaxisban:

https: // [E-mail védett]/Username/reponame.git.

A Github-on keresztül a GIT programon keresztül dolgozik

Mostantól a Github webes felületen lévő táncok teljesnek tekinthetők. Ezután csak a Git program használatával dolgozhat.

Először is, meg kell tennie a GIT program kis beállításait: Adja meg a felhasználó helyi GIT rendszerét és e-mailben. Ezt a következő parancsok végzik, amelyek bármelyik könyvtárban végrehajthatók:

git config - global user.name "yourfulname"
Git config - global user.Email [E-mail védett]

ahol a yourfulname helyett meg kell írnia a nevét, és helyette [E-mail védett] - az email címed. Ezeket az értékeket a Github bejelentkezéshez használják. Ezért meg kell adnia a bejelentkezést a Githubon - a helyszínen [E-mail védett] Meg kell adnia a titkosítási kulcsok létrehozásakor megadott e-mailt.

Ezen beállítások után a fájlokat a tárolóba öntheti. Menjen a katalógusba a projekthez, és adja meg a csapatokat:

git elkötelezi magát -a -m "első elkövetés"

gIT Remote Rein Add [E-mail védett]: felhasználónév / reponame.git

git push -u eredetű mester

Ezen parancsok után a könyvtár fájljainak egy példánya van kialakítva a Github kiszolgálón, amelyben a parancsadatokat elvégezték. Ezután már elkötelezett, töltse ki a Github kiszolgáló módosításait, olvassa el a szerver változásait. De ez egy teljesen más történet.

Az emberek számára természetesen ellenállhat. Ha a GIT nem találkozott veled, amikor elkezdtél dolgozni a verziók vezérlőrendszerekkel, valószínűleg kényelmesebbnek érzi magát a subversion rendszerben (SVN).

Gyakran az emberek azt mondják, hogy a git túl bonyolult a kezdőknek. Mindazonáltal megengedem magam, hogy nem értek egyet vele.

Ebben a leckében elmondom, hogyan kell használni a GIT-t a projektekben. Tegyük fel, hogy létrehoz egy projektet a semmiből, és szeretné kezelni a git használatával. Miután elindult a nagy parancsok listáján, megkapja azt a gondolatot, hogyan kell elhelyezni a kódot a felhőbe Github által.

Ebben a cikkben beszélünk a GIT alapjairól - Hogyan lehet inicializálni a projekteket, hogyan kell új és meglévő fájlokat kezelni, és hogyan mentheti a kódot a felhőben.

Mi nem érinti a viszonylag összetett részeket a git, például az elágazás, mivel ez a lecke kezdőknek készült.

A GIT telepítése.

A hivatalos site git részletes információka telepítésénél Linux, Mac és Windows. A mi esetünkben az Ubuntu 13.04 bemutatására használjuk a git telepítését az APT-GET segítségével:

sudo apt-get install git

Kezdeti beállítás

Hozzunk létre olyan könyvtárat, amelyen belül dolgozunk. Alternatív megoldásként a GIT-t használhatja a meglévő projektek egyikének kezelésére; Ebben az esetben nem kell létrehoznia egy demo könyvtárat az alábbiak szerint:

mkdir my_git_project cd my_git_project

Az első lépés a git inicializálása a könyvtárban. Ezt az Init parancs segítségével lehet elvégezni, amely létrehozza a .git könyvtárat, amely tartalmazza a projekthez tartozó összes információt.

git config - global user.name "shaumik" git config -global usemail " [E-mail védett]"GIT Config - Global Color.ui" Auto "

Fontos megjegyezni, hogy ha nem adja meg a nevét és az e-mail címét, az alapértelmezett értékeket használjuk. A mi esetünkben az alapértelmezett értékek Donny Felhasználónév és e-mail cím lenne [E-mail védett].

Ezenkívül beállítottuk az automatikus értéket a felhasználói felület színéhez, így a git parancs kimenete színes háttérvilágítással rendelkezik.

A -global előtag szükséges ahhoz, hogy ne adja meg ezeket a beállításokat parancsokat, amikor a következő alkalommal indítsa el a GIT projektet a rendszerünkben.

Fájlok készítése kötelezettségért

A következő lépés a fájlok létrehozása a könyvtárban. Használhatja például a VIM szövegszerkesztőt. Ne feledje, hogy ha GIT-t szeretne hozzáadni egy meglévő könyvtárba, akkor nem kell ezt a lépést végrehajtani:

Ellenőrizze a tároló állapotát

Most, hogy több fájlunk van a tárolónkban, lássuk, hogy a git hogyan fordul rájuk. Az aktuális adattár állapotának ellenőrzéséhez használni kell a Git Status parancsot:

Fájlok hozzáadása a githez

Jelenleg nincsenek fájljaink a Git használatával. A fájlokat kifejezetten a GIT-ben kell hozzáadnunk annak érdekében, hogy meghatározzuk a nyomon követendő git.

Fájlok hozzáadása az Add parancs segítségével:

A tároló állapotának ellenőrzése után látni fogjuk, hogy egy fájlt hozzáadtunk:

Több fájl hozzáadásához a következő parancs bejegyzést használhatja (vegye figyelembe, hogy hozzáadunk egy másik fájlt a demonstrációhoz):

git hozzá myfile2 myfile3

A GIT-t rekurzív módon hozzáadhatja, de vigyázzon ezzel a paranccsal. Vannak bizonyos fájlok (például összeállított fájlok), amelyeket általában a git tárolón kívül tárolnak.

Ha rekurzív módon használja az Add parancsot, akkor hozzáad minden ilyen fájlt, ha léteznek a tárolóban.

Fájlok törlése

De az egyszerű git RM parancs végrehajtása nem csak a gitből, hanem a helyi fájlrendszerből is törli a fájlt! Nak nek

A GIT leállította a fájlt követve, de a fájl maga is megmarad a helyi rendszeren, futtassa a következő parancsot:

git rm --cached

Változtatásokat követ el

Miután elhelyezte a fájlokat, betarthatja őket a githez. Képzeld el, hogy a kötelezettség egy bizonyos pontot rögzít, amelyhez visszatérhet a tárolóhoz való hozzáféréshez.

Minden bizottsághoz kötődhet, amelyet az előtag -M előtaggal adunk hozzá:

git elkötelezi magát -m "az első elkötelezettségemet"

Hasznos üzenetekkel elősegíti, mert segít meghatározni, hogy mit változtatott ebben a COM-ban.

Elkerülje a túl közös üzeneteket, mint " Rögzített hibák" Ha van egy feladatkövető, akkor adhat üzeneteket a " Fix hiba # 234».

A bevált gyakorlat az, hogy az ág nevét vagy a funkció nevét a kötelezettségjelentés előtagként használja. Például, " Eszközkezelés: Hozzáadott funkció a PDF Asset fájlok létrehozásához- értelmes üzenet.

A GIT azonosítja kötelezettségeket, ha hosszú hexadecimális számot ad hozzá minden elkötelezettséghez. Rendszerint nem kell átmásolni az egész karakterláncot, hogy meghatározza-e eléggé első 5-6 karaktert.

Kérjük, vegye figyelembe, hogy a képernyőképen az első kötelezettségünket a 8DD76FC kód határozza meg.

További elkötelezi magát

Most változtassunk meg több fájlt az első elkötelezettségünk után. Változásuk után látni fogjuk, hogy a GIT Status Git parancs végrehajtásának eredményeképpen felfedeztem az általa nyomon követett fájlok változásait:

A GIT diff parancs segítségével ellenőrizheti az utolsó megjegyzésben végrehajtott nyomkövetési fájlok módosításait. Ha meg szeretné tekinteni a változtatásokat egy adott fájlban, használja a Git diff parancsot :

Ezeket a fájlokat ismét hozzá kell adnia ahhoz, hogy módosítsa a következő kötelezettségvállalás nyomkövetési fájljait. Az összes megfigyelt fájlt hozzáadhatja a parancs futtatásával:

Ezt a parancsot a Git Commit parancs előtaggal történő használatával elkerülheti, amely hozzáadja az összes módosítást a fájlok nyomon követéséhez.

Ez a folyamat azonban nagyon veszélyes, mivel károsíthatja a projektet. Például mondjuk, hogy kinyitotta a fájlt, és véletlenül megváltoztatta.

Ha szelektíven helyezi el a fájlokat, vegye figyelembe az egyes fájlok változásait. De ha hozzáadja az előtagot - az Ön elkötelezettségéhez, az összes fájl megemlékezésre kerül, és nem lesz képes azonosítani a lehetséges hibákat.

Miután elküldte a fájlokat, folytathatja a kötelezettségvállalást. Megemlítettem, hogy egy üzenet, amelyet bemutatunk az előtag-MA-val, az egyes bizottságokhoz kapcsolódhat.

Azonban lehetőség van egy üzenet beírása több sorban a Git Commit parancs használatával, amely interaktív formanyomtatványt nyit meg:

Projektmenedzsment

A projekt történetének megtekintéséhez a következő parancsot hajthatja végre:

Tehát megjelenik a projekt teljes története, amely az összes elkötelezettség és információ felsorolása. A kötelezettségvállalásról szóló információk magukban foglalják a Kesh Coit kódot, a szerzőt, az idő- és kommutációs üzenetet. Számos lehetőség van a Git naplóra, amelyet fel lehet vizsgálni, amint mérlegelheti az ág (ág) fogalmát a gitben.

A módosított kereskedelemről és fájlokról szóló részletes információk megtekintéséhez futtassa a következő parancsot:

git show.

hol Ez egy hexadecimális szám, amely egy elkötelezettséggel jár. Mivel ez a lecke az újonnan érkezettek számára készült, nem fogjuk megvizsgálni, hogyan kell visszatérni egy bizonyos elkötelezettség állapotához, vagy hogyan ellenőrizhetjük az ágakat.

Kódelhelyezés a felhőben

Most, hogy megtudta, hogyan kell kezelni a kódot a rendszeren, itt az ideje, hogy a kódot a felhőbe helyezze.

A Github egy nagyon jól ismert platform a nyitott projektek forráskódjának tárolására, terjesztésére és kezelésére. Ez a szolgáltatás világszerte számos fejlesztőt használ, köztük nagyvállalatok, mint például a Microsoft, a Redhat és sok más, számos népszerű projekt több száz fejlesztője is.

A platform lehetőséget nyújt nemcsak a megtekintéséhez a kódot és annak elosztása, hanem a történelem változatban, közös fejlesztési eszközök, szerszámok vonatkozó dokumentációt, a kibocsátások és a visszajelzést. És a legérdekesebb dolog, amit a GIHUB-nál nyitott és magánprojektek lehetnek. Ebben a cikkben megnézzük, hogyan kell használni a Githubot a projekt elhelyezéséhez. Szóval beszélni, github kezdőknek.

Tehát mondjuk, hogy saját projekted van, és azt szeretné, hogy a kódot a többi felhasználó számára nyilvános hozzáféréssel hozza meg, és részt vehetné a fejlődésben. Az első dolog, amit meg kell tennie, hozzon létre egy fiókot.

1. Számla létrehozása

Új fiók létrehozása a webhelyen Nyissa meg a Github főoldalát, és azonnal azonnal megadhatja az adatokat egy új fiókhoz. Meg kell adnia a felhasználónevet, az e-mailt és a jelszót:

Ha befejezte a bejegyzést, kattintson "REGISZTRÁLJ INGYEN":

A következő lépésben ki kell választania a tároló típusát. A nyilvános tárolók ingyenesek, de ha saját adattárat szeretne létrehozni, akkor a kód csak akkor lesz elérhető, ha havonta 7 dollárt kell fizetnie.

Fiók készen áll, és átirányítja az oldalra, ahol létrehozhatja az első projektet. De mielőtt megteheti, meg kell erősítenie az e-mail címét. Ehhez nyissa meg a postafiókját, és kövesse a linket a githubból.

Nincs szükség Github telepítésre, csak néhány kattintással az egérrel.

2. A tároló létrehozása

A megnyíló oldalon ez az engedélyezett felhasználók fő oldala, kattintson "Indítsa el a projektet":

A repository azonnali inicializálása README fájl létrehozásával, ehhez meg kell említenie a kullancsot "Inicializálja ezt a tárolót egy README-vel" a lap alján. Kiválaszthat egy engedélyt is:

Ha minden készen áll, válassza ki "Projekt létrehozása"A README fájl segítségével új projektet hoznak létre, amely tartalmazza a leírást és a licencfájlt.

3. ágak hozzáadása

A Github ágak lehetővé teszik, hogy egyszerre több projekt verzióval dolgozzon. Alapértelmezés szerint a tároló létrehozásakor létrejön a Master Branch, ez a fő működő ág. További fiókokat hozhat létre például annak érdekében, hogy teszteljék a szoftvert, mielőtt megjelentek a mester ágban. Így egyidejűleg kifejleszthet egy terméket, és biztosíthatja a felhasználókat stabil verzióval. Különböző rendszerekhez is létrehozhat egyéni fiókokat is.

Az aktuális ág a bal felső sarokban található a szó után "Ág".Új fiók létrehozásához egyszerűen telepítse ezt a listát, és indítsa el a nevét:

A webhely azt javasolja, hogy hozzon létre egy új fióktelepet, válassza ki "Ág létrehozása".

Közvetlenül a teremtés után, akkor az ág által létrehozott.

4. Fájlok módosítása és elkötelezése

A Github fájlok bármilyen módosítása kötelező. A kötelezettségvállalás a korrekciókat, és leírja ezeket a korrekciókat. Ez annak érdekében szükséges ahhoz, hogy tudd meg ezt és amikor megváltozott, és megkönnyíti a csapat munkáját is. A szó commote lehet fordítani a „fix”. Vagyis több fájlban módosíthatjuk, majd javíthatjuk őket. Módosítsuk a Példa README fájlt. Ehhez keresse meg a billentyűt a panel jobb oldalán, és kattintson rá:

A szövegszerkesztő megnyílik, ahol megadhatja a szükséges helyességet:

Miután mindent megtesz, meg kell töltenie a mezőt "ELKÖVETNI" a lap alján. Röviden írja le, hogy mi változott, majd kattintson a gombra "Változások elkövetése":

Ezeket a változtatásokat a projekt aktuális ágába fogják bevinni, mivel most a teszteléssel dolgozunk, akkor a módosításokat elküldjük.

5. Mergers lekérdezések létrehozása (pull kérés)

A kezdőknek a kezdőknek nagyon nehéznek tűnhetnek az ilyen funkciók miatt, de nagyon kényelmes, ha kitalálod. Az összefolyás kérés vagy Pull kér egy lehetőség, amelynek köszönhetően bármely fejlesztő kérhet egy másik, például az alkotó a repository megtekintheti a kód, és add meg a fő projekt, vagy elágazik. A fúziós kérésekkel rendelkező munkaeszköz a diffösszetevő eszközt használja, így az összes módosítást láthatja, majd egy másik szín hangsúlyozza őket. A Pull kérelmet azonnal létrehozhatják a kötelezettségvállalás megteremtése után. Küldjünk Pull kérelmet a tesztelő ágakról a főre. Először nyissa meg a lapot "Húzza a kérést".

Itt kattintson "Húzási kérelem létrehozása":

Ebben az ablakban megtekintheti az összes módosítást, most láthatunk egy sort:

6. A fúziós kérelmek megtekintése és jóváhagyása

Most, ugyanazon a push kérések lapon, csak egy összefonódás iránti kérelmet tettünk, és csak kattintva tudjuk venni "Egyesítse a pull kérelmet":

De ha ez a kérés érkezett egy másik személy, akkor ellenőriznie kell, hogy megváltoztatta ott, és hogy szükséges-e, hogy ezt erre, kattintson a keresett leírást, és látni fogja egy ismerős változás nézet ablak:

A kódot ezután importálják a fő ágba, és a vizsgálati ág biztonságosan eltávolítható.

7. Hibajelentések

Olyan kényelmes, hogy a Githubot nemcsak a kód fejlesztésére és kezelésére lehet használni, hanem a felhasználók visszajelzését is. A lapon "Probléma" A felhasználók üzeneteket hagyhatnak arról a problémákról, amellyel találkoztak a termék használatakor. Nyílt lap "Problémák"és kattintson a gombra "ÚJ PROBLÉMA":

8. Kiadások

Az utóbbi, hogy ma megfontoljuk, kiadják a kiadványokat. Amikor a termék elérte egy bizonyos szakaszban, felszabadíthatja a felszabadulást a felhasználóknak, és biztos lehet benne, hogy minden stabil ott van, és senki sem tört semmit a Mesterben. Először a fő projekt oldalra kell mennie, majd a lapon "Kiadások":

Ezen az oldalon meg kell adnia a mezőben található verziót. "Tag verzió", akkor a kiadás neve és egy kis leírás. Ha bináris archívumokat állított össze, akkor itt kell csatolni. Majd kattintson "Készítsen kiadás":

A kiadás létrehozása után ilyen oldal jön létre:

következtetések

Ebben a cikkben áttekintettük, hogyan kell használni a Githubot a projektünk befogadására és kezelésére. Az egész rendszer angolul van, így a nyelv alapvető ismerete nagyon kívánatos, de anélkül, hogy a githubokkal együtt nem lesz nagyon nehéz. Remélem, ez az információ hasznos volt az Ön számára. Ha érdekel, hogyan kell dolgozni a GIT-vel a parancssorból, lásd a Kezdőket.

Részletes bevezetés a GIT-vel való munkához

Mi a git és miért van?

A GIT egy elosztott verzióvezérlő rendszer, amely lehetővé teszi, hogy mentse a tárolt fájlban tárolt fájlok összes módosítását. A változásokat pillanatfelvételek formájában tárolják, amelyeket számos kiszolgálóra helyezhetünk. Tekintsük ezt a szabványt felhő biztonsági mentések a szteroidok - akkor nem csak visszaállítani a kódot meghibásodás esetén, hanem visszaállíthatja a kódot az előző mentett állapotok. Könnyen kölcsönhatásba léphet más fejlesztőkkel is - ismételten, mivel néhány ember egy fájlt tud dolgozni a Google Dokumentumokban, és a fejlesztők egyidejűleg dolgozhatnak egy tárolóban, és fenntarthatják a változásokat.

Tekintettel az összes előnyére, a GIT egy nélkülözhetetlen eszköz mindenki számára, aki csinál vagy fejlődik. Ebben a cikkben megnézzük a leghasznosabb git parancsokat és a helyzetet, amikor érdemes használni. Ez is segíti a tudásuk frissítését, ha már ismeri a GIT-t.

Hogyan kell dolgoznunk a GIT-vel

Sok parancs elérhető a GIT-ben, így hasznos, hogy megoszthassa őket a témában / oka használatához. Először is megnézzük a munkát a helyi gépen a GIT-vel, mivel a legtöbb művelet pontosan ott fordul elő, majd forduljon egy multiplayer formátumhoz.

A GIT-vel mind a parancssoron keresztül is működhet, és a Grafikus felületen keresztül, mint például a Github Desktop. Bár a parancssor kezdődõ fejlesztői megijeszthetnek, még mindig jobb tanulni, mert több lehetőséget kínál, mint sok eszköz az interfészen.

Általános szabályként a git csapatok a git típusát veszik<команда> <аргументы> ahol az érv lehet a fájl elérési útja. A csapatok is lehetnek olyan opciók, amelyek jelzik -<опция> vagy -<однобуквенная опция> . Lehetővé teszik, hogy részletesebben konfigurálja a parancs műveleteket. Ebben a cikkben a csapatot általában bemutatják, így minden van<> Meg kell cserélni saját jelentéseit.

Ha nem tudja, hogyan kell használni a parancsot, megnyithatja az útmutatót Git Súgó segítségével<команда> , és ha csak emlékeztetőre van szüksége, használja a git<команда> -h vagy git.<команда> --help (--help és -h egyenértékű).

GIT előkészítése.

A GIT telepítése.

A Windows felhasználók letölthetik innen.

A MacOS (OS X) git az XCODE parancssori eszközök részeként történik, így telepítenie kell őket. A GIT elérhetőségének ellenőrzéséhez nyissa meg a terminálot, és írja be a GIT-verziót, hogy ellenőrizze a verziót.

Ha Linuxot használ, akkor használja a sudo apt telepítése git-all parancsot vagy sudo dnf telepíteni git-mind (RPM alapján).

A konfigurációs fájl konfigurálása

Az első dolog, amit a GIT telepítése után kell tennie, a felhasználónevet és az e-mailt konfigurálja, mivel azokat a felvett képek azonosítására és tárolására használják. Ezeket a beállításokat a konfigurációs fájlban tárolja az összes többiekkel.

Akkor sem közvetlenül szerkesztheti a file.gitconfig szövegszerkesztővel, vagy használja a Git Config --Global --edit parancsot, és szerkeszteni lehet külön mezőkben a Git Config --Global parancs<поле> <значение> - Mi érdekli a user.name és a user.Email mezők.

Szövegszerkesztőt is konfigurálhat a Core.editor Field segítségével. Kezdetben az alapértelmezett rendszerszerkesztőt használja, például a VI Linux / Mac esetében. A COMMATION.Template mező lehetővé teszi, hogy megadja az egyes COM-nál használt sablont.

Sok más terület van, de az egyik leghasznosabb az álnév, amely megköti a csapatot a pszeudonmába. Például Git Config - Global alias.t "állapot -s" lehetővé teszi, hogy a git state -s helyett git st

A GIT Config -list parancs megjeleníti az összes mezőt és értékét a konfigurációs fájlból.

Git tároló létrehozása

Az új tároló inicializálása. A git init parancs használható, vagy ha szeretné másolni a meglévő, git klónt<адрес репозитория> .

A GIT-ben elkövetett történelem

A GIT tárolja az adatokat egy olyan könnyű "pillanatfelvétel" formájában, amelyet elkötelezettek. A fájlrendszer állapotát egy bizonyos időpontban tárolják, valamint egy mutatót az előző (ek) kötelezettségeire. Minden bizottság tartalmaz egy egyedi ellenőrző - egy azonosító, Git felhasználás céljából a elkövetni. A történet nyomon követéséhez GIT tárolja a fejjel mutatót, amely jelzi az első elkötelezettséget (a Kötelezettségi láncot fordított sorrendben követjük az előző bizottságok eléréséhez).

A csekken keresztül utalhatunk, vagy a fejhöz viszonyítva pozíciójával, például a 4-es fejjel, a 4-es fejre utal, amely 4 évvel korábban köteleződik a fejnél.

Fájlrendszer git.

Git nyomon követi a fájlokat három fő szakaszban:

• munkakönyvtár (a számítógép fájlrendszere);
• az elkészített fájlok területe (a szünetmentes terület tárolja a következő kötelezettség tartalmát);
• Fej (az utolsó elkötelezettség a tárolóban).

Minden nagyobb fájlokat dolgozó csökken a fájl annak megértéséhez, hogyan Git vezérli a három részből áll. Van egy közös félreértés, hogy az elkészített fájlok területe csak változtatásokat tárol. Jobb, ha ezeket a három szakaszot külön fájlrendszerként gondolom, amelyek mindegyike tartalmazza a fájlok másolatát.

A fájlrendszerek módosításainak megtekintése

A GIT Status parancs minden olyan fájlt jelenít meg, amely három szakasz között különbözik. A fájlok 4 állammal rendelkeznek:

1. Megoldott (kifogástalan) - a munkakönyvtárban van, de nincs változat a fejben vagy az elkészített fájlok területén (git nem tudja a fájlról).
2. Megváltozott (módosított) - a munkakönyvtárban újabb verzió van a tárolt fejhöz vagy az előkészített fájlok mezőjéhez képest (a változások nem a következő COM-ban vannak.
3. Elkészített (rendezett) - Van egy újabb verzió a munkakönyvtárban és az előkészített fájlok területén a fejhez képest (készen áll a kötelezettségre).
4. Változás nélkül - a fájl egyik változata minden szakaszban, azaz az utolsó kommuátorokban az aktuális verziót tartalmazza.

MEGJEGYZÉS A fájl egyidejűleg "megváltozott" és "Elkészített", ha a munkakönyvtárban található verzió újabb, mint az előkészített fájlok területén, ami viszont az újabb verzió a fejében.

A GIT állapotparancsának a -s opciót használhatjuk, hogy kompakt kimenetet kapjunk (a fájlhoz a fájlhoz). Ha a fájl nincs nyomon követve, akkor megjelenik ?? ; Ha megváltozott volna, a neve piros lesz, és ha elkészült - zöld.

A módosítások megtekintéséhez, és nem módosíthatja a fájlokat, a következő parancsokat használhatja:

• git diff - a munkakönyvtár összehasonlítása az elkészített fájlok területével;
• git diff-stated - az előkészített fájlok fejének összehasonlítása fejjel.

Ha argumentumot használ<файл/папка> , A diff csak a megadott fájlok / mappák, például a Git Diff SRC /.

Fájlrendszer frissítése

Csapat git add<файл/папка> Frissíti a benyújtott fájlok / mappák területének területét a munkakönyvtárból.

A GIT Commit parancs frissíti a fejet egy új elkötelezettséggel, amely képeket készít az elkészített fájlok területén.

Git reset parancs művelet<коммит> Három lehetséges lépésből áll:

1. Mozgassa a fejjel<коммит> (Például, ha rollback versenyezni a munka könyvtárba és a terület előkészített fájlok lesznek új verziói a fájlok, mint a fej). Emellett az ág vezető mutatója erre a kötelezettségre kerül.
2. Frissítse az elkészített fájlok területét az elkötelezettség tartalmával. Ebben az esetben csak a munkakönyvtár lesz a fájlok legújabb verziói.
3. Frissítse az előkészített fájlok területének munkakönyvtár tartalmát. Óvatosan kell lenned, mert a fájlváltozások végül megsemmisülnek.

Alapértelmezés szerint a GIT Reset parancs csak az 1. és 2. lépést hajt végre, de viselkedése megváltoztatható a -soft Options (csak 1 lépés) és a --hard (minden lépés).

Ha elküldi a Fájl / mappa elérési útját, akkor a parancs csak számukra történik, például git reset --soft fej ~ 1 src /.

Csapat Git Checkout fej<файл> ugyanolyan eredményhez vezet, mint a git reset --hard fej<файл> - felülírja a fájl egy változata az elkészített fájlok mezőjében, és a fejváltozat munkakönyvtárában, azaz törlőkendő az utolsó elkövetés után.

Másrészt, Git Checkout<файл> (Már fej nélkül) felülírja a fájl verzióját a munkakönyvtárának változata terén előkészített fájlokat, hogy van, elveti a módosításokat, mivel az utolsó elkészített változata.

Végül git rm<файл> Megszakítja a fájl követését, és törli a munkakönyvtárból, az opció -cached menteni fogja a fájlt.

Fájlok figyelmen kívül hagyása

Gyakran nincs szükségünk GIT-re, hogy nyomon kövesse az összes fájlt a tárolóban, mert a számuk tartalmazhat:

• Érzékeny információkkal rendelkező fájlok, mint a jelszavak;
• nagy bináris fájlok;
• Összeszerelési fájlok, amelyeket minden egyes összeállítás után hoznak létre;
• oS / IDE fájlok, például, .Ds_store. Macos vagy .iml Az Intellij ötlethez - szükségünk van a tárolóra, hogy a lehető legkisebb legyen a rendszertől.

A fájl figyelmen kívül hagyása.Gitignore. A figyelmen kívül hagyni kívánt fájlok megjelöléséhez használhatja a keresési mintákat (fontolja meg őket egyszerűsített rendszeres kifejezések):

• / ___ - elkerüli a rekurzitást - megfelel a fájlokat csak az aktuális könyvtárban;
• __ / - megfelel az összes fájlnak a megadott könyvtárban;
• * ___ - megfelel az összes fájlnak a megadott végekkel;
• ! - a megadott minta alá tartozó fájlok figyelmen kívül hagyása;
• [__] - megfelel a négyszögletes zárójelben meghatározott karaktereknek;
• ? - minden szimbólumnak felel meg;
• / ** / - megfelel a beágyazott könyvtáraknak, például a / ** / d megfelel A / D, A / B / D, A / B / C / D, stb.

A keresési mintákat is használhatunk más parancsok fájl / mappájának megadásakor. Például Git Add Src / *. A CSS hozzáadja az összes fájlt. CSS az SRC mappában.

Elkötelezettség

Mivel az elkötelezettség a változatok történetének alapja, nem lesz felesleges, hogy többet megtudjon róluk.

A GIT Commit parancs megnyitja a szövegszerkesztőt, hogy belépjen az üzenetekbe. Ez a csapat több közös érvet vesz igénybe:

• -m lehetővé teszi, hogy üzenetet írjon a csapattal a szerkesztő megnyitása nélkül. Például Git elkövetése -m "rögzítő táska";
• -a átmásolja az összes megfigyelt fájlt az elkészített fájlok területére, és magában foglalja azokat a Commote-ban (lehetővé teszi, hogy kihagyja a git hozzáadását a kötelezettségvállalás előtt);
• --amend helyettesíti az utolsó követ el egy új módosított elkövetni, ami hasznos lehet, ha helytelenül adta meg az üzenetet az utolsó követ el, vagy elfelejtette, hogy tartalmaz néhány fájlt bele.

Számos tipp, akinek érdemes meghallgatni:

• Érdekes gyakran: nem fogod visszafordítani a változások visszafordítását, ha visszafordulsz, hogy visszaadja azt.
• Az egyik változás egy elkövetés: Ne helyezze az összes változás egy komor, oszd meg őket, hogy könnyebben visszahúzódott.
• Üzenetformátum: A címnek meg kell felelnie, kevesebb, mint 50 karakter hosszú, és logikusan kiegészíti ezt a kötelezettségét ___ (ez a kötelezettség javítja a hibákat - ez elkövetik a hibákat). Az üzenet megmagyaráznia kell, hogy miért történt a kötelezettség, és maga a kötelezettség megmutatja, mi változott. Részletesen ütemezett, hogyan kell írni az üzeneteket.
• (Opcionális) Ne kövessen kisebb változtatásokat: egy nagy adattárban sok kis elkötelezettség eltömődhet. A jó hangot úgy kell tekinteni, hogy az ilyen elkötelezettséget kövesse el, és amikor egy nagy adattárba hozza őket, hogy összekapcsolják őket egy elkötelezettségbe.

A történelem változásainak megtekintése

Használhatja a Git Log paranccsal megtekinthetjük a történelem előző commit fordított időrendi sorrendben. Különböző lehetőségeket tud átadni:

• -p mutatja az egyes com változásait.
• --stat mutatja rövidített statisztikák vállalkozik, mint a megváltozott fájlokat és a több hozzáadott / távoli húrok mindegyikük;
• -N megmutatja n. a legutóbbi elkötelezettségek;
• --since \u003d ___ és --until \u003d ___ Lehetővé teszi, hogy a szűrést követően egy idő alatt elkötelezze magát, például - - a "2019-01-01" 2019. január 1-jétől számít.
• --pretty megadhatja, naplófájlformátumot (például --pretty \u003d OneLine), akkor is használhatja --pretty \u003d Formátum nagyobb testreszabás, például --pretty \u003d formátum: „% h% s”;
• --grep és -s szűrő vállalkozik üzenetekkel / Kód módosítása, amelyek tartalmazzák a megadott karakterlánc például Git Log -s_name_name lehetővé teszi, hogy hozzáadása / törlése a funkció;
• --no-egyesülések áthaladnak az egyesült ágakkal;
• veta1..Tell2 lehetővé teszi, hogy a kötelezettségvállalások a 2 elágazás nem bankfiókban 1 (hasznos, ha egyesülő ágak). Például Git Log Master..test megmutatja, hogy mi elkötelezett a teszt ág nem a mester (beszéljen az ágakat egy kicsit később).
• --left jobb branch1 ... Branch2 mutatja vállalkozik, amelyek akár egy ág 1, vagy egy ág 2, de nem mind a két; jel< обозначает коммиты из ветка1 , а > - A fióktól2. Figyelem feltöltése: Három pontot használnak, nem kettő;
• -L elfogadja érv kezdete, vége: Fájlok vagy: Fájl: Fájl és mutatja a változások történetében a tompított sorban vagy funkciókról a fájl.

Egy másik hasznos csapat git hibás<файл> , amely minden egyes fájlsorra mutatja a szerzőt és az utolsó kötelezettségvállalás ellenőrzési összegét, amely megváltoztatta ezt a karakterláncot. -L.<начало>, <конец> Lehetővé teszi, hogy korlátozza ezt a parancsot meghatározott sorokba. Ez például megtudhatja, hogy mely bizottságok vezetett egy adott hibához (úgyhogy vissza tudsz fordulni).

Végül van egy Git Grep parancs, amely a megadott rendszeres kifejezés szerint a történelemben (és nem csak a munkanélküli könyvtárban) keres minden fájlt. Az Option -N megjeleníti a megfelelő sorszámot az egyes mérkőzések fájljában, és - az egyes fájlok mérkőzésének számát mutatja.

MEGJEGYZÉS Ne zavarja a git grep git log --grep! Az első olyan fájlokat keres, amelyek az elkötelezettek között vannak, és az utóbbi naplóüzeneteket néz.

Távoli kiszolgálók

Eddig megvitattuk a GIT használatát csak a helyi gépen. Azonban tárolhatjuk a távoli tárolók kötelezettségvállalási előzményeit, amelyek figyelemmel kísérhetők és frissíthetők (figyelembe vesszük távoli felhőjét a mi elkötelezettségünkről).

A GIT Remote -v parancs megjeleníti a nyomon követett távoli tárhelyek listáját, és az általunk elnevezett neveket.

A GIT klón parancs használata esetén Nemcsak a tároló másolatát töltjük fel, hanem implicit módon nyomon követjük a távoli kiszolgálót, amely a megadott címen van, és amely a név eredetét hozzárendeli.

A leginkább fogyó parancsok:

• git távoli hozzáadása.<имя> - egy távoli tárhelyet ad hozzá a megadott névvel;
• git távoli eltávolítás.<имя> - eltávolítja a távoli tárolót a megadott névvel;
• git távirányítás.<старое имя> <новое имя> - átnevezi a távoli adattárat;
• git távoli set-url<имя> - hozzárendel egy új címet nevű tárhelyet;
• git távoli show.<имя> - Megjeleníti az adattárat.

A következő parancsok eltávolított ágakkal működnek:

• git letöltés.<имя> <ветка> - adatokat kap a megadott tároló ágából, de nem egyesíti a változtatásokat;
• githúzás<имя> <ветка> - a megadott adattárág ágából származó adatokat összeolvasztja;
• git push.<имя> <ветка> - A megadott tároló ágának módosításait küldi. Ha a helyi ág már nyomon követi a távoli, akkor csak git push vagy git húzhatást használhat.

Így több ember kérheti a szerver változásait, megváltoztathatja a helyi másolatok módosítását, majd elküldi őket egy távoli kiszolgálóra, amely lehetővé teszi, hogy kölcsönhatásba lépjen egymással egy tárolón belül.

Ág

Mindez jó és nagyszerű, ha minden fejlesztő különböző időpontokban dolgozik egy projekten. A fentiekben bemutatott diagramok csak az eredeti tárolóban vagy helyi másolatokban változtak, de nem több ember munkáját.

Ez vezet minket a git elágazás kulcsfontosságú eleméhez, a projekt különböző verzióiban való munkavégzéshez. Ez azt jelenti, hogy a rendezett kötelezettségvállalás egy listája helyett a történet bizonyos pontokon eltér (ami hasonlóvá teszi a fát). Minden ág Git tartalmaz egy könnyű fej fej az utolsó elkövetni ebben a téma, amely lehetővé teszi, hogy hozzon létre egy csomó ágak minden további költség nélkül. Tipp: hívjon egy fióktelepet a benne kialakított funkcionalitásnak megfelelően. Az alapértelmezett ágot mesternek nevezik.

Tehát van egy általános mutatónk Fej. És menj minden ág számára. Így az ágak közötti váltás csak mozog Fej. A megfelelő ág fején.

Standard csapatok:

• git ág.<имя ветки> - új fiókot hoz létre a fejjel jelezve Fej.. Ha nem adja át az érvet<имя ветки> , a csapat megjeleníti az összes helyi fiók listáját;
• git Checkout<имя ветки> - Az ágra vált. Elmeheti a -b opciót, hogy új ágat hozzon létre a váltás előtt;
• git ág -d.<имя ветки> - Eltávolítja az ágat.

Mivel a helyi tároló, és a távoli, lehet egy csomó ágak, így amikor a pálya távoli tároló, valóban ellenőrizni eltávolított ág (git clone hozza a mester ága a származási / fő ága a távoli repository).

Az eltávolított ághoz való kötődés:

• git Branch -u.<имя удалённого репозитория>/<удалённая ветка> - megköti az aktuális fiókot a megadott távoli ágra;
• git checkout --track<имя удалённого репозитория>/<удалённая ветка> - az előző parancs analógja;
• git Checkout -b.<ветка> <имя удалённого репозитория>/<удалённая ветка> - létrehoz egy új helyi fióktelepet, és elkezdi nyomon követni a távoli;
• gIT BRANCH --VV - helyi és felügyelt távoli ágakat mutat;
• git Checkout<удалённая ветка> - Hozzon létre egy helyi fióktelepet ugyanolyan névvel, mint a távoli, és elkezdi követni.

Általánosságban elmondható, hogy a Git Checkout a hely helyét tartalmazza, amely az ágak fejét mutatja, ami úgy néz ki, mint a git reset az általános fejet.

Hebet és tisztítás

Van egy finomság - Ha a GIT ágak átkapcsolása megköveteli, hogy a működő állapot tiszta legyen, azaz a nyomkövetési fájlok összes módosítását rögzíteni kell.

Kb. fordít Ez nem egészen így van. Bizonyos körülmények között a GIT automatikusan átviheti a töröletlen változás egy másik ágra.

Azonban néha befejezetlen változtatásokat nem lehet rögzíteni. Ilyen helyzetben meg lehet menteni és "elrejteni" a Git Stash parancs használatával. A módosítások visszaállításához használja a Git Stash alkalmazást.

Talán inkább meg akarja törölni az összes módosítást. Ebben az esetben használja a git tiszta parancsot. A -D opció törli a nem minősített fájlokat is. Tipp: Adja hozzá a -n lehetőséget, hogy megnézze, mi történik, ha közvetlen használat nélkül elindítja a git tiszta.

Az ágak kombinálása

Miután megvitattuk, hogy milyen ágak vannak, és mindketten a kapcsolódnak, itt az ideje, hogy beszéljen arról, hogy hogyan lehet kombinálni a fejlődés után. Az ág, amelyben a változásokat egyesíteni akarjuk, a főnek nevezik, és az ág, ahonnan egyesítjük őket - tematikus. Kétféleképpen lehet változtatni egy ágból a másikra: összeolvad és mozog.

Összefonódás

Ez magában foglalja az új elkötelezettség létrehozását, amely két ág által végzett ősein alapul, és mindkét fejét korábbi kötelezettségként jelzi. Az egyesüléshez a fő ágba megyünk, és használja a Git Merge parancsot<тематическая ветка> .

Ha mindkét ág megváltoztatja a fájl azonos részét, akkor a konfliktus konfliktus merül fel - a helyzet, amelyben a GIT nem tudja, melyik fájl változatát takaríthatja meg, így szükség van a konfliktus személyre szabására. Az ütköző fájlok megtekintéséhez használja a GIT státuszt.

Az ilyen fájlok megnyitása után hasonló konfliktusmegoldási markerek jelennek meg:

<<<<<<< HEAD:index.html Everything above the ==== is the version in master. ======= Everything below the ==== is the version in the test branch. >\u003e\u003e\u003e\u003e\u003e\u003e Teszt: index.html

Cserélje ki ebben a blokkban mindent a távozni kívánt verzióban, és készítse el a fájlt. Az összes konfliktus megoldása után használhatja a git elkötelezettségét az egyesítés befejezéséhez.

Mozog

Az összefonódási bizottság két ágának ötvözése helyett a mozgó reprodukálja a tematikus ág bizottságait az alapkamat új bizottságainak formájában, amelyet a kötelezettségvállalások tisztább történetébe öntik.

A GIT Rebase parancsot a mozgáshoz használják<основная ветка> <тематическая ветка> amely reprodukálja a fő tematikus ágának változásait; A fej tematikus ág jelzi az utolsó reprodukált elkötelezettséget.

Mozgassa vs. összefonódás

Miután összevonja a naplót egy történetgel, véletlenszerűen néz ki. Másrészt, a mozgás lehetővé teszi, hogy a történetet normális, konzisztens formában írja át.

Akkor miért kell összefonódni, ha mindig használhatja az időt? Sajnos a mozgás nem csodák a zavaró rönköktől, mivel az elmozdult elkötelezettek valóban eltérnek az eredetiektől, bár ugyanaz a szerző, az üzenet és a változás.

Képzeld el egy forgatókönyvet:

• Az ágban számos elkötelezettséget vállal, és egyesíti őket a mesterágba.
• Valaki más úgy dönt, hogy elkötelezettségei alapján dolgozik.
• Úgy dönt, hogy áthelyezi az elkötelezettséget, és elküldi őket a szerverre.
• Amikor valaki megpróbálja egyesülni munkájukat a kezdeti elkötelezettségei alapján, végül két párhuzamos ágot kapunk egy szerzővel, üzenetekkel és változtatással, de különböző elkötelezettségekkel.

Ezért itt van a tanács:

Mozgassa a változásokat csak a magán helyi fiókjában - Ne mozgassa azt a kötelezettségeket, amelyeken valaki más függ.

BIZOTTSÁGI RENDSZER - VISSZATÉRÍTÉS ÉS VISSZA

Hasonló viták arról, hogy mi a jobb használni, akkor fordul elő, ha vissza akarja fordítani a Cunkát. Csapat Git visszatér.<коммит> Új kötelezettséget vállal, törölve a változtatásokat, hanem a történelem megőrzését, míg a git reset<коммит> A fejjel mutatja a tisztább történelem biztosításával (mintha ez nem történt meg). Fontos megjegyezni, hogy azt is jelenti, hogy már nem fog visszatérni ezekhez a változásokhoz, például, ha még mindig úgy dönt, hogy a kötelezettség törlése felesleges volt. Tisztább - nem jelent jobban!

Összesít

Ebben a szakaszban szinte mindent meg kell dolgoznod a GIT-vel. Az alábbiakban több (opcionális) fejlett tipp lesz a nagyobb ellenőrzéshez a kötelezettségvállalások és a történelem. Ezenkívül véletlenül befolyásoljuk a Githubot - az egyik leghíresebb platformot, amelyek a GIT-vel dolgoznak, ami hasznos lehet az Ön számára.

Github.

A Github egy olyan platform, amely tárolja a git tárolót több kiszolgálón. Github felhasználóként tárolhatja a távoli tárolókat a kiszolgálókon, valamint hozzájárulhat más nyílt forráskódú tárolóhöz. A Github kiegészíti a GIT használatát néhány új funkcióval.

Például egy villás távoli adattárat készíthet, azaz a tároló másolatának megteremtése a Github északi részén. Ez olyan esetekben hasznos, ahol nincs joga arra, hogy fióktelepet hozzon létre az eredeti tárolóban. A GIT CLONE parancs használatakor a helyi adattár a távoli űrlapot eredetként és az eredeti adattárként fogja követni.

Ezután előfordulhat, hogy a távoli tároló tematikus ágát le kell üríteni az eredeti fő ágában. Ehhez létrehozhat egy új pull kérelmet - a módosítások kérését, ahol a github ellenőrzi a konfliktusok jelenlétét, mielőtt egyesítést végezne. Gyakran más ellenőrzések is vannak az egyesítés előtt, például a kódolás megtekintése és jóváhagyása, vagy akár elindítási tesztek. A lekérdezésben megvitathatja a kódot, és a távoli tematikus ághoz küldött összes kötelezettség automatikusan hozzáadódik a kérelemhez, még akkor is, ha ezek a kötelezettségek előtt létrejöttek.

Haladó használat: Interaktív előkészítés

Könnyedén kezelheti területén előkészített fájlok (például, amikor rögzítéséről több kis vállalkozik egy helyett nagy) egy interaktív konzol, hogy a Git hozzáadása -i indítható. 8 csapat elérhető:

• Állapot - egy rövid leírást mutat az egyes fájlokhoz (nem) elkészítve;
• frissítés - A nyomkövetési fájlok készítése;
• visszatérés - Távolítson el egy vagy több fájlt az előkészített területről;
• hozzáadhatozott - felkészíti a nem minősített fájlt;
• patch - csak a fájl csak egy részét képezi (hasznos, ha például több funkciót módosított, de több elkötelezettségváltozásokat szeretne megtörni). A fájl kiválasztása után megjelenik Önnek töredékek és bemutatott parancsok: Stage This Hunk? . Beléphetek? hogy megtudja, mi teszi az egyes csapatot;
• diff - megjeleníti az elkészített fájlok listáját, és lehetővé teszi, hogy megtekinthesse a változásokat mindegyikük számára;
• kilép - kijön az interaktív konzolból;
• segítség - Minden csapat rövid leírását mutatja.

A fájl melletti szimbólum azt jelenti, hogy a parancs megváltoztatja az állapotát (elkészített / felkészületlen attól függően, hogy a frissítés vagy a visszavonás bekövetkezik-e). Ha megnyomja az Enter billentyűt anélkül, hogy bármit beírna a parancsmenü bármelyikébe, akkor az összes fájl átvált (NO) elkészített állapotba.

Kérjük, vegye figyelembe, hogy a foltok létrehozása (csak a fájl egy részének előkészítése) nemcsak az interaktív konzolban, hanem a Git Add -p parancson keresztül is elérhető.

Haladó használat: Szabálytörténet

A helyi fióktelep történetének nagyobb ellenőrzése érdekében a Git Rebase -i Head ~ parancsot használhatja n. amely megnyitja az interaktív konzolt az utóbbi halmazának mozgatásához n. Elkötelezettek a régi és az új (azaz a sorrendben, amelyben mozgatásra kerülnek). Tehát a "Történelem szerkesztése", de ne feledje, hogy az eredeti kötelezettségeket nem lehet megváltoztatni, csak mozogni.

Megváltoztathatja a kötelezettségvállalás sorrendjét a sorrendelés megváltoztatásával.

Változtassa meg a kötelezettséget / eladási kötelezettségeket

A módosítani kívánt bizottság megadásához a szerkesztési parancsot használják. Aztán, amikor a git mozog, akkor megáll ez a com. Ezután használhatja a GIT kötelezettségvállalás -amendát az üzenet megváltoztatásához vagy az elfelejtett fájlok előkészítéséhez. Ha meg szeretné osztani a Cunkát, akkor adja meg a git reset fejét ^ (a fej eredményeként, akkor egy visszahívásra kerül, és az összes fájl megváltozott ebben. Ezután a szokásos módon javíthatja az egyéni kötelezettségeket.

A szerkesztés befejezése után írja be a Git Rebase --Continue-t.

Több elkövetés felülírása

Néha szükség lehet több elkötelezettség felülírására - ilyen esetekben használhatja a git szűrő ágot. Például törölni egy véletlenszerűen felvett fájlt, akkor meg Git Szűrő Branch --Tree-Filter „Git rm -f<имя файла>- Fej. Úgy vélem azonban, hogy ugyanakkor az egész történet mozog.

Több elkötelezettség

Miközben a projekt új funkcióján dolgozik, fokozatosan rögzítheti a tematikus ág legkisebb változását is. Emiatt azonban a történelem eltömődik az ilyen kis elkötelezettségek, amelyek ellentmondanak a projekt szabályainak. Ezt korrigálhatjuk, ha több elkötelezettséget vállalunk egy nagyra. Ehhez először használja a Pick parancsot az első kötelezettségvállalás kiválasztásához, majd a Squash azután. A GIT minden változást fog alkalmazni, és kéri, hogy szerkessze az általános elkötelezettség üzenetét.

Külön összefüggést ad

Amellett, hogy a tematikus ág összes elkötelezettségének egyesülése / mozgása mellett csak bizonyos elkötelezettséget tudsz érdekelni. Tegyük fel, hogy van egy helyi tervezet ága, ahol több potenciális cikken dolgozik, de csak az egyiket szeretné közzétenni. Ehhez használhatja a Git Cherry-pick parancsot. Hogy bizonyos kötelezettséget vállaljon, amellyel szeretnénk választani, használhatja a git naplót<основная ветка>..<тематическая> .

Felhívjuk figyelmét, hogy az új elkövetni jön létre ilyen módon, ami csak megismétli a DIFF a kiválasztott elkövetni (azaz a különbség ezen elkövetni, és az előzőt), de nem az állapotát.

Következtetés

Tehát áttekintettük a git alapfogalmát. Ezt a cikket rövid referenciakönyvként használhatja, és elolvashatja a "Pro Git" könyvet, amely sokkal több (~ 450 oldal), és jobban leírja a git mélyebben.

Szeretne mélyebbre ásni a gitbe, de kevés (vagy fordítva, sokat) egy nagy könyv? Akkor nézd meg.

A változások konfrontációja - a személy fő jellemzője. Ha egyszerre kezdtél dolgozni a Version Control Systems-szel, akkor nem volt git - nagyon valószínű, hogy elkezdtél szubverziót. Gyakran az emberek azt mondják, hogy a git túl bonyolult a kezdőknek. Mindazonáltal megengedem magam, hogy nem értek egyet veled.

Ebben a cikkben elmondom, hogyan kell használni a Git használatát a projektekkel való együttműködésben. Feltételezzük, hogy létrehoz egy projektet a semmiből, és szeretnénk használni a GIT-t verzióvezérlő rendszerként. Miután elolvasta a fő parancsokat, elolvassuk, hogyan lehet a kódot a Githubon.

Ez a cikk az alapvető dolgokat fogja beszélni - hogyan lehet inicializálni a projektet, hogyan kell új és meglévő fájlokat kezelni, és hogyan kell tárolni a kódot a felhőben. Csökkentünk néhány összetett dolgokat, mint az elágazás, mivel a cikk kezdődik a kezdők.

A GIT telepítése.

A Hivatalos Site Git különböző rendszereken - Linux, Mac, Windows. A mi esetünkben az Ubuntu 13.04-et fogjuk használni, és a GIT-t apt-get segítségével telepítjük.

Sudo apt-get install git

Kezdeti konfiguráció

Hozzon létre egy könyvtárat, amelyben fogunk dolgozni. A GIT-t egy meglévő projekthez való munkához is használhatja, és ebben az esetben az alábbiakban leírt demonstrációs könyvtárat nem hoz létre.

Mkdir my_git_project cd my_git_project

Először is, szükség van a git tároló inicializálása a projektkönyvtárban. Ezt az init parancs segítségével teheti meg, amely létrehoz egy könyvtárat. A projekt minden információjával rendelkezik.

Git config - global user.name "shaumik" git config -global usemail " [E-mail védett]"GIT Config - Global Color.ui" Auto "

Érdemes megjegyezni, hogy ha nem adja meg a címét és a nevét, akkor az alapértelmezett értékek helyett használják. A mi esetünkben az alapértelmezett értékek donny és [E-mail védett]

Az interfész színét az automatikus értékre is beállítottuk, így a git parancsok kimenete színe lesz. Ezekhez a parancsokhoz - azokat a parancsokhoz adjuk hozzá, hogy ezeket az értékeket a rendszer egészében használják, és az egyes projektek esetében nem kellett beállítani őket.

A kötelezettségvállalások előkészítése

A következő lépés több fájlt hozunk létre. Használhat bármely szövegszerkesztőt erre. Ne feledje, hogy ha inicializálja a Git egy meglévő projektben, akkor nem kell ezt a lépést tenni.

Ellenőrizze a tároló állapotát

Most, hogy vannak fájlok a projektben, lássuk, hogy a GIT hogyan vonzza őket velük. Az aktuális tároló állapotának ellenőrzéséhez használja a Git állapotparancsot.

Fájlok hozzáadása a githez

Ebben a szakaszban a GIT nem követi az egyik fájlt. Szükséges, hogy kifejezetten fájlokat adjon hozzá a gitnek, hogy történt. Ehhez használja a Parancs hozzáadása.

Git add hozzá a my_file-t.

A tároló állapotának ellenőrzése után látjuk, hogy az egyik fájlt már hozzáadták hozzá.

Ahhoz, hogy hozzá több fájlt, akkor az alábbi (észre, hogy mi került az első fájl korábban, így csak hozzá a maradék kettő).

Git hozzá myfile2 myfile3

A GIT-t rekurzív módon hozzáadhatja, de vigyázzon ezzel a paranccsal. Vannak olyan fájlok (például összeállított programok), amelyeket nem szabad hozzáadni a verzióvezérlő rendszerhez. Ha a GIT-t rekurzív módon használja, az ilyen fájlok szintén a tárolóba esnek.

Fájlok törlése

Képzeld el, hogy véletlenül hozzáadott egy fájlt az adattárba, amely nem volt ott. Vagy el kívánja távolítani a fájlt a verzióvezérlő rendszerből. Általában a GIT RM parancs nem egyszerűen törli a fájlt a tárolóból, de fizikailag törli a lemezről. A git stop nyomon követése a fájl, de a lemezen maradt, használja a következő parancsot:

Git rm --cached [fájlnév]

Commimim változások

Miután hozzáadta az összes szükséges fájlt, kommentálhatja (javíthatja) őket gitbe. Képzeld el, hogy a kötelezettség a projekt állapotának pillanatképe egy bizonyos szakaszban, amelyre bármikor visszatérhet, és a projekt állapotát abban az időben láthatja. Minden bizottsággal egy üzenet társul, hogy az argumentum az előtag után van-e

Git elkötelezi magát -m "az első elkötelezettségemet"

Adjon meg olyan üzenetet, amely hasznos információkat tartalmaz, amennyiben segítenek megérteni, hogy mit változtattak meg ebben a kötelezettségben. Kerülje el a közös üzeneteket, például a "hibák szabályait". Ha van hibakövetője, megadhat egy üzenet típust "Bug # 123". Jó gyakorlat - jelezze az ág nevét vagy javulását. Például: "Asset Management - hozzáadta az eszköz alapú PDF létrehozását" - világos és érthető üzenet.

A GIT meghatározza a hosszú hexadecimális számot. Általában nincs szükség az egész sort másolására, az első 5-6 karakter elegendő egy adott elkötelezettség azonosítására. A képernyőképen látható, hogy a Cunkainkat a 8DD76FC számmal azonosítják.

További elkötelezi magát

Módosítsuk több fájlt, miután megkezdtük őket. Miután megváltoztattuk őket, a Git Status jelentést tesz arról, hogy megváltoztattuk a fájlokat.

Láthatja, hogy mi változott ezeken a fájlokban az előző kötelezettségvállalás óta, a Git diff parancs használatával. Ha meg szeretné tekinteni egy adott fájl módosítását, használhatja a git diff<файл> .

A változtatásokat meg kell indexelni, és kinyomtatni őket. Minden módosított projektfájl a következő parancshoz adható hozzá a kötelezettségvállaláshoz:

Ezt a parancsot elkerülheti, ha hozzáad egy paramétert a git elkötelezettségéhez. Ez a parancs az összes módosított fájlt indexeli, és a komódokat. De ez a megközelítés meglehetősen veszélyes lehet, így véletlenül meg tudod adni azt a tényt, hogy nem akartam. Például mondjuk, hogy kinyitotta a fájlt, és véletlenül megváltoztatta. A módosított fájlok indexelésénél értesítést kap az egyes fájlok változásairól. De ha elküldi az összes módosított fájlt anélkül, hogy segítséget keresne. Git elkötelezi magát, akkor minden fájl elkötelezett, beleértve azokat is, amelyeket nem akarsz.

Amint az indexelt fájlok, akkor folytathatja az elkötelezettséget. Amint korábban említettük, megadhat egy üzenetet a kulcs-m-es kötelezettségvállaláshoz. De akkor is meg többsoros megjegyzéseket a Git commit parancs, amely megnyitja a konzolt beírásához megjegyzést.

Problémamegoldás

A projekt előzményeinek megtekintéséhez a következő parancsot használhatja:

Ez megjeleníti a teljes történelem történelmét egy elkötelezettségi lista és információ formájában. A kötelezettségvállalásról szóló információ a hash elkötelezettségét, szerzőit, idő- és kommutációs üzenetét tartalmazza. Sokféle GIT naplócsapat létezik, amelyek megismerkedniük kell, hogy az elágazást a GIT-ben használják. A konkrét elkötelezettség és módosított fájlok részleteinek megtekintéséhez futtassa a következő parancsot:

Git show.<хеш_коммита>

hol<хеш_коммита> - HEX szám, amely egy elkötelezettséggel jár. Mivel ez a kézikönyv kezdőknek vannak tervezve, nem fogjuk megfontolni, hogyan kell visszaadni az államot egy adott elkötelezettség idején, vagy hogyan kell irányítani az ágakat.