Hoja de Referencia de Comandos Esenciales de Git para Desarrolladores

31 de marzo de 2026 · 12 min de lectura

Git es la columna vertebral del desarrollo de software moderno. Ya sea que trabajes solo o colabores con un equipo de cientos, dominar los comandos de Git es esencial para un control de versiones eficiente y la gestión de código.

Esta hoja de referencia completa cubre todo, desde operaciones básicas hasta técnicas avanzadas. Guarda esta página en marcadores y consúltala cuando necesites una referencia rápida de comandos de Git.

Configuración e Instalación

Antes de comenzar a usar Git, necesitas configurar tu identidad y preferencias. Estas configuraciones determinan cómo se comporta Git y cómo se atribuyen tus commits.

Configuración Inicial

Ejecuta estos comandos una vez por máquina para configurar tu entorno de Git:

# Establece tu nombre y correo electrónico (requerido)
git config --global user.name "Tu Nombre"
git config --global user.email "[email protected]"

# Establece el nombre de rama predeterminado como 'main'
git config --global init.defaultBranch main

# Habilita salida de color para mejor legibilidad
git config --global color.ui auto

# Establece tu editor de texto preferido
git config --global core.editor "code --wait"  # VS Code
git config --global core.editor "vim"          # Vim
git config --global core.editor "nano"         # Nano

# Ver todas las configuraciones
git config --list

# Ver configuración específica
git config user.name
git config user.email

La bandera --global aplica configuraciones a todos los repositorios en tu máquina. Para configurar ajustes para un solo repositorio, navega a ese repo y omite la bandera --global.

Niveles de Configuración

Git tiene tres niveles de configuración, cada uno anulando el anterior:

Opciones de Configuración Útiles

# Configurar almacenamiento en caché de credenciales (evitar solicitudes repetidas de contraseña)
git config --global credential.helper cache
git config --global credential.helper 'cache --timeout=3600'

# Habilitar conversión automática de finales de línea
git config --global core.autocrlf true   # Windows
git config --global core.autocrlf input  # Mac/Linux

# Configurar alias para comandos comunes
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status
git config --global alias.unstage 'reset HEAD --'
git config --global alias.last 'log -1 HEAD'

# Configurar herramientas de fusión y diferencias
git config --global merge.tool vimdiff
git config --global diff.tool vimdiff

Comandos Básicos de Git

Estos son los comandos fundamentales que usarás diariamente. Domina estos primero antes de pasar a operaciones avanzadas.

Inicialización de Repositorio

# Inicializar un nuevo repositorio Git
git init

# Inicializar con un nombre de rama específico
git init -b main

# Clonar un repositorio existente
git clone https://github.com/usuario/repo.git
git clone [email protected]:usuario/repo.git  # SSH
git clone https://github.com/usuario/repo.git mi-carpeta  # Nombre de carpeta personalizado

# Clonar solo el historial reciente (más rápido para repos grandes)
git clone --depth 1 https://github.com/usuario/repo.git

Trabajando con Cambios

# Verificar estado del directorio de trabajo
git status
git status -s  # Formato corto
git status -sb # Formato corto con información de rama

# Preparar archivos para commit
git add archivo.js         # Archivo único
git add src/               # Directorio completo
git add .                  # Todos los cambios en el directorio actual
git add -A                 # Todos los cambios en todo el repo
git add -p                 # Preparación interactiva (modo parche)
git add *.js               # Todos los archivos JavaScript

# Quitar archivos del área de preparación
git reset archivo.js       # Quitar archivo específico
git reset                  # Quitar todos los archivos

# Hacer commit de cambios preparados
git commit -m "feat: agregar autenticación de usuario"
git commit -am "fix: resolver error de inicio de sesión"  # Preparar + commit archivos rastreados
git commit --amend         # Modificar el último commit
git commit --amend --no-edit  # Modificar sin cambiar el mensaje

# Ver diferencias
git diff                   # Cambios no preparados
git diff --staged          # Cambios preparados
git diff HEAD              # Todos los cambios desde el último commit
git diff main..feature     # Entre ramas
git diff --stat            # Resumen de cambios

Eliminar y Mover Archivos

# Eliminar archivos
git rm archivo.js          # Eliminar del directorio de trabajo y preparar eliminación
git rm --cached archivo.js # Eliminar de Git pero mantener en directorio de trabajo
git rm -r directorio/      # Eliminar directorio recursivamente

# Mover o renombrar archivos
git mv nombre-antiguo.js nombre-nuevo.js
git mv src/archivo.js lib/archivo.js  # Mover a directorio diferente

Cuando usas git mv o git rm, los cambios se preparan automáticamente. Esto es más conveniente que usar comandos regulares de shell y luego preparar los cambios por separado.

Ramificación y Fusión

Las ramas son la característica estrella de Git. Te permiten trabajar en múltiples funcionalidades simultáneamente sin interferir con el código base principal.

Gestión de Ramas

# Listar ramas
git branch                 # Ramas locales
git branch -r              # Ramas remotas
git branch -a              # Todas las ramas (locales + remotas)
git branch -v              # Con información del último commit
git branch --merged        # Ramas fusionadas en la rama actual
git branch --no-merged     # Ramas aún no fusionadas

# Crear ramas
git branch feature-login   # Crear nueva rama
git checkout -b feature-login  # Crear y cambiar a nueva rama
git switch -c feature-login    # Alternativa moderna a checkout

# Cambiar ramas
git checkout main          # Cambiar a rama main
git switch main            # Alternativa moderna
git checkout -            # Cambiar a rama anterior

# Renombrar ramas
git branch -m nombre-antiguo nombre-nuevo  # Renombrar rama
git branch -M nombre-nuevo     # Forzar renombrado de rama actual

# Eliminar ramas
git branch -d feature-login     # Eliminar rama fusionada
git branch -D feature-login     # Forzar eliminación (incluso si no está fusionada)
git push origin --delete feature-login  # Eliminar rama remota

Estrategias de Fusión

# Fusionar ramas
git merge feature-login    # Fusionar feature-login en rama actual
git merge --no-ff feature-login  # Crear commit de fusión incluso para avance rápido
git merge --squash feature-login # Comprimir todos los commits en uno

# Abortar una fusión
git merge --abort

# Continuar después de resolver conflictos
git merge --continue

Rebase

El rebase reescribe el historial de commits moviendo tu rama a un nuevo commit base. Esto crea un historial más limpio y lineal, pero debe usarse con cuidado.

# Hacer rebase de la rama actual sobre main
git rebase main

# Rebase interactivo (editar, comprimir, reordenar commits)
git rebase -i HEAD~3       # Últimos 3 commits
git rebase -i main         # Todos los commits desde la ramificación de main

# Continuar después de resolver conflictos
git rebase --continue

# Saltar commit actual
git rebase --skip

# Abortar rebase
git rebase --abort

Resolver Conflictos de Fusión

Cuando Git no puede fusionar cambios automáticamente, necesitarás resolver conflictos manualmente:

1. Ejecuta git status para ver qué archivos tienen conflictos
2. Abre los archivos en conflicto y busca los marcadores de conflicto (<<<<<<<, =======, >>>>>>>)
3. Edita el archivo para resolver conflictos, eliminando los marcadores
4. Prepara los archivos resueltos con git add
5. Completa la fusión con git commit o git merge --continue

# Usar herramientas de fusión para resolver conflictos
git mergetool

# Aceptar todos los cambios de un lado
git checkout --ours archivo.js    # Mantener tu versión
git checkout --theirs archivo.js  # Mantener su versión

Operaciones Remotas

Los repositorios remotos permiten la colaboración. Estos comandos te ayudan a sincronizar tu trabajo local con servidores remotos como GitHub, GitLab o Bitbucket.

Gestión de Remotos

# Listar repositorios remotos
git remote
git remote -v              # Con URLs

# Agregar repositorio remoto
git remote add origin https://github.com/usuario/repo.git
git remote add upstream https://github.com/original/repo.git

# Cambiar URL remota
git remote set-url origin [email protected]:usuario/repo.git

# Eliminar remoto
git remote remove origin

# Renombrar remoto
git remote rename origin upstream

# Mostrar detalles del remoto
git remote show origin

Obtener y Jalar

# Obtener cambios del remoto (no fusiona)
git fetch origin
git fetch --all            # Obtener de todos los remotos
git fetch --prune          # Eliminar ramas remotas eliminadas

# Jalar cambios (obtener + fusionar)
git pull origin main
git pull --rebase origin main  # Obtener + rebase en lugar de fusionar
git pull --ff-only         # Solo avance rápido, fallar si se necesita fusión

# Jalar con guardado automático
git pull --autostash

La diferencia entre fetch y pull es importante. Fetch descarga cambios pero no modifica tu directorio de trabajo, mientras que pull fusiona automáticamente los cambios.

Enviar Cambios

# Enviar al remoto
git push origin main
git push -u origin feature-login  # Establecer upstream y enviar
git push --all             # Enviar todas las ramas
git push --tags            # Enviar todas las etiquetas

# Forzar envío (¡usar con precaución!)
git push --force           # Sobrescribir historial remoto
git push --force-with-lease # Envío forzado más seguro, falla si el remoto se actualizó

# Eliminar rama remota
git push origin --delete feature-login
git push origin :feature-login  # Sintaxis alternativa

Ramas de Seguimiento

# Establecer rama upstream
git branch --set-upstream-to=origin/main main
git branch -u origin/main  # Forma abreviada

# Crear rama de seguimiento
git checkout -b feature origin/feature
git checkout --track origin/feature  # Nomenclatura automática

# Ver relaciones de seguimiento
git branch -vv

Guardado Temporal de Cambios

El guardado temporal (stashing) guarda cambios temporalmente para que puedas trabajar en otra cosa sin hacer commit de trabajo incompleto.

# Guardar cambios actuales
git stash
git stash save "trabajo en progreso en funcionalidad de inicio de sesión"
git stash -u               # Incluir archivos sin rastrear
git stash -a               # Incluir archivos sin rastrear e ignorados

# Listar guardados
git stash list

# Aplicar cambios guardados
git stash apply            # Aplicar guardado más reciente
git stash apply stash@{2}  # Aplicar guardado específico
git stash pop              # Aplicar y eliminar de la lista de guardados

# Ver contenido del guardado
git stash show
git stash show -p          # Mostrar diferencia completa
git stash show stash@{1}   # Mostrar guardado específico

# Crear rama desde guardado
git stash branch nombre-funcionalidad

# Eliminar guardados
git stash drop stash@{1}   # Eliminar guardado específico
git stash clear            # Eliminar todos los guardados

El guardado temporal es perfecto