Usando una analogía, podemos decir que las ramas son como cuando hacíamos una tarea en el colegio. El cuaderno principal que entregamos al profesor sería la rama master o main. Los cuadernos auxiliares con notas, borradores etc. serían las ramas auxiliares.
NOTA: Al comenzar un proyecto, debido a que la palabra "master" en inglés no es políticamente correcta, se prefiere utilizar como nombre de la rama principal "main". Por ello al iniciar un proyecto podemos transformar la rama master en main con:
$ git checkout -b main
Aunque sea adelantarnos esta instrucción lo que hace es crear la rama e ir a ella directamente.
Dicho esto, el comando con el que trabajaremos al utilizar las ramas es:
$ git branch
Con ella podemos crear, eliminar y manipular ramas.
Con:
$ git branch
Se muestran todas las ramas de un repositorio.
$ git branch [nombre_nueva_rama]
Se creará una nueva rama.
Por ejemplo. Creemos una nueva rama con el nombre de "Prueba". Luego indicaremos al programa que queremos ver todas las ramas existentes.
chema@lenovo:~/proyecto$ git branch Prueba
chema@lenovo:~/proyecto$ git branch
Prueba
* master
Como puedes ver el asterisco * nos indica en que rama estamos en este momento.
Para cambiar de una rama a otra:
$ git checkout [nombre_rama]
chema@lenovo:~/proyecto$ git checkout Prueba
Switched to branch 'Prueba'
chema@lenovo:~/proyecto$ git branch
* Prueba
master
El utilizar esta instrucción tiene su lógica ya que este comando hace que volvamos a la última instantánea que haya de ese sitio, ya se un commit, un archivo o una rama.
Al crear una rama y movernos a ella, hace que todos los archivos que creemos o modificaciones que hagamos se queden en esta rama (podemos decir que es otra versión distinta del repositorio). Si volvemos a movernos a la rama principal, vemos que no están los archivos o modificaciones que hayamos confirmado en la rama auxiliar. No se han perdido, si no que simplemente están ahora en los commits de esa rama.
Para clarificar un poco el concepto y como la instrucción "git checkout" se utiliza para muchas cosas, git (switch = cambiar) recientemente añadió este comando que hace lo mismo:
$ git switch [nombre_rama]
Eliminar una rama.
$ git branch -d [rama_a_eliminar]
Si la rama esta vacía, no tiene contenido, el programa no realiza ningún aviso, las borra y ya está. Por el contrario si la rama tiene contenido, porque previamente hemos hecho en ella algún commit, al intentar borrarla, si antes no la hemos mezclado con la rama principal (cosa que veremos en breve), nos realizará un aviso.
Para borrar una rama, previamente tenemos que cambiarnos a una rama diferente.
Ejemplo de una rama con contenido que queremos borrar:
chema@lenovo:~/proyecto$ git branch -d Prueba
error: The branch 'Prueba' is not fully merged.
If you are sure you want to delete it, run 'git branch -D Prueba'.
Fusión de ramas.
Tenemos que estar en la rama a la que queremos fusionar otra. Por ejemplo si tenemos una rama auxiliar que queremos fusionar con la rama principal del repositorio entonces tenemos que estar en esta última para realizar la fusión.
El comando a utilizar es:
$ git merge [rama_a_fusionar]
La fusión va a combinar tanto los datos de las ramas como el historial.
GIT utiliza dos algoritmos diferentes para realizar una fusión.
1) fast-forward (fusión de avance rápido)
2) three-way merge (fusión de tres vías)
1) Fast-Forward.
Cuando todas las confirmaciones en la rama extraída también están en la que se está fusionando, es decir hay una ruta lineal directa desde la rama de origen a la rama de destino. En este tipo de fusión, Git mueve el puntero de la rama de origen al puntero de la rama de destino sin crear una confirmación de fusión adicional.
Veamos un ejemplo:
Tenemos una rama principal con tres confirmaciones (commits).
A continuación creamos una rama llamada auxiliar. En Git realmente una rama no es más que un puntero a una determinada confirmación. En este momento tanto la rama principal como la rama auxiliar apuntan a la misma confirmación.
Ahora cambiemos a la rama auxiliar y realicemos un par de confirmaciones.
Para fusionar los cambios en la rama principal, todo lo que tenemos que hacer es cambiar el puntero de la rama principal hacia adelante. Por eso este método se llama fusión de avance rápido.
Como entenderlo puede ser un poco farragoso vamos a verlo con un ejemplo teórico y luego otro real.
Digamos que tenemos un directorio llamado MAIN_V_1.0. Es un programa que estamos desarrollando y ahí estarán todos sus archivos. Ahora imaginemos que queremos añadirle nuevas funcionalidades. Como no sabemos si estas nueva funcionalidades estropearán el programa principal lo que hacemos es copiar esta carpeta y renombrarla como MAIN_FIX_V_1.0. El código de esta última carpeta es idéntico al del directorio original. Ahora digamos que hicimos cambios en esta carpeta para mejorar el programa, no hay errores de ejecución y llegamos a MAIN_FIX_V_2.0. La pregunta que se plantea es ¿Cómo llevamos esos cambios a la carpeta Principal MAIN_V_1.0?
Solución 1: Copiamos todos los archivos de MAIN_FIX a MAIN. Esta no es la mejor solución ya que las operaciones de copia pueden llevar bastante tiempo si tenemos muchos archivos en la carpeta MAIN_FIX. Debería haber una mejor solución.
Solución 2: Dado que no hemos modificado el directorio Principal "MAIN_V_1.0" y todo en este directorio es esencialmente la primera versión de MAIN_FIX, simplemente podemos cambiar el nombre de MAIN_FIX a MAIN_V_2.0. De ahora en adelante, podemos decir que este es nuestro nuevo directorio Principal. El concepto de avance rápido en GIT es muy similar a esta solución.
Ejemplo PRACTICO:
$ git init $ echo hola>hola.txt $ git add . $ git commit -m 'primer commit' $ echo mundo>>hola.txt $ git add . $ git commit -m 'segundo commit' $ echo '¿Que tal?'>>hola.txt $ git commit -a -m 'tercer commit' - Después de hacer tres confirmaciones creamos una nueva rama. $ git branch auxiliar $ git switch auxiliar - Añadimos una nueva línea a hola.txt y creamos un archivo nuevo en esta nueva rama. $ echo 'Estamos en una nueva rama'>>hola.txt $ touch nuevo_archivo.txt $ git add . $ git commit -m 'auxiliar 1' $ echo 'ultimo texto'>>hola.txt $ git add . $ git commit -m 'auxiliar 2' - Puedes probar a cambiar entre ramas y ver los directorios. Verás que en la rama master solo esta el archivo hola.txt y el texto que hemos añadido en los commits suyos. En la rama auxiliar, sin embargo, hay un archivo más, nuevo_archivo.txt y el archivo hola.txt tiene más texto. - Ahora cambiamos a la rama master y realizamos la fusión. $ git switch master $ git merge auxiliar Ya esta la rama master actualizada con lo últimos commits de la rama auxiliar.
2) Three-way merge.
Se utiliza cuando el historial de las ramas de la fusión ha divergido de alguna manera. Vamos a verlo con un ejemplo. En el siguiente gráfico vemos como la rama Auxiliar está dos commits o confirmaciones por delante de la rama principal.
Antes de fusionarla con la rama principal, digamos que hemos modificado algo en la misma (un archivo nuevo, algún dato a mayores etc) y hemos realizado una confirmación adicional, como se muestra en el siguiente gráfico.
La razón por la que se llama fusión de tres vías es porque se basa en tres confirmaciones diferentes.
1.- El ancestro común de todas las ramas que en nuestro caso es el commit C3. Esta confirmación contiene el código del repositorio antes de que divergiéramos en diferentes ramas.
2.- La punta de la rama Principal que es la ultima confirmación realizada, es decir C6.
3.- La punta de la rama Auxiliar que es la última confirmación realizada en esta rama es decir la C5.
Para fusionar los cambios de ambas ramas, Git mira las tres confirmaciones diferentes. Basándose en estas instantáneas, Git combina los cambios mediante la creación de una nueva confirmación denominada Merge Commit.
Veámoslo con un ejemplo:
$ git init $ echo uno>1.txt $ git add . $ git commit -m 'c1' $ echo dos>2.txt $ git add . $ git commit -m 'c2' $ echo tres>3.txt $ git add . $ git commit -m 'c3' $ git branch auxiliar $ git switch auxiliar $ echo cuatro>4.txt $ git add . $ git commit -m 'c4' $ echo cinco>5.txt $ git add . $ git commit -m 'c5' $ git switch master $echo seis>6.txt $ git add . $ git commit -m 'c6' $ git merge auxiliar $ git log --oneline --all --graph
Salida
Merge made by the 'ort' strategy. 4.txt | 1 + 5.txt | 1 + 2 files changed, 2 insertions(+) create mode 100644 4.txt create mode 100644 5.txt * fc9005e (HEAD -> master) Merge branch 'auxiliar' |\ | * d5002e6 (auxiliar) c5 | * a66d859 c4 * | 3e7c402 c6 |/ * 1c0f647 c3 * 9c7f558 c2 * 5b7bd0c c1
Nota:
$ git log --oneline --graph
git log --oneline hace que los diferentes log se nos muestren de una forma más bonita, en una sola línea y mostrando solo una versión abreviada del Id del commit, rama y texto del commit.
git log --graph nos muestra las ramas en forma de gráfico.
IMPORTANTE: El fusionar ramas puede dar lugar a problemas o conflictos de fusión si hay cambios en un mismo archivo en las dos ramas. Luego veremos porque se producen y como solventarlas.
Deshacer una Fusión.
Si nos surge cualquier problema a la hora de realizar una fusión, es decir nos salga un error en que se nos diga que hay un conflicto de fusión, como salvavidas de escape tenemos el siguiente comando:
$ git merge --abort
Si como en el ejemplo previo, la fusión se realizó correctamente, pero por la razón que sea queremos volver a como estaban las cosas antes de la misma:
Comprobamos que estamos en la rama principal:
chema@lenovo:~/proyecto$ git branch
auxiliar
* master
$ git reset --hard [ultimo_commit_antes_de_la_fusión]
$ git reset --hard 3e7c402
