Tutorial 3 de 10

30% completado

Comandos esenciales de Git

Domina los comandos básicos para seguir los cambios, crear commits y gestionar tus archivos.

Comandos esenciales de Git

Ahora que Git está instalado y configurado, vamos a descubrir los comandos que utilizarás a diario. Este tutorial cubre las operaciones fundamentales para gestionar tus archivos y crear un historial coherente de tu proyecto.

Visión general del flujo de trabajo de Git

Comandos de estado e información

git status

El comando más utilizado para conocer el estado de tu repositorio:

# Ver el estado completo
git status

# Versión corta
git status -s
git status --short

Ejemplo de salida:

On branch main
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        new file:   index.html

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   README.md

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        style.css

git log

Consultar el historial de commits:

# Historial completo
git log

# Versión condensada
git log --oneline

# Con gráfico de las ramas
git log --oneline --graph --all

# Limitar el número de commits
git log -5

# Desde una fecha
git log --since="2024-01-01"

# Por autor
git log --author="Nom Auteur"

git show

Mostrar los detalles de un commit:

# Último commit
git show

# Commit específico
git show abc1234

# Archivo específico en un commit
git show abc1234:fichier.txt

Gestión de archivos

git add

Añadir archivos a la staging area:

# Añadir un archivo específico
git add fichier.txt

# Añadir varios archivos
git add fichier1.txt fichier2.txt

# Añadir todos los archivos modificados
git add .

# Añadir todos los archivos (incluso los eliminados)
git add -A
git add --all

# Añadir de forma interactiva
git add -i

# Añadir por partes (patch)
git add -p

git commit

Crear una instantánea de tus cambios:

# Commit con mensaje
git commit -m "Message de commit"

# Commit con mensaje detallado
git commit -m "Titre du commit" -m "Description détaillée"

# Commit añadiendo automáticamente los archivos modificados
git commit -am "Message de commit"

# Modificar el último commit
git commit --amend

# Commit con firma GPG
git commit -S -m "Message signé"

Buenas prácticas para los mensajes de commit

# Formato recomendado
git commit -m "type: description courte

Description plus détaillée si nécessaire.

- Point important 1
- Point important 2

Fixes #123"

Tipos habituales:

feat: nueva funcionalidad
fix: corrección de un bug
docs: documentación
style: formato, puntos y comas que faltan, etc.
refactor: refactorización del código
test: adición de tests
chore: mantenimiento

Gestión de los cambios

git diff

Comparar los cambios:

# Diferencias en el working directory
git diff

# Diferencias en la staging area
git diff --staged
git diff --cached

# Diferencias entre dos commits
git diff abc1234 def5678

# Diferencias de un archivo específico
git diff fichier.txt

# Estadísticas de los cambios
git diff --stat

git restore

Deshacer cambios (Git 2.23+):

# Restaurar un archivo modificado
git restore fichier.txt

# Restaurar todos los archivos modificados
git restore .

# Quitar un archivo de la staging area
git restore --staged fichier.txt

# Restaurar desde un commit específico
git restore --source=abc1234 fichier.txt

git reset

Reiniciar el estado del repositorio:

# Quitar un archivo de la staging area
git reset fichier.txt

# Reiniciar la staging area
git reset

# Volver al commit anterior (conserva los cambios)
git reset HEAD~1

# Reiniciar por completo (ATENCIÓN: pérdida de datos)
git reset --hard HEAD~1

Gestión de archivos y carpetas

git rm

Eliminar archivos:

# Eliminar un archivo del repositorio y del sistema
git rm fichier.txt

# Eliminar solo del repositorio (conservarlo en local)
git rm --cached fichier.txt

# Eliminar una carpeta de forma recursiva
git rm -r dossier/

git mv

Mover o renombrar archivos:

# Renombrar un archivo
git mv ancien-nom.txt nouveau-nom.txt

# Mover un archivo
git mv fichier.txt dossier/fichier.txt

Archivo .gitignore

Ignorar archivos y carpetas:

# Archivos de log
*.log

# Carpetas de build
build/
dist/

# Archivos de configuración local
.env
config.local.js

# Dependencias
node_modules/
vendor/

# Archivos del sistema
.DS_Store
Thumbs.db

# IDE
.vscode/
.idea/
*.swp
*.swo

# Archivos temporales
*.tmp
*.temp

Comandos de .gitignore

# Comprobar si un archivo está ignorado
git check-ignore fichier.txt

# Forzar la adición de un archivo ignorado
git add -f fichier.txt

# Quitar un archivo ya rastreado pero ahora ignorado
git rm --cached fichier.txt

Navegación por el historial

git checkout

Navegar entre commits y ramas:

# Ir a un commit específico (modo detached)
git checkout abc1234

# Volver a la rama principal
git checkout main

# Crear una nueva rama y cambiar a ella
git checkout -b nouvelle-branche

git switch (Git 2.23+)

Alternativa moderna a checkout:

# Cambiar a una rama
git switch main

# Crear una nueva rama y cambiar a ella
git switch -c nouvelle-branche

# Volver a la rama anterior
git switch -

Comandos de ayuda e información

git help

Obtener ayuda:

# Ayuda general
git help

# Ayuda para un comando específico
git help commit
git commit --help

# Lista de comandos habituales
git help -a

git config

Gestionar la configuración:

# Ver toda la configuración
git config --list

# Ver un valor específico
git config user.name

# Modificar un valor
git config --global user.email "nouveau@email.com"

Ejercicios prácticos

Ejercicio 1: flujo de trabajo básico

# 1. Crear un nuevo proyecto
mkdir exercice-git
cd exercice-git
git init

# 2. Crear archivos
echo "# Mon Projet" > README.md
echo "console.log('Hello World');" > app.js
echo "body { margin: 0; }" > style.css

# 3. Comprobar el estado
git status

# 4. Añadir los archivos
git add README.md app.js
git status

# 5. Hacer un commit
git commit -m "feat: ajout des fichiers de base"

# 6. Añadir el CSS
git add style.css
git commit -m "style: ajout du CSS de base"

# 7. Ver el historial
git log --oneline

Ejercicio 2: modificaciones y correcciones

# 1. Modificar un archivo
echo "// Commentaire ajouté" >> app.js

# 2. Ver las diferencias
git diff

# 3. Añadir a la staging area
git add app.js

# 4. Ver las diferencias staged
git diff --staged

# 5. Commit
git commit -m "docs: ajout de commentaire"

# 6. Modificar el último commit
git commit --amend -m "docs: ajout de commentaire dans app.js"

Ejercicio 3: gestión de errores

# 1. Crear un archivo por error
echo "Fichier temporaire" > temp.txt
git add temp.txt

# 2. Quitarlo de la staging area
git restore --staged temp.txt

# 3. Eliminar el archivo
rm temp.txt

# 4. Modificar un archivo y luego deshacer el cambio
echo "Modification non désirée" >> README.md
git restore README.md

Comandos avanzados útiles

git stash

Guardar cambios temporalmente:

# Guardar los cambios
git stash

# Guardar con un mensaje
git stash push -m "Travail en cours sur la feature X"

# Ver la lista de stash
git stash list

# Aplicar el último stash
git stash pop

# Aplicar un stash específico
git stash apply stash@{1}

git clean

Limpiar los archivos no rastreados:

# Ver lo que se eliminaría
git clean -n

# Eliminar los archivos no rastreados
git clean -f

# Eliminar también las carpetas
git clean -fd

Alias útiles

Configura estos alias para ahorrar tiempo:

git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.unstage 'restore --staged'
git config --global alias.last 'log -1 HEAD'
git config --global alias.lg 'log --oneline --graph --decorate --all'
git config --global alias.amend 'commit --amend --no-edit'

Resolución de problemas habituales

Deshacer el último commit (conservando los cambios)

git reset HEAD~1

Deshacer por completo el último commit

git reset --hard HEAD~1

Recuperar un archivo eliminado

git restore fichier.txt
# o desde un commit específico
git restore --source=HEAD~1 fichier.txt

Ver quién ha modificado una línea

git blame fichier.txt

Buenas prácticas

Haz commits a menudo: commits pequeños y frecuentes
Mensajes claros: describe lo que hace el commit
Verifica antes de hacer commit: git status y git diff
Usa .gitignore: evita los archivos innecesarios
Prueba antes de hacer commit: asegúrate de que el código funciona

Recursos adicionales

Cheat sheets

Herramientas visuales

gitk: interfaz gráfica integrada
git gui: interfaz para los commits

Conclusión

Estos comandos son la base de tu uso diario de Git. Dominar estas operaciones te permitirá gestionar eficazmente tus proyectos y mantener un historial limpio y coherente.

En el próximo tutorial exploraremos las ramas y la fusión, conceptos esenciales para el trabajo colaborativo y la gestión de funcionalidades en paralelo.

Tiempo de lectura estimado: 25 minutos
Nivel: Principiante
Etapa anterior: Configuración y primeros pasos
Siguiente etapa: Ramas y fusión