Il ribasamento è un processo per riapplicare i commit sopra un altro viaggio di base. Viene utilizzato per applicare una sequenza di commit da rami distinti in un commit finale. È un'alternativa al comando git merge. È un processo lineare di fusione.

In Git, il termine rebase viene indicato come il processo di spostamento o combinazione di una sequenza di commit in un nuovo commit di base. La ribasatura è molto vantaggiosa e visualizza il processo nell'ambiente di un flusso di lavoro con ramificazione delle funzionalità.

È bene riorganizzare il ramo prima di unirlo.

Generalmente, è un'alternativa al comando git merge. L'unione è sempre un record che cambia in avanti. In confronto, rebase è uno strumento avvincente per la riscrittura della cronologia in git. Unisce i diversi commit uno per uno.

Supponiamo che tu abbia effettuato tre commit nel ramo master e tre nell'altro ramo denominato test. Se lo unisci, unirà tutti i commit in una volta. Ma se lo ribasi, verrà unito in modo lineare. Considera l'immagine qui sotto:

L'immagine sopra descrive come funziona git rebase. I tre commit del ramo master vengono fusi linearmente con i commit del ramo test.

La fusione è il modo più semplice per integrare i rami. Esegue un'unione a tre vie tra i due ultimi commit di ramo.

Come ribasare

Quando hai effettuato alcuni commit su un ramo funzionalità (ramo test) e alcuni nel ramo master. Puoi riassegnare uno qualsiasi di questi rami. Utilizza il comando git log per tenere traccia delle modifiche (cronologia dei commit). Acquista il ramo desiderato che desideri rebase. Ora esegui il comando rebase come segue:

Sintassi:

 $git rebase 

Se ci sono dei conflitti nel ramo, risolvili ed esegui i comandi seguenti per continuare le modifiche:

 $ git status 

Viene utilizzato per verificare lo stato,

 $git rebase --continue 

Il comando precedente viene utilizzato per continuare con le modifiche apportate. Se vuoi saltare la modifica, puoi saltare come segue:

sottostringa di assetto JavaScript

 $ git rebase --skip 

Una volta completata la ribasatura. Spingi il repository all'origine. Considera l'esempio seguente per comprendere il comando git merge.

Supponiamo che tu abbia una filiale da dire prova2 su cui stai lavorando. Ora sei sul ramo test2 e hai apportato alcune modifiche al file del progetto nuovofile1.txt .

Aggiungi questo file al repository:

 $ git add newfile1.txt 

Ora, conferma le modifiche. Utilizza il comando seguente:

 $ git commit -m 'new commit for test2 branch.' 

L'output sarà simile a:

 [test2 a835504] new commitfor test2 branch 1 file changed, 1 insertion(+) 

Passa il ramo a master:

 $ git checkout master 

Produzione:

 Switched to branch 'master.' Your branch is up to date with 'origin/master.' 

Adesso sei sul ramo master. Ho aggiunto le modifiche al mio file, dice nuovofile.txt . Il comando seguente viene utilizzato per aggiungere il file nel repository.

 $ git add newfile.txt 

Ora esegui il commit del file per le modifiche:

algoritmo di Kruskals

 $ git commit -m ' new commit made on the master branch.' 

Produzione:

 [master 7fe5e7a] new commit made on master 1 file changed, 1 insertion(+) HiMaNshU@HiMaNshU-PC MINGW64 ~/Desktop/GitExample2 (master) 

Per controllare la cronologia del registro, eseguire il comando seguente.

 $ git log --oneline 

Produzione:

Come possiamo vedere nella cronologia del log, c'è un nuovo commit nel ramo master. Se voglio rebase il mio ramo test2, cosa devo fare? Vedere lo scenario del ramo rebase riportato di seguito:

Ribasare il ramo

Se abbiamo molti commit da rami distinti e vogliamo unirli in uno solo. Per fare ciò, abbiamo due scelte: possiamo unirlo o ribasarlo. È bene riorientare il tuo ramo.

Dall'esempio sopra, ci siamo impegnati nel ramo master e vogliamo ribasarlo sul ramo test2. Vediamo i comandi seguenti:

 $ git checkout test2 

Questo comando ti commuterà sul ramo test2 dal master.

Produzione:

 Switched to branch 'test2.' 

Ora sei sul ramo test2. Quindi, puoi ribasare il ramo test2 con il ramo master. Vedi il comando seguente:

 $ git rebase master 

Questo comando ribaserà il ramo test2 e verrà visualizzato come Applicazione: nuovo commit sul ramo test2 . Considera l'output seguente:

Produzione:

Git Interactive Rebase

Git facilita con Interactive Rebase; è uno strumento potente che consente varie operazioni come modificare, riscrivere, riordinare, e altro sui commit esistenti. Interactive Rebase può essere utilizzato solo sul ramo attualmente estratto. Pertanto, imposta il tuo ramo HEAD locale nella barra laterale.

Git Interactive Rebase può essere richiamato con il comando rebase, basta digitare -io insieme al comando rebase. Qui ' io ' sta per interattivo. La sintassi di questo comando è riportata di seguito:

Sintassi:

 $ git rebase -i 

Elencherà tutte le opzioni interattive disponibili.

Produzione:

Dopo l'output fornito, si aprirà un editor con le opzioni disponibili. Considera l'output seguente:

Produzione:

cos'è l'oggetto Java

Quando eseguiamo il comando git Interactive rebase, si aprirà il tuo editor di testo predefinito con l'output sopra.

Le opzioni in esso contenute sono elencate di seguito:

• Scegliere
• Riformulare
• Modificare
• Schiacciare
• Aggiustare
• Esecutivo
• Rottura
• Gocciolare
• Etichetta
• Ripristina
• Unisci

Le opzioni di cui sopra eseguono i loro compiti specifici con git-rebase. Comprendiamo ciascuna di queste opzioni in breve.

Scegli (-p):

Pick indica qui che il commit è incluso. L'ordine dei commit dipende dall'ordine dei comandi di selezione durante il rebase. Se non vuoi aggiungere un commit, devi eliminare l'intera riga.

Riformulazione (-r):

La riformulazione è abbastanza simile al comando pick. L'opzione reword mette in pausa il processo di rebase e offre la possibilità di modificare il messaggio di commit. Non influisce sulle modifiche apportate dal commit.

Modifica/i:

L'opzione di modifica consente di modificare il commit. I mezzi di modifica, i commit possono essere aggiunti o modificati interamente. Possiamo anche effettuare ulteriori commit prima del comando rebase continue. Ci consente di dividere un commit di grandi dimensioni in un commit più piccolo; inoltre, possiamo rimuovere modifiche errate apportate in un commit.

Zucca (-s):

L'opzione squash ti consente di combinare due o più commit in un unico commit. Ci permette anche di scrivere un nuovo messaggio di commit per descrivere le modifiche.

Correzione (-f):

È abbastanza simile al comando squash. Ha scartato il messaggio del commit da unire. Il messaggio di commit più vecchio viene utilizzato per descrivere entrambe le modifiche.

Esegui (-x):

L'opzione exec ti consente di eseguire comandi shell arbitrari contro un commit.

Rottura (-b):

L'opzione di interruzione interrompe il ribasamento nella giusta posizione. Continuerà a ribasare in seguito con ' git rebase --continua 'comando.

Rilascia (-d):

L'opzione drop viene utilizzata per rimuovere il commit.

Etichetta (-l):

L'opzione etichetta viene utilizzata per contrassegnare la posizione corrente della testa con un nome.

Reimposta (-t):

L'opzione di ripristino viene utilizzata per reimpostare la testina su un'etichetta.

matematica discreta con negazione

GitMerge contro Rebase

Una delle domande sconcertanti più comuni per gli utenti git è quando utilizzare il comando merge e quando utilizzare rebase. Entrambi i comandi sono simili ed entrambi vengono utilizzati per unire i commit effettuati dai diversi rami di un repository.

Il rebasing non è consigliato in un ramo condiviso perché il processo di rebasing creerà repository incoerenti. Per gli individui, la riorganizzazione può essere più utile della fusione. Se vuoi vedere la cronologia completa, dovresti usare l'unione. Merge tiene traccia dell'intera cronologia dei commit, mentre rebase ne riscrive una nuova.

Comandi Git rebase indicati come alternativa a git merge. Tuttavia, presentano alcune differenze fondamentali: