Flujo de trabajo básico en Git

El flujo de trabajo básico en Git consiste en una serie de pasos que te permiten gestionar los cambios en tu código de manera eficiente. Dominar este flujo es fundamental para cualquier desarrollador que utilice Git como sistema de control de versiones.

Visión general del flujo de trabajo

El flujo de trabajo estándar en Git sigue estos pasos principales:

1. Crear o clonar un repositorio
2. Realizar cambios en los archivos
3. Revisar el estado de los archivos
4. Añadir cambios al área de preparación (staging)
5. Confirmar los cambios (commit)
6. Sincronizar con el repositorio remoto (push/pull)

Veamos cada uno de estos pasos en detalle.

1. Crear o clonar un repositorio

Para comenzar a trabajar con Git, necesitas un repositorio. Puedes crear uno nuevo o clonar uno existente.

Crear un nuevo repositorio

# Crear un directorio para el proyecto
mkdir mi-proyecto
cd mi-proyecto

# Inicializar un repositorio Git
git init

Esto crea un subdirectorio .git que contiene todos los archivos necesarios para el repositorio.

Clonar un repositorio existente

# Clonar un repositorio remoto
git clone https://github.com/usuario/repositorio.git

# Clonar a un directorio específico
git clone https://github.com/usuario/repositorio.git mi-directorio

Al clonar, Git descarga una copia completa del repositorio, incluyendo todo el historial de cambios.

2. Realizar cambios en los archivos

Una vez que tienes tu repositorio configurado, puedes comenzar a trabajar en tus archivos:

• Crear nuevos archivos
• Modificar archivos existentes
• Eliminar archivos que ya no necesitas

# Crear un nuevo archivo
touch README.md

# Editar el archivo con tu editor preferido
code README.md  # Para Visual Studio Code
vim README.md   # Para Vim
nano README.md  # Para Nano

3. Revisar el estado de los archivos

Después de realizar cambios, es buena práctica verificar el estado de tu repositorio:

git status

Este comando muestra:

• Archivos modificados que no están en el área de preparación
• Archivos en el área de preparación listos para commit
• Archivos nuevos que no están siendo rastreados por Git

Ejemplo de salida:

On branch main
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:   archivo1.txt

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

no changes added to commit (use "git add" and/or "git commit -a")

4. Añadir cambios al área de preparación (staging)

Antes de confirmar los cambios, debes añadirlos al área de preparación:

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

# Añadir varios archivos
git add archivo1.txt archivo2.txt

# Añadir todos los archivos modificados y nuevos
git add .

# Añadir todos los archivos modificados (no incluye nuevos)
git add -u

# Añadir interactivamente (seleccionar partes específicas)
git add -p

Puedes verificar qué cambios están preparados para commit con:

git status
# o para ver los cambios detallados
git diff --staged

5. Confirmar los cambios (commit)

Una vez que has añadido los cambios al área de preparación, puedes confirmarlos con un commit:

# Commit con mensaje
git commit -m "Añade funcionalidad de inicio de sesión"

# Commit con mensaje más detallado (abrirá el editor)
git commit

# Añadir y hacer commit de archivos ya rastreados en un solo paso
git commit -am "Actualiza la documentación"

Buenas prácticas para mensajes de commit

Un buen mensaje de commit debe:

1. Tener una primera línea breve (50 caracteres o menos)
2. Seguir con una línea en blanco
3. Incluir una descripción detallada si es necesario

Ejemplo:

Implementa autenticación con Google OAuth

- Añade endpoint para manejar la redirección de OAuth
- Integra el SDK de Google para verificar tokens
- Actualiza la base de datos de usuarios para almacenar IDs de Google

6. Sincronizar con el repositorio remoto

Para compartir tus cambios o recibir actualizaciones de otros, necesitas sincronizar con el repositorio remoto.

Configurar un repositorio remoto

Si iniciaste con git init, primero debes añadir un remoto:

git remote add origin https://github.com/usuario/repositorio.git

Enviar cambios al repositorio remoto (push)

# Primera vez que haces push (establece la rama upstream)
git push -u origin main

# Después de configurar el upstream
git push

Recibir cambios del repositorio remoto (pull)

# Obtener e integrar cambios
git pull

# Equivalente a fetch + merge
git fetch
git merge origin/main

Flujo de trabajo completo: Ejemplo práctico

Veamos un ejemplo completo del flujo de trabajo básico:

# 1. Clonar el repositorio
git clone https://github.com/usuario/proyecto.git
cd proyecto

# 2. Crear una rama para trabajar (buena práctica)
git checkout -b feature/nueva-funcionalidad

# 3. Realizar cambios
echo "# Mi Proyecto" > README.md
mkdir src
touch src/app.js

# 4. Verificar estado
git status

# 5. Añadir cambios al staging
git add README.md src/

# 6. Hacer commit
git commit -m "Añade estructura inicial del proyecto"

# 7. Más cambios y commits
echo "console.log('Hola mundo');" > src/app.js
git add src/app.js
git commit -m "Implementa función básica en app.js"

# 8. Cambiar a la rama principal
git checkout main

# 9. Actualizar con los últimos cambios del remoto
git pull

# 10. Fusionar tu rama de funcionalidad
git merge feature/nueva-funcionalidad

# 11. Enviar cambios al repositorio remoto
git push

Visualización del flujo de trabajo

+----------------+      +----------------+      +----------------+
| Working        |      | Staging        |      | Local          |
| Directory      | add  | Area           |commit| Repository     |
|                |----->|                |----->|                |
| (modificas     |      | (preparas      |      | (confirmas     |
|  archivos)     |      |  cambios)      |      |  cambios)      |
+----------------+      +----------------+      +----------------+
                                                       |
                                                       | push
                                                       v
                                                +----------------+
                                                | Remote         |
                                                | Repository     |
                                                |                |
                                                | (compartes     |
                                                |  cambios)      |
                                                +----------------+

Comandos adicionales útiles

Ver el historial de cambios

# Ver historial de commits
git log

# Ver historial en formato compacto
git log --oneline

# Ver historial con gráfico
git log --graph --oneline --all

Deshacer cambios

# Deshacer cambios en el directorio de trabajo
git restore archivo.txt

# Deshacer cambios en el área de preparación
git restore --staged archivo.txt

# Modificar el último commit
git commit --amend

# Revertir un commit (crea un nuevo commit que deshace los cambios)
git revert abc123

Gestionar ramas

# Ver todas las ramas
git branch

# Crear una nueva rama
git branch nueva-rama

# Cambiar a una rama
git checkout otra-rama
# o en Git más reciente
git switch otra-rama

# Crear y cambiar a una nueva rama
git checkout -b nueva-caracteristica

Mejores prácticas

1. Commits frecuentes y pequeños: Realiza commits pequeños que representen cambios lógicos completos.
2. Mensajes descriptivos: Escribe mensajes claros que expliquen el "qué" y el "por qué" del cambio.
3. Pull antes de Push: Siempre actualiza tu repositorio local antes de enviar cambios.
4. Usa ramas: Desarrolla nuevas funcionalidades en ramas separadas.
5. Revisa antes de confirmar: Usa git diff y git status para verificar tus cambios.
6. Sincroniza regularmente: Haz push de tus cambios con frecuencia para evitar conflictos grandes.

Conclusión

El flujo de trabajo básico de Git proporciona una estructura sólida para gestionar cambios en tu código. Aunque existen flujos de trabajo más complejos para equipos grandes o proyectos específicos, dominar estos conceptos fundamentales te permitirá trabajar eficientemente con Git en cualquier proyecto.

A medida que te familiarices con este flujo básico, podrás explorar características más avanzadas de Git para optimizar tu proceso de desarrollo.