# Deshacer sin romper nada

URL canónica: https://missyera.com/guias/git-desde-cero/deshacer/
Última actualización: 2026-11-17
Autora: Gera Flores (Miss Yera)

> **Respuesta corta**
>
> Hay tres comandos para deshacer y se parecen tanto que casi todo el mundo usa el equivocado. <code>restore</code> tira lo que no está guardado, <code>revert</code> crea un commit que anula otro sin borrar nada, y <code>reset</code> mueve la historia hacia atrás. El único que destruye trabajo de verdad es <code>reset --hard</code> ⚠️

Capítulo 7 de 33 del libro [Git desde cero](https://missyera.com/guias/git-desde-cero.md).

![Árbol de decisión para deshacer en Git. Primera pregunta: si ya lo subiste a GitHub, va revert, que anula con un commit nuevo y no borra historia. Si no lo subiste, segunda pregunta: si conservas lo escrito va reset soft, y si no, reset hard, que se pierde de verdad.](https://missyera.com/static/diagramas/webp/git-07-deshacer.webp)

*La pregunta que decide no es cuál comando suena mejor, es si eso ya salió de tu máquina. Lo que otra persona ya se bajó no se puede borrar sin romperle su copia.*

## La tabla que quiero que te lleves

Antes de nada, esto:

| Quiero | Comando | ¿Destruye? |
|---|---|---|
| Tirar lo que edité y no guardé | `git restore archivo` | Sí, eso |
| Sacar algo de la foto | `git restore --staged archivo` | No |
| Anular un commit ya compartido | `git revert hash` | No |
| Deshacer el último commit y quedarme los cambios | `git reset --soft HEAD~1` | No |
| Borrar el último commit y todo lo que traía | `git reset --hard HEAD~1` | Sí, todo |

Guárdala. Yo la tuve pegada en la pantalla meses 📌

## Preparo el terreno

```bash
mkdir tienda
cd tienda
git init -q
printf 'ciudad,monto\nLima,1200\n' > ventas.csv
git add ventas.csv
git commit -q -m "Primeras ventas de Lima"
printf 'Arequipa,890\n' >> ventas.csv
git add ventas.csv
git commit -q -m "Se agregan las ventas de Arequipa"
git log --oneline
```

```text
571877b Se agregan las ventas de Arequipa
54da6e2 Primeras ventas de Lima
```

## Revert, el que se puede usar sin miedo

`revert` no borra el commit: crea uno nuevo que hace justo lo contrario. La historia crece en vez de encogerse.

```bash
git revert --no-edit HEAD
git log --oneline
```

```text
[main 42cbe91] Revert "Se agregan las ventas de Arequipa"
 Date: Thu Jan 15 09:00:00 2026 -0500
 1 file changed, 1 deletion(-)
42cbe91 Revert "Se agregan las ventas de Arequipa"
571877b Se agregan las ventas de Arequipa
54da6e2 Primeras ventas de Lima
```

Tres commits, no uno. El de Arequipa sigue ahí y encima hay otro que lo deshace. Y el archivo quedó como estaba antes:

```bash
cat ventas.csv
```

```text
ciudad,monto
Lima,1200
```

Este es **el único que se puede usar cuando el commit ya lo tiene otra persona**, porque no cambia nada de lo que ya estaba. Los demás reescriben, y eso se cuenta en el capítulo 10.

## Reset soft, deshacer el commit y quedarte lo hecho

```bash
git reset --soft HEAD~1
git log --oneline
git status --short
```

```text
571877b Se agregan las ventas de Arequipa
54da6e2 Primeras ventas de Lima
M  ventas.csv
```

El commit del revert desapareció de la historia, pero su contenido se quedó en la foto, listo para volver a guardarse. Es lo que uso cuando hice un commit antes de tiempo o con el mensaje mal.

## Reset hard, el que sí borra

```bash
git reset --hard HEAD
printf 'Cusco,760\n' >> ventas.csv
git reset --hard HEAD
cat ventas.csv
```

```text
HEAD is now at 571877b Se agregan las ventas de Arequipa
HEAD is now at 571877b Se agregan las ventas de Arequipa
ciudad,monto
Lima,1200
Arequipa,890
```

Cusco no está. No se fue a ningún sitio recuperable: **nunca llegó a un commit**, así que Git no tiene de dónde sacarlo.

Este es el único comando de todo el libro que destruye trabajo de verdad, y por eso el capítulo 8 existe: hay una forma de guardar lo que llevas antes de limpiar.

## El error de anular un commit que no existe

```bash
git revert --no-edit abc1234
```

```
fatal: bad revision 'abc1234'
```

*Bad revisión*: ese hash no está en esta historia. Suele pasar cuando copias un hash de otra rama o de un mensaje viejo.

La trampa

Llevas dos horas con el análisis de las ventas por canal, se te enreda todo y decides empezar de nuevo desde el último commit.

```
$ git reset --hard HEAD

HEAD is now at 8a2b19c Ventas por canal de Lima
```

**Qué está mal**

Esas dos horas ya no existen 💀

`reset --hard` es el único comando de este libro que borra trabajo **sin posibilidad de recuperarlo**. Lo que nunca llegó a un commit no está en ningún lado, así que Git tampoco lo puede devolver.

Lo peligroso es que se parece a los otros: `restore`, `revert` y `reset` suenan igual de inocentes y hacen cosas muy distintas. Por eso este capítulo trae la tabla de cuál usar cuándo, y por eso conviene leerla antes de necesitarla.

La red de seguridad se pone en un segundo: `git stash` guarda lo que llevas antes de limpiar. Después decides si lo recuperas o no.

## Comprueba que se entendió

Comprueba que lo tienes

Subiste un commit que ya se llevaron dos compañeras y hay que anularlo. ¿Qué usas?

- `git reset --hard`
- `git revert`
- `git restore`
- Borrar el archivo y hacer un commit nuevo

## Ejercicios

**1. Tira un cambio que no querías**

Escribe un monto mal en el CSV y descártalo.

```bash
printf 'Piura,99999999\n' >> ventas.csv
git restore ventas.csv
cat ventas.csv
```

```text
ciudad,monto
Lima,1200
Arequipa,890
```

El archivo volvió a lo último guardado. Es lo que quieres nueve de cada diez veces que dices "deshacer" 🔙

**2. Saca algo de la foto sin perderlo**

Agrega un archivo de clientes, mételo en la foto y después sácalo.

```bash
printf 'bodega,ciudad\nBodega Sol,Lima\n' > clientes.csv
git add clientes.csv
git restore --staged clientes.csv
git status --short
```

```text
?? clientes.csv
```

Las dos interrogaciones dicen que Git volvió a no conocerlo, y el archivo sigue en tu carpeta. Ese `--staged` es la diferencia entre sacar de la foto y borrar 🙌

**3. Un commit y su anulación**

Guarda el archivo de clientes y después anúlalo con revert.

```bash
git add clientes.csv
git commit -q -m "Se agrega el catalogo de clientes"
git revert --no-edit HEAD
git log --oneline
```

```text
[main 5972d6a] Revert "Se agrega el catalogo de clientes"
 Date: Thu Jan 15 09:00:00 2026 -0500
 1 file changed, 2 deletions(-)
 delete mode 100644 clientes.csv
5972d6a Revert "Se agrega el catalogo de clientes"
e4eb86b Se agrega el catalogo de clientes
571877b Se agregan las ventas de Arequipa
54da6e2 Primeras ventas de Lima
```

Los dos commits en la historia: el que puso el archivo y el que lo quitó. Nadie borró nada y se puede reconstruir todo.

**4. Comprueba que el archivo se fue**

Mira qué hay en la carpeta después del revert.

```bash
ls
```

```text
ventas.csv
```

`clientes.csv` ya no está, porque el revert deshizo lo que el commit había hecho. Y sigue estando en la historia, a un `git show` de distancia.

**5. Deshaz el commit pero quédate lo hecho**

Usa `--soft` sobre el revert y mira dónde quedan las cosas.

```bash
git reset --soft HEAD~1
git log --oneline
git status --short
```

```text
e4eb86b Se agrega el catalogo de clientes
571877b Se agregan las ventas de Arequipa
54da6e2 Primeras ventas de Lima
D  clientes.csv
```

La `D` en la primera columna significa que el borrado está en la foto, listo para guardarse otra vez. El commit se fue; su contenido no.

**6. Vuelve al último commit y limpia**

Descarta todo lo que hay pendiente con un reset duro.

```bash
git reset --hard HEAD
git status --short
ls
```

```text
HEAD is now at e4eb86b Se agrega el catalogo de clientes
clientes.csv
ventas.csv
```

Estado limpio y el archivo de clientes de vuelta, porque el commit que lo creaba volvió a ser el último. Aquí `--hard` no destruyó nada porque no había nada sin guardar ✅

**7. Un hash inventado**

Intenta anular un commit que no existe.

```bash
git revert --no-edit 0000000
```

```
fatal: bad revision '0000000'
```

Antes de pelearte con un comando, comprueba que el hash existe con `git log --oneline`. La mitad de los errores raros de Git son un hash mal copiado 📋

## Lo que te llevas

**revert nunca destruye, reset --hard siempre puede. Si dudas, usa revert.**

## Seguir leyendo

- Anterior: [Leer la historia sin abrir un archivo](https://missyera.com/guias/git-desde-cero/leer-la-historia.md)
- Siguiente: [Cambiar de tarea a mitad de camino](https://missyera.com/guias/git-desde-cero/guardar-a-medias.md)

## Contacto

- Diagnóstico de 30 minutos con Miss Yera: https://calendly.com/soymissyera/reunion-con-yera
- Correo: hola@missyera.com
- Esta página en HTML: https://missyera.com/guias/git-desde-cero/deshacer/
- Índice de todas las páginas en texto: https://missyera.com/llms-index.txt
