¿Qué es Git y cómo funciona?

En caso de que no estés muy versado en el mundo de la programación, quizás te estarás preguntando qué es Git. En pocas palabras, Git es lo que se conoce como un sistema de control de versiones.

Esto significa que cualquier desarrollador que tenga acceso al repositorio (así se le llama a la carpeta que contiene el proyecto) tiene acceso al código fuente del proyecto. 

De esta forma se puede modificar el código, publicar sus modificaciones, y todo quedará guardado en una linea del tiempo que puede ser navegada andando atrás y volviendo adelante.

Esto quiere decir que si unos cambios no están bien se pueden deshacer y el código así volverá a la última versión funcionando. ¿Quieres exprimir al máximo el potencial de Git? Sigue leyendo y te contamos todo al respecto.

Entonces, ¿en qué nos beneficia Git? Básicamente, a la hora de unir los nuevos cambios desde las ramas B y C hacia la rama A, este controla todos los archivos que han cambiado y remplaza, en los archivos originales, solamente la parte del código que ha sido modificada.

Esto quiere decir que, si en el menú sólo se ha pedido cambiar un enlace, en el archivo original sólo se modificará este enlace. Por otro lado, si se han creado archivos nuevos, se añadirán al proyecto original y de igual manera, si se han eliminado archivos, se eliminarán en el proyecto original. 

Para que todo esto quede más claro, vamos a poner un ejemplo gráfico de cómo funciona:

Ahora, para volver al correcto flujo de trabajo en una empresa, vamos a analizar esta imagen como si se tratara de un proyecto que nos han entregado:

La rama principal A es el punto de partida de nuestro proyecto. 

Habitualmente esta rama se llama master o main, pero puede tener otros nombres, como por ejemplo test, preproduction o production. Muchas veces se le otorga un nombre para poder entender dónde está el proyecto en el que estamos trabajando. 

Para poder empezar a trabajar en el proyecto, la empresa primero da acceso al repositorio al desarrollador y luego le pasará el comando git clone seguido de una línea que sirve para acceder al  repositorio.

Aquí tienes algunos ejemplos: 

git clone ssh://[email protected]/repositorio_nuevo.git git clone https://ejemplo_de_web.es/repositorio_externo.git 

Al ejecutar este comando a través del terminal o de un editor como Visual Studio Code o Atom (hay más), en la carpeta donde lo ejecutamos, se crea una copia de la carpeta del proyecto que se encuentra en el repositorio. 

Cabe resaltar que una vez se ha abierto el proyecto muchas veces, puede que sea necesario instalar las dependencias del mismo. O sea los archivos que necesita el proyecto para funcionar y que, por  razones de espacio, no se guardan en el repositorio.  

Pero esto es un asunto aparte. Si quieres saber más al respecto, puedes buscar información sobre composer update y npm install , dos comandos que sirven para instalar las dependencias de un proyecto.  

Ejemplo de cómo trabajar con ramas

Bien, ahora que tenemos nuestro proyecto funcionando en el punto A, primero de todo habría que ejecutar el comando git branch, el cual devuelve un listado con las ramas que tiene el proyecto. 

• git branch 

Hecho esto, nos situamos en la rama que nos indican. Para moverse de una rama a otra se utiliza el comando git checkout <nombre de la rama>. 

• git checkout <nombre de la rama>

Una vez que estamos en la rama correcta — en nuestro ejemplo en el punto A — creamos las nuevas ramas para realizar los cambios que se han pedido. 

Para crear una rama se utiliza el comando git branch <nombre nueva rama>. En el caso de la imagen habría que ejecutar: git branch B y git branch C. 

• git branch <nombre de la nueva rama> 

Hay que tener en cuenta algo importante: al crear una nueva rama, se crea la rama pero todavía estamos situados en la rama A. Por lo que es imprescindible acordarse, después de crear una rama, de hacer git checkout <nombre  de la rama creada> para situarnos en la misma. 

Perfecto, hecho esto, ahora nos encontramos en las ramas B y C, donde el código es igual al del punto A. Podemos empezar a realizar cambios sin que el código de la rama A se vea afectado. 

Una vez que hayamos hecho los cambios y comprobado que todo funcione bien, primero guardamos los cambios en la rama donde estamos y luego procedemos a traer los cambios a la rama principal. 

Para guardar los cambios en la rama en la que estamos primero hay que ejecutar el comando git add.  

• git add 

Este comando indica a Git que queremos incluir cambios en nuestro flujo de trabajo, así que toma nota de todos los archivos que han cambiado. Después de hacer esto utilizamos el comando git commit -m ‘nombre del cambio hecho’.

• git commit -m ‘nombre del cambio hecho’

Pasos para integrar los cambios en la rama principal

Tras dar estos pasos, en este momento en nuestra rama se creará un punto donde estarán incluidos los cambios hechos. Es en este momento cuando estamos listos para traer los cambios a la rama principal. En el ejemplo de la imagen que hemos mostrado al principio, todos los puntos son commit.  

Finalmente, para traer los cambios a la rama principal hay que respetar cuatro pasos. Vamos a repasar cada uno de ellos:

Primer paso

Nos tenemos que situar en la rama principal a través del comando git checkout A.

Segundo paso

Una vez que estamos en la rama A muy importante es ejecutar el comando git pull.

• git pull 

El comando git pull averigua si hay algún cambio en la rama principal que nosotros no tengamos en nuestra rama local. Esto puede pasar, por ejemplo, si hay más desarrolladores que trabajan en el proyecto y uno o más de ellos ha hecho y subido cambios a la rama antes que nosotros.

Una vez ejecutado el git pull, y teniendo la rama actualizada, podemos traer los cambios de las ramas (B o C) a la rama A, que es en la cual nos encontramos.

Tercer paso

Para traer los cambios utilizaremos el comando git merge <nombre de la rama>.

git merge <nombre de la rama> 

En nuestro caso sería git merge B o git merge C, dependiendo si queremos traer los cambios de la rama B o C, a la rama A. 

Cuarto paso

Por último, ejecutamos el comando git push. 

• git push 

Con este comando vamos a guardar todos los cambios que hemos traído a la rama A local, en la rama A que está en remoto. De esta forma los demás desarrolladores, al hacer un git pull de la rama A en el propio local, tendrán estos cambios disponibles. 

Llegados a este punto, nuestra tarea ha terminado y ya estamos listo para proceder con otros cambios al proyecto principal. 

Últimas consideraciones

Al trabajar en un proyecto de Git, hay unos pasos a seguir que son fundamentales para poder trabajar bien y en equipo sobre un mismo proyecto, sin cometer errores. Claramente al principio seguramente se cometerá algún error pero no te preocupes ya que, gracias a Git, son reversibles.  

Para terminar, es importante hacer una mención a un archivo muy importante que encontraremos al trabajar con Git: el archivo .gitignore.

En este archivo se pondrá el nombre de los archivos que no queremos que sean rastreados por Git. Esto quiere decir que los archivos que están en el .gitignore no se copiaran en el repositorio  remoto. Es muy común poner en el .gitignore ciertos archivos que contienen datos sensibles como pueden ser los siguientes: claves api,  contraseñas, datos personales, etc. 

Esperamos que estos conceptos hayan quedado claros para aquellos que están empezando a trabajar con Git o que, después haber trabajado por su cuenta, se aproximan a trabajar en una empresa juntos a otros desarrolladores. 

Si quieres aprender en profundidad sobre estos conceptos, te recomendamos que te unas al Máster en Full Stack Development de Nuclio Digital School. Con este programa intensivo y especializado, lograrás integrarte en el mundo de la programación en tiempo récord.