Summary  
This chapter covers how to discard uncommitted changes in the working tree using `git restore`, allowing you to reset files either to the staged version or to the latest commit.  

General domain of usage  
Version control with Git

A veces se pueden modificar el **árbol de trabajo** y decidir descartar esos cambios antes de prepararlos para el staging.  
Ahora se exploran métodos para revertir cambios en **Git** antes de que se agreguen al área de staging.

## Descartar cambios con git restore
El comando `git restore` es una herramienta versátil para descartar cambios en el **árbol de trabajo**. Para revertir cambios en archivos modificados antes del staging, se puede utilizar este comando de la siguiente manera:

```bash
git restore <file>
```
Donde `<file>` es el **nombre** de los archivos o su **ruta relativa al directorio del proyecto**. Este comando revierte el archivo especificado a la versión que está **en staging**. Si el área de staging está vacía, revierte el archivo a la versión del **último commit**. 


## Revertir a la versión en staging

Primero, crear un archivo nuevo llamado `recipe.txt` que contenga una **receta sencilla para huevos hervidos** usando el comando `echo`:
```
echo "1. Prepare the Eggs
2. Boil Water
3. Place Eggs in the Saucepan
4. Boil the Eggs
5. Reduce Heat
6. Cook for 6-7 minutes" > recipe.txt
```

Ahora agrega este archivo y modifícalo añadiendo otra línea con el siguiente paso de la receta:
```
git add recipe.txt
```

```
echo "7. Transfer eggs to ice water or run cold water over them" > recipe.txt
```

Ups, se utilizó el **operador incorrecto** — `>` (que sobrescribe el archivo) en lugar de `>>` (que agrega una nueva línea).
Antes de corregirlo, verifica el **estado** del árbol de trabajo y el área de preparación:
```
git status
```

Como puedes ver, la versión inicial del archivo está **preparada** (staged), así que restaura el archivo a esta versión y verifica el **estado** del árbol de trabajo y del área de preparación nuevamente:
```
git restore recipe.txt
```

Como puedes ver, nuestro árbol de trabajo ahora está **limpio**, por lo que los cambios se deshicieron y el archivo volvió a la versión **preparada**.


## Revertir al último commit

Primero, confirmar la creación del archivo `recipe.txt`:
```
git commit -m "Add a file with a simple recipe for boiled eggs"
```

El commit se realiza correctamente.
Ahora agregar **otra línea** al archivo con el siguiente paso de la receta y comprobar el estado del **árbol de trabajo**:
```
echo "10. Transfer eggs to ice water or run cold water over them">> recipe.txt
```

Vaya, ocurrió otro error: el paso añadido debería ser **7**, no **10**.  
No hay problema; puedes revertir este cambio al **último commit**.  
Primero, verifica el último commit:
```
git log -n 1
```

Este commit es exactamente el necesario, así que **restaurar** los cambios a esta versión y verificar que el árbol de trabajo esté **limpio**:
```
git restore recipe.txt
```

El árbol de trabajo está **limpio**, lo que significa que los cambios fueron deshechos y el archivo fue restaurado a la versión del **último commit**.

¿Qué hace el comando `git restore <file>` antes de indexar los cambios?

Git es el sistema de control de versiones más popular, utilizado por millones de desarrolladores en todo el mundo. Tanto si eres un desarrollador experimentado como si eres principiante, este curso te proporcionará los conocimientos y habilidades necesarios para gestionar eficientemente tus proyectos de software, colaborar con otros y dominar el arte del control de versiones.

Primero, se proporcionará una visión general de los sistemas de control de versiones en general. Posteriormente, se abordará Git y se aprenderán los conceptos básicos de la creación de un repositorio y la realización de cambios en él.

Ahora es momento de abordar una interacción más avanzada con Git, lo que aumentará su eficiencia y le permitirá familiarizarse con algunos de los flujos de trabajo comunes en Git.

Como sistema de control de versiones, Git permite deshacer cambios cuando sea necesario, por lo que es momento de descubrir las técnicas en Git para revertir cambios no preparados en el árbol de trabajo, cambios preparados e incluso revertir o sobrescribir commits.

Las ramas en Git son sumamente útiles al colaborar con otras personas, corregir errores o desarrollar ciertas funcionalidades en tu proyecto. Sin más preámbulos, exploremos todos los matices del trabajo con ramas.

Revertir Cambios Antes de Preparar

Descartar cambios con git restore

Revertir a la versión en staging

Revertir al último commit