Tutorial de Introducción a Git

Git es una herramienta muy útil a la hora de gestionar el código de los proyectos en los que trabajas. No es fácil para los principiantes, especialmente si nunca has trabajado como parte de un equipo. Si siempre has trabajado solo y quieres aprender a utilizar Git en cuestión de minutos, este tutorial es para ti.

Introducción

En esta guía aprenderás qué es Git y por qué puede resultarte útil tanto si trabajas solo como si formas parte de un equipo. El único requisito previo es que sepas crear un proyecto web de cualquier tipo y que lo hayas subido alguna vez a alguna cuenta de hosting o a algún servidor. También necesitarás ciertos conocimientos básicos de la línea de comandos. Si no los tienes, consulta qué es y cómo se utiliza la línea de comandos.

Seguidamente, crearemos un proyecto local y lo subiremos a un servidor utilizando Git desde la línea de comandos. Cierto es que existen herramientas visuales que te permitirán usar Git con mayor facilidad, pero es casi indispensable que aprendas ciertos comandos básicos y no tan básicos, puesto que a la hora de la verdad, los necesitarás. Para que veáis que no miento, en la mayor parte de las empresas en las que he trabajado era indispensable el uso de Git desde la línea de comandos.

Estos son los requisitos de este tutorial:

• Que tengas soltura en el uso de la línea de comandos.
• Que sepas crear un proyecto web.

Estos son los objetivos de este tutorial:

• Aprender qué es Git y que comiences a utilizarlo desde ya.
• Que aprendas a crear un proyecto local integrado con Git y que lo pongas a funcionar en un servidor usando esta herramienta.

Qué es Git

Git es un sistema de control de versiones que se utiliza para gestionar el código. Se utiliza para registrar los cambios de las diferentes revisiones del código y así permitir que tanto un desarrollador individual como un equipo puedan trabajar juntos en un proyecto. Para ello Git pone a disposición de los equipos las ramas o branches, que permiten trabajar en diversas funcionalidades a los miembros de un equipo.

A los sistemas de control de versiones también se les llama VCS «Version Control System». Si quieres conoces algo más acerca de la historia de Git, puedes consultar este enlace.

Cómo funciona Git

Si estás leyendo esto es porque seguramente estés acostumbrado a utilizar el protocolo FTP (File Transfer Protocol) para subir a tu servidor los archivos de tus proyectos. Para ello, seguramente habrás utilizado aplicaciones como Transmit, WinFTP o FileZilla.

• Cuando utilizas el protocolo FTP, sueles utilizar alguna aplicación que soporta este protocolo para subir los archivos a tu servidor. Cuando descargas archivos desde tu servidor mediante FTP, el proceso es el mismo, pero a la inversa: Entorno Local ⇋ Aplicación FTP ⇋ Entorno de Producción
• Git funciona de un modo muy parecido: Entorno Local ⇋ Repositorio ⇋ Entorno de Producción

Con Git, partes de un repositorio de código central, al que llamaremos repositorio origen. Este repositorio contendrá tu código.

Cuando trabajas localmente, simplemente creas una copia del repositorio origen, creando un repositorio local. Cuando terminas de trabajar y quieres guardar los cambios localmente, agregas el código a tu repositorio local.

Cuando quieres compartir los cambios que has hecho, debes sincronizar tu repositorio local con el  repositorio origen, lo que equivale a subir los cambios. A esta acción se le llama push.

Sin embargo, todavía tienes tu código en el repositorio origen. ¿Qué debes hacer cuando quieres subir estos cambios a tu servidor? Pues muy sencillo; simplemente debes crear una copia del repositorio origen en tu servidor de producción y sincronizarlo. A este repositorio le llamaremos repositorio de producción. Bastará una sola línea de código para realizar esta tarea. A esta acción se le llama pull.

Entiendo que esto pueda parecer engorroso al principio, pero con el tiempo no podrás ni siquiera concebir el hecho de trabajar sin esta herramienta, aunque trabajes tú solo en un proyecto.

Existen también aplicaciones de interfaz gráfica (GUI), como Git Tower, SourceTree e incluso la aplicación de GitHub para Mac y Windows. Su interfaz permite realizar la mayor parte de las acciones que realizarás habitualmente con Git, pero no todas. Es útil aprenderlas, pero más útil resulta aprender a utilizar Git desde la terminal. Os aseguro que es mejor tener estos conocimientos como base.

Instalación de Git

Según cual sea tu sistema operativo, Git se instalará de una forma diferente. Puedes consulta el tutorial de instalación de Git para ver en detalle varios métodos de instalación o seguir los pasos que se muestran a continuación según cual sea tu sistema operativo.

Instalación de Git en Windows

Lo mejor que puedes hacer es descargar Git for Windows. Git for Windows incluye una aplicación llamada Git Bash que permite usar los comandos de la terminal de Linux de forma emulada, de modo que funcionen con Windows. Si quieres una guía detallada paso a paso acerca de la instalación de Git en Windows, consulta la guía de instalación de Git en Windows, aunque con lo que tienes a continuación debería ser suficiente.

En general, bastará con que sigas los pasos que se muestran en pantalla, seleccionando todas las opciones que se muestran por defecto. Lo único, cuando tengas que seleccionar un editor de texto, es recomendable que selecciones un editor diferente a Vim en caso de que jamás hayas usado este editor. Algunas buenas opciones son Notepad++ o VS Code. Si quieres usar un editor de terminal como nano consulta cómo instalar y utilizar nano. Podrás hacerlo desde Git bash cuando finalice la instalación.

Instalación de Git en Linux

Para instalar Git en Linux, debes usar el gestor de paquetes que incluye tu distribución.

• Si tu distribución es Ubuntu en cualquiera de sus versiones, Debian o similar, inicia una ventana de Terminal y actualiza la lista de paquetes disponibles mediante el comando sudo apt-get update. Seguidamente, instala Git utilizando el comando sudo apt-get install git.
• Si tu distribución es CentOS, RHEL, Fedora o similar, inicia una ventana de Terminal e instala Git utilizando el comando yum install git. Si quieres, puedes consultar el tutorial de instalación de Git en CentOS, en donde se explica todo con más detalle.

Por último e independientemente de la distribución que utilices, ejecuta el comando git --version para comprobar que Git se ha instalado correctamente. Debería mostrarse el número de versión de Git.

Instalación de Git en Mac

Para instalar Git en Mac, abre primero una ventana de Terminal. Seguidamente introduce el comando git --version y pulsa INTRO. Si se muestra algún número de versión, esto indicará que Git ya está instalado en tu sistema. Si por el contrario se muestra un mensaje indicando que no se ha encontrado el comando, como por ejemplo -bash: git: command not found, entonces debes instalar Git.

Para instalar Git, primero instala Xcode desde la App Store. Seguidamente inicia Xcode e instala las Command Line Tools accediendo a Preferencias ➜ Descargas (Downloads) ➜ Command Line Tools. Y con esto, ya podrás utilizar Git.

Aunque no es necesario para este tutorial, quizás sea también un buen momento para que instales Homebrew, que es un gestor de paquetes para macOS que facilitará bastante ciertas tareas. De hecho, otro método de instalación consiste en que simplemente instales Homebrew y que luego ejecutes el comando brew install git.

Comandos Básicos de Git

A modo de referencia, aquí tienes una lista con los comandos básicos de Git:

• git status: Comprueba el estado de un repositorio.
• git add: Sirve parar agregar los nuevos archivos al repositorio, llevando así un control sobre ellos.
• git commit: Se utiliza para agrega al repositorio los cambios en los archivos que han sido modificados.
• git push: Se utiliza para subir los archivos al origen, que en nuestro caso será GitHub.
• git pull: Se utiliza para descargar los archivos del repositorio junto con los cambios que otros usuarios hayan realizado en él.
• git stash: Deshacer los cambios no guardados.
• git init: Se utiliza para crear un nuevo repositorio vacío.
• git config: Se usa para configurar diversos aspectos de Git.
• git remote: Sirve para configurar el repositorio remoto asociado a un repositorio local.

No te preocupes si no entiendes algunos comandos, ya que a continuación veremos cómo se utilizan todos y cada uno de ellos.

Crea un Repositorio de Git

Podrías instalar Git en tu servidor para crear un repositorio. Sin embargo, existen muchos servicios que permiten hospedar repositorios, siendo el más conocido GitHub. Llegados a este punto, lo que debes hacer es crear una cuenta de GitHub. No te preocupes, ya que salvo que quieras utilizar ciertas funcionalidades avanzadas en el marco de un equipo para proyectos privados, es un servicio gratuito.

Cuando te registres en GitHub tendrás que escoger un nombre de usuario. De ahora en adelante haremos referencia a tu nombre de usuario como «usuario». Tu URL en GitHub tendrá la forma github.com/usuario.

Una vez hayas terminado de crear tu cuenta de usuario, haz clic en Repositories (Repositorios) desde la interfaz de GitHub y luego en New (Nuevo). Ahora debes introducir un nombre para el repositorio, al que llamaremos «proyecto». No marques la opción de inicializar el repositorio con un archivo Readme.md o con un archivo .gitignore, al menos por ahora. Luego haz clic en Crear repositorio (Create repository). Nada más crearlo estará vació, aunque pronto agregaremos algunos archivos.

Crea un Proyecto Local

En este apartado tendrás que utilizar bastante la Terminal. En caso de que no la sepas utilizar, es importante que te familiarices con ella primero consultado el tutorial de la línea de comandos que se corresponda con tu sistema operativo. Si utilizas Linux o Mac, utilizarás la Terminal. Si utilizas Windows, usarás Git Bash o también la Terminal que incluye el subsistema de Linux para Windows, en caso de que lo hayas activado. Los comandos serán los mismos en cualquier caso.

Primero inicia la Terminal. Aparecerás en tu directorio de usuario. Para confirmarlo usa el comando pwd:

pwd

Deberías estar en el directorio /Users/usuario, siendo usuario tu nombre de usuario en el sistema operativo.

Ahora crea un directorio nuevo, que es en donde residirá el código de tu proyecto. Par ello puedes usar el siguiente comando:

mkdir mi-proyecto

Ahora accede al directorio que has creado:

cd mi-proyecto

De ahora en adelante usaremos comandos de Git. La cantidad de comandos de Git es inmensa, pero has de saber que en el 90% de los casos utilizarás un reducido conjunto de comandos, que son los que aprenderás en esta introducción.

Lo primero que deberías hacer, en caso de que no lo hayas hecho ya, es configurar tu cuenta local de Git, introduciendo tu nombre y tu email. Para ello introduce los siguientes comandos, remplazando los datos de ejemplo por tu nombre y por tu email reales:

git config --global user.name "Nombre"
git config --global user.email usuario@dominio.tld

Ahora, asegúrate que estás en el directorio mi-proyecto que has creado previamente e inicializa el repositorio de Git con este comando:

git init

Esto creará un subdirectorio llamado .git dentro del directorio de tu proyecto. Si no se muestra, introduce el comando ls -la para verlo, o si accedes desde el explorador de Windows, asegúrate de que los archivos ocultos son visibles.

Ahora viene la parte más interesante, ya que ahora vamos a enlazar el respositorio local con el repositorio de GitHub. Para ello introduce el siguiente comando, reemplazando la URL por la de tu repositorio.

git remote add origin https://github.com/usuario/proyecto

Si no sabes cual es la URL de tu repositorio, basta con que accedas a él desde GitHub y copies la URL que se muestra.

Agrega Archivos al Proyecto

Ahora vamos a agregar archivos al proyecto. En este ejemplo agregaremos un archivo llamado index.html y otro llamado style.css. Puedes incluir cualquier cosa en el archivo index.html, como por ejemplo esta plantilla:

<!DOCTYPE html>
<html lang="es">
  <head>
    <meta charset="utf-8" />
    <meta http-equiv="x-ua-compatible" content="ie=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <title>Título</title>
    <link rel="stylesheet" href="style.css" />
  </head>
  <body>
    <h1>Título</h1>
  </body>
</html>

En el archivo style.css puedes incluir, por ejemplo, lo siguiente:

body {
  background-color: grey;
}

h1 {
  font-size: 24px;
}

Puedes agregar todos los archivos que quieras, aunque en este tutorial daremos por hecho que solamente existen estos dos.

Seguidamente, comprueba el estado del repositorio mediante el comando git status:

git status

Seguramente se muestre un mensaje similar a este:

On branch master
Initial commit

Untracked files:
(use "git add ..." to include in what will be committed)

  index.html
  style.css

nothing added to commit but untracked files present (use "git add" to track)

Se nos indica que existen dos archivos que todavía no han sido agregados al repositorio, por lo que Git no está haciendo un seguimiento con sus cambios.

Add: Añade los Archivos al Repositorio

Para agregar los archivos que has añadido al repositorio debes usar el comando git add:

git add .

El punto que hemos agregado indica que quieres agregar todos los archivos nuevos que se han encontrado en el directorio del proyecto. Si solo quisieras agregar un archivo, como por ejemplo el archivo index.html, tendrías que usar el siguiente comando:

git add index.html

Ahora vuelve a ejecutar el comando git status para verificar que los archivos se han agregado correctamente al repostiorio:

git status

Y estos deberían ser los resultados:

On branch master
Initial commit

Changes to be committed:
(use "git rm --cached ..." to unstage)

  new file: index.html
  new file: style.css

Tal y como podrás comprobar, los archivos se  han agregado al repositorio.

Commit: Guarda los Cambios en el Repositorio

Hemos agregado los archivos al repositorio, pero todavía tenemos que agregar los cambios en los archivos mediante el comando git commit:

git commit -m "Commit inicial"

Hemos utilizado el flag -m, que nos permite introducir un mensaje en la propia línea en la que escribimos el comando. De lo contrario se abrirá un editor externo, en donde tendrás que guardar los cambios y salir. Decir que en caso de que te olvides del comentario, se abra Vim y no sepas utilizarlo, lo cual es bastante común, debes escribir :q! y pulsar INTRO para cerrar el editor.

Cada vez que realices cambios que quieras guardar en los archivos del repositorio tendrás que ejecutar el comando anterior, ya que de lo contrario, Git los ignorará.

Y por última vez, ejecuta de nuevo el comando git status para verificar el estado de los archivos:

[master (root-commit)] Initial
  2 files changed, 20 insertions(+)

  create mode index.html
  create mode style.css

Todavía no hemos visto las ramas (branches) de Git. Sin embargo, has de saber que por ahora estás trabajando con la rama principal o master.

Stash: Deshaz los Cambios no Guardados

Es muy habitual que tras haber modificado varios archivos quieras deshacer todos los cambios. De este modo te ahorras el tener que editar los archivos uno a uno. Siempre y cuando no hayas hecho un commit de los cambios, podrás deshacerlos mediante el comando git stash:

git stash

Ten cuidado, ya que esto deshará todos los cambios no guardados.

Push: Sube el Código al Repositorio Remoto

Ahora vamos a subir los cambios al servidor, por lo que debes utilizar el comando git push:

git push origin master

Se mostrará un mensaje en la Terminal en el que se te pedirá que introduzcas tu nombre de usuario y contraseña. Al igual que muchas otras contraseñas en Linux, esta no tiene eco, por lo que no se mostrará en pantalla cuando la introduzcas.

Lo que has hecho ha sido subir el código al origen agregado al inicio del tutorial, que es tu cuenta de GitHub. En concreto, has subido el código a la rama master.

Desde ahora podrás trabajar con este código desde cualquier ordenador o servidor.

Pull: Actualiza el Repositorio Remoto

Imagínate que otro usuario que utiliza el mismo repositorio ha agregado un archivo o ha modificado alguno de los que has subido al repositorio. Lo ideal sería que pudieses obtener los cambios directamente, y esto es precisamente lo que hace el comando git pull:

git pull

Una vez se haya ejecutado el comando anterior, deberías tener tu repositorio local actualizado.

Crea un Repositorio en tu Servidor

Para explicar esto vamos a partir de que dispones de un servidor o de una cuenta de hosting a la que puedes acceder mediante SSH. Si estás leyendo este tutorial es por que quizás, antes subías los archivos mediante FTP. Bastaba con introducir la URL de tu servidor, el puerto, tu nombre de usuario y la contraseña para acceder mediante alguna aplicación de interfaz gráfica.

Ahora tendrás que acceder mediante SSH, que te permitirá hacer lo mismo, pero desde la línea de comandos. Tendrás que usar el comando ssh para acceder a tu servidor o a tu cuenta de hosting. Si usas una cuenta de hosting compartido y no dispones de los datos de acceso, consúltalos en el mismo panel en donde están los datos de acceso mediante FTP, ya que suelen encontrarse ahí.

Una vez tengas los datos de acceso SSH, introduce el siguiente comando, reemplazando «usuario» por tu nombre de usuario y «dominio.com» por el nombre de algún dominio o subdominio que apunte a tu servidor:

ssh usuario@dominio.com

Si tu servidor no usa el puerto 22, tendrás que especificarlo mediante el flag -p, como en este ejemplo en el que usamos el puerto 23:

ssh usuario@dominio.com -p 23

Acto seguido se te preguntará por tu contraseña de usuario. Una vez la introduzcas ya estarás dentro de tu servidor, por lo que todo lo que ejecutes no se ejecutará en tu entorno local, sino en tu servidor. Si quieres cerrar la conexión para volver a tu servidor, basta con que uses el comando exit.

Antes de nada, debes instalar GitHub en tu servidor. Para ello, sigue las instrucciones que se mostraban algo más arriba, pero para el sistema operativo de tu servidor, o también puedes consultar la guía de instalación de Git. Debes configurar tanto tu nombre como tu dirección de email al gual que antes. Puedes consultar estas opciones en cualquier momento mediante el siguiente comando:

git --list

Seguramente uses algún panel como CPanel o VestaCP, o quizás tengas algún host virtual ya configurado. Si no es así, esto es algo que se sale del alcance de este tutorial y que puedes consultar en muchos otros tutoriales. Partiendo de esto, accede desde la Terminal al directorio de tu proyecto mediante el comando cd, que es aquel al que accedías mediante FTP para subir tus archivos.

Una vez estés en el directorio adecuado, utiliza el comando git init para inicializar un nuevo repositorio:

git init

Seguidamente, configura el repositorio remoto con los datos de tu repositorio de GitHub, al igual que has hecho con tu repositorio local.

git remote add origin https://github.com/usuario/proyecto.git

Ahora basta con que hagas un pull para descargar la rama master, que es la que contiene el código que has agregado al repositorio:

git pull origin master

Otra opción es que en vez de agregar el origen y realizar el pull, clones el repositorio mediante el comando git clone:

git clone git@github.com:usuario/proyecto.git

Si accedes a la URL en la que está tu proyecto desde el navegador deberías poder ver tu proyecto. De ahora en adelante, bastará con que hagas un pull desde la terminal mediante SSH para actualizar el código de tu proyecto. Mucho más rápido que utilizando FTP.

Qué son las Ramas y cómo Crearlas

Cuando creas un repositorio se crea una rama por defecto, que es la rama master, que es la única que has utilizado hasta ahora. Una rama es una versión paralela a la principal en la que se suelen agregar nuevas funcionalidades, manteniendo así la estabilidad de la rama master. Por ejemplo, si trabajas solo, seguramente quieras tener una rama de desarrollo en la que agregar nuevas funcionalidades. A esta rama se le suele dar el nombre de dev. Sin embargo, es habitual agregar una rama para cada nueva funcionalidad, especialmente cuando trabajas en un equipo.

Branch: Trabajando con Ramas

Para saber la rama en la que estás actualmente, utilizarás el comando git branch:

git branch

Esto es lo que se debería mostrar por pantalla:

$ git branch
* master

Como podrás comprobar, tan solo existe una rama en tu repositorio local. De haber más, se mostrarían todas las ramas, y aquella con la que estás actualmente se indicará con un asterisco situado justo antes del nombre de la rama.

En caso de que quieras borrar una rama, tendrías que usar el comando git branch junto con el flag -d y el nombre de la rama a eliminar. Nunca debes eliminar la rama master. Por ejemplo:

git branch -d nombrerama

Checkout: Cambia o Crea Ramas

Si quieres cambiar de rama a otra existente, tendrías que utilizar el comando git checkout:

git checkout nombre-rama

Para crear una rama nueva, tendrás que usar el comando git checkout junto con el flag -b, que indica que quieres crear una rama vacía. Vamos a crear una nueva rama. En este ejemplo le llamaremos funcionalidad:

git checkout -b funcionalidad

El comando anterior cambiará automáticamente de rama, por lo que ahora deberías estar trabajando en la rama funcionalidad. Para comprobarlo, ejecuta de nuevo el comando git branch:

$ git branch
master
* funcionalidad

Tal y como puedes comprobar, ahora estás trabajando en la rama funcionalidad. Puedes modificar el código de esta nueva rama e incluso agregar o eliminar archivos sin que esto afecte a la rama master en la que estabas anteriormente.

Por ejemplo, vamos a renombrar el archivo style.css y le vamos a dar el nombre de style2.css. Luego edita el archivo index.html y cambia la línea en la que se incluye el archivo style.css, de modo que se incluya el archivo style2.css. Agrega también alguna línea adicional al archivo index.html, como por ejemplo algo de texto y algún encabezado h2.

Ahora ejecuta el comando git add para agregar los nuevos archivos a Git, de modo que Git sepa que debe realizar un seguimiento del archivo style2.css:

git add .

Suidamente, haz un commit de los cambios realizados para guardarlos:

git commit -m "Estilos modificados"

Los cambios se guardarán en la rama funcionalidad.

Ahora haz un checkout de la rama master para trabajar de nuevo con ella:

git checkout master

Y tal y como podrás comprobar, el archivo style.css que habías borrado está de vuelta. Del mismo modo, los cambios que habías realizado en el archivo index.html ya no están presentes

Diff: Visualiza Diferencias entre Ramas

Si quieres ver las diferencias entre ambas ramas, puedes usar el comando git diff, especificando aquellas ramas cuyas diferencias quieres ver por pantalla:

git diff --stat master funcionalidad

Se mostrarán aquellas línea modificadas y aquellos archivos que han sido agregados o eliminados.

En el siguiente apartado veremos cómo puedes integrar la nueva funcionalidad que has creado en la  rama master.

Merge: Integrando Ramas y Funcionalidades

Una vez has terminado de trabajar en una funcionalidad, debes integrar los cambios en tu rama master. Habitualmente suelen integrase los cambios en alguna rama de prueba o testing, de forma que los cambios se pueden probar antes de pasar a producción. Sin embargo, simplificaremos las cosas integrando los cambios en la rama master.

Lo que vamos a hacer es un branch merging, que consiste en mezclar o integrar nuestra rama funcionalidad con nuestra rama master. Para ellos debemos hacer un checkout para trabajar con la rama master y, seguidamente, integrar la rama funcionalidad mediante el comand git merge:

git checkout master
git merge funcionalidad

Y con esto, ya tendríamos la rama master actualizada con los cambios que hemos realizado en la rama funcionalidad. Una vez hayas integrado una rama, ya no la necesitarás más, por lo que puedes borrarla:

git branch -d funcionalidad

Resolución de Conflictos

Imagínate que has creado una rama llamada funcionalidad-a y otra llamada funcionalidad-b, y que en ambas ramas has modificado las mismas líneas del archivo index.html. Cuando hagas un merge de la funcionalidad-a en master, no habrá ningún problema. Sin embargo, cuando hagas un merge de la funcionalidad-b, aparecerá un conflicto, ya que, dado que ambas rabas fueron creadas desde el mismo punto, Git no sabrá con qué código ha de quedarse, mostrándose un mensaje similar a este:

git merge funcionalidad-b
Auto-merged deliverance.py
CONFLICT (content): Merge conflict in index.html
Automatic merge failed; fix conflcits and then commit the result.

En este caso, Git agregará ambas versiones del código a los archivos, indicando a qué rama corresponde cada porción de código que está en conflicto. Debemos editar el archivo index.html con cualquier editor y, manualmente, borrar el código de la versión que no queremos incluir. Una vez soluciones este conflicto, realiza un git add y un git commit de los cambios:

git add index.html
git commit -m "Solución de conflicto durante merge"

Y con esto, el conflicto debería estar solucionado.

Cómo Deshacer un Merge

Siempre se puede dar el caso de que o bien tú o bien algún miembro del equipo hayáis hecho algo mal o hayáis integrado código que no deberíais. Por norma general, suele ser culpa del otro miembro del equipo, y esto mismo también se aplica al otro miembro del equipo. La culpa suele ser el espíritu que ronda la oficina. En mi caso, suelo crear una copia de la rama en la que integro los cambios por si algo va mal. Ya sea este el caso o si ves que los conflictos son excesivos, es recomendable deshacer el merge.

Git incluye el comando reset, que te permitirá volver a algún paso anterior, antes de realizar el merge:

git reset --hard HEAD

El comando reset sirve para devolver el índice de archivos de Git a un estado anterior, pero no actualizará los archivos en el directorio de tu proyecto, por lo que debes agregar el flag --hard HEAD para revertir los cambios tanto en el índice de Git como en los archivos de tu proyecto.

Cómo Deshacer un Commit

En caso de que lo único que queras deshacer sea un commit del que te hayas arrepentido, debes hacer también un reset, pero en lugar de usar la opción --hard HEAD, debes usar el flag --hard ORIG_HEAD:

git reset --head ORIG_HEAD

Debes tener en cuenta que esto solamente revertirá el último commit. En caso de que quieras revertir más commits, tendrías que usar el comando revert, que es quizás demasiado complicado para lo que se pretende en este tutorial. Además, si haces las cosas bien, su uso es poco frecuente.

Ayuda de Git

Git incluye in comando de ayuda que te proporcionará información acerca de los diferentes comandos que puedes usar con Git. Por ejemplo, vamos a consultar la ayuda del comando git merge con el siguiente comando:

git help merge

Y esto ha sido todo.

---