Come unire rami senza avanzare velocemente in Git

Come Unire Rami Senza Avanzare Velocemente In Git



Mentre lavorano su un sistema di controllo della versione decentralizzato noto come Git, gli utenti possono creare molti rami nel repository per molteplici scopi. Inoltre, puoi unirli nel ramo principale principale. Tuttavia, quando i rami vengono uniti con un commit di unione, questo processo è noto come unione senza avanzamento rapido.

D'altra parte, quando abbiamo un percorso lineare diretto tra il ramo di origine e il ramo di destinazione, è possibile eseguire l'unione in avanti veloce.

Questa guida discuterà la procedura per unire i rami senza l'avanzamento rapido in Git.







Come unire rami senza avanzare rapidamente in Git?

Si supponga di aver creato un nuovo ramo per lavorare su un progetto specifico e di voler integrare i risultati nel codice o nel file principale. Per lo scopo specificato, è necessario unire il ramo specifico con il ramo radice.



Seguire la procedura indicata di seguito per questo scopo corrispondente.



Passaggio 1: avvia Git Bash
Innanzitutto, avvia il ' Git bash ” terminale con l'aiuto del “ Avviare ' menù:





Passaggio 2: crea una directory Git
Corri il ' mkdir ” comando per creare la nuova directory Git:



$ mkdir I miei_rami

Qui, ' I miei_rami ” è il nome della nostra directory appena creata:

Passaggio 3: vai alla directory Git
Passa alla directory locale in cui desideri apportare modifiche:

$ CD I miei_rami

Passaggio 4: inizializza il repository Git
Ora, crea il repository Git vuoto usando il comando fornito di seguito:

$ Fa caldo

Passaggio 5: crea e aggiungi file
Corri il ' tocco ” comando per creare un file di testo denominato “ file.txt ” nella directory corrente:

$ tocco file.txt

Ora aggiungilo al repository Git con l'aiuto di ' git aggiungi comando ':

$ git aggiungi file.txt

Passaggio 6: conferma le modifiche
Successivamente, conferma le modifiche con un messaggio informativo:

$ git commit -m 'file.txt aggiunto'

Qui, abbiamo inserito il messaggio di commit tra virgolette doppie:

Passaggio 7: crea filiale
Quindi, esegui il comando fornito di seguito per creare un nuovo ramo:

$ ramo git sviluppare

Fino a questo punto, abbiamo creato con successo il nuovo nome della filiale “ sviluppare ”:

Passaggio 8: cambia ramo
Esegui il ' git checkout comando ” per passare al ramo appena creato:

$ git checkout sviluppare

Passaggio 9: crea e aggiungi file
Ora, prima crea un nuovo file all'interno del nuovo ramo tramite il comando indicato di seguito:

$ tocco fil2.txt

Dopodiché aggiungilo al repository Git:

$ git aggiungi -UN

Passaggio 10: confermare il messaggio
Conferma le modifiche con un messaggio utilizzando ' git commit comando ':

$ git commit -m 'file2.txt aggiunto'

Passaggio 11: passa a Branch
Quindi, passa al ramo principale ' maestro ” usando il comando seguente:

$ git checkout maestro

Passaggio 12: unisci i rami Git
Infine, unisci i rami senza l'avanzamento veloce utilizzando il ' git merge comando '. Qui, il “ –non -ff Il flag ” impedisce all'unione di eseguire la funzionalità di avanzamento rapido:

$ git merge --no-ff sviluppare

Come puoi vedere, abbiamo unito il ' maestro ” ramo con il “ sviluppare ' ramo:

Passaggio 13: verifica unione
Assicurati che le filiali siano unite con ' registro git comando ':

$ registro git --in linea

Di seguito l'output indica che i nostri due rami sono uniti:

Abbiamo compilato il processo più semplice per unire i rami senza avanzare rapidamente in Git.

Conclusione

Per unire i rami senza l'avanzamento veloce in Git, prima inizializza una directory con il ' $ git calore comando '. Quindi, crea un nuovo file, aggiungilo e salva le modifiche con un messaggio nel repository Git. Successivamente, crea e passa al nuovo ramo. Ancora una volta crea, aggiungi un nuovo file nel ramo commutato e esegui il commit. Infine, esegui il ' $ git merge --no-ff ” comando per unire entrambi i rami. Questa guida ha illustrato la procedura per unire i rami senza avanzare rapidamente in Git.