RECURSOS DE PROGRAMACIÓN

Git: comandos esenciales

Comandos habituales para trabajar con repositorios, ramas, commits, sincronización y resolución de cambios.

FUNDAMENTOS

Qué es Git y cómo pensar en él

Git es un sistema de control de versiones distribuido. Permite registrar la evolución de un proyecto, comparar cambios, recuperar versiones anteriores y coordinar el trabajo entre varias personas.

Para trabajar con Git conviene distinguir cuatro zonas. Entenderlas evita muchos de los errores habituales al empezar.

Zona	Función	Ejemplo
Directorio de trabajo	Archivos que estamos editando actualmente.	`app.py`modificado en el editor
Staging area	Cambios seleccionados para el próximo commit.	`git add app.py`
Repositorio local	Historial de commits almacenado en nuestro equipo.	`git commit`
Repositorio remoto	Copia compartida alojada en GitHub, GitLab u otro servidor.	`git push`

Una idea importante: guardar un archivo no significa crear un commit. Git solo registra una nueva versión cuando seleccionamos los cambios y hacemos un commit.

Editar archivos ↓
git add ↓
Staging area ↓
git commit ↓
Repositorio local ↓
git push ↓
Repositorio remoto

PRIMEROS PASOS

Configuración inicial

Antes de crear commits conviene configurar el nombre y el correo que quedarán asociados al historial del repositorio.

git config --global user.name "Tu nombre"
git config --global user.email "tu@ejemplo.com"

Podemos consultar la configuración activa con:

git config --list

La opción --globalaplica la configuración a todos los repositorios del usuario. Si queremos configurar únicamente el repositorio actual, podemos omitirla.

git config user.email "correo-proyecto@ejemplo.com"

REPOSITORIOS

Crear o clonar un repositorio

Si empezamos un proyecto desde cero, podemos convertir la carpeta actual en un repositorio Git mediante git init.

mkdir proyecto-demo
cd proyecto-demo
git init

Si el proyecto ya existe en un servidor remoto, normalmente lo descargaremos mediante git clone.

git clone https://github.com/usuario/proyecto.git
cd proyecto

git cloneno descarga únicamente los archivos actuales: también obtiene el historial del repositorio y configura normalmente un remoto llamado origin.

FLUJO DE TRABAJO

El ciclo habitual: status, add y commit

El comando que conviene utilizar con más frecuencia al aprender Git es git status. Nos indica qué archivos se han modificado, cuáles están preparados y cuál es la situación de la rama actual.

git status

Después seleccionamos los cambios que queremos incluir en el siguiente commit. Es preferible comprender qué estamos añadiendo en lugar de utilizar git add .de forma automática.

git add src/app.py
git add README.md

Podemos revisar lo preparado antes de confirmar:

git diff --staged

Finalmente registramos el cambio:

git commit -m "Añade validación del formulario"

Un buen commit debería representar un cambio lógico y comprensible. Suele ser preferible realizar varios commits pequeños y descriptivos que acumular muchos cambios no relacionados.

INSPECCIÓN

Examinar cambios antes de confirmarlos

Git permite comparar el estado actual de los archivos con otras versiones del proyecto. Esta capacidad resulta especialmente útil para revisar qué hemos cambiado antes de hacer commit.

Mostrar modificaciones todavía no añadidas al staging:

git diff

Mostrar cambios ya preparados:

git diff --staged

Examinar únicamente un archivo:

git diff src/app.py

Revisar el diff ayuda a detectar código de prueba, archivos modificados accidentalmente o cambios que deberían pertenecer a otro commit.

HISTORIAL

Consultar commits y cambios anteriores

El historial es una de las principales ventajas de un sistema de control de versiones. Podemos consultar los commits realizados y examinar qué cambió en cada uno.

git log

Una vista compacta:

git log --oneline

Para visualizar ramas y bifurcaciones:

git log --oneline --graph --decorate --all

Examinar un commit concreto:

git show a1b2c3d

El identificador completo de un commit es un hash. Normalmente podemos utilizar sus primeros caracteres si bastan para identificarlo de forma única.

RAMAS

Trabajar sin modificar directamente la rama principal

Las ramas permiten desarrollar una funcionalidad o corrección de forma aislada. El repositorio puede mantener una rama principal estable mientras el trabajo continúa en otra rama.

Consultar las ramas disponibles:

git branch

Crear una rama y cambiar directamente a ella:

git switch -c mejora-formulario

Volver a la rama principal:

git switch main

Integrar los commits de la rama:

git merge mejora-formulario

En versiones antiguas de Git es habitual encontrar git checkout. Actualmente, git switchexpresa de forma más clara las operaciones de cambio de rama.

TRABAJO REMOTO

Origin, fetch, pull y push

Un repositorio local puede estar conectado con uno o varios repositorios remotos. El nombre origines una convención habitual para identificar el remoto principal creado al clonar un proyecto.

Consultar los remotos configurados:

git remote -v

fetchobtiene información del remoto sin integrar automáticamente los cambios.

git fetch origin

Consultar commits que existen en el remoto pero no en nuestra rama:

git log --oneline main..origin/main

pulldescarga los cambios y después los integra siguiendo la configuración del repositorio.

git pull origin main

Para publicar nuestros commits:

git push origin main

COLABORACIÓN

Qué ocurre cuando aparece un conflicto

Un conflicto aparece cuando Git no puede decidir automáticamente cómo combinar dos cambios. Por ejemplo, dos personas pueden haber modificado las mismas líneas de un archivo.

Git puede mostrar marcas similares a estas:

<<<<<<< HEAD
mensaje="Versión local"=======mensaje="Versión remota"
>>>>>>> rama-remota

Resolver el conflicto consiste en editar manualmente el archivo y conservar el contenido correcto. Después se marca como resuelto y se continúa con el commit.

git status
git add archivo-conflictivo.py
git commit

CAMBIOS TEMPORALES

Guardar trabajo sin crear un commit

A veces necesitamos cambiar de rama pero todavía no queremos crear un commit con el trabajo actual. git stashpermite guardar temporalmente esos cambios.

git stash push -m "Formulario pendiente"

Consultar los elementos guardados:

git stash list

Recuperar el último:

git stash pop

RECUPERACIÓN

Deshacer cambios con criterio

Git dispone de varias formas de volver atrás, pero no todas tienen el mismo efecto. Antes de ejecutar un comando de recuperación conviene saber si el cambio está únicamente en el directorio de trabajo, en staging o ya forma parte de un commit.

Descartar cambios no preparados de un archivo:

git restore archivo.py

Atención:si esos cambios no están guardados en otro lugar, pueden perderse.

Sacar un archivo del staging sin eliminar sus modificaciones:

git restore --staged archivo.py

Anular un commit mediante un nuevo commit inverso:

git revert a1b2c3d

Comandos como git reset --hard, git cleano git push --forcepueden eliminar trabajo o reescribir historial. No deberían utilizarse sin comprender sus consecuencias.

BUENAS PRÁCTICAS

Evitar archivos innecesarios con .gitignore

No todos los archivos de un proyecto deben almacenarse en Git. Dependencias descargadas, archivos temporales y configuraciones locales suelen quedar fuera del repositorio.

# Entorno virtual de Python
.venv/ # Dependencias JavaScript
node_modules/ # Archivos temporales
*.log # Configuración local
.env # IDE
.vscode/

Si un archivo ya está siendo rastreado por Git, añadirlo posteriormente a .gitignoreno lo elimina automáticamente del historial.

VERSIONES

Etiquetar versiones del proyecto

Las etiquetas permiten identificar commits importantes, por ejemplo una versión publicada de una aplicación.

git tag v1.0.0

Consultar etiquetas:

git tag

Publicar una etiqueta concreta:

git push origin v1.0.0

EJEMPLO PRÁCTICO

Un flujo completo de trabajo

# Actualizar información del remoto
git fetch origin # Actualizar la rama principal
git switch main
git pull origin main # Crear una rama de trabajo
git switch -c feature/validacion-email # Editar los archivos... # Revisar cambios
git status
git diff # Preparar archivos
git add src/formulario.py
git add tests/test_formulario.py # Revisar staging
git diff --staged # Crear el commit
git commit -m "Añade validación de correo electrónico" # Publicar la rama
git push -u origin feature/validacion-email

Este flujo separa la funcionalidad de la rama principal, permite revisar los cambios antes del commit y deja la rama disponible en el repositorio remoto para revisión o integración.

PRÁCTICA PROPUESTA

Ejercicio para afianzar el flujo de Git

Crea una carpeta llamada practica-gite inicializa un repositorio.
Crea un archivo README.md.
Consulta el estado con git status.
Añade el archivo al staging y crea el primer commit.
Crea una rama llamada feature/documentacion.
Modifica el README y añade un segundo archivo.
Utiliza git diffantes de preparar los cambios.
Crea un commit en la nueva rama.
Regresa a maine integra la rama.
Consulta el historial con git log --oneline --graph --decorate --all.

ERRORES HABITUALES

Problemas frecuentes al empezar con Git

Situación	Qué revisar
El archivo no aparece en el commit	Comprueba `git status`y si se añadió al staging.
He trabajado en la rama equivocada	Revisa la rama activa antes de empezar a modificar archivos.
El push es rechazado	Puede haber cambios remotos que todavía no tienes localmente.
Aparece un conflicto	Revisa los archivos indicados por Git y resuelve manualmente las diferencias.
.gitignore no ignora un archivo	Comprueba si ese archivo ya estaba siendo rastreado.
No sé qué ha cambiado	Usa `git status`, `git diff`y `git log`.

CRITERIO PROFESIONAL

Buenas prácticas de trabajo

Consulta git statusantes y después de operaciones importantes.
Revisa git diffantes de preparar un cambio.
Crea commits pequeños y coherentes.
Utiliza mensajes de commit descriptivos.
No almacenes contraseñas, claves API ni secretos.
Utiliza ramas para funcionalidades o cambios independientes.
Actualiza el repositorio antes de integrar cambios en proyectos colaborativos.
No utilices comandos destructivos simplemente para hacer desaparecer un error.

REFERENCIA RÁPIDA

Comandos esenciales

Acción	Comando
Estado	`git status`
Ver cambios	`git diff`
Preparar archivo	`git add archivo`
Crear commit	`git commit -m "mensaje"`
Historial breve	`git log --oneline`
Crear rama	`git switch -c nombre-rama`
Cambiar rama	`git switch nombre-rama`
Integrar rama	`git merge nombre-rama`
Consultar remotos	`git remote -v`
Descargar referencias	`git fetch origin`
Actualizar rama	`git pull`
Publicar commits	`git push`
Guardar temporalmente	`git stash`
Recuperar stash	`git stash pop`
Crear etiqueta	`git tag v1.0.0`

PARA AMPLIAR