Tutorial do Git Rebase

Iniciantes do Git são avisados ​​contra o comando de rebase. E com razão. Com todas as coisas novas a aprender, os iniciantes provavelmente estão melhor dominar os conceitos básicos antes de se aprofundar nos meandros de Rebasing. No entanto, se você entender o básico da fusão de galhos, saber como rebase pode ajudá -lo a resolver alguns quebra -cabeças complicados de desenvolvimento quando chegar a hora certa.

Git Rebase: Definições

De acordo com a documentação do Git, o comando rebase reaplicará se inscreverá no topo de outra dica de base. Esta definição pode ser um pouco assustadora. É mais fácil explicar o Rebase como um procedimento que adiciona as mudanças do ramo atual à cauda de outro ramo. Vamos passar por um exemplo para ter uma idéia melhor do que acontece.

Exemplo Git Rebasing

Neste exemplo, primeiro criaremos um caso de teste com 'Master' e 'Feature' Branch. Então faremos uma mesclagem padrão. Em seguida, recriaremos o caso de teste e realizaremos rebase e mesclagem.

1. Criação de ramos mestre e característica

Aqui está o cenário que criaremos:

A - B - C (mestre)

\

E - f (recurso)

No exemplo acima, estamos seguindo o seguinte caminho:

1. Comprometo a: Adicionamos um.Arquivo TXT na filial 'Master'

2. Commit B: Adicionamos B.Arquivo TXT na filial 'Master'

3. Nesta fase, criamos o ramo 'recurso', o que significa que ele terá um.txt e b.TXT

4. Commit C: Adicionamos C.Arquivo TXT na filial 'Master'

5. Nós vamos para o ramo de 'recurso'

6. Commit E: modificamos um.ramo txt em 'recurso'

7. Commit F: Modificamos B.ramo txt em 'recurso'

Você pode criar uma pasta e executar o código a seguir dentro da pasta para criar a situação acima:

git init
toque a.TXT
git add -a
Git Commit -m "Commit A: Adicionado A.TXT"
toque b.TXT
git add -a
Git Commit -M "Commits B: Adicionado B.TXT"
Recurso do ramo Git
toque c.TXT
git add -a
Git Commit -M "Commits C: Adicionado C.TXT"
status git
Recurso de checkout do git
eco aaa> a.TXT
git add -a
Git Commit -m "Commit E: modificado a.TXT"
echo bbb> b.TXT
git add -a
Git Commit -M "Commit F: Modified B.TXT"

---

2. Fusão simples

Vamos usar o comando log para verificar as duas filiais.

Resultados para 'Mestre':

$ git checkout mestre
Mudou para a filial 'Mestre'
$ git log --oneeline
2BBDE47 Commit C: Adicionado C.TXT
B430AB5 Commit B: Adicionado B.TXT
6F30E95 Comprome.TXT
$ ls
a.txt b.txt c.TXT

Resultados para 'Recurso':

Recurso de checkout de $ git
Mudou para o ramo 'Recurso'
$ git log --oneeline
0286690 Commit F: modificado B.TXT
7C5C85E Commit E: modificado a.TXT
B430AB5 Commit B: Adicionado B.TXT
6F30E95 Comprome.TXT
$ ls
a.txt b.TXT

Observe como a filial do recurso não tem comprometimento C

Agora vamos correr, ramo 'ramo' com 'master' ramo. Você será solicitado a entrar em um comentário. No comentário, adicione "Commiti G:" No começo para facilitar o rastreamento.

$ git checkout mestre
Mudou para a filial 'Mestre'
Recurso de mesclagem $ git
Merge feita pela estratégia 'recursiva'.
a.txt | 1 +
b.txt | 1 +
2 arquivos alterados, 2 inserções (+)

Resultados para 'Mestre':

$ git checkout mestre
Já em 'mestre'
$ git log --oneeline
D086FF9 Commit G: Merge Branch 'Recurso'
0286690 Commit F: modificado B.TXT
7C5C85E Commit E: modificado a.TXT
2BBDE47 Commit C: Adicionado C.TXT
B430AB5 Commit B: Adicionado B.TXT
6F30E95 Comprome.TXT
$ ls
a.txt b.txt c.TXT

Resultados para 'Recurso':

Recurso de checkout de $ git
Mudou para o ramo 'Recurso'
$ git log --oneeline
0286690 Commit F: modificado B.TXT
7C5C85E Commit E: modificado a.TXT
B430AB5 Commit B: Adicionado B.TXT
6F30E95 Comprome.TXT
$ ls
a.txt b.TXT

No ramo 'Master', você notará que há um novo Commit G que mesclou as alterações do ramo 'Feature'. Basicamente, a seguinte ação ocorreu:

A - b - c - g (mestre)
\ / /
E - f (recurso)

No Commit G, todas as mudanças do ramo 'Recurso' foram trazidas para o ramo mestre. Mas a própria ramificação de 'recurso' permaneceu intocada devido ao processo de mesclagem. Observe o hash de cada commit. Após a mesclagem, E (7C5C85E) e F (0286690) Commit tem o mesmo hash no ramo 'Recurso' e 'Master'.

---

3. Fundindo -se com a rebasing

Vamos repetir a etapa 1 para criar as ramificações 'mestre' e 'característica' novamente.

Resultados para 'Mestre':

$ git checkout mestre
Mudou para a filial 'Mestre'
$ git log --oneeline
7F573D8 Commit C: Adicionado C.TXT
795DA3C Commit B: Adicionado B.TXT
0f4ed5b Commit A: Adicionado um.TXT
$ ls
a.txt b.txt c.TXT

Resultados para 'Recurso':

Recurso de checkout de $ git
Mudou para o ramo 'Recurso'
$ git log --oneeline
8ed0c4e Commit F: modificado B.TXT
6E12B57 Commit E: modificado a.TXT
795DA3C Commit B: Adicionado B.TXT
0f4ed5b Commit A: Adicionado um.TXT
$ ls
a.txt b.TXT

Vamos refazer da filial 'Recurso'.

Recurso de checkout de $ git
Mudou para o ramo 'Recurso'
$ git rebase mestre
Primeiro, retrocedendo a cabeça para reproduzir seu trabalho em cima dele ..
Aplicação: Commit E: modificado a.TXT
Aplicação: Commit F: modificado B.TXT

Em seguida, mesclar 'recurso' em 'mestre'.

$ git checkout mestre
Mudou para a filial 'Mestre'
Recurso de mesclagem $ git
Atualizando 7F573D8… 9EFA1A3
Avanço rápido
a.txt | 1 +
b.txt | 1 +
2 arquivos alterados, 2 inserções (+)

Resultados para o ramo 'Master':

$ git checkout mestre
Já em 'mestre'
$ git log --oneeline
9EFA1A3 Commit F: modificado B.TXT
8710174 Commit E: modificado a.TXT
7F573D8 Commit C: Adicionado C.TXT
795DA3C Commit B: Adicionado B.TXT
0f4ed5b Commit A: Adicionado um.TXT
$ ls
a.txt b.txt c.TXT

Resultados para o ramo 'Recurso':

Recurso de checkout de $ git
Mudou para o ramo 'Recurso'
$ git log --oneeline
9EFA1A3 Commit F: modificado B.TXT
8710174 Commit E: modificado a.TXT
7F573D8 Commit C: Adicionado C.TXT
795DA3C Commit B: Adicionado B.TXT
0f4ed5b Commit A: Adicionado um.TXT
$ ls
a.txt b.txt c.TXT

Observe que, após a rebase e a mesclagem, ambos os ramos são os mesmos. Além disso, os hashes para E e F mudaram nos dois ramos. Basicamente, no cenário de rebase, foi o que aconteceu:

A - B - C
\
E ' - f' (recurso, mestre)

É por isso que não há novo compromisso. Os compromissos E e F foram recalculados e travados ao final do ramo 'mestre'.

Rebasing é uma ferramenta útil quando você deseja limpar a história do seu trabalho. No entanto, há um perigo que deu à luz a regra de ouro.

---

Regra de ouro de rebasing

A regra de ouro de Rebasing é:

Nunca refaça uma filial pública.

Como você pode ver no exemplo acima, rebateding recalcula os compromissos. Quando várias pessoas estão se ramificando a partir de um repositório público, a Rebasing pode criar situações em que os desenvolvedores que criaram novas filiais terão situações de mesclagem muito complicadas. Então, é uma boa ideia nunca rebatar ramos públicos que são compartilhados.

Para concluir:

Rebasing é uma característica única do git. Mas use -o com cautela.

Mais Informações:

Aqui estão alguns links para mais estudos:

• Documentação do Git Rebase
• Merging atlassiano vs Rebasing
• Como ver o histórico de commit do repositório Git
• Mostrar árvore git no terminal
• https: // www.Atlassiano.com/git/tutoriais/mesclagem-vs-rebanding
• https: // git-scm.com/docs/git-reabase