¡Deshacer cambios en GitHub! Introducción a reset, revert y checkout

En los artículos anteriores, aprendimos a usar `git add` y `git commit` para registrar los cambios en nuestros archivos. Sin embargo, en el desarrollo, los errores son inevitables. Es muy común pensar: "¡Vaya, he hecho commit del archivo equivocado!" o "Quiero volver a la versión anterior...".

La potencia de Git reside en que cuenta con funciones para deshacer estos errores de operación de forma segura y sencilla. En este artículo, explicaremos de manera sencilla las diferencias entre los tres comandos principales para "deshacer" cambios: `git checkout`, `git reset`, y `git revert`, así como su uso concreto en diferentes situaciones. ¡Si dominas esto, ya no tendrás que temer a los errores de operación!

Los 3 comandos para "deshacer": ¿cuál usar y cuándo?

Git tiene varios comandos para deshacer cambios, lo que suele confundir a los principiantes. Primero, vamos a organizar de forma simple el papel y el uso de cada uno.

• git checkout: Se usa cuando quieres deshacer cambios en tu directorio de trabajo sin haber hecho commit. Es ideal para situaciones como: "¡Al final, no quiero ninguno de estos cambios en este archivo!".
• git reset: Se usa para cancelar un commit en el repositorio local que aún no has subido con push. Es un comando potente que hace que un commit "nunca haya existido", pero como reescribe la historia, no debe usarse en repositorios remotos ya compartidos.
• git revert: Se usa para deshacer un commit que ya ha sido subido con push y es público. No borra el commit, sino que crea un "nuevo commit que anula los cambios del commit especificado". Es una forma segura de corregir el historial, por lo que es un comando esencial en el desarrollo en equipo.

Para que te hagas una idea, la diferencia es que `reset` es como "viajar al pasado en una máquina del tiempo y borrar el futuro (el commit)", mientras que `revert` es como "publicar un nuevo artículo para corregir un error del pasado".

¡En la práctica! Procedimientos para "deshacer" según la situación

Ahora, veamos cómo usar cada comando en escenarios concretos.

Caso 1: Descartar cambios en curso sin hacer commit (`checkout`)

Este es el caso en el que has editado un archivo pero decides que "al final, no quiero ninguno de estos cambios". Es la forma más sencilla de deshacer cambios antes de prepararlos para el commit (staging).

Primero, modifica un archivo para practicar. Luego, al comprobar con `git status`, el archivo aparecerá como "modified". Para descartar este cambio, ejecuta el siguiente comando.

git checkout -- [nombre_del_archivo]

Por ejemplo, si quieres deshacer los cambios en `index.html`, sería así:

git checkout -- index.html

Al ejecutar este comando, el archivo especificado volverá completamente al estado del último commit. ¡Atención: los cambios eliminados con esta operación no se pueden recuperar!

Caso 2: Cancelar el último commit (antes de hacer push) (`reset`)

Este es el caso para deshacer un error local cuando piensas: "¡Hice commit, pero me equivoqué!", y aún no lo has compartido con nadie (no has hecho push). `reset` tiene varias opciones, pero aquí te presentamos las más comunes.

Primero, comprueba el historial de commits con `git log --oneline` para asegurarte de que el commit que quieres deshacer es el último.

git log --oneline

Opción 1: --soft (Cancela solo el commit, mantiene los cambios)
Se usa cuando quieres cancelar solo el último commit, pero mantener los cambios de ese commit en el área de preparación (staging area). Es útil para cuando "te equivocaste en el mensaje del commit".

git reset --soft HEAD^

Opción 2: --mixed (Cancela el commit y el staging)
Se usa cuando quieres cancelar el último commit y devolver los cambios al directorio de trabajo. Es el comportamiento por defecto del comando `reset`. Es útil para cuando "se te olvidó añadir un archivo", permitiéndote resetear, y luego hacer `add` y `commit` de nuevo.

git reset --mixed HEAD^

Opción 3: --hard (Elimina por completo el commit y los cambios)
Se usa cuando quieres borrar por completo y sin dejar rastro el último commit y sus cambios. Es un comando peligroso, ya que los cambios en los archivos no se podrán recuperar, así que úsalo con mucho cuidado.

git reset --hard HEAD^

HEAD^ se refiere al "commit anterior". Si quieres retroceder dos commits, puedes especificar `HEAD^^` o `HEAD~2`.

Caso 3: Deshacer un commit que ya ha sido subido con push (`revert`)

Si estás trabajando en equipo, borrar un commit que ya ha sido subido con `reset` puede crear conflictos con el historial de otras personas y causar una gran confusión. Por eso, para deshacer un commit que ya es público, siempre debes usar `revert`.

`revert` crea automáticamente un "nuevo commit" que anula todos los cambios del commit que especifiques. Es un método seguro que no borra la historia, sino que añade una nueva historia que corrige el error.

Primero, usa `git log` para encontrar el ID (hash) del commit que quieres deshacer.

git log

Copia el hash del commit que quieres deshacer (ej: `1a2b3c4d`) y ejecuta el siguiente comando.

git revert 1a2b3c4d

Al ejecutarlo, se abrirá una pantalla de edición del mensaje del commit. Si estás de acuerdo con el mensaje por defecto, simplemente guárdalo y ciérralo. Con esto, se creará un "commit de reversión". Finalmente, haz `push` de ese commit para que la corrección se refleje también en el repositorio remoto.

【Copia y pega para probar】Ejemplo de HTML para practicar

Para probar las operaciones de Git, es útil tener un archivo al que realmente puedas hacerle cambios. Guarda el siguiente código HTML con un nombre como `practice.html` y prueba a usar `add`, `commit`, `checkout`, `reset`, etc., con este archivo.

<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <title>Página de Práctica de Git</title>
    <style>
        body { font-family: sans-serif; text-align: center; margin-top: 50px; }
        .box { width: 200px; height: 200px; margin: 20px auto; border: 2px solid #333; display: flex; justify-content: center; align-items: center; font-size: 1.5rem; }
        .box.red { background-color: #ffcccc; }
        .box.blue { background-color: #cceeff; }
        button { padding: 10px 20px; font-size: 1rem; cursor: pointer; }
    </style>
</head>
<body>
    <h1>Practicando Operaciones de Git</h1>
    <div id="colorBox" class="box">Texto aquí</div>
    <button id="changeColorBtn">Cambiar Color</button>
    <script>
        const colorBox = document.getElementById('colorBox');
        const changeColorBtn = document.getElementById('changeColorBtn');
        changeColorBtn.addEventListener('click', () => {
            if (colorBox.classList.contains('red')) {
                colorBox.classList.remove('red');
                colorBox.classList.add('blue');
                colorBox.textContent = '¡Cambiado a Azul!';
            } else {
                colorBox.classList.remove('blue');
                colorBox.classList.add('red');
                colorBox.textContent = '¡Cambiado a Rojo!';
            }
        });
    </script>
</body>
</html>

Conclusión: Elige el comando óptimo para cada situación

Para terminar, resumamos de forma sencilla el uso de los tres comandos para deshacer cambios.

• Descartar cambios sin commit → git checkout -- [nombre_del_archivo]
• Cancelar un commit local → git reset [opción] HEAD^
• Anular un commit ya público → git revert [commit_id]

Si dominas estos tres, ya no tendrás que tenerle miedo a los errores de operación en Git. ¡Escribe código y haz commits con confianza!