Aprende sobre ramas con Bitbucket Cloud

Preparación Revisa el flujo de trabajo de ramas

Objetivo

En este tutorial, aprenderás las nociones básicas de crear, revisar y fusionar ramas, además de trabajar con ellas, utilizando Git y Bitbucket Cloud.

Duración	Público	Requisitos previos
35 minutos	Dominio del flujo de trabajo básico de Git	Tienes Git instalado
		Tienes una cuenta de Bitbucket

Este tutorial es para ti si ya dominas el flujo de trabajo básico de Git, lo que incluye saber hacer lo siguiente:

Clonar: Copiar el repositorio remoto de Bitbucket Cloud en tu sistema local.
Añadir o preparar: Coger los cambios que has hecho y prepararlos para añadirlos a tu historial de Git.
Confirmar: Añadir los archivos nuevos o cambiados al historial de Git correspondiente al repositorio.
Incorporar cambios: Meter los nuevos cambios que otras personas han añadido en tu repositorio local.
Enviar (push): Pasar los cambios de tu sistema local al repositorio remoto.

Si no conoces los conceptos básicos de Git, no te preocupes. Consulta nuestro tutorial Aprende a usar Git con Bitbucket Cloud y te pondrás al día enseguida.

Por qué es importante crear ramas

Crear ramas es una de las mejores formas de sacar el máximo partido de Git para el control de versiones. Crear ramas en Git te permite lo siguiente:

Que varios equipos puedan trabajar desde un solo repositorio al mismo tiempo.
Que los miembros del equipo puedan usar Bitbucket Cloud desde cualquier rincón del mundo para colaborar.
Que haya varias líneas de desarrollo ejecutándose al mismo tiempo y de forma independiente sin necesidad de congelaciones del código.

Preparación

Como queremos que te sientas como si estuvieras trabajando en un equipo, en un mismo repositorio de Bitbucket, te pediremos que bifurques un repositorio público que hemos proporcionado.

¿En qué consiste bifurcar?

Bifurcar es otra forma de guardar una clonación o una copia. El término "bifurcar" (o "fork", en programación) deriva de una llamada de sistema Unix que crea una copia de un proceso existente. Así que, a diferencia de una rama, una bifurcación es independiente del repositorio original. Si se elimina el repositorio original, la bifurcación se conserva. Si bifurcas un repositorio, obtienes ese repositorio y todas sus ramas.

Entra en tutorials/tutorials.git.bitbucket.org.
Haz clic en + > Bifurcar este repositorio en el lado izquierdo de la pantalla.
Modifica el nombre para que sea exclusivo de tu equipo y, a continuación, haz clic en Bifurcar repositorio.
Crea en el repositorio un directorio al que se pueda acceder cómodamente. Puedes optar por algo como esto:
```
 $ mkdir test-repositories $ cd test-repositories/ $ test-repositories
```
El ejemplo anterior crea el directorio test-repositories mediante el comando mkdir (crear directorio) y cambia a ese directorio mediante el comando cd (cambiar directorio).

Clona el repositorio bifurcado en el directorio que acabas de crear. Podría ser algo parecido a esto:

 $ git clone https://dstevenstest@bitbucket.org/dstevenstest/mygittutorial.bitbucket.io.git Cloning into 'mygittutorial.bitbucket.io'... remote: Counting objects: 12392, done. remote: Compressing objects: 100% (12030/12030), done. remote: Total 12392 (delta 8044), reused 564 (delta 360) Receiving objects: 100% (12392/12392), 2.72 MiB | 701.00 KiB/s, done. Resolving deltas: 100% (8044/8044), done. $ cd mygittutorial.bitbucket.io/

De este modo, se clona el repositorio usando el comando git clone y se crea el directorio resultante de la clonación: mygittutorial.git.bitbucket.io.

Crea una rama y cambia algo utilizando el flujo de trabajo de creación de ramas

En esta rama, vas a añadir una cita a tu sitio web.

Crea una rama mediante el comando git branch.
```
 $ git branch test-1
```
Extrae esta rama que acabas de crear mediante el comando git checkout.
```
 $ git checkout test-1 Switched to branch 'test-1'
```
Muestra una lista de las ramas que tienes localmente utilizando el comando git branch.
```
 $ git branch main * test-1
```
Haz una modificación en el archivo editme.html añadiendo una cita. Puedes usar algo como lo siguiente:
```
  Esto es una cita, y me gusta.
 Una cita: El arte de citar 
```
Añade ese cambio.
```
 git add editme.html
```
Nota: Tu cambio no se ha confirmado en el historial de Git todavía. Está en estado de "espera". Esto lo aprendimos en Guardado de cambios.
Confirma el cambio con un mensaje de confirmación descriptivo.
```
 git commit editme.html -m'added a new quote' [test-1 063b772] added a new quote 1 file changed, 3 insertions(+), 3 deletions(-)
```
Nota: Ahora los cambios forman parte del historial de Git como una única "confirmación". Esto lo aprendimos en Guardado de cambios.
Envía ese cambio a Bitbucket utilizando el comando git push.
```
 git push fatal: The current branch test-1 has no upstream branch. To push the current branch and set the remote as upstream, use git push --set-upstream origin test-1
```
Verás un error, porque la primera vez que envías una nueva rama que has creado localmente tienes que designar esa rama.

Envía la rama y cambia utilizando el comando git push branch.

 $ git push origin test-1 Counting objects: 3, done. Delta compression using up to 8 threads. Compressing objects: 100% (3/3), done. Writing objects: 100% (3/3), 253 bytes | 0 bytes/s, done. Total 3 (delta 2), reused 0 (delta 0) remote: remote: Create pull request for test-1: remote: https://bitbucket.org/dstevenstest/dans.git.bitbucket.org/pull-requests/new?source=test-1&t=1 remote: To https://bitbucket.org/dstevenstest/dans.git.bitbucket.org.git * [new branch] test-1 -> test-1

Esto le indica al sistema que el repositorio de origen es el destino de esta nueva rama.

Abre tu repositorio del tutorial y haz clic en Ramas. Ahora deberías ver tanto la rama principal como la test-1. Debería ser algo así:

Crea, recupera y consulta una rama remota

Cuando trabajas en un equipo, es probable que tengas que recuperar o incorporar cambios en ramas que creen el resto de los miembros del equipo y enviarlos a Bitbucket. Este ejemplo te brindará algunos de los conceptos básicos para crear ramas y trabajar con ramas creadas por otras personas.

RamasAccede a tu repositorio del tutorial en Bitbucket y haz clic en Ramas. Deberías ver algo como esto:
Haz clic en Crear rama, llámala "test-2" y haz clic en Crear.

Copia el comando git fetch en el cuadro de diálogo para extraer tu rama. Probablemente sea algo parecido a esto:

 $ git fetch && git checkout test-2 From https://bitbucket.org/dstevenstest/dans.git.bitbucket.org * [new branch] test-2 -> origin/test-2 Branch test-2 set up to track remote branch test-2 from origin. Switched to a new branch 'test-2'

Utiliza el comando git branch en tu terminal. Deberías ver una lista de ramas con algo parecido a esto:
```
 $ git branch main test-1 * test-2
```
La rama con el asterisco * es la rama activa. Es fundamental que recuerdes esto cuando trabajes en cualquier flujo de trabajo de creación de ramas.
Usa el comando git status y verás algo parecido a esto:
```
 $ git status On branch test-2 Your branch is up-to-date with 'origin/test-2'. nothing to commit, working tree clean
```
Puedes ver en qué rama estás y que la rama está actualizada en esos momentos con respecto a la rama remota (origin).
Utiliza el comando git checkout para volver a cambiar el centro de atención a la otra rama. El comando será algo parecido a esto:
```
 $ git checkout test-1 Switched to branch 'test-1' Your branch is ahead of 'origin/test-1' by 3 commits. (use "git push" to publish your local commits)
```
Una de las cosas más importantes que hay que recordar al trabajar con ramas es que debes asegurarte de que la rama en la que estés metiendo cambios sea la correcta.

Envía el cambio y crea una solicitud de incorporación de cambios

Ha llegado el momento de que te revisen tu primer cambio y de fusionar la rama.

Haz clic en + > Crear solicitud de incorporación de cambios. Puedes ver tu rama test-1 como la rama de origen y la principal en la rama de destino.

Como hemos creado este repositorio bifurcando uno existente, el destino se define en la rama principal del repositorio que hemos bifurcado.

Para corregir esto, tendrás que cambiar la rama de destino del repositorio (la rama en la que fusionarás tus cambios) de tutorials/tutorials.git.bitbucket.org a tu repositorio.

También tendrás que añadir revisores de tu equipo a la solicitud de incorporación de cambios. Más información sobre las solicitudes de incorporación de cambios
Haz clic en Crear solicitud de incorporación de cambios.
Para meter un comentario en la solicitud de incorporación de cambios, selecciona una línea de la comparación (el área que muestra el cambio que hiciste en el archivo editme.html).
Haz clic en Aprobar en la parte superior izquierda de la página. Obviamente, en una solicitud de incorporación de cambios real, tendrías revisores para hacerte comentarios.
Haz clic en Fusionar.
Opcional: Actualiza el Mensaje de confirmación con más detalles.
Selecciona la estrategia de fusión Fusionar confirmación de entre las dos opciones que se te ofrecerán:
- Fusionar confirmación: Conserva todas las confirmaciones de la rama original y las integra en la rama de destino. Esta opción equivale a introducir git merge --no-ff en la línea de comandos.
- Combinar: Combina las confirmaciones al fusionar la rama de origen en la de destino. Esta opción equivale a introducir git merge squash en la línea de comandos.
Obtén más información para conocer los detalles sobre estos dos tipos de estrategias de fusión.
Haz clic en Confirmaciones y verás cómo encaja la rama que acabas de fusionar en el esquema general de los cambios.

Elimina una rama e incorpora los cambios de la rama principal en la rama de trabajo local

Ahora has pasado por el flujo de trabajo de creación de ramas básico y tu cambio está en la rama principal. Lo último que aprenderemos es cómo eliminar la rama que acabas de fusionar, incorporar cambios a la rama principal actualizada y fusionar la rama principal actualizada en tu rama test-2 .

¿Por qué eliminar la rama?

Recuerda que la creación de ramas en Git se diferencia de SVN o de sistemas semejantes de control de versiones por utilizar tanto ramas de larga ejecución (por ejemplo, una rama principal y una de desarrollo) como ramas de desarrollo a corto plazo (como los ejemplos que utilizamos en este tutorial). Como este es el caso, no es una mala idea eliminar las ramas locales para que tu entorno local esté más limpio.

¿Por qué incorporar los cambios de la rama principal y fusionarla con test-2?

Esto es un ejemplo de un caso en el que estás trabajando en un repositorio en el que también está trabajando otro miembro del equipo. Es una buena idea incorporar los cambios en tu rama de trabajo de vez en cuando para evitar los conflictos de fusión en las solicitudes de incorporación de cambios.

Abre tu terminal y ejecuta el comando git status. El resultado debería ser algo parecido a esto:
```
 $ git status On branch test-1 nothing to commit, working tree clean
```
Puedes ver que estás en la rama que acabas de utilizar para hacer el cambio y que no tienes ningún cambio. Estamos listos para deshacernos de esa rama ahora que hemos acabado ese trabajo.
Cambia a la rama principal. Para ello, ejecuta el comando git checkout main . El resultado debería ser algo parecido a esto:
```
 git checkout main Switched to branch 'main' Your branch is up-to-date with 'origin/main'.
```
¿Te has fijado en que en el mensaje pone que la rama está actualizada? Se refiere solo a la rama local. Sabemos esto porque acabamos de fusionar un cambio en la principal y no hemos incorporado ese cambio del repositorio remoto a nuestro sistema local. Eso es lo que haremos a continuación.

Ejecuta el comando git pull. El resultado debería ser algo parecido a esto:

 $ git pull remote: Counting objects: 1, done. remote: Total 1 (delta 0), reused 0 (delta 0) Unpacking objects: 100% (1/1), done. From https://bitbucket.org/dstevenstest/dans.git.bitbucket.org 2d4c0ab..dd424cb main -> origin/main Updating 2d4c0ab..dd424cb Fast-forward editme.html | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)

Lo que ha sucedido es que, al incorporar los cambios del repositorio remoto, Git ejecuta una fusión con avance rápido para integrar los cambios que hiciste. Asimismo, enumera cuántos archivos y líneas han cambiado en el archivo en cuestión.

Ejecuta el comando git branch -d {branch_name} para eliminar la rama test-1. El resultado será algo parecido a esto:
```
 $ git branch -d test-1 Deleted branch test-1 (was 063b772)
```
Como puedes ver, ha borrado la rama y te indica cuál era el último hash de confirmación de dicha rama. Esta es la forma segura de borrar una rama, ya que Git no te permitirá borrarla si tiene cambios sin confirmar. Sin embargo, debes tener en cuenta que esto no impedirá que se borren los cambios que están confirmados en el historial de Git pero no fusionados en otra rama.

Cambia a la rama test-2. Para ello, utiliza el comando git checkout.

 $ git checkout test-2 Switched to branch 'test-2' Your branch is up-to-date with 'origin/test-2'.

Fusiona la rama principal en tu rama de trabajo usando el comando git merge main test-2 . El resultado será algo parecido a esto:
```
 $ git merge main test-2 Updating 2d4c0ab..dd424cb Fast-forward editme.html | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
```
Es importante recordar lo siguiente:
- Hay que tener en cuenta qué rama está activa. Si quieres fusionar la rama principal en test-2, deberías haber extraído test-2 (activa). Lo mismo sucede si quieres fusionar test-2 en la principal, que tendrás que haberla extraído.
- Para ver en cualquier momento cuál es la rama que está activa, usa git branch y la rama activa se marcará con un asterisco, o utiliza git status y te indicará en qué rama estás y si hay cambios locales pendientes.

Esperamos que hayas aprendido un poco sobre la creación de ramas y los comandos implicados. Vamos a revisar lo que hemos explicado:

Revisa el flujo de trabajo de ramas

El flujo de trabajo de creación de ramas de función en Git es una forma eficaz de trabajar con tu equipo en Bitbucket. En este flujo de trabajo, todo el desarrollo de funciones se produce en ramas separadas de la rama principal. Como resultado, varios desarrolladores pueden trabajar en sus propias funciones sin tocar el código principal.

Empieza con la rama principal

Este flujo de trabajo te ayuda a colaborar en tu código con al menos una persona más. Siempre que tus repositorios locales y Bitbucket estén actualizados, lo tendrás todo listo para empezar.

Crea una rama nueva

Debes utilizar una rama aparte para cada función o incidencia en la que trabajes. Cuando la hayas creado, extráela localmente para que todos los cambios que hagas se apliquen en dicha rama.

Actualiza, añade, confirma y envía los cambios

Trabaja en la función y haz confirmaciones como lo harías en cualquier ocasión que usaras Git. Cuando lo tengas todo listo, envía tus confirmaciones para actualizar así la rama de función en Bitbucket.

Pide que te revisen el código

Para recibir comentarios sobre tu código, crea una solicitud de incorporación de cambios en Bitbucket. A partir de ahí, podrás añadir revisores y asegurarte de que todo esté listo antes de la fusión.

Resuelve los comentarios

Ahora, tus compañeros de equipo podrán comentar y dar su aprobación. Resuelve sus comentarios localmente, confirma y envía los cambios a Bitbucket. Las actualizaciones aparecen en la solicitud de incorporación de cambios.

Fusiona tu rama

Antes de fusionar, quizá tengas que resolver conflictos de fusión si otras personas han hecho cambios en el repositorio. Cuando tu solicitud de incorporación de cambios esté aprobada y libre de conflictos, podrás añadir tu código a la rama principal. Debes fusionar desde la solicitud de incorporación de cambios en Bitbucket.

En este tutorial no se puede mostrar en su totalidad cómo pueden las ramas aumentar la eficacia de los equipos. Existen varios enfoques para la creación de ramas, algunos de los cuales los explicamos en: Comparar flujos de trabajo.