Trabajando con ramas
Las ramas (branches) nos permiten desviarnos de la línea principal de desarrollo que después podemos integrar a la línea principal o descartar. Las ramas son útiles para trabajar en nuevas funcionalidades, solución de errores o realizar experimentos, especialmente cuando estamos trabajando con más desarrolladores sobre el mismo proyecto.
Por defecto git crea una rama por defecto llamada master.
Para ver en qué rama te encuentras utiliza el comando git status. La primera línea nos dice en qué rama estamos:
Listando las ramas
Para ver una lista de las ramas utiliza el comando git branch. Por ejemplo, suponiendo que tienes tres ramas (master, rama-1 y rama-2) el resultado sería similar al siguiente:
La rama con el asterisco a la izquierda es en la que nos encontramos actualmente.
Creando una rama
Para crear una rama utiliza el comando git branch seguido del nombre que le quieres dar a la rama. Por ejemplo, para crear una nueva rama llamada mi-rama ejecutaríamos el siguiente comando:
Este comando crea la rama pero no nos ubica sobre ella. Para cambiar de rama debes ejecutar el siguiente comando:
Sin embargo, la mayoría de veces, cuando uno quiere crear una rama también se quiere ubicar sobre ella, así que existe un atajo:
La diferencia con el comando anterior es la opción -b.
Una vez que estamos ubicados sobre una rama, todos los commits se realizarán sobre esa rama.
Cambiando el nombre de una rama
Para cambiar el nombre de la rama debes estar ubicado sobre ella y ejecutar el comando git branch -m seguido del nuevo nombre. Por ejemplo, asumiendo que estamos sobre la rama mi-rama, y que queremos cambiarle el nombre a otra-rama, ejecutaríamos el siguiente comando:
Integrando una rama
Para integrar los commits de una rama (p.e. mi-rama) a otra (p.e. master) primero debemos ubicarnos sobre la rama principal (p.e. master) y ejecutar el comando git merge seguido del nombre de la rama:
Si master no tiene commits adicionales desde que creamos mi-rama, no es necesario crear un commit adicional. Sin embargo, si hay otros commits en master se crearía un nuevo commit, llamado merge commit, que integraría los cambios de mi-rama.
Solucionando conflictos
Es posible que se realicen cambios en las dos ramas que generen conflictos a la hora de integrarlas (p.e. si se crea un archivo con el mismo nombre en las dos ramas o si se cambia la misma línea de un archivo). En este caso es necesario solucionar los conflictos a la hora de hacer el git merge.
Por ejemplo, suponiendo que en master se creó un archivo llamado prueba.txt con un texto Hola desde master y en mi-rama se creo otro archivo con el mismo nombre pero el texto Hola desde mi-rama, al hacer el git merge veríamos lo siguiente en la consola:
La línea 4 nos dice que existe un conflicto en prueba.txt. Al abrir el archivo veríamos algo así:
Lo que está entre la línea 1 y 3 es lo que está en master y lo que está entre la línea 3 y 5 es lo que está en mi-rama. Para solucionar el conflicto debemos decidir qué vamos a dejar y qué vamos a eliminar. Muy importante es siempre elimianar las líneas que definen los límites (las que comienzan con <<<<<<<, ======= y >>>>>>>).
Por ejemplo, asumiendo que queremos dejar las dos frases deberíamos modificar el archivo para que quede de la siguiente forma:
Los editores de programación como VSCode o Atom nos permiten solucionar los conflictos gráficamente. Por ejemplo, la siguiente imagen nos muestra lo que aparecería en Atom cuando abrimos prueba.txt:
Podemos utilizar los botones que dicen use me si sólo queremos dejar alguno de los cambios, o podemos dar click sobre los tres puntos para ver más opciones. Lo importante es que al final no nos queden las líneas que definen los límites y el archivo quede como queramos.
Una vez solucionado el conflicto debemos indicarle a git que ya lo solucionamos utilizando el comando git add y continuar con el merge.
Si omites el mensaje se abrirá el editor de texto por defecto para que lo ingreses.
Eliminado una rama
Para eliminar una rama que ya ha sido integrada en otra utilizamos el comando git branch -d. Para que este comando funcione debemos estar ubicados en la rama a la que fue integrada. Por ejemplo, asumiendo que mi-rama ya fue integrada a master ejecutaríamos el siguiente comando:
Si no hemos integrado la rama pero igual la queremos eliminarla, podemos cambiar la opción -d por -D. Por ejemplo, asumiendo que la rama mi-rama tiene nuevos commits y no ha sido integrada, podemos eliminarla ejecutando el siguiente comando:
Rebasando una rama
Nota: Rebasar ramas es un tema avanzado que recomendamos omitir hasta que tengas un poco más experiencia con Git.
Una rama se rebasa con alguno de dos siguientes objetivos:
Actualizar una rama con respecto a otra. Imagina que estás en una
mi-ramapero enmasterhay unos commits nuevos que necesitas traer ami-ramapara terminar lo que estás haciendo.Evitar el merge commit al integrar. Si rebasas
mi-ramacontramasterantes de integrarla vas a evitar la necesidad de crear un merge commit cuando ejecutesgit merge(asumiendo quemastertiene nuevos commits).
Para rebasar una rama debes ubicarte sobre la rama derivada (p.e. mi-rama) y ejecutar el siguiente comando (asumiendo que la quieres rebasar contra master):
Lo que hace el comando git rebase es lo siguiente:
Mueve los nuevos commits que hayas hecho sobre
mi-ramaa un lugar temporal.Actualiza
mi-ramacon los nuevos commits que se hayan creado enmaster.Aplica los nuevos commits que hayas hecho sobre
mi-rama, pero ahora ya está actualizada con respecto amaster.
El resultado es que mi-rama tiene los mismos commits que master más los nuevos que tenías en mi-rama.
En el paso 3 pueden ocurrir conflictos que deberás solucionar de forma similar a lo que vimos en la sección Solucionando conflictos.
Last updated