Tutorial Git Rebase

Se advierte a los principiantes de GIT contra el Comando Rebase. Y con razón. Con todas las cosas nuevas que aprender, los principiantes probablemente estén mejor dominando los conceptos básicos antes de profundizar en las complejidades de la rebaja. Sin embargo, si comprende los conceptos básicos de fusionar ramas, entonces saber cómo rebase puede ayudarlo a resolver algunos acertijos de desarrollo complicados cuando llegue el momento adecuado.

Git Rebase: definiciones

Según la documentación de GIT, el comando Rebase volverá a aplicar las comisiones sobre otro consejo base. Esta definición puede ser un poco desalentadora. Es más fácil explicar a Rebase como un procedimiento que agrega los cambios de la rama actual a la cola de otra rama. Caminemos por un ejemplo para tener una mejor idea de lo que sucede.

Git Rebasing Ejemplo

En este ejemplo, primero crearemos un caso de prueba con la rama 'maestro' y 'característica'. Entonces haremos una fusión estándar. A continuación, recrearemos el caso de prueba y realizaremos Rebase y Fusionar.

1. Creación de ramas maestras y de largometrajes

Aquí está el escenario que crearemos:

A - B - C (Maestro)

\

E - F (característica)

En el ejemplo anterior, estamos tomando la siguiente ruta:

1. Commit A: agregamos un.archivo txt en la rama 'maestro'

2. Commit B: agregamos B.archivo txt en la rama 'maestro'

3. En esta etapa, creamos la rama 'característica', lo que significa que tendrá un.txt y b.TXT

4. Commit C: agregamos C.archivo txt en la rama 'maestro'

5. Vamos a la rama 'característica'

6. Commit E: modificamos un.txt en la rama 'característica'

7. Commit F: Modificamos B.txt en la rama 'característica'

Puede crear una carpeta y ejecutar el siguiente código dentro de la carpeta para crear la situación anterior:

git init
tocar un.TXT
git add -a
git commit -m "commit a: agregó un.TXT"
toque B.TXT
git add -a
git commit -m "commit b: agregado b.TXT"
función de rama de git
Touch C.TXT
git add -a
git commit -m "commit c: agregado c.TXT"
estado de git
Función Git Checkout
Echo aaa> a.TXT
git add -a
git commit -m "commit e: modificado un.TXT"
Echo bbb> b.TXT
git add -a
git commit -m "commit f: modificado b.TXT"

---

2. Fusión simple

Usemos el comando de registro para verificar ambas ramas.

Resultados para 'maestro':

$ git checkout maestro
Cambio a la rama 'maestro'
$ git log -enneline
2BBDE47 Commit C: agregado C.TXT
B430AB5 Commit B: agregado B.TXT
6F30E95 Commit A: agregó un.TXT
$ LS
a.txt b.txt c.TXT

Resultados para 'característica':

función de pago de $ git
Cambiado a la rama 'característica'
$ git log -enneline
0286690 Commit F: Modificado B.TXT
7C5C85E Commit E: modificado un.TXT
B430AB5 Commit B: agregado B.TXT
6F30E95 Commit A: agregó un.TXT
$ LS
a.txt b.TXT

Observe cómo la rama de la función no tiene commit c

Ahora ejecutemos la rama de "característica" con rama 'maestro'. Se le pedirá que ingrese un comentario. En el comentario, agregue "Comprometer G:" al principio para que sea más fácil rastrear.

$ git checkout maestro
Cambio a la rama 'maestro'
función de fusión de $ git
Fusionar hecha por la estrategia 'recursiva'.
a.txt | 1 +
b.txt | 1 +
2 archivos cambiados, 2 inserciones (+)

Resultados para 'maestro':

$ git checkout maestro
Ya en 'maestro'
$ git log -enneline
D086FF9 Commit G: Function 'Function' de Fusion Branch '
0286690 Commit F: Modificado B.TXT
7C5C85E Commit E: modificado un.TXT
2BBDE47 Commit C: agregado C.TXT
B430AB5 Commit B: agregado B.TXT
6F30E95 Commit A: agregó un.TXT
$ LS
a.txt b.txt c.TXT

Resultados para 'característica':

función de pago de $ git
Cambiado a la rama 'característica'
$ git log -enneline
0286690 Commit F: Modificado B.TXT
7C5C85E Commit E: modificado un.TXT
B430AB5 Commit B: agregado B.TXT
6F30E95 Commit A: agregó un.TXT
$ LS
a.txt b.TXT

En la sucursal 'maestro', notará que hay un nuevo compromiso G que ha fusionado los cambios de la rama 'característica'. Básicamente, ha tenido lugar la siguiente acción:

A - B - C - G (Maestro)
\ /
E - F (característica)

En el comet G, todos los cambios de la rama 'característica' se han traído a la rama maestra. Pero la rama de 'característica' en sí ha permanecido intacta debido al proceso de fusión. Observe el hash de cada compromiso. Después de la fusión, E (7C5C85E) y F (0286690) la confirmación tiene el mismo hash en la rama 'característica' y 'maestra'.

---

3. Fusionándose con rebasando

Repitemos el paso 1 para crear las ramas 'maestro' y 'característica' nuevamente.

Resultados para 'maestro':

$ git checkout maestro
Cambio a la rama 'maestro'
$ git log -enneline
7f573d8 Commit C: agregado C.TXT
795DA3C Commit B: agregado B.TXT
0F4ED5B COMISMA A: Se agregó un.TXT
$ LS
a.txt b.txt c.TXT

Resultados para 'característica':

función de pago de $ git
Cambiado a la rama 'característica'
$ git log -enneline
8ED0C4E Conjunto F: Modificado B.TXT
6E12B57 Commit E: modificado un.TXT
795DA3C Commit B: agregado B.TXT
0F4ED5B COMISMA A: Se agregó un.TXT
$ LS
a.txt b.TXT

Vamos a rebotar de la rama 'característica'.

función de pago de $ git
Cambiado a la rama 'característica'
$ Git Rebase Master
Primero, rebobinar la cabeza para reproducir su trabajo sobre él ..
Aplicación: Commit E: modificado un.TXT
Aplicación: Commit F: Modificado B.TXT

Luego fusionar 'característica' en 'maestro'.

$ git checkout maestro
Cambio a la rama 'maestro'
función de fusión de $ git
Actualización 7F573D8 ... 9EFA1A3
Avance rápido
a.txt | 1 +
b.txt | 1 +
2 archivos cambiados, 2 inserciones (+)

Resultados para la rama 'maestro':

$ git checkout maestro
Ya en 'maestro'
$ git log -enneline
9EFA1A3 Commit F: Modificado B.TXT
8710174 Commit E: modificado un.TXT
7f573d8 Commit C: agregado C.TXT
795DA3C Commit B: agregado B.TXT
0F4ED5B COMISMA A: Se agregó un.TXT
$ LS
a.txt b.txt c.TXT

Resultados para la rama 'característica':

función de pago de $ git
Cambiado a la rama 'característica'
$ git log -enneline
9EFA1A3 Commit F: Modificado B.TXT
8710174 Commit E: modificado un.TXT
7f573d8 Commit C: agregado C.TXT
795DA3C Commit B: agregado B.TXT
0F4ED5B COMISMA A: Se agregó un.TXT
$ LS
a.txt b.txt c.TXT

Observe que después de Rebase y la fusión, ambas ramas son las mismas. Además, los hash para E y F han cambiado en ambas ramas. Básicamente, en el escenario de Rebase, esto es lo que sucedió:

A B C
\
E ' - f' (característica, maestro)

Por eso no hay un nuevo compromiso. Las confirmaciones de E y F han sido recalculadas y enganchadas hasta el final de la rama 'Maestro'.

Rebasing es una herramienta útil cuando desea limpiar el historial de su trabajo. Sin embargo, existe un peligro que ha dado a luz a la regla de oro.

---

Regla de oro de la rebaja

La regla de oro de la rebaja es:

Nunca rebase una rama pública.

Como puede ver en el ejemplo anterior, Rebasing recalcula los compromisos. Cuando varias personas se ramifican desde un repositorio público, Rebasing puede crear situaciones en las que los desarrolladores que hayan creado nuevas ramas se encontrarán con situaciones de fusión muy complicadas. Entonces, es una buena idea nunca rebajar las ramas públicas que se comparten.

En conclusión:

Rebasing es una característica única de Git. Pero úsalo con precaución.

Más información:

Aquí hay algunos enlaces para su posterior estudio:

• Git Rebase Documentation
• Atlassian Fusioning vs Rebasing
• Cómo ver el historial de confirmación del repositorio Git
• Mostrar árbol Git en la terminal
• https: // www.atlassiano.com/git/tutorials/fusion-vs-rebasing
• https: // git-scm.com/docs/git-reasbase