Idiota

Tutorial Git Rebasebase

Tutorial Git Rebasebase

I principianti di Git sono avvisati del comando rebase. E giustamente così. Con tutte le nuove cose da imparare, i principianti probabilmente farebbero meglio a padroneggiare i concetti di base prima di addentrarsi nelle complessità del rebase. Tuttavia, se comprendi le basi della fusione dei rami, sapere come eseguire il rebase può aiutarti a risolvere alcuni complicati enigmi di sviluppo quando arriva il momento giusto.

Git Rebase: definizioni

Secondo la documentazione git, il comando rebase riapplica i commit sopra un altro suggerimento di base. Questa definizione potrebbe essere un po' scoraggiante. È più facile spiegare rebase come una procedura che aggiunge le modifiche del ramo corrente alla coda di un altro ramo. Facciamo un esempio per avere un'idea migliore di cosa succede.

Esempio di ribasamento di Git

In questo esempio, creeremo prima un test case con 'master' e 'feature' branch. Quindi faremo un'unione standard. Successivamente, ricreeremo il test case ed eseguiremo il rebase e l'unione.

1. Creazione di rami principali e feature

Ecco lo scenario che creeremo:

A - B - C (master) \ E - F (caratteristica)

Nell'esempio sopra, stiamo seguendo il seguente percorso:

  1. Commit A: aggiungiamo a.txt nel ramo 'master'
  1. Commit B: aggiungiamo b.txt nel ramo 'master'
  1. A questo punto, creiamo la "funzione" del ramo, il che significa che avrà un.txt e b.TXT
  1. Commit C: aggiungiamo c.txt nel ramo 'master'
  1. Andiamo al ramo 'funzionalità'
  1. Commit E: modifichiamo a.txt nel ramo "funzionalità"'
  1. Commit F: modifichiamo b.txt nel ramo "funzionalità"'

Puoi creare una cartella ed eseguire il seguente codice all'interno della cartella per creare la situazione sopra:

git init touch a.txt git add -A git commit -m "Commit A: aggiunto a.txt" tocca b.txt git add -A git commit -m "Commit B: aggiunto b.txt" git branch feature touch c.txt git add -A git commit -m "Commit C: aggiunto c.txt" git status git checkout feature echo aaa > a.txt git add -A git commit -m "Commit E: modificato a.txt" echo bbb > b.txt git add -A git commit -m "Commit F: modificato b.TXT"

2. Unione semplice

Usiamo il comando log per controllare entrambi i rami.

Risultati per 'maestro':

$ git checkout master Passato al ramo 'master' $ git log --oneline 2bbde47 Commit C: aggiunto c.txt b430ab5 Commit B: aggiunto b.txt 6f30e95 Commit A: aggiunto a.txt $ ls a.txt b.txt c.TXT

Risultati per 'funzione':

$ git checkout feature Passato al branch 'feature' $ git log --oneline 0286690 Commit F: modificato b.txt 7c5c85e Commit E: modificato a.txt b430ab5 Commit B: aggiunto b.txt 6f30e95 Commit A: aggiunto a.txt $ ls a.txt b.TXT

Nota come il ramo di funzionalità non ha Commit C

Ora eseguiamo unisci il ramo 'feature' con il ramo 'master'. Ti verrà chiesto di inserire un commento. Nel commento, aggiungi "Commit G:" all'inizio per semplificare il monitoraggio.

$ git checkout master Passato al ramo 'master' $ git merge feature Merge effettuato dalla strategia 'recursive'. un.txt | 1 + b.txt | 1 + 2 file modificati, 2 inserimenti(+)

Risultati per 'maestro':

 $ git checkout master Già su 'master' $ git log --oneline d086ff9 Commit G: Unisci ramo 'feature' 0286690 Commit F: modificato b.txt 7c5c85e Commit E: modificato a.txt 2bbde47 Commit C: aggiunto c.txt b430ab5 Commit B: aggiunto b.txt 6f30e95 Commit A: aggiunto a.txt $ ls a.txt b.txt c.TXT

Risultati per 'funzione':

$ git checkout feature Passato al branch 'feature' $ git log --oneline 0286690 Commit F: modificato b.txt 7c5c85e Commit E: modificato a.txt b430ab5 Commit B: aggiunto b.txt 6f30e95 Commit A: aggiunto a.txt $ ls a.txt b.TXT

Nel ramo 'master', noterai che c'è un nuovo commit G che ha unito le modifiche dal ramo 'feature'. In sostanza, sono state eseguite le seguenti azioni:

A - B - C  - G (master) \   / E - F (caratteristica)

Nel Commit G, tutte le modifiche dal branch 'feature' sono state portate nel branch master. Ma il ramo "caratteristica" stesso è rimasto intatto a causa del processo di fusione. Nota l'hash di ogni commit. Dopo l'unione, il commit E (7c5c85e) e F (0286690) ha lo stesso hash sul ramo 'feature' e 'master'.

3. Unione con Ribasatura

Ripetiamo il passaggio 1 per creare nuovamente i rami "master" e "feature".

Risultati per 'maestro':

$ git checkout master Passato al ramo 'master' $ git log --oneline 7f573d8 Commit C: aggiunto c.txt 795da3c Commit B: aggiunto b.txt 0f4ed5b Commit A: aggiunto a.txt $ ls a.txt b.txt c.TXT

Risultati per 'funzione':

$ git checkout feature Passato al branch 'feature' $ git log --oneline 8ed0c4e Commit F: modificato b.txt 6e12b57 Commit E: modificato a.txt 795da3c Commit B: aggiunto b.txt 0f4ed5b Commit A: aggiunto a.txt $ ls a.txt b.TXT

Riprendiamo dal ramo 'funzionalità'.

$ git checkout feature Passato al branch 'feature' $ git rebase master Innanzitutto, riavvolgendo la testa per ripetere il lavoro su di essa... Applicazione: Commit E: modificato a.txt Applicando: Commit F: modificato b.TXT

Quindi unisci 'feature' in 'master'.

$ git checkout master Passato al ramo 'master' $ funzione git merge Aggiornamento 7f573d8… 9efa1a3 Avanzamento veloce a.txt | 1 + b.txt | 1 + 2 file modificati, 2 inserimenti(+)

Risultati per il ramo 'master':

$ git checkout master Già su 'master' $ git log --oneline 9efa1a3 Commit F: modificato b.txt 8710174 Commit E: modificato a.txt 7f573d8 Commit C: aggiunto c.txt 795da3c Commit B: aggiunto b.txt 0f4ed5b Commit A: aggiunto a.txt $ ls a.txt b.txt c.TXT

Risultati per il ramo 'caratteristica':

$ git checkout feature Passato al branch 'feature' $ git log --oneline 9efa1a3 Commit F: modificato b.txt 8710174 Commit E: modificato a.txt 7f573d8 Commit C: aggiunto c.txt 795da3c Commit B: aggiunto b.txt 0f4ed5b Commit A: aggiunto a.txt $ ls a.txt b.txt c.TXT

Nota che dopo il rebase e l'unione entrambi i rami sono gli stessi. Inoltre, gli hash per E e F sono cambiati in entrambi i rami. Fondamentalmente, nello scenario rebase, questo è quello che è successo:

A - B - C \ E' - F' (caratteristica, maestro)

Ecco perché non c'è un nuovo commit. I commit E e F sono stati ricalcolati e agganciati alla fine del ramo 'master'.

Il rebasing è uno strumento utile quando vuoi ripulire la cronologia del tuo lavoro. Tuttavia, c'è un pericolo che ha dato vita alla regola d'oro.

Regola d'oro del rebasing

La regola d'oro del rebasing è:

Non ribasare mai un ramo pubblico.

Come puoi vedere dall'esempio sopra, il rebasing ricalcola i commit. Quando più persone si diramano da un repository pubblico, il rebase può creare situazioni in cui gli sviluppatori che hanno creato nuovi rami si imbatteranno in situazioni di unione molto complicate. Quindi, è una buona idea non rifondare mai rami pubblici condivisi.

In conclusione:

Il rebasing è una caratteristica unica di Git. Ma usalo con cautela.

Maggiori informazioni:

Ecco alcuni link per ulteriori approfondimenti:

Documentazione di Git Rebase
Fusione Atlassian vs Rebasing

Riferimenti:

Giochi I migliori giochi di laboratorio dell'app Oculus
I migliori giochi di laboratorio dell'app Oculus
Se possiedi un visore Oculus, devi essere informato sul sideloading. Il sideloading è il processo di installazione di contenuti non archiviati sul vis...
Giochi I 10 migliori giochi da giocare su Ubuntu
I 10 migliori giochi da giocare su Ubuntu
La piattaforma Windows è stata una delle piattaforme dominanti per i giochi a causa dell'enorme percentuale di giochi che si stanno sviluppando oggi p...
Giochi I 5 migliori giochi arcade per Linux
I 5 migliori giochi arcade per Linux
Al giorno d'oggi, i computer sono macchine serie utilizzate per i giochi. Se non riesci a ottenere il nuovo punteggio più alto, saprai cosa intendo. I...