Introducción

En el lenguaje cotidiano "guardas" un documento, pero en Git la acción equivalente se llama commit. Un commit registra una instantánea permanente de los archivos preparados y sus cambios en el historial del repositorio. A diferencia de presionar Guardar en un editor, un commit no sobrescribe la versión anterior — añade una nueva entrada a una línea de tiempo que puedes revisar, comparar o revertir en cualquier momento.

Esta página es un mapa de los comandos que usas para guardar cambios localmente y prepararlos para compartirlos. Cada sección enlaza a un capítulo dedicado con todas las opciones y ejemplos.

Las tres áreas por las que pasan los cambios

Para entender cómo se guarda en Git, es útil saber que un archivo puede encontrarse en tres lugares a la vez:

• Directorio de trabajo — los archivos que editas en el disco.
• Área de preparación (también llamada index) — una zona de espera donde ensambles exactamente qué contendrá el próximo commit.
• Repositorio — el historial confirmado, almacenado en la carpeta oculta .git.

Guardar cambios significa moverlos desde el directorio de trabajo, pasando por el área de preparación, hasta el repositorio:

edit files        # changes live in the working directory
git add <file>    # move them into the staging area
git commit        # record them permanently in the repository

El flujo de dos pasos add y luego commit es intencional: te permite confirmar solo una parte de tu trabajo y dejar el resto para después, produciendo commits enfocados y significativos.

git add

El comando git add mueve los cambios del directorio de trabajo al área de preparación. Le indica a Git qué actualizaciones incluir en el próximo commit. Por sí solo, git add no registra nada de forma permanente — debes seguirlo con git commit.

git add index.html      # stage a single file
git add src/            # stage everything under a directory
git add .               # stage all changes in the current directory tree

Ejecuta git status en cualquier momento para ver qué archivos están preparados, modificados o sin seguimiento.

git commit

El comando git commit registra todos los cambios actualmente preparados como una nueva instantánea en el repositorio. Cada commit es un punto permanente en el historial al que puedes volver. Dado que solo se capturan los cambios preparados, git add debe ejecutarse primero.

git commit -m "Add contact form validation"

Usa un mensaje corto y descriptivo en modo imperativo ("Add", "Fix", "Update"). Si omites -m, Git abre el editor configurado para que puedas escribir un mensaje más extenso.

git diff

El comando git diff compara diferentes estados de tu proyecto para que puedas revisar exactamente qué estás a punto de guardar. Por defecto, git diff muestra los cambios no preparados — la diferencia entre tu directorio de trabajo y el área de preparación. Añade --staged para ver qué ya está preparado y listo para confirmar.

git diff             # working directory vs. staging area (not yet staged)
git diff --staged    # staging area vs. last commit (about to be committed)

Revisar un diff antes de confirmar es la mejor forma de evitar guardar código de depuración o ediciones accidentales.

git stash

El comando git stash guarda temporalmente los cambios no confirmados para que tu directorio de trabajo quede limpio — útil cuando necesitas cambiar de tarea o incorporar actualizaciones sin confirmar trabajo a medias. Los cambios se guardan en una pila que puedes volver a aplicar más adelante.

git stash        # set aside current changes and revert to a clean tree
git stash pop    # re-apply the most recent stash and remove it from the stack

.gitignore

Algunos archivos nunca deben confirmarse — salidas de compilación, dependencias, secretos o metadatos del sistema operativo. Git lee un archivo llamado .gitignore para decidir qué rutas omitir. No existe un comando git ignore; tú mismo creas y confirmas este archivo con los patrones que Git debe excluir del seguimiento:

# Dependencies
node_modules/
# OS files
.DS_Store
Thumbs.db
# Secrets
.env

Ten en cuenta que .gitignore solo afecta a los archivos que Git aún no está rastreando. Para dejar de rastrear un archivo que fue confirmado antes de ser ignorado, usa git rm --cached.

Flujo de trabajo típico

Una secuencia estándar para guardar y compartir cambios tiene este aspecto:

git status                          # see what changed
git add .                           # stage the changes
git diff --staged                   # review what is about to be committed
git commit -m "Implement feature"   # save a permanent snapshot
git push origin main                # upload commits to the remote

Los primeros cuatro pasos guardan tu trabajo localmente; git push es lo que lo comparte con un servidor remoto como GitHub.

Deshacer antes de guardar

Si preparas algo por error, puedes sacarlo del área de preparación sin perder tus ediciones:

git restore --staged <file>    # unstage, keep the changes in the working directory
git restore <file>             # discard working-directory changes (cannot be undone)

Para más formas de revertir cambios después de confirmarlos, consulta git reset.

Práctica