Si estás utilizando Git para la gestión del código fuente, es posible que necesites fusionar diferentes ramas de desarrollo para un proyecto en una sola rama. Este artículo te guiará sobre cómo combinar dos ramas de desarrollo con el comando merge de Git.
Te mostraremos cómo crear un proyecto Git, crear diferentes ramas y fusionar una rama en otra. Además, aprenderás qué es una fusión “fast-word” y una fusión de tres vías, y cómo fusionar una rama en un repositorio remoto.
¿Qué es Git merge?
Git es una herramienta popular de DevOps que los desarrolladores pueden utilizar para rastrear y gestionar cambios en el código escrito por distintos equipos. Con el comando Git merge, puedes tomar tu rama de desarrollo actual (que has bifurcado de la rama principal) y fusionar sus cambios de código de nuevo en la rama principal.
El merge de Git es un comando que usarás con mayor frecuencia cuando estés trabajando en equipo. Puede haber momentos en los que tú y otro desarrollador colaboren en una característica en dos ramas separadas. Sin embargo, llegará un momento en el que necesitarás combinar tu trabajo en una sola rama, probar esos cambios y luego fusionar tu desarrollo colaborativo en la rama principal de desarrollo.
A medida que la rama principal de desarrollo se actualiza, la rama de características separada en la que tú y otros desarrolladores están trabajando no se actualizará con los cambios de tu equipo. Por lo tanto, como mejor práctica, cuando llegue el momento de enviar una solicitud de extracción, siempre debes comenzar por actualizar tu versión local de la rama principal con los cambios más recientes. Luego, puedes fusionar la rama principal actualizada en tu rama de desarrollo antes de confirmar y enviar una solicitud de extracción para fusionarla en la rama principal de desarrollo.
Cómo combinar dos ramas de Git con Git merge
Como desarrollador, ser competente en Git realmente puede ayudarte a ser más productivo. Para empezar, es fundamental entender cómo ejecutar comandos de Git desde la línea de comandos. Antes de comenzar, veamos qué necesitas configurar primero antes de poder empezar a fusionar diferentes ramas de Git.
Requisitos previos
Para empezar, necesitarás los siguientes elementos:
- A Windows, Mac, or Linux machine to run Git.
- La aplicación Git, que está disponible para descargar aquí.
- A GitHub or Gitlab account.
- Software de edición de código como Visual Studio Code.
Vamos a revisar rápidamente los diferentes pasos necesarios para instalar Git en una PC con Windows (también tenemos una guía separada sobre cómo instalar Git en Ubuntu):
- Sigue el enlace para descargar Git para tu máquina e instalar los archivos.
- Una vez instalado, abre tu terminal y escribe git –version:
git –version
Si recibes un número de versión, ¡genial! Sin embargo, si recibes un mensaje de “comando no encontrado”, entonces es posible que necesites agregar Git a tu variable $PATH. Esto suele ser un problema de Windows.
Vamos a remediar eso rápidamente para que no tengas que buscar mucho.
- Ve a la barra de inicio y haz clic derecho en Este PC.
- Selecciona Propiedades.
- Haz clic en Configuración avanzada del sistema.
- Bajo Propiedades del sistema, haz clic en Variables de entorno. Aquí puedes añadir valores a la variable $PATH.
- Seleccione $PATH y haga clic en Editar.
- Haga clic en Nuevo y agregue una ruta al git/cmd.
- Haga clic en Nuevo y agregue la ruta al archivo git.exe.
Guarde los cambios, regrese al terminal y ejecute nuevamente el comando git -version.
git -version
Ahora debería obtener el número de versión devuelto. Después de hacer la preparación y configurar su cuenta de GitHub o GitLab, debería estar listo para trabajar.
Creando un proyecto Git
En esta sección, te guiaré a través de los diferentes pasos necesarios para crear un nuevo repositorio.
En tu cuenta de Github recién creada, haz clic en Nuevo en el lado izquierdo de la pantalla.
Luego, deberás darle un nombre a tu repositorio y completar algunos detalles más. Dale una breve descripción si lo deseas, hazlo público y una buena práctica es siempre agregar un archivo ReadMe. Una vez hecho, haz clic en Crear repositorio.
Ahora, para empezar a trabajar en tu editor de código, querrás clonar tu nuevo repositorio haciendo clic en el botón Clonar. Selecciona HTTPS, copia la dirección y abre tu terminal.
En tu terminal, usa el comando cd para elegir dónde quieres crear un nuevo directorio para tu proyecto.
cd user/desktop/repo/
Cuando estés en la rama correcta, utiliza el comando mkdir para crear un nuevo directorio:
mkdir <name of your directory>
Ahora, utiliza nuevamente el comando cd para cambiar a ese directorio recién creado:
cd <name of your newly created directory>
Una vez en tu nuevo directorio, utiliza el comando git init para crear un nuevo repositorio:
git init
A continuación, utiliza el comando git clone con la dirección HTTPS correcta y presiona Enter. Por defecto, esto creará una rama principal en tu repositorio local.
git clone <paste https address here>
Ahora, abre tu repositorio clonado recientemente con Visual Studio Code. Ahora puedes empezar a escribir código.
Después de crear tu repositorio, ya estarás en la rama principal. Como práctica recomendada, nunca, jamás, debes enviar código directamente a la rama principal, la cual debe estar protegida.
Para este tutorial, no revisaremos las ramas protegidas de Git. Pero en el campo, nunca podrás enviar código a la rama principal sin una solicitud de extracción.
Crear otra rama de Git
Actualmente estamos en la rama principal, has codificado algo para crear contenido, y ahora quieres crear una nueva rama.
En tu terminal, usa el comando git checkout para crear una nueva rama y cambiar automáticamente a ella:
git checkout -b <name of new branch>
El comando debería crear automáticamente esa nueva rama a partir de tu rama principal, por lo que el código de esta última no debería cambiar.
Ahora, aquí viene la parte divertida donde podremos usar el comando git merge. En tu nueva rama creada, primero necesitarás agregar más código para que tu rama actual esté por delante de la rama principal con algunos cambios nuevos.
Ahora que deseas fusionar esta nueva rama en la principal, es posible que te encuentres con un conflicto de fusión, que es una inserción de código que entra en conflicto con el código que ya existe. Realmente no es divertido lidiar con estos.
Entonces, ¿qué haces? Veamos cómo fusionar una rama en la otra.
Fusionando tus dos ramas de Git en tu repositorio local
Mientras estás en tu nueva rama, ve a tu terminal y usa el comando git branch para verificar el nombre de la rama en la que te encuentras:
git branch
Ahora estás en tu nueva rama, usa el comando git checkout nuevamente para cambiar a tu rama principal:
git checkout Main
Luego, usa el comando git pull para importar los cambios que tu equipo pueda haber hecho y actualizar tu rama principal local:
git pull
Ahora, usa git checkout nuevamente para cambiar a la nueva rama con la que quieres fusionar la rama principal:
git checkout <your specified branch>
Ahora es momento de usar el comando git merge. Esto tomará la versión actual de tu rama principal y la fusionará con tu rama de desarrollo:
git merge Main
El resultado de la fusión tendrá la última versión del código más la función que desarrollaste.
Otras formas de fusionar ramas en Git
Después de mostrarte cómo fusionar una nueva rama con nuestra rama principal, veamos otras formas de fusionar ramas en Git que puedas necesitar usar.
¿Qué es una fusión “fast-forward”?
A fast-forward merge is another way to merge multiple commits on one branch with one command rather than merging them all manually. Another advantage of using a fast-forward merge is that it will combine the histories of multiple commits while squashing the commit history.
Supongamos que tenemos una rama de características por delante de la rama principal por varios commits. Queremos fusionar todos estos commits sin tener que hacerlo manualmente uno por uno. En este caso, utilizaremos una fusión de avance rápido.
En nuestro ejemplo, comenzaremos escribiendo algo de código y agregando un nuevo commit a nuestra rama con los comandos git add y git commit:
git add <filename>
git commit –m “added a thing”
Ahora, agregaremos otro commit a nuestra nueva rama utilizando los mismos comandos nuevamente:
git add <filename>
git commit –m “added another thing”
A continuación, queremos enviar estos dos commits a nuestro repositorio remoto sin tener que hacer dos envíos. Para hacerlo, necesitamos usar el –ff en el comando git merge
git merge --ff
Esto fusionará ambos commits al mismo tiempo en uno solo y hará que tu código se ponga al día con la rama principal.
¿Qué es una fusión de 3 vías?
Imagina un caso en el que tu equipo de desarrollo ha creado algunas nuevas características en dos ramas separadas. Ahora estás listo para actualizar las ramas y fusionarlas en la rama principal para que esta esté lista para enviar código a un repositorio remoto.
Para asegurarte de que las nuevas características funcionan correctamente juntas, es buena idea fusionar las ramas de características entre sí y luego hacer algunas pruebas. Una fusión de 3 vías nos permitirá combinar dos ramas separadas con su ancestro común.
Vamos a recorrer los pasos necesarios para realizar una fusión en 3 vías con la rama objetivo. En el ejemplo a continuación, comenzaremos creando una nueva rama, agregando dos confirmaciones a ella y la combinaremos con nuestra rama principal utilizando una fusión en 3 vías.
Primero, comencemos creando una rama ‘nueva-caracteristica’ y cambiando automáticamente a ella con el comando git checkout. Especificar -b con este comando hace que se cree una nueva rama:
git checkout -b new-feature main
Luego, agregamos algunos archivos y una nueva confirmación a nuestra rama con los siguientes comandos:
git add <file>
git commit -m "Start a feature"
Luego, agregamos otra confirmación a nuestra nueva rama con los siguientes comandos:
git add <file>
git commit -m "Finish a feature"
Después de agregar nuevo código a nuestra nueva rama, debes imaginar una situación en la que nuestra rama principal también continúa progresando. Primero cambiaremos de nuevo a ella con el comando git checkout:
git checkout main
A continuación, agregaremos una nueva confirmación a nuestra rama principal:
git add <file>
git commit -m "make some changes to Main"
Ahora, queremos fusionar la rama ‘nueva-caracteristica’ que creamos anteriormente con nuestra rama principal actualizada. Como el trabajo continuará en nuestra rama principal, terminaremos eliminando la rama ‘nueva-caracteristica’ con el comando git branch.
git merge new-feature
git branch -d new-feature
Ahora, fusionamos nuestras dos ramas con un ancestro común en nuestra rama principal. Esta última ya está lista para ser fusionada en su repositorio remoto y seguir incrementando nuestro proyecto de software, y veremos cómo hacerlo a continuación.
Cómo fusionar una rama de Git en un repositorio remoto
A veces puede que necesites fusionar una rama en un repositorio remoto. Vamos a repasar los pasos sobre cómo lograr eso.
Imaginemos una situación en la que has escrito nuevo código para una nueva característica que tu propietario de producto quería crear. Después de probar tu código y revisarlo con tu propietario de producto, ahora estás listo para fusionar tu arduo trabajo en el repositorio remoto de tu equipo.
Tal como se mencionó antes, nunca deberías poder enviar tu código directamente a la rama principal. Siempre debes respetar el flujo de trabajo de Git que detallamos al principio de esta guía.
Después de revisar el proceso de Git, vamos a fusionar tu código. Continuando desde donde lo dejamos, ahora tenemos una rama actualizada: las últimas actualizaciones de la rama principal se han descargado en tu repositorio local.
Ahora estás frente a las puertas del repositorio remoto. ¿Cómo llegas allí? Simple, vamos a utilizar algunos comandos más de git.
Como buena práctica, siempre debes verificar el estado de tu rama con el comando git status. Este comando mostrará qué archivos se han añadido, eliminado, seguido, o no seguido.
git status
También debes verificar si has añadido archivos no seguidos. En ese caso, necesitas añadirlos para que sean seguidos y añadidos al commit.
Puedes utilizar el comando git add para añadir todos los archivos que creaste en tu desarrollo. Ahora, puede que necesites escribir algunos nombres de archivo si solo quieres añadir archivos específicos. Si deseas añadir todos los archivos, utiliza “.” para agregar todos los archivos.
A continuación, utilizaremos el comando git commit para confirmar todos los archivos que añadimos en el paso anterior. Deberás utilizar la bandera -m para escribir un mensaje, de lo contrario, se abrirá el editor de texto para que escribas un mensaje, lo cual no es un proceso directo.
Para tu mensaje, puedes escribir una breve nota sobre lo que hiciste. Por ejemplo, “creé una nueva función genial, añadí un nuevo icono al menú y realicé correcciones de errores.”
git commit -m “<your commit message goes here>”
Finalmente, puedes utilizar el comando git push para enviar tu rama al repositorio remoto.
git push --set-upstream origin <<your branch name>>
Ahora, después de enviar tu rama, deberás ir a GitHub o donde se encuentren alojados tus repositorios remotos, encontrar tu último envío y hacer clic en Crear solicitud de extracción.
Una vez que hagas clic en este botón, te llevarán a una página para agregar revisores y miembros de tu equipo que aprobarán o rechazarán tu solicitud de fusión. En el segundo caso, podrán añadir comentarios sobre lo que necesita ser corregido antes de permitirte fusionar tu rama en la rama principal remota.
Una vez que la revisión esté completa y tu solicitud de combinación haya sido aprobada, el botón Combinar estará disponible. Haz clic en este botón para iniciar la combinación. Si la combinación es exitosa, recibirás un mensaje confirmando que tu nuevo código ha sido añadido.
¡Felicidades! ¡Has dominado lo básico para usar el comando git merge!
Conclusión
Git merge es un comando poderoso que te permitirá a ti y a tu equipo utilizar diferentes ramas para trabajar en nuevas funcionalidades, y luego unirlas a tu repositorio principal.
Has aprendido los pasos adecuados necesarios para crear ramas, combinarlas, añadir archivos y confirmaciones a ellas, y lo más importante, subir esas ramas a un repositorio remoto. Además, ahora entiendes cómo hacer una combinación de avance rápido para combinar varias ramas relacionadas utilizando un solo comando, lo cual realmente puede ayudar a que cualquier trabajo de desarrollo sea más eficiente.
Git es una herramienta poderosa que puede hacer mucho. Cuanto más aprendas sobre los diferentes comandos que puedes utilizar, mejor te volverás como desarrollador. Ahora que has aprendido todo lo que necesitas saber sobre combinar ramas, es hora de ir y aprender otros comandos. ¡Buena suerte en tu búsqueda por dominar Git!