The git rebase command van egy hírnév, hogy mágikus Git voodoo, hogy a kezdőknek távol kell maradniuk, de ez valójában, hogy az élet sokkal könnyebb a fejlesztő csapat, ha óvatosan használják. Ebben a cikkben összehasonlítjuk a git rebase – ot a kapcsolódó git merge paranccsal, és azonosítjuk az összes lehetséges lehetőséget az újraindítás beépítésére a tipikus Git munkafolyamatba.,

fogalmi áttekintés

az első dolog, amit meg kell érteni agit rebase az, hogy megoldja ugyanazt a problémát, mint a git merge. Mindkét parancs célja az egyik ágból a másikba történő változások integrálása – csak nagyon különböző módon csinálják.

fontolja meg, hogy mi történik, amikor egy új szolgáltatáson dolgozik egy dedikált fiókban, majd egy másik csapattag frissíti a master ágat új elkötelezettséggel. Ez egy villás történelmet eredményez, amelyet mindenkinek ismernie kell, aki a Git-t együttműködési eszközként használta.,

most tegyük fel, hogy az új elkötelezi magát amaster releváns a funkció, hogy éppen dolgozik. Ha be szeretné építeni az új kötelezettségvállalásokat a feature fiókjába, két lehetősége van: egyesítés vagy újraindítás.,

Az Egyesítés Lehetőséget

A legegyszerűbb lehetőség, hogy összevonja a master ág a funkciót ág használ valamit, mint a következő:

git checkout feature git merge master

Vagy, akkor lecsapódik, hogy egy-bélés:

 git merge feature master

Ez létrehoz egy új “merge követett el” a feature ág köti össze a történetek, mind a fióktelepek, így egy ág szerkezet, ami így néz ki:

Összevonása örülök, mert ez egy non-destruktív művelet. A meglévő ágak semmilyen módon nem változnak., Ez elkerüli az újraindítás összes lehetséges buktatóját (az alábbiakban tárgyaljuk).

másrészt ez azt is jelenti, hogy a feature ág egy idegen merge commit minden alkalommal, amikor be kell építeni upstream változások. Ha a master nagyon aktív, ez eléggé szennyezheti a szolgáltatáság történetét. Bár lehetséges, hogy enyhítse ezt a problémát az advanced git log opciókkal, megnehezítheti más fejlesztők számára, hogy megértsék a projekt történetét.,

az egyesítés alternatívájaként afeatureágat a master ágra a következő parancsokkal: 

git checkout feature git rebase master

Ez a teljesfeatureág a master ág csúcsán kezdődik, hatékonyan beépítve az összes új kötelezettséget a master – be. De ahelyett, hogy egy merge commit, újraindítása újraírja a projekt története létrehozásával vadonatúj vállal minden elkövetni az eredeti ág.,

az újraindítás fő előnye, hogy sokkal tisztább projekt előzményeket kap. Először is kiküszöböli a git mergeáltal megkövetelt felesleges egyesítési kötelezettségeket. Másodszor, amint az a fenti ábrán látható, az újraindítás tökéletesen lineáris projekttörténetet eredményez—a feature végét a projekt kezdetéig villák nélkül követheti. Ez megkönnyíti a projekt navigálását olyan parancsokkal, mint a git log, git bisect, és gitk.,

de két kompromisszum van az eredeti elkövetési előzményekkel kapcsolatban: a biztonság és a nyomon követhetőség. Ha nem követi az Újraindítás aranyszabályát, a projekt előzményeinek újraírása potenciálisan katasztrofális lehet az együttműködési munkafolyamat szempontjából. Kevésbé fontos, hogy az újraindítás elveszíti a merge commit által biztosított kontextust—nem láthatja, hogy az upstream változások mikor épültek be a funkcióba.

Interactive Rebasing

Interactive rebasing megadja a lehetőséget, hogy megváltoztassa követ, ahogy átkerülnek az új ág., Ez még erősebb, mint egy automatizált rebase, mivel teljes ellenőrzést biztosít az ág elkötelezett története felett. Általában ez egy rendetlen előzmények tisztítására szolgál, mielőtt egy funkció ágat master – ra egyesítene.,

kezdeni egy interaktív rebasing ülésen adja át a i lehetőséget, hogy a git rebase parancs:

git checkout feature git rebase -i master

Ez megnyit egy szövegszerkesztő felsorolásával, az vállalja, hogy hamarosan elköltözött:

pick 33d5b7a Message for commit #1 pick 9480b3d Message for commit #2 pick 5c67e61 Message for commit #3

Ez a lista határozza meg, hogy pontosan mi az ág fog kinézni, miután a rebase végzik. A pick parancs megváltoztatásával és/vagy a bejegyzések újrarendelésével az ág előzményei úgy nézhetnek ki, mint amit akarnak., Például, ha a 2. elkövetni javítások egy kis problémám a 1 követett el, lecsapódhat őket egyetlen követett el azzal, hogy a fixup parancs:

pick 33d5b7a Message for commit #1 fixup 9480b3d Message for commit #2 pick 5c67e61 Message for commit #3

Ha a mentés gombra, majd zárja be a fájlt, Git elvégzi a rebase utasítása szerint, ami a projekt története, ami úgy néz ki, mint a következő:

Megszüntetése jelentéktelen kötelezi magát, mint ez teszi a szolgáltatás történelem sokkal könnyebb megérteni. Ez valami, amit git merge egyszerűen nem tud megtenni.,

A

újraindítás aranyszabálya miután megértette, mi az újraindítás, a legfontosabb dolog, amit meg kell tanulni, amikor nem kell csinálni. A git rebase aranyszabálya az, hogy soha ne használja nyilvános ágakon.

például gondoljon arra, hogy mi történne, ha visszaállítaná a master – t a feature ágra:

a rebase az összes kötelezettséget a master featurehegyére. A probléma az, hogy ez csak a tárolóban történt., Az összes többi fejlesztő még mindig dolgozik az eredeti master. Mivel rebasing eredmények a márka új vállalja, Git azt hiszik, hogy a master fióktelep történelem eltért mindenki más.

Az egyetlen módja, hogy szinkronizálja a két master ágak van, hogy egyesíti őket együtt, ami egy extra merge elkövet két vállalja, hogy az tartalmazza a változtatásokat (az eredeti azok, akik a rebased ág). Mondanom sem kell, hogy ez egy nagyon zavaró helyzet.,

tehát a git rebase futtatása előtt mindig kérdezd meg magadtól: “valaki más nézi ezt az ágat?”Ha a válasz igen, vegye le a kezét a billentyűzetről, és kezdjen el gondolkodni a változtatások roncsolásmentes módjáról (például a git revert parancs). Ellenkező esetben biztonságosan újra írhatja a történelmet, amennyit csak akar.

Force-Pushing

Ha megpróbálja, hogy álljon a rebased master ág vissza egy távoli adattár, Git megakadályozza, hogy ezt, mert ütközik a távoli master ág., De, akkor kényszeríteni a push, hogy menjen át, átadva a --force zászló, mint így:

# Be very careful with this command! git push --force

Ez felülírja a távoli master ág, hogy megfeleljen a rebased egy a tároló, és teszi a dolgokat nagyon zavaros a többi csapat. Tehát legyen nagyon óvatos, ha ezt a parancsot csak akkor használja, ha pontosan tudja, mit csinál.

az egyik egyetlen alkalom, amikor kényszeríteni kell, az, amikor helyi tisztítást végzett, miután egy privát szolgáltatás ágat egy távoli tárolóba tolt (például biztonsági mentés céljából)., Ez olyan, mint azt mondani, ” Hoppá, nem igazán akartam, hogy álljon, hogy az eredeti változata a funkció ág. Vegyük a jelenlegi helyett.”Ismét fontos, hogy senki sem dolgozza ki a elköteleződést a szolgáltatás ágának eredeti verziójától.

Workflow Walkthrough

Rebasing lehet építeni a meglévő Git munkafolyamat annyi vagy kevés, mint a csapat kényelmes. Ebben a részben megnézzük azokat az előnyöket, amelyeket az újraindítás kínálhat a szolgáltatás fejlesztésének különböző szakaszaiban.,

minden olyan munkafolyamat első lépése, amely kihasználja agit rebase egy külön ág létrehozása minden funkcióhoz. Ez megadja a szükséges ágszerkezetet az újraindítás biztonságos használatához:

helyi Tisztítás

az újraindítás beépítésének egyik legjobb módja a helyi, folyamatban lévő funkciók tisztítása. Az interaktív rebase rendszeres végrehajtásával meggyőződhet arról, hogy a szolgáltatás minden egyes elkötelezettsége fókuszált és értelmes., Ez lehetővé teszi, hogy írjon a kódot anélkül, hogy aggódnia szakítás fel elszigetelt vállal-meg tudja oldani azt követően, hogy az a tény.

agit rebase hívásakor két lehetősége van az új alapra: a szolgáltatás szülő ága (pl.master), vagy egy korábbi elköteleződés a szolgáltatásban. Láttunk egy példát az első lehetőségre az interaktív újraindítás szakaszban. Az utóbbi lehetőség szép, ha csak az utolsó néhány elkötelezettséget kell kijavítania. Például a következő parancs csak az utolsó 3 követ interaktív újraindítását indítja el.,

git checkout feature git rebase -i HEAD~3

megadásával HEAD~3 mint az új bázis, te valójában nem mozog a fióktelep—te csak interaktívan újraírja a 3 elkötelezi magát, hogy kövesse azt. Vegye figyelembe, hogy ez nem foglalja magában az upstream változásokat a feature ágba.

Ha újra szeretné írni a teljes funkciót ezzel a módszerrel, a git merge-baseparancs hasznos lehet a feature ág eredeti alapjának megtalálásához., Az alábbiakban az eredeti bázis commit ID-jét adjuk vissza, amelyet ezután a git rebase:

git merge-base feature master

Ez az interaktív újraindítás nagyszerű módja a git rebase bevezetésének a munkafolyamatba, mivel csak a helyi ágakat érinti. Az egyetlen dolog, amit más fejlesztők látni fogják, a késztermék, amelynek tiszta, könnyen követhető funkció-ág előzményeinek kell lennie.

de ismét, ez csak akkor működik, privát funkció ágak., Ha ugyanazon a szolgáltatóágon keresztül együttműködik más fejlesztőkkel, az az ág nyilvános, és nem írhatja újra az előzményeket.

nincsgit merge alternatív megoldás a helyi elköteleződések interaktív rebázzal történő tisztítására.

az Upstream változások beépítése a

funkcióba a fogalmi áttekintési szakaszban láttuk, hogy egy szolgáltatáság hogyan képes beépíteni a master upstream változásokat git merge vagy git rebase., Az összevonás egy biztonságos lehetőség, amely megőrzi az adattár teljes történetét, míg az újraindítás lineáris előzményeket hoz létre úgy, hogy a szolgáltatás ágát a masterhegyére mozgatja.

a git rebase használata hasonló a helyi tisztításhoz (és egyszerre is elvégezhető), de a folyamat során magában foglalja a masterupstream követéseket.

ne feledje, hogy teljesen legális a masterhelyett egy távoli ágra rebase., Ez akkor fordulhat elő, ha ugyanazon a szolgáltatáson dolgozik egy másik fejlesztővel, és módosításait be kell építenie a tárolóba.,

például, ha egy fejlesztő egy John nevű ki vállalja, hogy a feature ág, a repository-úgy néz ki, mint az alábbi után elragadó a távoli feature ág a John adattár:

Meg lehet oldani ezt a villát a pontos ugyanúgy integrálni upstream változik master: vagy összeolvad a helyi feature a john/feature, vagy rebase a helyi feature – ra a hegye john/feature.,

Megjegyezzük, hogy ez a rebase nem sérti az Arany Szabály Rebasing, mert csak a helyi feature vállalja, hogy költözött—azelőtt minden érintetlen. Ez olyan, mintha azt mondaná: “add hozzá a változásaimat ahhoz, amit John már megtett.”A legtöbb esetben ez intuitívabb, mint a távoli ággal való szinkronizálás egy merge commit segítségével.

alapértelmezés szerint a git pull parancs egy egyesítést hajt végre, de kényszerítheti arra, hogy a távoli ágat egy rebase-vel integrálja a --rebase opció átadásával.,

áttekintve a funkció egy Pull kérés

ha használja pull kérések részeként a kód felülvizsgálati folyamat, el kell kerülni a git rebase létrehozása után a pull kérés. Amint megteszi a húzási kérelmet, más fejlesztők megvizsgálják a kötelezettségvállalásait, ami azt jelenti, hogy ez egy nyilvános fióktelep. Az előzmények újraírása lehetetlenné teszi, hogy a Git és a csapattársai nyomon kövessék a funkcióhoz hozzáadott nyomon követési kötelezettségeket.

minden más fejlesztőtől származó változást be kell építeni a git merge git rebasehelyett.,

emiatt általában jó ötlet, hogy tisztítsa meg a kódot egy interaktív rebase benyújtása előtt a pull kérés.

egy jóváhagyott funkció integrálása

miután egy funkciót a csapata jóváhagyott, lehetősége van arra, hogy újraindítsa a funkciót a master ág hegyére a git merge használata előtt, hogy integrálja a funkciót a fő kódbázisba.,

Ez hasonló helyzet, mint az upstream változások beépítése egy funkció ágba, de mivel nem szabad újra írni a master ágban, végül a git merge – et kell használnia a szolgáltatás integrálásához. Az egyesítés előtt végrehajtott rebase végrehajtásával azonban biztos lehet benne, hogy az egyesítés gyorsan továbbításra kerül, ami tökéletesen lineáris előzményeket eredményez. Ez lehetőséget ad arra is, hogy a húzási kérelem során hozzáadott nyomon követési kötelezettségvállalásokat összegyűjtse.,

Ha nem teljesen elégedett a git rebase, akkor mindig elvégezheti a rebase-t egy ideiglenes ágban. Így, ha véletlenül elrontani a funkció története, akkor nézd meg az eredeti ág, majd próbálja újra. Például:

git checkout feature git checkout -b temporary-branch git rebase -i master # git checkout master git merge temporary-branch

összefoglaló

és ez minden, amit tudnod kell az ágak újraindításához., Ha szeretné, egy tiszta, lineáris történelem ingyenes felesleges merge vállalja, hogy el kell érni, hogy az git rebase helyett git merge ha változások integrálása a másik ág.

másrészt, ha meg akarja őrizni a projekt teljes történetét, és el akarja kerülni a nyilvános kötelezettségvállalások újbóli írásának kockázatát, akkor ragaszkodhat a git merge – hoz. Bármelyik opció tökéletesen érvényes, de legalább most lehetősége van arra, hogy kihasználja a git rebaseelőnyeit.