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

No solo las empresas desarrollan proyectos de software de forma colaborativa: también en el sector del código abierto, varios cientos o incluso miles de voluntarios y colaboradores pueden participar en la creación, el mantenimiento, la optimización o la edición de un programa, dependiendo del tamaño del proyecto. Sería prácticamente imposible llevar a cabo estas tareas sin un buen sistema para registrar y controlar los numerosos cambios realizados por todos los desarrolladores.

Una de las soluciones más populares en este sentido es Git, un programa de licencia libre que puedes aprender a manejar rápidamente y utilizar de forma totalmente 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 desarrollado en 2005 por Linus Thorvalds, el creador de Linux, y publicado bajo la licencia de software libre GPLv2 de GNU. La particularidad de esta herramienta es que, aunque guarda un repositorio central para cada proyecto, todos los participantes descargan una copia local del mismo en su propio dispositivo. Cada una de estas copias constituye una copia completa de todo el contenido del repositorio, 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 repositorio principal falle o resulte dañado. Los cambios en los archivos pueden intercambiarse con todos los demás participantes del proyecto en cualquier momento y, si corresponde, añadirse al repositorio.

Si quieres empezar a utilizar Git como programa de control de versiones, en primer lugar, debes familiarizarte con el propio software y su interfaz de usuario. Git está disponible para Windows, Unix/Linux y macOS, con diferentes versiones que presentan pequeñas diferencias de uso. Después de llevar a cabo la instalación estándar correspondiente, puedes controlar el programa con el símbolo del sistema o una interfaz gráfica de usuario en cualquiera de los sistemas operativos.

En la página oficial del proyecto Git, encontrarás los archivos de instalación binarios, las instrucciones para instalar el administrador de paquetes (sistemas Unix) y las ediciones portátiles listas para usar para cada sistema operativo. Solo tienes que descargar el paquete de instalación deseado o elegir el paquete apropiado mediante el administrador y, a continuación, seguir las instrucciones del asistente. Obviamente, con las ediciones portátiles no es necesario llevar a cabo la instalació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 comprender las funciones y comandos básicos para sacarle el máximo partido a la herramienta. En nuestro completo tutorial de Git, te explicamos los comandos más importantes para configurar y utilizar Git mediante la interfaz de línea de comandos y que puedas crear y administrar fácilmente tu propio repositorio.

El repositorio Git es el directorio central de un proyecto y, por lo tanto, también el principal punto de contacto para todos los participantes, a través del cual se lleva a cabo el control de todas las versiones. Por ello, el primer paso consiste en crear este repositorio principal o clonarlo (en forma de copia de trabajo) en caso de que vayas a incorporarte a un proyecto que ya se esté gestionando con Git.

Tanto si quieres configurar el control de versiones para un nuevo proyecto como si acabas de instalar Git para aprender a trabajar con la herramienta, debes crear un nuevo repositorio. Para ello, ejecuta el comando cd (change directory) para acceder al directorio de tu dispositivo donde desees ubicarlo:

Una vez allí, introduce el siguiente comando para crear un repositorio .git:

Si ya existe un repositorio Git para el proyecto, solo tienes que introducir el comando git clone seguido de la dirección web o de red de ese repositorio para crear una copia de trabajo en el ordenador:

Uno de los conceptos básicos para utilizar Git es organizar adecuadamente el propio directorio de trabajo, lo que permite no solo proponer cambios e innovaciones personales a un proyecto, que luego son aceptados mediante el comando git commit (enviar), sino también obtener información sobre las actividades de otros usuarios. Puedes comprobar si tu copia de trabajo está actualizada ejecutando 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 encontrarse en tu directorio de trabajo. En nuestro tutorial, añadiremos un documento de texto llamado “Test” como ejemplo:

Cualquier cambio que hayas propuesto incorporar al proyecto, como hemos explicado en el punto anterior, debe confirmarse 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 transfirieron los cambios (en este caso, master, ya que nuestro repositorio de trabajo también es el repositorio principal) y, por otra parte, la suma de comprobación SHA-1 del commit (en este caso, c0fdc90). Les siguen el comentario 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 eliminarlo por completo en cualquier momento más adelante. Por ejemplo, un caso típico sería precipitarse al ejecutar commit y olvidarse de algún archivo o configuración importante. En este caso, puedes registrar archivos nuevos o modificados a posteriori mediante el comando git add y volver a transferirlos. 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 registrado por última vez en el HEAD. Los archivos que contiene se restablecen como “cambios planificados para el próximo commit” en el estado del proyecto. Si lo que quieres es eliminar por completo los datos introducidos, ejecuta el siguiente comando en lugar del anterior:

Aprender a gestionar proyectos con Git es especialmente útil debido a las características 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 visualizar los últimos cambios que se han realizado en el repositorio. Para ello, puedes utilizar el siguiente comando de Git:

El comando git log también puede modificarse utilizando varios parámetros. En la siguiente tabla, te mostramos algunas de las posibilidades:

Hasta ahora, hemos mostrado cómo guardar los cambios como commit en el HEAD del directorio local. Para que estos también se incluyan en el repositorio principal, debes ejecutar el siguiente comando:

De este modo, Git transfiere automáticamente todos los commits ejecutados, que hasta ahora solo habían estado en la copia de trabajo, al directorio principal, que también recibe el nombre de master. Si sustituyes este nombre por el de otra rama (la del proyecto), los archivos se enviarán directamente allí.

Al igual que muchos otros sistemas de control de versiones, Git tiene una función de etiquetado que resalta los elementos seleccionados en el historial del repositorio. Por lo general, estas etiquetas se utilizan para identificar versiones del software, como 1.0, 2.0 o posteriores, 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 independientes en la base de datos e incluyen su propia suma de comprobación, etiqueta, fecha, nombre y dirección de correo electrónico del creador de la etiqueta, así como la firma opcional GNU Privacy Guard (GPG).
• Etiquetas no anotadas (lightweight): al igual que las ramas, solo sirven de referencia para identificar 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 directamente en el símbolo del sistema. En este tutorial de Git, hemos generado el commit “Test”, que ahora vincularemos a una etiqueta que incluye el mensaje “example tag”:

Para las etiquetas no anotadas, procedemos de manera similar: en este caso, solo ejecutamos el comando básico git tag en el commit deseado y no utilizamos 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 repositorio, podemos mostrarlas con el mencionado git tag y los parámetros opcionales -l o --list:

Para eliminar una etiqueta del directorio de trabajo local, ejecuta el comando git tag -d. Nuestra referencia a “Test” se elimina de la siguiente manera:

Ten en cuenta que también debes transferir las etiquetas al repositorio 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 repositorio:

Las ramas ya mencionadas en este tutorial de Git no son, en principio, más que versiones de trabajo individuales del repositorio principal, que también se clasifica como una rama llamada master. Mediante esta estructura, Git proporciona una base perfecta para desarrollar características y funciones de forma independiente y combinarlas en etapas posteriores, 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 directorio que debe incluir la otra rama y, después, ejecuta allí este comando, incluyendo el nombre de la rama que se fusionará. Nuestra versión de trabajo test_branch se puede fusionar con el repositorio principal de la siguiente manera:

Si has fusionado varias ramas de trabajo y, por lo tanto, ya no te hace falta una rama en particular, puedes eliminarla fácilmente. Para ello, introduce el comando git branch -d y la rama que ya no necesites. Eliminaremos test_branch, nuestro ejemplo en este tutorial de Git, mediante el siguiente comando: