In questo articolo, parlerò di come funziona Git Rebase, delle differenze tra Git Rebase e Git Merge e come lavorare con Git Rebase. Quindi iniziamo.

Git rebase:

Diciamo, hai un repository git con i commit UN, B, C nel maestro ramo. Quindi, hai creato una nuova filiale Somebranch e aggiunto 2 nuovi commit D E E al Somebranch ramo.

Fig 1: cronologia iniziale di commit.

Ora, diciamo, hai dimenticato di aggiungere qualcosa in maestro ramo. Quindi, torni al maestro ramo e aggiungi un nuovo commit G al maestro ramo. La tua storia di Git dovrebbe apparire come segue.

Fig 2: commit cronologia dopo aver aggiunto il commit g nella filiale principale.

Tutto sembra buono. Ora, se volevi ogni modifica che hai apportato al Somebranch ramo per essere nel maestro ramo, puoi unire il Somebranch ramo al maestro ramo. Questo è ciò che git unire Fare.

E se vuoi il commit G essere disponibile in Somebranch ramo? Bene, puoi usare Git Rebase per questo.

Dalla storia del commit in Fig 2, puoi vedere che il ramo Somebranch Inizia dal commit C. Se fai un Git Rebase Somebranch, Quindi inizierebbe dal commit G come mostrato in Fig 3 sotto. Si noti che, il contenuto del commit D E E cambierà anche dopo l'operazione Rebase. Gli commit D E E includerà i cambiamenti nel commit G. Questo è il motivo per cui ho aggiunto * simbolo prima degli impegni D E E.

Se vuoi sapere come sarebbe la storia del commit se la fossi unito, allora dai un'occhiata alla Fig 4. L'ho incluso solo così sarai in grado di confrontarlo con Git Rebase.

Fig 4: commessa la storia se è stato utilizzato Git Merge.

Ora che sai cos'è Git Rebase, la differenza tra Git Rebase e Git Merge e perché Git Rebase ha usato, ti mostrerò come usarlo nella prossima sezione di questo articolo di seguito.

Flusso di lavoro Git Rebase:

In questa sezione, creerò un nuovo repository Git sul mio computer locale e ti mostrerò come funziona Git Rebase. Ti consiglio di avere una buona comprensione di Git Rebase prima di applicarlo sul tuo progetto.

Innanzitutto, crea un nuovo repository git Rebase-Demo/ sul tuo computer come segue:

$ git init rebase-demo

Ora, naviga su Rebase-Demo/ directory come segue:

$ cd cd rebase-demo/

Ora, crea un nuovo file test.TXT come segue:

$ echo "a"> test.TXT

Il test.Il file TXT contiene solo una riga UN. Diciamo, questo è il tuo codice di progetto iniziale.

Ora, commetti i cambiamenti come segue:

$ git aggiungi .
$ git commit -m 'a'

Ora aggiungi un'altra riga B al test.TXT File come mostrato nello screenshot seguente.

Ora, commetti i cambiamenti come segue:

$ git aggiungi .
$ git commit -m 'b'

Ora aggiungiamo un'altra riga C al test.TXT file.

Inoltre, commetti i cambiamenti come segue:

$ git aggiungi .
$ git commit -m 'c'

Ora, la storia del commit del ramo principale dovrebbe apparire come segue:

$ git log --oneline

Ora, diciamo, hai alcune nuove idee che vuoi provare. Quindi, creiamo e facciamo il checkout a una nuova filiale nuova caratteristica come segue:

$ git checkout -b new -feat

Ora aggiungi la tua nuova idea (la linea D Diciamo) al test.TXT file.

Ora, commetti i cambiamenti come segue:

$ git aggiungi .
$ git commit -m 'd'

Ora, aggiungi la riga e al test.TXT file.

Commettere le modifiche come segue:

$ git aggiungi .
$ git commit -m 'e'

Ora, la storia del commit del nuova caratteristica Il ramo dovrebbe sembrare come segue:

$ git log --oneline

Guarda come sono gli commit in ordine a < B < C < D < E?

Ora, ricordi che ti sei dimenticato di aggiungere qualcosa al maestro ramo che volevi anche essere nel nuova caratteristica ramo! Quindi, checkout al maestro ramo.

Ho aggiunto una nuova riga alla fine del test.TXT file come puoi vedere.

Ora, commetti i cambiamenti come segue:

$ git aggiungi .
$ git commit -m 'g'

Ora, la storia del commit del maestro Branch dovrebbe apparire così.

UN < B < C < G

Ora, per ribellarsi gli commit dal maestro ramo al nuova caratteristica Branch, primo checkout al nuova caratteristica ramo.

$ git checkout newout

Ora, fai una rebase git del maestro ramo come segue:

$ git rebase master

Alcuni conflitti uniscono! Risolviamolo.

Bene, le modifiche che ho apportato al commit G E D sono in conflitto tra loro. Voglio mantenere entrambi.

Dopo aver fissato il conflitto di unione, il test.TXT Il file dovrebbe sembrare come segue:

Ora, aggiungi le modifiche all'area di stadiazione come segue:

$ git aggiungi .

Ora, continua il rebase operante come segue:

$ git rebase -Continua

Un altro conflitto di unione! Bene, questo può accadere. Rebase cambia la storia del commit git. Quindi, cose del genere sono previste.

Sembra che il processo di unione non sia riuscito a causa di alcune linee vuote. Risolviamolo.

Dopo aver fissato il conflitto di unione, il test.TXT Il file dovrebbe apparire come segue.

Ora, aggiungi le modifiche all'area di stadiazione come segue:

$ git aggiungi .

Ora, continua l'operazione Rebase come segue:

$ git rebase -Continua

Git Rebase è completo.

Come puoi vedere, la storia di commit della filiale di nuova caratteristica viene aggiornata. Ora, la storia del commit è la seguente:

UN < B < C < G < D < E

Proprio come previsto.

Il finale test.TXT Il file dovrebbe apparire come segue.

Git Rebase è uno strumento potente. Ma non dovresti mai usarlo su repository GIT condivisi. Usalo solo nei repository Git che lavori solo. Altrimenti, dovrai affrontare molti problemi lungo la strada.

Quindi, è così che usi Git Rebase. Grazie per aver letto questo articolo.