Inicio Informática Git, el sistema de gestión de código fuente descentralizado (Vol.4)
about git

Git, el sistema de gestión de código fuente descentralizado (Vol.4)

por entreunosyceros

Una vez más aquí. En este volumen 4 vamos a continuar la serie de artículos sobre el sistema de gestión de código fuente descentralizado llamado git. En el último artículo lo dejamos en Cómo eliminar el repositorio, por lo que ahora lo lógico es seguir con el uso de ramas o branches.

Uso de branches o ramas en git

Si has seguido esta serie de artículos, hasta ahora hemos utilizado la rama master para realizar todos los trabajos. Esto es algo que debemos evitar, ya que lo habitual es dejar la rama master (o maestra) con el código definitivo y trabajar siempre con otras ramas para añadir los cambios. Una vez que se comprueba y testa que todos los cambios son correctos, ya podemos meterlos en la rama master.

Dicho de forma más clara, el código de un proyecto gestionado con git lo podemos bifurcar, sin necesidad de hacer copias. Una vez que creamos una rama, podemos modificar ese código sin que eso afecte a la rama principal (o maestra).

Mediante el sistema de ramas o branches, git nos ofrece un mecanismo seguro para:

  • Añadir nuevas funcionalidades, conocidas como features.
  • Añadir correcciones, conocidas como bugfixes.
  • Hacer pruebas.
  • Compartir el código y colaborar con otros.

Una vez creada una nueva rama a partir de master, esta puede avanzar su camino añadiendo commits mientras la rama master avanza. Más adelante podemos optar o no por integrar la nueva rama.

evolución branch git

Creando una rama con git branch

Para empezar vamos a ver cómo crear una nueva rama con el proyecto git que venimos viendo en los ejemplos de esta serie de artículo.

Habitualmente las ramas se crean a partir del punto actual de la rama maestra, aun que se pueden crear desde cualquier commit o rama.

En este ejemplo vamos a crear una rama para desarrollar una función llamada feature-rama1. Para esto esto en la terminal (Ctrl+Alt+T) tendremos que utilizar el siguiente comando:

git branch nombre-de-la-rama

A continuación vamos a decirle a git que estamos en esa rama:

feature-ejemplo1
git checkout feature-rama1

En las capturas de pantalla no se ven, por que tengo personalizado el prompt para que no cambie, pero de no ser así veríamos en el promt que se nos indica que estamos en la rama feature-rama1.

De forma más simple y rápida, también se podría crear la rama directamente con un checkout con la opción -b, que conseguirá que se cree la rama y se cambie directamente a ella.

git checkout -b nombre-de-la-rama

Resulta evidente que el nombre de la rama aun que se le pueda dar un cualquier nombre, lo aconsejable es utilizar un nombre que indique el objetivo de la rama en cuestión.

A partir de aquí, ya podemos comenzar a trabajar en la rama. Podemos añadir archivos o modificando los existentes y confirmando los cambios con los commits. Las ramas se puede ramificar tanto como queramos. Esto hará que se vuelvan más complicadas, por lo que no resulta muy recomendable.

Movernos a otra rama

Para cambiarnos entre ramas, solo necesitaremos utilizar el comando git checkout. En nuestro ejemplo, si quisiésemos volver a la rama master, el comando a utilizar sería el siguiente:

cambiando a la rama master
git checkout master

Hay que tener claro que git no permitirá cambiar de rama si en la rama actual hay cambios sin guardar. Si te encuentras en esa situación, las opciones posibles son tres:

  • Añadir los cambios.
  • Guardar los cambios con git stat (que aún no hemos visto).
  • Descartar los cambios con git checkout.

Comparando ramas

Ya que podemos comparar distintos commits, lo lógico es que git también nos permita comparar distintas ramas. Esto se puede hacer con el comando git diff:

git diff nombre-rama1 nombre-rama2

Renombrar una rama

Si nos damos cuenta de que hemos cometido un error a la hora de dar el nombre a un rama, basta con ejecutar el siguiente comando para renombrar la rama en la que nos encontramos:

git branch -m nuevo-nombre-de-la-rama

Comprobar las ramas existentes

Si queremos comprobar las ramas existentes, en cualquier momento podemos ejecutar el siguiente comando. Git nos mostrará las ramas disponibles además de marcar con un * la rama actual en la que nos encontramos:

listar ramas con git branch
git branch

Eliminar una rama

Cuando una rama se haya aplicado (mergeado) a la rama maestra o simplemente cuando ya no tenga utilidad, desde la rama master podemos eliminarla ejecutando el comando:

eliminar una rama
git branch -d nombre-de-la-rama

Merges

El comando merge realiza la operación que unifica dos ramas. Esto se puede entender como la operación opuesta a la creación de ramas o bifurcaciones.

Una de las formas básicas de trabajar con git es:

  • Crearemos una nueva rama a partir de la rama maestra.
  • Se trabajará sobre la rama creada, en uno o más commits.
  • Una vez que el trabajo realizado en la rama se testea y se le da el visto bueno, esa rama se mezcla o se mergea con la rama maestra.

Esta mezcla entre ramas git las hace de manera automática, siempre que sea posible y que no detecte conflictos.

git merge

Para continuar, vamos a suponer que seguimos teniendo dispnible la rama que eliminamos anteriormente (feature/rama1) y que hemos realizado los cambios precisos y realizado commit de todo. Lo siguiente que vamos a hacer será integrar los cambios con la rama master.

Para empezar vamos a movernos a la rama master:

cambiar a la rama master
git checkout master

Ahora ya podemos aplicar el merge:

git merge feature/rama1

En el merge se indican los archivos afectados y los cambios concretos aplicados en los mismo.

Conflictos

En algunas ocasiones en los merges ocurren conflictos. Esto se produce por que los cambios que se han hecho en un archivo sobre las mismas líneas son distintos entre dos ramas. Si se trata de líneas distintas, git mezcla estas líneas de forma correcta, pero si se hacen cambios en las mismas líneas, lo más probable es que merge nos indique un conflicto.

Si se da este caso, git se queda en estado de conflicto y debemos resolver el los problemas decidiendo cómo debe quedar el código editando manualmente los archivos. Una vez editado, se añaden los cambios al hacer commit y el merge se habrá completado.

El arreglar los conflictos queda en manos del desarrollador, pues es el que debe tener claro qué contenido debe prevalecer al mezclar las ramas con un merge.

Utiliza merge o rebase con git

Cuando estamos realizando un proyecto en equipo, es frecuente que mientras estás trabajando en un rama, algún compañero actualice la rama master.

Si la rama master cambia, también conviene actualizar la rama actual para tener los últimos cambios. Para esto se puede hacer un merge o un rebase.

Estas dos opciones para mantener actualizada una rama con respecto a la rama master cuentan con sus seguidores y detractores. Aun que el efecto final sobre el código es el mismo, si te interesa mantener un aspecto de árbol de commits lo más limpio posible, resulta recomendable utilizar rebase.

Hasta aquí llega el volumen 4. En el próximo vamos a comenzar a trabajar con repositorios remotos, y el servicio de alojamiento para hacerlo es sin duda GitHub.


También te puede interesar ...

Deja tu comentario

* Al utilizar este formulario, acepta que este sitio web almacene y maneje sus datos.

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.