# 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**. ## ¿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. --- ### Consejo Una de las alternativas más conocidas a Git es **Subversion**, una herramienta también de código abierto y más conocida como **SVN**, que se basa en un **sistema de gestión central**, contrariamente a Git. En nuestro artículo *[Git vs. SVN: una comparativa del control de versiones](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/git-vs-svn-una-comparativa-del-control-de-versiones/ "Git vs. SVN: una comparativa del control de versiones")*, te contamos qué tienen en común estos programas y en qué se diferencian. --- ## Cómo instalar Git en el dispositivo 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. --- ### Nota Para poder utilizar los comandos explicados en este tutorial de Git, los usuarios de Windows deben ejecutarlo a través de **Git Bash**, un *shell* de estilo Unix que emula la línea de comandos de Git y está incluido en el paquete de instalación. Si lo prefieres, también es posible controlar el software con el símbolo del sistema o la terminal de Windows, aunque debes tener en cuenta que la estructura de los parámetros de los comandos difiere (por ejemplo, se emplean signos de ídem en lugar de comillas). --- En la [página oficial del proyecto Git](https://git-scm.com/downloads "git-scm.com: sitio oficial de 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. --- ### Consejo En la [página de descargas de git-scm.com](https://git-scm.com/downloads/guis/ "Clientes GUI en el centro de descargas de git-scm.com"), la comunidad de Git ofrece **diferentes interfaces gráficas** para el sistema de control de versiones. Además, entre otras cosas, proporciona aplicaciones Git para **Android** e **iOS** que permiten utilizar esta herramienta de código abierto en dispositivos móviles. --- ## 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. --- ### Nota Pese a conocerse desde 2015 que una configuración errónea de Git o, para ser más exactos, del servidor web en activo, pone a los repositorios del sistema de gestión de versiones a disposición pública en la red, son muchas las webs que a día de hoy aún exponen a sus ficheros. Esto ocurre siempre que un directorio Git se guarda en el directorio web raíz del servidor, algo a evitar en todos los casos. Hay dos opciones: o no se guardan nunca aquí o se configura al servidor web de tal manera que no pueda accederse al directorio *.git* desde fuera. En [esta entrada del blog Internetwache.org](https://en.internetwache.org/dont-publicly-expose-git-or-how-we-downloaded-your-websites-sourcecode-an-analysis-of-alexas-1m-28-07-2015/ "Don't publicly expose .git en Internetwache.org"), encuentras una guía detallada para proteger el directorio *.git*. --- ### 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 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**: ```none cd ruta al directorio ``` Una vez allí, introduce el siguiente comando para **crear un repositorio** ***.git***: ```none git init ``` [![Imagen: Git Bash: cambio de directorio y creación del repositorio](https://www.ionos.com/es-us/digitalguide/fileadmin/_processed_/8/1/csm_git-tutorial-1_8ddb81ffec.webp "Git Bash: cambio de directorio y creación del repositorio")](https://www.ionos.com/es-us/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/git-tutorial-1.jpg) Git Bash: cambio de directorio y creación del repositorio. 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: ```none git clone https://one-test.website/git-repository ``` --- ### Nota Git es compatible con varios protocolos de transferencia. Como alternativa a HTTPS, utilizado en el ejemplo, puedes recurrir a [SSH](https://www.ionos.com/es-us/digitalguide/servidores/herramientas/protocolo-ssh/ "Protocolo SSH") para acceder a un repositorio, siempre que dispongas de los correspondientes permisos. --- ### 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: ```none 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*). [![Imagen: Git Bash: comprobación del estado del repositorio de Git](https://www.ionos.com/es-us/digitalguide/fileadmin/_processed_/d/b/csm_git-tutorial-2_7400b70e7d.webp "Git Bash: comprobación del estado del repositorio de Git")](https://www.ionos.com/es-us/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/git-tutorial-2.jpg) Git Bash: comprobación del estado del repositorio de Git. 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: ```none git add Test.txt ``` 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 (C*hanges to be commited*): [![Imagen: Git Bash: comprobación del estado tras modificar la copia de trabajo](https://www.ionos.com/es-us/digitalguide/fileadmin/_processed_/e/d/csm_git-tutorial-3_e2f3c6923a.webp "Git Bash: comprobación del estado tras modificar la copia de trabajo")](https://www.ionos.com/es-us/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/git-tutorial-3.jpg) 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: ```none git commit ``` --- ### Nota Antes de ejecutar el comando *git commit*, no te olvides de comprobar si has marcado todos los cambios que deseas incluir en el repositorio remoto (con *git add*). De lo contrario, estos serán ignorados, incluso si se encuentran en la copia de trabajo guardada en el directorio. --- Después de ejecutar el comando, Git **inicia automáticamente el editor** que configuraste como predeterminado durante la instalación o que el propio sistema abre por defecto. En el documento, puedes añadir un **comentario personal** sobre el *commit* planificado, en el que las líneas anotadas se separan por punto y coma y, por lo tanto, no se muestran más adelante. En cuanto **cierres el editor**, Git creará el *commit*: [![Imagen: Tutorial de Git: salida de Git Bash después de ejecutar el comando “git commit”](https://www.ionos.com/es-us/digitalguide/fileadmin/_processed_/0/8/csm_git-tutorial-4_fd7dfd4d17.webp "Tutorial de Git: salida de Git Bash después de ejecutar el comando “git commit”")](https://www.ionos.com/es-us/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/git-tutorial-4.jpg) Salida de Git Bash después de ejecutar el comando “git commit”. 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. ### 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: ```none git commit --amend ``` Si quieres **deshacer** el último ***commit*** generado, puedes hacerlo con el siguiente comando de Git: ```none 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: ```none 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: ```none git log ``` De manera predeterminada, el comando *[git log](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/git-log/ "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: [![Imagen: Tutorial de Git: historial de commit con un registro](https://www.ionos.com/es-us/digitalguide/fileadmin/_processed_/8/8/csm_git-tutorial-5_748b3e97fd.webp "Tutorial de Git: historial de commit con un registro")](https://www.ionos.com/es-us/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/git-tutorial-5.jpg) 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 enumera todos los commits en una sola línea
--abbrev-commit Muestra solo los primeros caracteres de una suma de comprobación SHA-1
--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: ```none 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”: ```none git tag -a Test -m “example tag” ``` --- ### Nota Si omites el parámetro *-m* al generar la etiqueta, Git abrirá automáticamente el editor para que puedas introducir el mensaje de la etiqueta. --- 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: ```none git tag Test ``` En cuanto haya etiquetas en el repositorio, podemos mostrarlas con el mencionado ***git tag*** y los parámetros opcionales ***-l*** o ***--list***: ```none git tag git tag -l git tag --list ``` [![Imagen: Tutorial de Git: listado de etiquetas existentes en el repositorio](https://www.ionos.com/es-us/digitalguide/fileadmin/_processed_/3/4/csm_git-tutorial-6_b5d46d48aa.webp "Tutorial de Git: listado de etiquetas existentes en el repositorio")](https://www.ionos.com/es-us/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/git-tutorial-6.jpg) 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: ```none 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: ```none 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: ```none git branch test_branch ``` Después, puedes cambiar a esta rama en cualquier momento mediante el comando ***git checkout***: ```none git checkout test_branch ``` [![Imagen: Tutorial de Git: cambio de rama con Git-Bash](https://www.ionos.com/es-us/digitalguide/fileadmin/_processed_/f/0/csm_git-tutorial-7_6aebff405d.webp "Tutorial de Git: cambio de rama con Git-Bash")](https://www.ionos.com/es-us/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/git-tutorial-7.jpg) 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: ```none 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: ```none 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: [![Imagen: Cambio de rama y eliminación a través de Git-Bash](https://www.ionos.com/es-us/digitalguide/fileadmin/_processed_/3/6/csm_git-tutorial-8_a15d6804b1.webp "Cambio de rama y eliminación a través de Git-Bash")](https://www.ionos.com/es-us/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/git-tutorial-8.jpg) Git confirma que se ha eliminado la rama con el mensaje “Deleted branch…”. --- ### Consejo En nuestra Digital Guide también encontrarás información sobre "[Git branch rename: cómo renombrar una rama local y remota de Git](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/git-branch-rename/ "Git branch rename")". --- This is a markdown version of: [https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/tutorial-de-git/](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/tutorial-de-git/) for AI/LLM consumption.