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 sistemapara 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.
¿Qué es Git?
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.
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) ylas 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.
Git: tutorial para empezar a utilizarlo paso a paso
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.
Crear o clonar un repositorio Git
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 principalo 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:
cd ruta al directorio
Una vez allí, introduce el siguiente comando para crear un [Link]:
git init
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:
git clone [Link]
Comprobar el estado del repositorio y añadir nuevos archivos al control de versiones
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:
git status
Por lo general, en el caso de los repositorios creados recientemente, o cuando el repositorio
principal y la copia de trabajo coinciden por completo, recibirás un aviso de que no se ha
modificado el proyecto (No commits yet). Además, Git te informa de que no has compartido tus
cambios para el próximo commit (nothing to commit).
Git Bash: comprobación del estado del repositorio de Git.
Para añadir un nuevo archivoal 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:
git add [Link]
Después, cuando vuelvas a comprobar el estado del repositorio, verás que el documento está a la
espera de someterse a la siguiente fase de confirmación de cambios del proyecto, en que estos se
aceptarán o no (Changes to be commited):
Git Bash: comprobación del estado tras modificar la copia de trabajo.
Confirmar los cambios mediante commit y añadirlos al HEAD
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:
git commit
Revisar o deshacer commits ejecutados
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:
git commit --amend
Si quieres deshacer el último commit generado, puedes hacerlo con el siguiente comando de Git:
git reset --soft HEAD~1
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:
git reset --hard HEAD~1
Mostrar el historial de commits
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:
git log
De manera predeterminada, el comando git log enumera los commits generados en orden
cronológico inverso: la suma de comprobación SHA-1, el autor (nombre y dirección de correo
electrónico) y la fecha de cada commit. Además, se muestra un comentario individual que sirve a
todos los usuarios como indicador para poder buscar rápidamente las versiones. En un apartado
anterior de este tutorial de Git, generamos un solo commit con el mensaje “Test”. Al ejecutar el
comando, se nos muestra el archivo solicitado:
Tutorial de Git: historial de commit con un registro.
El comando git log también puede modificarse utilizando varios parámetros. En la siguiente tabla,
te mostramos algunas de las posibilidades:
Parámetros para git
log Descripción
-p Muestra también los cambios incluidos en un commit
-2 Enumera solo los dos últimos commits ejecutados
--stat Añade una pequeña estadística a cada registro que muestra qué archivos se han modificado y
cuántas líneas se han insertado o eliminado
--pretty Cambia el formato de salida con diferentes posibilidades; por ejemplo, --pretty=online enumer
todos los commits en una sola línea
--abbrev-commit Muestra solo los primeros caracteres de una suma de comprobación SHA-1
Parámetros para git
log Descripción
--relative-date Muestra la fecha de un cambio en formato relativo (por ejemplo, “hace dos semanas”)
Incluir commits en el repositorio principal
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:
git push origin master
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í.
Crear, eliminar y enumerar etiquetas en Git
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”:
git tag -a Test -m “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:
git tag Test
En cuanto haya etiquetas en el repositorio, podemos mostrarlas con el mencionado git tag y los
parámetros opcionales -lo --list:
git tag
git tag -l
git tag --list
El comando git tag muestra la etiqueta creada anteriormente para “Test”, el commit de ejemplo.
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:
git tag -d Test
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:
git push origin --tags
Crear, administrar y eliminar ramas
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:
git branch test_branch
Después, puedes cambiar a esta rama en cualquier momento mediante el comando git checkout:
git checkout test_branch
Al cambiar de rama, Git muestra el mensaje “Switched to branch…” (cambiado a la rama…).
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:
git checkout master
git merge test_branch
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:
git branch -d test_branch
El único requisito para eliminar una rama es encontrarse en otra distinta en ese momento. Por lo
tanto, has de cambiar al repositorio principal antes de ejecutar el comando, como puedes ver en la
siguiente captura de pantalla:
