Git: tutorial básico del sistema de control de versiones

No solo las empresas de­sa­rro­llan proyectos de software de forma co­la­bo­ra­ti­va: también en el sector del código abierto, varios cientos o incluso miles de vo­lu­n­ta­rios y co­la­bo­ra­do­res pueden pa­r­ti­ci­par en la creación, el ma­n­te­ni­mie­n­to, la op­ti­mi­za­ción o la edición de un programa, de­pe­n­die­n­do del tamaño del proyecto. Sería prá­c­ti­ca­me­n­te imposible llevar a cabo estas tareas sin un buen sistema para registrar y controlar los numerosos cambios rea­li­za­dos por todos los de­sa­rro­lla­do­res.

Una de las so­lu­cio­nes más populares en este sentido es Git, un programa de licencia libre que puedes aprender a manejar rá­pi­da­me­n­te y utilizar de forma to­ta­l­me­n­te gratuita. En nuestro tutorial, te enseñamos todos los conceptos básicos para que seas capaz de dar tus primeros pasos con este sistema de control de versiones.

Git es un sistema de control de versiones de­sa­rro­lla­do en 2005 por Linus Thorvalds, el creador de Linux, y publicado bajo la licencia de software libre GPLv2 de GNU. La pa­r­ti­cu­la­ri­dad de esta he­rra­mie­n­ta es que, aunque guarda un re­po­si­to­rio central para cada proyecto, todos los pa­r­ti­ci­pa­n­tes descargan una copia local del mismo en su propio di­s­po­si­ti­vo. Cada una de estas copias co­n­s­ti­tu­ye una copia completa de todo el contenido del re­po­si­to­rio, por lo que no es necesario estar conectado a la red para trabajar. Además, estos archivos sirven como copia de seguridad en caso de que el re­po­si­to­rio principal falle o resulte dañado. Los cambios en los archivos pueden in­te­r­ca­m­biar­se con todos los demás pa­r­ti­ci­pa­n­tes del proyecto en cualquier momento y, si co­rre­s­po­n­de, añadirse al re­po­si­to­rio.

Si quieres empezar a utilizar Git como programa de control de versiones, en primer lugar, debes fa­mi­lia­ri­zar­te con el propio software y su interfaz de usuario. Git está di­s­po­ni­ble para Windows, Unix/Linux y macOS, con di­fe­re­n­tes versiones que presentan pequeñas di­fe­re­n­cias de uso. Después de llevar a cabo la in­s­ta­la­ción estándar co­rre­s­po­n­die­n­te, puedes controlar el programa con el símbolo del sistema o una interfaz gráfica de usuario en cua­l­quie­ra de los sistemas ope­ra­ti­vos.

En la página oficial del proyecto Git, en­co­n­tra­rás los archivos de in­s­ta­la­ción binarios, las in­s­tru­c­cio­nes para instalar el ad­mi­ni­s­tra­dor de paquetes (sistemas Unix) y las ediciones po­r­tá­ti­les listas para usar para cada sistema operativo. Solo tienes que descargar el paquete de in­s­ta­la­ción deseado o elegir el paquete apropiado mediante el ad­mi­ni­s­tra­dor y, a co­n­ti­nua­ción, seguir las in­s­tru­c­cio­nes del asistente. Ob­via­me­n­te, con las ediciones po­r­tá­ti­les no es necesario llevar a cabo la in­s­ta­la­ción.

Una vez instalado Git, ya puedes utilizar el sistema para controlar las versiones de tus proyectos. Como con cualquier otro programa, el primer paso es co­m­pre­n­der las funciones y comandos básicos para sacarle el máximo partido a la he­rra­mie­n­ta. En nuestro completo tutorial de Git, te ex­pli­ca­mos los comandos más im­po­r­ta­n­tes para co­n­fi­gu­rar y utilizar Git mediante la interfaz de línea de comandos y que puedas crear y ad­mi­ni­s­trar fá­ci­l­me­n­te tu propio re­po­si­to­rio.

El re­po­si­to­rio Git es el di­re­c­to­rio central de un proyecto y, por lo tanto, también el principal punto de contacto para todos los pa­r­ti­ci­pa­n­tes, a través del cual se lleva a cabo el control de todas las versiones. Por ello, el primer paso consiste en crear este re­po­si­to­rio principal o clonarlo (en forma de copia de trabajo) en caso de que vayas a in­co­r­po­rar­te a un proyecto que ya se esté ge­s­tio­na­n­do con Git.

Tanto si quieres co­n­fi­gu­rar el control de versiones para un nuevo proyecto como si acabas de instalar Git para aprender a trabajar con la he­rra­mie­n­ta, debes crear un nuevo re­po­si­to­rio. Para ello, ejecuta el comando cd (change directory) para acceder al di­re­c­to­rio de tu di­s­po­si­ti­vo donde desees ubicarlo:

Una vez allí, introduce el siguiente comando para crear un re­po­si­to­rio .git:

Si ya existe un re­po­si­to­rio Git para el proyecto, solo tienes que in­tro­du­cir el comando git clone seguido de la dirección web o de red de ese re­po­si­to­rio para crear una copia de trabajo en el ordenador:

Uno de los conceptos básicos para utilizar Git es organizar ade­cua­da­me­n­te el propio di­re­c­to­rio de trabajo, lo que permite no solo proponer cambios e in­no­va­cio­nes pe­r­so­na­les a un proyecto, que luego son aceptados mediante el comando git commit (enviar), sino también obtener in­fo­r­ma­ción sobre las ac­ti­vi­da­des de otros usuarios. Puedes comprobar si tu copia de trabajo está ac­tua­li­za­da eje­cu­ta­n­do este comando:

Para añadir un nuevo archivo al control de versiones o para registrar algún cambio para el siguiente commit, introduce el comando git add y el nombre de este archivo, que debe en­co­n­trar­se en tu di­re­c­to­rio de trabajo. En nuestro tutorial, aña­di­re­mos un documento de texto llamado “Test” como ejemplo:

Cualquier cambio que hayas propuesto in­co­r­po­rar al proyecto, como hemos explicado en el punto anterior, debe co­n­fi­r­mar­se con commit para que se incluya en el HEAD. El HEAD es una especie de índice que apunta al último commit efectuado en el entorno de trabajo Git actual (también llamado “rama”). El comando para hacerlo es el siguiente:

Como se muestra en la captura de pantalla, después de ejecutar git commit, obtienes un mensaje que resume el commit: entre corchetes figuran, por un lado, el nombre de la rama del proyecto a la que se tra­n­s­fi­rie­ron los cambios (en este caso, master, ya que nuestro re­po­si­to­rio de trabajo también es el re­po­si­to­rio principal) y, por otra parte, la suma de co­m­pro­ba­ción SHA-1 del commit (en este caso, c0fdc90). Les siguen el co­me­n­ta­rio que anotó el propio usuario (aquí, “Test”) y algunos datos concretos sobre los cambios.

Una vez aceptados los cambios mediante el comando commit, puedes editar el contenido o eli­mi­nar­lo por completo en cualquier momento más adelante. Por ejemplo, un caso típico sería pre­ci­pi­tar­se al ejecutar commit y olvidarse de algún archivo o co­n­fi­gu­ra­ción im­po­r­ta­n­te. En este caso, puedes registrar archivos nuevos o mo­di­fi­ca­dos a po­s­te­rio­ri mediante el comando git add y volver a tra­n­s­fe­ri­r­los. Para ello, añade --amend al comando estándar:

Si quieres deshacer el último commit generado, puedes hacerlo con el siguiente comando de Git:

Este comando cancela el commit re­gi­s­tra­do por última vez en el HEAD. Los archivos que contiene se re­s­ta­ble­cen como “cambios pla­ni­fi­ca­dos para el próximo commit” en el estado del proyecto. Si lo que quieres es eliminar por completo los datos in­tro­du­ci­dos, ejecuta el siguiente comando en lugar del anterior:

Aprender a gestionar proyectos con Git es es­pe­cia­l­me­n­te útil debido a las ca­ra­c­te­rí­s­ti­cas básicas de control de versiones que ofrece el sistema. Por ejemplo, una gran ventaja de este programa de código abierto es que siempre puedes vi­sua­li­zar los últimos cambios que se han realizado en el re­po­si­to­rio. Para ello, puedes utilizar el siguiente comando de Git:

El comando git log también puede mo­di­fi­car­se uti­li­za­n­do varios pa­rá­me­tros. En la siguiente tabla, te mostramos algunas de las po­si­bi­li­da­des:

Hasta ahora, hemos mostrado cómo guardar los cambios como commit en el HEAD del di­re­c­to­rio local. Para que estos también se incluyan en el re­po­si­to­rio principal, debes ejecutar el siguiente comando:

De este modo, Git tra­n­s­fie­re au­to­má­ti­ca­me­n­te todos los commits eje­cu­ta­dos, que hasta ahora solo habían estado en la copia de trabajo, al di­re­c­to­rio principal, que también recibe el nombre de master. Si su­s­ti­tu­yes este nombre por el de otra rama (la del proyecto), los archivos se enviarán di­re­c­ta­me­n­te allí.

Al igual que muchos otros sistemas de control de versiones, Git tiene una función de eti­que­ta­do que resalta los elementos se­le­c­cio­na­dos en el historial del re­po­si­to­rio. Por lo general, estas etiquetas se utilizan para ide­n­ti­fi­car versiones del software, como 1.0, 2.0 o po­s­te­rio­res, y permitir que estas sean fáciles de acceder en todo momento, incluso en el caso de los proyectos grandes. Git admite dos tipos de etiquetas:

• Etiquetas anotadas (annotated): se guardan como objetos in­de­pe­n­die­n­tes en la base de datos e incluyen su propia suma de co­m­pro­ba­ción, etiqueta, fecha, nombre y dirección de correo ele­c­tró­ni­co del creador de la etiqueta, así como la firma opcional GNU Privacy Guard (GPG).
• Etiquetas no anotadas (li­gh­t­wei­ght): al igual que las ramas, solo sirven de re­fe­re­n­cia para ide­n­ti­fi­car un commit. Este tipo resulta útil si solo necesitas una etiqueta temporal o si no quieres guardar datos avanzados.

Para crear etiquetas anotadas en Git, ejecuta el comando git tag -a en el commit que desees. Si también añades el parámetro -m, podrás anotar entre comillas el mensaje que debe incluir la etiqueta di­re­c­ta­me­n­te en el símbolo del sistema. En este tutorial de Git, hemos generado el commit “Test”, que ahora vi­n­cu­la­re­mos a una etiqueta que incluye el mensaje “example tag”:

Para las etiquetas no anotadas, pro­ce­de­mos de manera similar: en este caso, solo eje­cu­ta­mos el comando básico git tag en el commit deseado y no uti­li­za­mos ningún otro parámetro. En el ejemplo utilizado en este tutorial de Git, el comando sería el siguiente:

En cuanto haya etiquetas en el re­po­si­to­rio, podemos mo­s­trar­las con el me­n­cio­na­do git tag y los pa­rá­me­tros op­cio­na­les -l o --list:

Para eliminar una etiqueta del di­re­c­to­rio de trabajo local, ejecuta el comando git tag -d. Nuestra re­fe­re­n­cia a “Test” se elimina de la siguiente manera:

Ten en cuenta que también debes tra­n­s­fe­rir las etiquetas al re­po­si­to­rio principal de forma manual como commit. Para ello, introduce el nombre de la etiqueta y el comando git push origin. También puedes añadir el parámetro --tags en vez del nombre de la etiqueta, mediante el cual todas las etiquetas generadas se incluyen en el re­po­si­to­rio:

Las ramas ya me­n­cio­na­das en este tutorial de Git no son, en principio, más que versiones de trabajo in­di­vi­dua­les del re­po­si­to­rio principal, que también se clasifica como una rama llamada master. Mediante esta es­tru­c­tu­ra, Git pro­po­r­cio­na una base perfecta para de­sa­rro­llar ca­ra­c­te­rí­s­ti­cas y funciones de forma in­de­pe­n­die­n­te y co­m­bi­nar­las en etapas po­s­te­rio­res, lo que también recibe el nombre de fusionar (en inglés, merge).

Crear una nueva rama es fácil: solo debes ejecutar el comando git branch y añadir el nombre que quieras poner a la rama. Por ejemplo, puedes generar una rama de ejemplo llamada test_branch de la siguiente manera:

Después, puedes cambiar a esta rama en cualquier momento mediante el comando git checkout:

Para combinar dos o más ramas, utiliza el comando git merge. Antes, ejecuta checkout para cambiar al di­re­c­to­rio que debe incluir la otra rama y, después, ejecuta allí este comando, in­clu­ye­n­do el nombre de la rama que se fusionará. Nuestra versión de trabajo test_branch se puede fusionar con el re­po­si­to­rio principal de la siguiente manera:

Si has fusionado varias ramas de trabajo y, por lo tanto, ya no te hace falta una rama en pa­r­ti­cu­lar, puedes eli­mi­nar­la fá­ci­l­me­n­te. Para ello, introduce el comando git branch -d y la rama que ya no necesites. Eli­mi­na­re­mos test_branch, nuestro ejemplo en este tutorial de Git, mediante el siguiente comando: