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 frontend.
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 branchPero antes de crear la rama, debemos actualizar la rama de donde vamos a partir, para esto utilizamos:
git fetch && git pull
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 antes de todo obtendrá todas las ramas del repositorio.
Después git pull actualiza nuestra rama con todos los cambios que no tengamos reflejados en nuestro ambiente local.
git statusYa 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>O si lo que queremos es volver a la rama donde estábamos anteriormente solo es necesario el comando:
git checkout -Con este comando volveremos a la ultima rama donde estuvimos antes de crear la nuestra o de cambiarnos a una nueva.
Ahora, 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.
Para este punto podemos suponer que tienes una rama y que has realizado el trabajo.
Ahora debemos actualizar nuestra rama de trabajo con nuestros cambios 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:
Con este comando no es necesario agregar archivo por archivo ya que git se encarga de agregar todos los archivos donde hicimos cambios.
git add -A o git add .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 con 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 pushCon 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~1Y el siguiente, cuando NO quieres mantener tus cambios:
git reset --hard HEAD~1Recuerda que estos últimos comandos solo funcionan si no has realizado el push a la rama.
Historial de cambios en git
Dentro de lo mas útil en git es saber el historial con el que cuenta una rama, para así poder identificar algún cambio en un archivo en concreto o incluso el error que hizo que la aplicación dejara de funcionar desde un punto en el que se pueda rescatar.
git logEl comando git log se utiliza para mostrar el historial completo de commits realizados en un repositorio Git, al ejecutarlo obtendrás una lista cronológica de todos los commits realizados, a continuación un ejemplo:
El comando te mostrara una lista de commits que contienen la siguiente información:
- SHA: Identificador único del commit.
- Autor: Nombre y correo del autor del commit.
- Fecha: Fecha y hora del commit.
- Mensaje: El mensaje que se agrego al hacer el commit.
Este comando es muy utilizado también en herramientas gráficas como SorceTree para encontrar fácilmente a los colaboradores del proyecto.
