En mis comienzos trabajando con git de manera profesional en una empresa donde colaboraban mas de 100 programadores lo que pensaba era: ¿Cómo tener un flujo de trabajo con git sin cometer errores?.

Con el paso del tiempo me eh dado cuenta que existe un método para evitar tener conflictos con el código de los demás, por eso eh decidido hacer esta pequeña entrada teniendo en cuenta que en el equipo donde estoy por un tiempo era el único front-end.

Comencemos con los comandos básicos de git que utilizo (el orden puede variar según el proyecto y la cantidad de programadores en el) específicamente cuando tengo una nueva rama en local donde estoy trabajando.

Creando y trabajando en mi rama local

git branch <nombre_de_la_rama>

La mayor de las veces trabajo en una rama local, ya sea a partir de producción o de una rama de desarrollo dependiendo el proyecto donde esté asignado.

Entonces lo que hago es hacer el branch estando parado en la rama donde después subiré mis cambios, también podemos verificar en que rama estamos si escribimos únicamente:

git branch

Pero antes de crear la rama, debemos actualizar la rama de donde vamos a partir, para esto utilizamos:

git fetch && git pull
Flujo de trabajo con git

Siempre al crear una rama a partir de otra, debemos actualizar la rama para estar seguros de que hemos creado una rama actualizada, para esto nos sirve git fetch que obtendrá todas las ramas de repositorio.

git pull actualiza nuestra rama con todos los cambios que no tengamos reflejados en nuestro ambiente local.

git status

Ya te explique que debemos actualizar la rama si no estamos seguros de estar actualizados pero ¿Como podemos consultar si existen cambios?

Para esto sirve el comando git status que nos responderá si necesitamos hacer un pull o de lo contrario estamos actualizados con la rama.

También nos ayuda a saber qué cambios hemos realizado en la rama, se nos mostrarán los archivos que hemos editado, agregado o eliminado.

git checkout <nombre_de_la_rama

Cuando estamos seguros que hemos hecho la actualización de la rama y la creación de una nueva con git pull y git branch es hora de cambiarnos de rama para esto nos sirve el comando git checkout.

Un atajo muy útil que ayuda a crear una nueva rama y ademas cambiarnos automáticamente es el:

git checkout -b <nombre_de_la_rama>

Con esto se crea una nueva rama y además nos cambia a la rama creada.

Flujo de trabajo con checkout

Para este punto podemos suponer que tienes una rama y que has realizado el trabajo.

Ahora debemos actualizar nuestra rama de trabajo y después subir los cambios a la rama donde esta trabajando el equipo.

Como vimos anteriormente para identificar que hemos cambiado podemos ejecutar el comando git status, cuando estemos seguros de nuestros cambios debemos ejecutar:

git add <path_del_archivo>

En mi caso, los archivos que debo subir son específicos así que utilizo el path de cada archivo y lo voy agregando uno a uno, en su defecto si lo que quieres es subir todos tus cambios existe un comando para agregar todo:

git add -A

Con este comando no es necesario agregar archivo por archivo ya que git se encarga de agregar todos los archivos donde hicimos cambios.


Publicando cambios en rama local

Lo que sigue es realizar un commit el cual es un mensaje para dar una breve explicación de lo que hemos realizado.

git commit -m "Mensaje del commit"

Este mensaje es la forma en que se verán reflejados sus cambios en una interfaz de software como pueden ser GitHub, GitLab, Bit Bucket.

Dependiendo la empresa se nos pedirá un formato en el mensaje, puedes leer esta guía en medium que me ah servido mucho en mis commits.

Una vez que tenemos nuestro trabajo en la rama, podemos subir esos cambios (que se reflejaran únicamente en esa rama) con el comando:

git push

Con esto empujamos nuestros cambios y ahora serán reflejados en cualquier persona que tenga tú rama actualizada.


Mezclando mi rama con ambiente de trabajo

Lo que sigue en un flujo de trabaja es ir a la rama donde esta trabajando el equipo con el comando git checkout y entonces mezclar la rama del equipo con la rama donde esta nuestro trabajo:

git merge <nombre_de_la_rama_de_trabajo>

Una vez que tengamos la rama mezclada con nuestros cambios (sin importar cuantos commits hayamos realizado) podemos dar por hecho que estaremos ok con nuestro flujo de trabajo.

Dependiendo de la empresa podemos eliminar la rama donde trabajamos o dejarla para tener un historial de lo que se ah hecho en cada rama.

Podemos eliminar la rama con el comando:

git branch -d <nombre_de_la_rama>

Y bueno, este es mi flujo de trabajo (el feliz) que ejecuto diariamente cuando tengo alguna tarea asignada.

Aunque también tenemos el comando de emergencia (cuando queremos eliminar un commit) y para esto tenemos 2 caminos, el primero para mantener nuestros cambios con:

git reset --soft HEAD~1

Y el siguiente, cuando NO quieres mantener tus cambios:

git reset --hard HEAD~1

Recuerda que estos últimos comandos solo funcionan si no has realizado el push a la rama.

por Eduardo López

Software Engineer ( FullStack con PHP y Javascript 🌍 ).