Guía de Git Nivel Medio: Ramas, Fusiones, Conflictos, Stash y Remotos por Santiago Soñora

“Hola, mundo” en Git

El 'Hola, mundo' en Git es crear un nuevo repositorio, añadir un archivo y hacer el primer commit.

📋 Copiar

git init
echo "# Mi Proyecto\n\nHola, mundo" > README.md
git add README.md
git commit -m "feat: Add initial README with greeting"

Resultado:

Output

[main (root-commit) sha1]: feat: Add initial README with greeting
 1 file changed, 3 insertions(+)
 create mode 100644 README.md

Comandos básicos

Familiarizarse con estos comandos es esencial para interactuar eficientemente con Git:

Inicializar un repositorio
📋 Copiar
```
git init
```
Crea un nuevo repositorio Git vacío o reinicializa uno existente en el directorio actual. Crea la carpeta `.git`.
Clonar un repositorio remoto
📋 Copiar
```
git clone https://github.com/usuario/repositorio.git
```
Copia un repositorio remoto al entorno local. Crea una copia del repositorio, incluyendo todas las ramas y commits, y configura el remoto `origin`.
Clonar un repositorio y renombrar el directorio
📋 Copiar
```
git clone https://github.com/usuario/repositorio.git mi-directorio-local
```
Clona el repositorio en un directorio con un nombre específico.
Ver estado del repositorio
📋 Copiar
```
git status
```
Muestra el estado del área de trabajo y el área de staging: qué archivos han sido modificados, cuáles están preparados para el commit, etc.
Agregar archivos al área de staging
📋 Copiar
```
git add archivo.txt
```
Agregar todos los archivos modificados y nuevos al staging
📋 Copiar
```
git add .
```
Prepara para el próximo commit todos los archivos nuevos, modificados y eliminados en el directorio actual y subdirectorios.
Hacer un commit
📋 Copiar
```
git commit -m "feat: Implementar nueva funcionalidad"
```
Guarda los cambios que están en el área de staging como un nuevo commit con un mensaje descriptivo.
Hacer un commit rápido (add y commit)
📋 Copiar
```
git commit -am "fix: Corregir error de login"
```
Combina `git add` para archivos *seguidos* (tracked) con `git commit`. No añade archivos nuevos no seguidos.
Ver historial de commits
📋 Copiar
```
git log
```
Muestra el historial completo de commits de la rama actual.
Ver historial conciso
📋 Copiar
```
git log --oneline
```
Muestra cada commit en una sola línea, incluyendo el hash corto y el mensaje del commit.
Ver historial con gráfico de ramas
📋 Copiar
```
git log --graph --oneline --all --decorate
```
Muestra un gráfico de texto del historial de ramas y fusiones, útil para visualizar el flujo del proyecto.
Enviar cambios locales al repositorio remoto
📋 Copiar
```
git push origin nombre-rama-local
```
Sube los commits de tu rama local al repositorio remoto `origin` y a la rama `nombre-rama-local`. Si las ramas tienen el mismo nombre y tracking, `git push` es suficiente.
Obtener (fetch) cambios remotos
📋 Copiar
```
git fetch origin
```
Descarga los objetos y referencias (commits, ramas) del repositorio remoto `origin`. Los cambios están disponibles localmente pero no integrados en tus ramas de trabajo.
Obtener y fusionar (pull) cambios remotos
📋 Copiar
```
git pull origin nombre-rama-remota
```
Una combinación de `git fetch` y `git merge`. Descarga los cambios del remoto y los fusiona automáticamente en tu rama actual. Si las ramas tienen tracking, `git pull` es suficiente.
Crear una nueva rama
📋 Copiar
```
git branch nombre-nueva-rama
```
Crea una nueva rama que apunta al commit actual, pero no cambia a ella.
Cambiar a una rama existente
📋 Copiar
```
git switch nombre-rama-existente
```
Cambia al área de trabajo y al historial de la rama especificada. Si la rama no existe, puedes usar `-c` para crearla.
Crear y cambiar a una nueva rama
📋 Copiar
```
git switch -c nombre-nueva-rama
```
Una forma concisa de crear una nueva rama Y cambiar a ella inmediatamente.
Fusionar una rama
📋 Copiar
```
git merge rama-a-fusionar-en-actual
```
Integra los cambios de la rama especificada en tu rama actual. Puede resultar en una fusión rápida (fast-forward) o en un commit de fusión (3-way merge).
Ver diferencias no preparadas (un मजेदार)
📋 Copiar
```
git diff
```
Muestra las diferencias entre los archivos en tu área de trabajo y los archivos en el área de staging.
Ver diferencias preparadas (staged)
📋 Copiar
```
git diff --staged
```
Muestra las diferencias entre los archivos en el área de staging y el último commit.
Guardar cambios temporalmente (stash)
📋 Copiar
```
git stash save "Mensaje opcional"
```
Guarda el estado actual del área de trabajo y el área de staging en un 'stash' temporal, y limpia el área de trabajo. El mensaje es opcional.
Aplicar cambios guardados (stash)
📋 Copiar
```
git stash apply
```
Aplica los cambios del stash más reciente al área de trabajo, pero mantiene el stash guardado.
Aplicar y eliminar stash
📋 Copiar
```
git stash pop
```
Aplica los cambios del stash más reciente y lo elimina de la lista de stashes.
Listar stashes guardados
📋 Copiar
```
git stash list
```
Muestra la lista de stashes guardados con sus identificadores.
Agregar un tag a un commit
📋 Copiar
```
git tag -a v1.0.0 -m "Release version 1.0.0"
```
Crea un tag 'anotado' con un mensaje, asociado al commit actual. Útil para marcar lanzamientos.
Deshacer cambios locales no staged
📋 Copiar
```
git checkout -- archivo.txt
```
Descarta los cambios locales no preparados (`unmaddened`) en un archivo. ¡Es una operación destructiva!
Eliminar una rama local
📋 Copiar
```
git branch -d nombre-rama-a-eliminar
```
Elimina la rama local especificada. Solo permite la eliminación si la rama ya ha sido fusionada en la rama actual (o la rama principal). Usa `-D` para forzar.

Conceptos Clave

Comprender estos conceptos fundamentales te ayudará a dominar Git de forma más organizada y eficiente:

Ramificación (Branching):

La capacidad fundamental de Git para crear 'ramas' como líneas de desarrollo paralelas. Cada rama apunta a un commit específico y permite trabajar en nuevas características, corregir errores o experimentar sin afectar la línea principal del proyecto (ej: `main`, `develop`). La ramificación es barata y rápida en Git.
Fusión (Merging):

El proceso de integrar los cambios de una rama en otra. Git puede realizar fusiones rápidas (Fast-forward merge) si el historial es lineal, o fusiones de 3 vías (3-way merge) que crean un nuevo commit de fusión para combinar los cambios de dos ramas que divergieron.
Resolución de Conflictos de Fusión (Merge Conflicts):

Situaciones que ocurren cuando Git no puede fusionar automáticamente los cambios porque el mismo archivo fue modificado en la misma línea en las ramas que se intentan fusionar. Requiere intervención manual para editar el archivo, decidir qué cambios mantener, y marcar la resolución.
Rebasing vs Merging:

Dos estrategias para integrar cambios de una rama en otra, con diferentes impactos en el historial. Merging preserva el historial original con commits de fusión. Rebasing reescribe el historial aplicando los commits de una rama *sobre* la punta de otra, creando un historial más limpio y lineal, pero debe usarse con precaución en ramas compartidas.
Repositorios Remotos Avanzado:

Trabajar con copias del repositorio alojadas en servidores (GitHub, GitLab, Bitbucket). Comprender cómo configurar remotos (`git remote`), cómo las ramas locales pueden 'seguir' (`track`) ramas remotas, y la diferencia crucial entre `git fetch` (solo descarga cambios) y `git pull` (descarga y fusiona/rebasea automáticamente).
Stashing Cambios:

Una herramienta útil para guardar temporalmente los cambios no commiteados en el área de trabajo y staging para limpiar el directorio y poder cambiar a otra rama o hacer otra tarea. Los cambios se pueden recuperar más tarde.
Ignorar Archivos (`.gitignore`):

Utilizar el archivo `.gitignore` en la raíz del repositorio para especificar patrones de archivos y directorios que Git debe ignorar y no rastrear. Esto es esencial para evitar commitear archivos generados automáticamente, dependencias instaladas, archivos de configuración local o datos sensibles.
Comparando Cambios (`git diff`):

Una herramienta fundamental para visualizar las diferencias entre el estado actual de los archivos en el área de trabajo y el staging, entre el staging y el último commit, entre dos commits cualquiera, o entre ramas.
Visualizando el Historial (`git log` options):

Explorar el historial de commits utilizando diferentes opciones de `git log` para mostrar la información de forma más útil, como `--oneline` (resumen), `--graph` (visualizar ramas), `--all` (ver todas las ramas), `--decorate` (mostrar referencias).
Flujos de Trabajo (Workflows) Comunes:

Entender diferentes estrategias para gestionar el proceso de desarrollo y colaboración utilizando ramas. Ejemplos incluyen Feature Branching (una rama por característica), Gitflow (un modelo más estructurado con ramas dedicadas para desarrollo, releases, hotfixes) o Trunk-Based Development (desarrollo directo en la rama principal con ramas de corta duración).
Tags:

Marcar puntos específicos e importantes en el historial de commits, típicamente para versiones de lanzamiento (ej: `v1.0.0`). Los tags pueden ser ligeros (simplemente un puntero) o anotados (incluyen metadatos como nombre del creador, fecha, mensaje).
Entendiendo el Árbol de Git (Commit, Branch, HEAD):

Una comprensión conceptual de cómo Git organiza el historial como una serie de 'snapshots' (commits) conectados. Las ramas son simplemente punteros móviles a commits. `HEAD` es un puntero especial que indica el commit actual en el que te encuentras trabajando.

Casos de uso

Algunos ejemplos de aplicaciones prácticas donde se utiliza Git:

Colaborar en nuevas características o correcciones utilizando ramas dedicadas y Pull Requests/Merge Requests:

Crear una rama para cada tarea, trabajar en ella de forma aislada, commitear tus cambios y luego abrir una Pull Request (GitHub) o Merge Request (GitLab/Bitbucket) para solicitar que tus cambios sean revisados y fusionados en la rama principal.
Integrar cambios de otros desarrolladores en tu trabajo resolviendo conflictos:

Obtener las últimas actualizaciones del repositorio remoto (`git fetch` o `git pull`) e integrar los cambios de otros en tu rama local, aprendiendo a manejar y resolver los posibles conflictos de fusión que puedan surgir.
Gestionar múltiples líneas de desarrollo (ej: una rama para la versión 1, otra para la 2):

Utilizar ramas para mantener y trabajar en paralelo en diferentes versiones de tu software o en funcionalidades a largo plazo que no deben interferir con la línea principal actual.
Limpiar temporalmente el área de trabajo para cambiar a una tarea urgente o probar algo rápido:

Usar `git stash` para guardar tus cambios actuales no commiteados de forma temporal, realizar otra tarea en una rama diferente, y luego volver a tu rama original y aplicar los cambios guardados.
Contribuir a proyectos de código abierto alojados en plataformas como GitHub/GitLab:

Entender el flujo de trabajo común: hacer un 'fork' del repositorio, clonar tu fork, crear una rama para tu contribución, hacer commits, enviar (`push`) los cambios a tu fork remoto y abrir una Pull Request al repositorio original.
Preparar y etiquetar lanzamientos de software:

Usar `git tag` para marcar commits específicos como versiones de lanzamiento (`v1.0.0`, `v1.1.0`), facilitando la identificación y recuperación de versiones estables.
Deshacer cambios locales o commiteados con diferentes estrategias:

Utilizar comandos como `git checkout -- <file>` (descartar cambios locales), `git reset <commit>` (mover HEAD/rama a un commit anterior, con diferentes opciones para el área de trabajo/staging) o `git revert <commit>` (crear un nuevo commit que deshace los cambios de un commit anterior) entendiendo las implicaciones de cada uno.

Consejos para Principiantes

Aquí tienes algunas recomendaciones para facilitar tus inicios en Git:

Domina el Branching (Ramificación) y el Cambio de Ramas:

Crear ramas es muy barato y rápido en Git. Acostúmbrate a crear una rama nueva para cada característica, corrección de error o experimento. Practica cambiar entre ramas con `git switch` (o `git checkout`).
No Le Temas a los Conflictos de Fusión (Merge Conflicts), Practica Resolverlos:

Son una parte normal del trabajo colaborativo. Aprende a identificar los archivos con conflictos (`git status`), a editar manualmente las secciones conflictivas en esos archivos (buscando los marcadores `<<<<<<<`, `=======`, `>>>>>>>`), a marcar el archivo como resuelto (`git add <archivo>`) y a finalizar la fusión (`git commit`). Herramientas GUI también pueden ayudar.
Usa `git status` Frecuentemente (¡Es tu Mejor Amigo!):

Ejecuta `git status` constantemente. Te dirá en qué rama estás, si tu área de trabajo está limpia, qué archivos han sido modificados, cuáles están en staging, y si estás adelantado o atrasado respecto a la rama remota.
Escribe Mensajes de Commit Descriptivos y Útiles:

Un buen mensaje de commit explica *por qué* se hizo el cambio (el problema que resuelve, el objetivo alcanzado), no solo *qué* líneas de código se modificaron. Sigue la convención: una línea de resumen concisa (menos de 50 caracteres), una línea en blanco, y luego un cuerpo más detallado si es necesario.
Entiende la Diferencia entre `git fetch` y `git pull`:

`git fetch` solo descarga los cambios del repositorio remoto a tu copia local del remoto, pero no afecta tus ramas locales de trabajo. `git pull` es una combinación de `Workspace` y `merge` (o `rebase`), integrando automáticamente los cambios descargados en tu rama actual. Es buena práctica hacer `Workspace` primero para ver los cambios antes de integrarlos con `merge` o `pull`.
Utiliza `.gitignore` desde el Principio:

Crea un archivo `.gitignore` en la raíz de tu proyecto y lista los archivos y directorios que Git debe ignorar (ej: archivos generados automáticamente por el sistema, dependencias de paquetes, archivos de configuración local, logs, archivos temporales). Esto mantiene tu repositorio limpio.
Practica el Stashing (`git stash`):

Es una forma conveniente de guardar temporalmente tus cambios no commiteados (área de trabajo y staging) cuando necesitas cambiar rápidamente de rama o trabajar en otra cosa sin hacer un commit. Úsalo en lugar de commitear cambios a medio hacer.
Backupea Tu Trabajo Frecuentemente (Haz Push):

Tu repositorio remoto (GitHub, GitLab, etc.) no es solo para colaborar, es tu backup principal. Haz `git push` con regularidad para asegurar que tus commits locales estén guardados en el servidor remoto.
Explora las Opciones de Visualización de `git log`:

Usa `git log --oneline`, `git log --graph --oneline --all --decorate` para obtener diferentes vistas del historial de commits y entender mejor el flujo de las ramas y fusiones.

Herramientas relacionadas

Si te interesa Git, también podrías explorar estas herramientas:

Recursos útiles

Amplía tus conocimientos con estos enlaces y materiales: