Git commit – Guardar cambios

Git commit es una herramienta pensada para registrar la evolución de un proyecto. Permite guardar un punto de control con todos los cambios preparados previamente. En este artículo aprenderás qué es, para qué sirve, cómo utilizarlo paso a paso y verás ejemplos reales para comprender cuándo conviene crear un commit.

1. ¿Qué es git commit?

El comando git commit se utiliza para guardar de forma permanente en el repositorio local todos los archivos que previamente fueron agregados al área de preparación (Staging Area) mediante git add (Agregar archivos).

Cada commit representa una versión del proyecto en un momento determinado. Esto permite consultar el historial, regresar a versiones anteriores o comparar cambios realizados a lo largo del desarrollo.

En otras palabras:

• git add prepara los archivos.
• git commit guarda esa preparación como una nueva versión.

Sin un commit, Git sabe que modificaste archivos, pero todavía no los considera una nueva versión del proyecto.

2. ¿Para qué sirve?

El objetivo principal de git commit es crear un registro seguro del estado del proyecto.

Algunas de sus principales utilidades son:

• Guardar el avance del proyecto.
• Crear un historial de cambios.
• Poder volver a versiones anteriores.
• Facilitar el trabajo en equipo.
• Saber quién realizó cada modificación.
• Resolver errores comparando versiones anteriores.
• Compartir posteriormente esos cambios mediante GitHub u otros servidores remotos.

Cada commit funciona como una fotografía del proyecto en un instante determinado.

3. ¿Cómo funciona?

Antes de ejecutar un commit existe un pequeño flujo de trabajo.

Modificar archivos
        ↓
git status
        ↓
git add
        ↓
git commit
        ↓
Nueva versión del proyecto

Es importante comprender que Git solamente guarda los archivos que fueron agregados previamente con git add.

Los cambios que no pasen por el Staging Area no formarán parte del commit.

4. Sintaxis de git commit

La forma más utilizada es:

git commit -m "Mensaje descriptivo"Lenguaje del código: JavaScript (javascript)

Por ejemplo:

git commit -m "Crear página de contacto"Lenguaje del código: JavaScript (javascript)

o

git commit -m "Corregir error en el menú principal"Lenguaje del código: JavaScript (javascript)

El parámetro -m permite escribir el mensaje del commit directamente desde la terminal.

5. ¿Qué sucede cuando ejecutamos git commit?

Cuando Git recibe este comando realiza varias tareas automáticamente.

• Crea un nuevo commit.
• Genera un identificador único (Hash).
• Guarda la fecha y hora.
• Guarda el autor del cambio.
• Guarda el mensaje del commit.
• Actualiza el historial del repositorio.
• Mueve el puntero HEAD al nuevo commit.

Todo esto ocurre en apenas unos segundos.

6. Paso a paso: cómo usar git commit

Supongamos que estamos creando una página web desde Visual Studio Code.

OJO! Y queremos hacer un commit usando la terminal de git desde este editor (recomendado si estamos aprendiendo)

Paso 1. Modificar un archivo

Tenemos un archivo llamado:

index.htmlLenguaje del código: CSS (css)

Agregamos un nuevo título:

<h1>Mi sitio web</h1>Lenguaje del código: HTML, XML (xml)

Git detectará que el archivo fue modificado.

Paso 2. Verificar los cambios

Ejecutamos:

git status

Resultado:

modified: index.htmlLenguaje del código: CSS (css)

Esto significa que el archivo cambió, pero todavía no está preparado para guardarse.

Paso 3. Agregar el archivo al Staging Area

git add index.htmlLenguaje del código: CSS (css)

Ahora Git sabe que ese archivo formará parte del próximo commit.

Podemos comprobarlo nuevamente:

git status

Ahora veremos algo parecido a:

Changes to be committed

Paso 4. Crear el commit

Ahora sí ejecutamos:

git commit -m "Agregar título principal"Lenguaje del código: JavaScript (javascript)

Salida aproximada:

[main 4a6f9d2] Agregar título principal
 1 file changed, 1 insertion(+)Lenguaje del código: CSS (css)

Listo.

El cambio quedó guardado como una nueva versión del proyecto.

Ejemplo completo del flujo de trabajo

git status

git add index.html

git status

git commit -m "Agregar encabezado principal"

git logLenguaje del código: JavaScript (javascript)

Este es probablemente el flujo más repetido durante todo el desarrollo de cualquier proyecto.

7. Cómo hacer un git commit sin usar la terminal en VS Code

Visual Studio Code incorpora una interfaz gráfica para Git que permite realizar commits sin necesidad de escribir comandos en la terminal.

A continuación, verás el proceso completo paso a paso.

Paso 1: Abrir el panel de Control de código fuente

Con tu proyecto abierto en Visual Studio Code, haz clic en el icono Control de código fuente (Source Control) que aparece en la barra lateral izquierda.

Si existen archivos modificados, aparecerá un número indicando la cantidad de cambios detectados por Git.

Paso 2. Revisar los archivos modificados

Dentro del panel verás todos los archivos que fueron modificados.

Por ejemplo:

index.html

estilos.css

script.jsLenguaje del código: CSS (css)

Puedes hacer clic sobre cualquiera de ellos para visualizar exactamente qué líneas fueron agregadas, eliminadas o modificadas.

Esto te permite revisar tus cambios antes de guardarlos.

Paso 3. Agregar los archivos al Staging Area

Ahora debes indicar qué archivos formarán parte del commit.

Tienes dos opciones:

• Hacer clic en el botón + que aparece junto a un archivo para agregar solamente ese archivo.
• Hacer clic en + (Stage All Changes) para agregar todos los archivos modificados de una sola vez.

Una vez agregados, los archivos pasarán desde la sección Changes hacia la sección Staged Changes.

Esto equivale a ejecutar el siguiente comando desde la terminal:

git add .

Paso 4. Escribir el mensaje del commit

En la parte superior del panel encontrarás un cuadro de texto.

Allí debes escribir un mensaje que describa claramente el cambio realizado.

Por ejemplo:

Agregar formulario de contacto

o

Corregir error en el menú principal

Un buen mensaje facilitará entender el historial del proyecto en el futuro.

Paso 5. Crear el commit

Una vez escrito el mensaje, haz clic en el botón Commit (✓) que aparece en la parte superior del panel de Control de código fuente.

Visual Studio Code ejecutará automáticamente el proceso y guardará una nueva versión del proyecto en el repositorio local.

No es necesario abrir la terminal para realizar esta acción.

Ejemplo práctico

Supongamos que realizaste los siguientes cambios:

• Agregaste una nueva sección al archivo index.html.
• Cambiaste los colores en estilos.css.
• Corregiste un error en script.js.

El proceso sería:

1. Abrir Control de código fuente.
2. Revisar los archivos modificados.
3. Hacer clic en Stage All Changes (+).
4. Escribir el mensaje:

Actualizar diseño de la página principal

5. Hacer clic en Commit (✓).

En pocos segundos, todos los cambios quedarán registrados como una nueva versión del proyecto.

Ventajas de hacer un commit desde la interfaz gráfica

Trabajar desde el panel de Git de Visual Studio Code ofrece varias ventajas:

• No es necesario memorizar comandos.
• Permite visualizar fácilmente los archivos modificados.
• Puedes comparar los cambios antes de confirmarlos.
• Es posible seleccionar únicamente los archivos que deseas incluir en el commit.
• Resulta muy intuitivo para quienes están dando sus primeros pasos con Git.

¿La interfaz gráfica hace lo mismo que la terminal?

Sí. Aunque el proceso se realiza mediante botones, Visual Studio Code ejecuta internamente los mismos comandos de Git que escribirías en la terminal.

Por ejemplo, al agregar archivos mediante el botón +, VS Code ejecuta internamente un git add. Del mismo modo, al hacer clic en Commit (✓) después de escribir un mensaje, ejecuta un git commit -m "mensaje".

La única diferencia es la forma de interactuar con Git: la terminal utiliza comandos escritos, mientras que la interfaz gráfica permite realizar las mismas acciones mediante clics. Ambas opciones generan exactamente el mismo resultado en el repositorio.

8. Cómo escribir buenos mensajes en git commit

El mensaje del commit debe explicar qué cambio se realizó.

Buenos ejemplos:

git commit -m "Agregar formulario de contacto"Lenguaje del código: JavaScript (javascript)

git commit -m "Corregir error en el menú"Lenguaje del código: JavaScript (javascript)

git commit -m "Actualizar estilos del encabezado"Lenguaje del código: JavaScript (javascript)

git commit -m "Optimizar carga de imágenes"Lenguaje del código: JavaScript (javascript)

Malos ejemplos:

git commit -m "Cambios"Lenguaje del código: JavaScript (javascript)

git commit -m "Hola"Lenguaje del código: JavaScript (javascript)

git commit -m "Prueba"Lenguaje del código: JavaScript (javascript)

Estos mensajes no ayudan a entender el historial del proyecto.

9. Casos reales donde normalmente se utiliza

9.1. Cuando terminamos una nueva funcionalidad

Supongamos que agregamos un formulario de contacto completo.

Al finalizar podemos guardar ese avance.

git commit -m "Agregar formulario de contacto"Lenguaje del código: JavaScript (javascript)

Así podremos regresar exactamente a ese punto si algo sale mal más adelante.

9.2. Después de corregir un error

Encontramos un problema en el menú de navegación.

Lo solucionamos.

Luego ejecutamos:

git commit -m "Corregir enlaces del menú principal"Lenguaje del código: JavaScript (javascript)

Quedará registrado exactamente cuándo fue solucionado el error.

9.3. Después de crear una nueva página

Creamos una página llamada:

nosotros.htmlLenguaje del código: CSS (css)

Una vez terminada:

git commit -m "Crear página Nosotros"Lenguaje del código: JavaScript (javascript)

9.4. Luego de mejorar el diseño

Modificamos varios estilos CSS.

Cuando finalizamos:

git commit -m "Mejorar diseño responsive"Lenguaje del código: JavaScript (javascript)

9.5. Antes de comenzar un cambio importante

Supongamos que vamos a rehacer completamente el menú del sitio.

Antes de hacerlo es recomendable guardar el estado actual.

git commit -m "Guardar versión estable antes de rediseñar el menú"Lenguaje del código: JavaScript (javascript)

Si el nuevo diseño falla podremos volver fácilmente.

9.6. Antes de actualizar una librería

Queremos actualizar Bootstrap.

Antes hacemos un commit.

git commit -m "Guardar proyecto antes de actualizar Bootstrap"Lenguaje del código: JavaScript (javascript)

Si aparece algún problema podremos regresar rápidamente.

9.7. Cuando trabajamos en equipo

Cada desarrollador crea commits con los cambios que realizó.

Por ejemplo:

git commit -m "Agregar validación del formulario de registro"Lenguaje del código: JavaScript (javascript)

Otro compañero podrá identificar fácilmente qué hizo cada integrante.

¿Cada cuánto conviene hacer un commit?

Una buena práctica es realizar commits pequeños y frecuentes.

Conviene hacer un commit cuando:

• Terminaste una funcionalidad.
• Solucionaste un error.
• Agregaste una nueva página.
• Finalizaste una sección del proyecto.
• El proyecto quedó en un estado estable.

No conviene esperar varios días para hacer un único commit enorme.

Los commits pequeños hacen que el historial sea mucho más fácil de entender.

10. Errores comunes al usarlo

10.1. Intentar hacer un commit sin usar git add

Si olvidamos ejecutar:

git add

El commit no incluirá los cambios.

Siempre verifica con:

git status

antes de crear un commit.

10.2. Escribir mensajes poco descriptivos

Mensajes como:

Cambios

o

Prueba

no aportan información.

Lo ideal es describir claramente qué se modificó.

10.3. Agrupar demasiados cambios

No es recomendable modificar veinte archivos distintos y guardar todo en un único commit si corresponden a tareas diferentes.

Es mejor crear varios commits pequeños.

Ejemplo:

Agregar login

Corregir menú

Actualizar estilos

Crear página contacto

Cada uno representa una tarea concreta.

11. Diferencia entre git add y git commit

Muchos principiantes confunden estos dos comandos.

git add	git commit
Prepara los archivos	Guarda una nueva versión
Lleva archivos al Staging Area	Guarda el contenido del Staging Area
Puede ejecutarse varias veces	Crea un nuevo commit
Todavía no guarda una versión	Sí crea una nueva versión del proyecto

Una forma sencilla de recordarlo es:

• git add selecciona qué cambios quieres guardar.
• git commit los convierte en una nueva versión del proyecto.

12. Buenas prácticas

Para mantener un historial claro y útil, es recomendable seguir estas prácticas:

• Haz commits pequeños y enfocados en una sola tarea.
• Escribe mensajes claros y específicos.
• Verifica el estado con git status antes de confirmar los cambios.
• Revisa las modificaciones con git diff cuando tengas dudas.
• Realiza commits con frecuencia para no perder trabajo.
• Guarda únicamente cambios que estén probados y funcionen correctamente.

Estas recomendaciones facilitan el mantenimiento del proyecto y hacen que el historial de Git sea mucho más fácil de entender para ti y para otros desarrolladores.

13. Resumen

git commit es uno de los comandos más importantes de Git porque permite guardar una nueva versión del proyecto en el repositorio local. Cada commit registra los cambios preparados previamente con git add, junto con un mensaje descriptivo, la fecha, el autor y un identificador único.

Crear commits pequeños, frecuentes y con mensajes claros te permitirá mantener un historial organizado, recuperar versiones anteriores con facilidad y colaborar de forma más eficiente en cualquier proyecto, ya sea trabajando solo o en equipo.