Lliçons de Git: fusió / reallotjament

El sistema de control de versions distribuït anomenat Git ha canviat la manera en què els desenvolupadors pensen en la fusió i ramificació de codis en comparació amb els sistemes de control de versions anteriors com CVS i SVN.


Amb Git, aquestes operacions es van fer relativament fàcils i ràpides de fer. Aquest sistema permet als desenvolupadors crear noves funcions aïllades de la branca mestra i integrar-les en un moment posterior quan la funció estigui preparada per a la seva integració.

Si sou nou de Git, els enllaços següents us poden ajudar a començar ràpidament:

  • Git: la guia senzilla
  • Fonaments bàsics
  • Fonaments de la branca de Git
  • Un model amb èxit de branca de git

A Git, hi ha dues maneres principals d’integrar els canvis d’una branca en una altra:

  1. fusionar
  2. rebens

Mirarem de combinar-se amb l’opció -ff i l’opció –no-ff. Nota: no hi ha cap ordre de rehabilitació de git –no-ff.

Configuració d’una demostració ràpida

Abans d’examinar les dues maneres de fusionar Git, establim primer un dipòsit de Git en funcionament amb les ordres següents:

1
2
3
4
5
6

mkdir mycode

eco de “foo bar baz” > mycode / foo.txt

git init mycode

cd mycode

git add foo.txt

git commit -m “Missatge de compromís”

Creem ara una nova branca anomenada “myfeature” i canviem-la:

1 git checkout -b myfeature

Ara podem fer un canvi al fitxer “foo.txt” de la branca “myfeature” de la nostra representació local:

1
2

eco -e “foo bar baznquux” > foo.txt

git commit -a -m “ha afegit myfeature”

Suposem que el nostre canvi de “característica” està completat i ara voldríem integrar aquesta funció en la nostra branca “mestra”..

El nostre gràfic git seria així:

1
2
3

   B la meva característica

  /

Un mestre

Com hem dit anteriorment sobre Git, tenim dues maneres de fer-ho: fer una fusió o un reembossament.

Com utilitzar: git merge

La comanda git merge uneix dues o més branques.

Primer, tornem al “mestre”, per tal que puguem aplicar la combinació a la nostra branca principal.

1 git checkout master

Ara podem fer la fusió, però parlem primer de les dues maneres diferents de crear una fusió.

Sovint el cap de branca actual és un avantpassat del comitè anomenat (“myfeature”). Aquest és el cas més habitual. En aquest cas, no és necessari un compromís nou per emmagatzemar l’historial combinat. En lloc d’això, la git HEAD (juntament amb l’índex) s’actualitza per assenyalar el commit anomenat sense crear un commit de combinació addicional.

El comportament predeterminat de la combinació de git és fer una combinació avançada quan sigui possible. Aquest comportament per defecte es pot fer explícit amb l’opció -ff, o es pot suprimir aquest comportament amb l’opció de fusió (–no-ff) no avançada. Quan fusiona una etiqueta anotada, Git sempre crea un compromís de combinació, fins i tot si és possible una fusió avançada.

Quan utilitzeu –no-ff, algú que revisi l’historial de git pot veure clarament la branca en què vau deixar la sessió. A més, observeu com la combinació –no-ff té un compromís addicional de fusió al final.

A continuació, es mostra una imatge que mostra la diferència entre la combinació –no-ff i -ff.

git - no-ff rebase

Així que ara tens l’opció d’utilitzar:

1 git merge myfeature

Després d’aquesta ordre, el nostre gràfic de git quedaria així:

1 A – B mestre

O podríem mantenir l’historial de les branques fent:

1 git merge-no-ff myfeature

En aquest darrer cas, el nostre gràfic git ara seria així:

1
2
3

  B la meva característica

/

Mestre A – C

I si executem la següent comanda git log:

1 git log –graph –full-history –all –pretty = format: “% h% x09% d% x20% s”

Això mostrarà un gràfic similar al git:

1
2
3
4
5

* 5368727 (HEAD, master) Unir la branca “myfeature”

|

| * 6267227 (myfeature) ha afegit myfeature

| /

* ac54e38 Missatge de compromís

Quin tipus de fusió preferiu depèn de quanta informació de la branca que vulgueu emmagatzemar quan feu una combinació.

Com s’utilitza: git rebase

La segona manera d’integrar els canvis d’una branca en una altra és fer un rebasió de git.

Quan la fusió reuneix dues branques tot mantenint el gràfic de cada historial de compromisos, unificar les branques reescrivint els canvis de la branca d’origen de manera que apareixen com a fills de la branca de destinació..

El local de git rebase rebaixa el compromís local amb el cap amunt actualitzat. Rebajar és el procés de traslladar una sucursal a un nou compromís base.

Això és el que sembla en un gràfic git. Suposem que existeix l’historial següent i la branca actual és “myfeature”:

1
2
3

      A – B – C característica

     /

D – E – F – G mestre

I si ho fem ara:

1 git reaparició mestre

El resultat seria:

1
2
3

        La seva característica de A – B – C –

       /

D —E — F — G mestre

La branca “mestre” ara conté els canvis de la branca “myfeature” a la commissió “G” sense crear un compromís de combinació. Així, en comptes d’unir les sucursals amb un compromís de combinació, reintegrar integra la branca “myfeature” construint a la part superior del master. El resultat és una història lineal que pot ser més fàcil d’entendre per als desenvolupadors. El registre de git ara mostrarà la història lineal de “D-E-F-G master”.

En cas de conflicte, el rebase de git s’aturarà al primer compromís amb problemes i deixarà marques de conflicte a l’arbre.

Combinar o reembossar?

Els dos mètodes d’integració de codis s’han d’utilitzar quan s’adapti millor. Hi ha diferents opinions sobre quan s’hauria d’utilitzar un determinat mètode.

A continuació, es detallen alguns enllaços que descriuen situacions en què un mètode pot ser preferit per un altre:

  • fusionar-se o tornar-se a fusionar?
  • Quan s’uneix i quan rebasseu?
  • Fluxos de treball de Git Team: fusionar o reaparèixer?
Jeffrey Wilson Administrator
Sorry! The Author has not filled his profile.
follow me