Formación corporativa en Git

Git es un sistema de control de versiones distribuido, diseñado para gestionar y registrar los cambios en archivos de código fuente durante el desarrollo de software.

Creado por Linus Torvalds en 2005, Git permite a múltiples desarrolladores trabajar de manera simultánea en un proyecto, facilitando la colaboración y manteniendo un historial completo de modificaciones. En la versión actual - Git 2.44 y posteriores - incorpora optimizaciones como commit-graph, multi-pack-index, partial clone, sparse-checkout en modo cono, soporte experimental de SHA-256 y mejoras importantes en git stash y git switch.

¿Qué es un sistema de control de versiones?

Un sistema de control de versiones es una herramienta que registra los cambios realizados en archivos a lo largo del tiempo. Permite revertir archivos a estados anteriores, comparar cambios y entender quién modificó qué y cuándo. Esto es esencial en proyectos de software donde el código evoluciona constantemente y varios colaboradores pueden estar trabajando en diferentes partes del proyecto.

Características principales de Git

• Distribuido: Cada copia de un repositorio Git es un repositorio completo con historial completo, lo que permite trabajar sin conexión y reduce el riesgo de pérdida de datos.
• Eficiencia: Optimizado para manejar proyectos grandes con rapidez y eficiencia gracias a commit-graph, multi-pack-index y packfiles incrementales.
• Integridad: Utiliza sumas de verificación - hash SHA-1 por defecto, SHA-256 experimental desde Git 2.29 - para garantizar la integridad de los datos.
• Ramas y fusiones: Facilita la creación y gestión de ramas para el desarrollo paralelo y la posterior fusión de cambios.
• Escalabilidad: partial clone y sparse-checkout permiten trabajar con repositorios gigantes sin descargar todo el histórico o el árbol.
• Recuperación: git reflog mantiene un registro local de los movimientos del HEAD durante 90 días por defecto, lo que permite rescatar commits aparentemente perdidos.

Instalación de Git

En Linux

La mayoría de las distribuciones incluyen Git en sus repositorios oficiales.

Para distribuciones basadas en Debian/Ubuntu:

sudo apt-get update
sudo apt-get install git

Para distribuciones basadas en Fedora:

sudo dnf install git

En macOS

Utiliza Homebrew para instalar Git:

brew install git

En Windows

Descarga el instalador desde la página oficial:

git-scm.com/download/win

Configuración inicial

Después de instalar Git, es recomendable configurar tu nombre de usuario y correo electrónico:

git config --global user.name "Tu Nombre"
git config --global user.email "tuemail@example.com"

Estos datos se utilizarán en cada commit que realices.

Comandos básicos de Git

Inicializar un repositorio

Para crear un nuevo repositorio en un directorio existente:

git init

Clonar un repositorio existente

Para obtener una copia local de un repositorio remoto:

git clone https://github.com/usuario/repositorio.git

Ver el estado del repositorio

Muestra los cambios realizados desde el último commit:

git status

Añadir cambios al área de preparación

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

git add archivo.txt          # Añade un archivo específico
git add .                    # Añade todos los archivos modificados

Realizar un commit

Confirma los cambios añadidos al área de preparación:

git commit -m "Mensaje descriptivo del cambio"

Ver el historial de commits

Muestra un registro de los commits realizados:

git log

Enviar cambios al repositorio remoto

Para subir tus commits al repositorio remoto:

git push origin main         # Envía a la rama 'main' en 'origin'

Obtener cambios del repositorio remoto

Actualiza tu repositorio local con los cambios remotos:

git pull origin main

Trabajo con ramas

Las ramas permiten desarrollar funcionalidades aisladas del código principal.

Crear una nueva rama

git branch nueva-funcionalidad

Cambiar a otra rama

git checkout nueva-funcionalidad

O crear y cambiar a la rama en un solo paso:

git checkout -b nueva-funcionalidad

Fusionar ramas

Para combinar los cambios de una rama con otra:

git checkout main
git merge nueva-funcionalidad

Eliminar una rama

Una vez fusionada, puedes eliminarla:

git branch -d nueva-funcionalidad

Resolución de conflictos

Al fusionar ramas, pueden surgir conflictos si se han modificado las mismas líneas en ambos lados.

Identificar conflictos

Git indicará qué archivos tienen conflictos después de una fusión fallida. Puedes verlos con:

git status

Resolver conflictos

Edita los archivos conflictivos para solucionar las discrepancias. Luego, añade los archivos resueltos y realiza un commit:

git add archivo_en_conflicto.txt
git commit -m "Resueltos conflictos de fusión"

Repositorios remotos

Añadir un repositorio remoto

Si tu repositorio local no está vinculado a uno remoto:

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

Ver repositorios remotos

git remote -v

Cambiar la URL de un remoto

git remote set-url origin https://github.com/usuario/nuevo-repositorio.git

Etiquetas

Las etiquetas se utilizan para marcar puntos específicos en el historial, como versiones de lanzamiento.

Crear una etiqueta

Etiqueta anotada con mensaje:

git tag -a v1.0 -m "Versión 1.0"

Listar etiquetas

git tag

Enviar etiquetas al remoto

git push origin v1.0
# O todas las etiquetas:
git push origin --tags

Archivo .gitignore

Para excluir archivos o directorios del seguimiento de Git, utiliza el archivo .gitignore.

Ejemplo de .gitignore

# Ignorar archivos compilados
*.class

# Ignorar directorios
/logs
/tmp

# Ignorar archivos específicos
secretos.txt

Revertir cambios

Deshacer cambios no añadidos al área de preparación

git checkout -- archivo.txt

Retirar archivos del área de preparación

git reset archivo.txt

Revertir un commit

Crea un nuevo commit que deshace los cambios:

git revert <id_commit>

Alias y configuraciones útiles

Crear alias para comandos frecuentes

git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.cm 'commit -m'

Ahora puedes usar git st en lugar de git status.

Funcionalidades modernas de Git 2.44+

Partial clone y sparse-checkout

Para repositorios muy grandes, partial clone descarga solo los objetos necesarios y difiere el resto:

git clone --filter=blob:none https://github.com/org/repo.git
git sparse-checkout init --cone
git sparse-checkout set src/frontend docs

Esto combina clonado perezoso con checkout parcial en modo cono, el formato recomendado desde Git 2.27. Solo se materializan las rutas declaradas.

commit-graph y multi-pack-index

Git mantiene índices auxiliares para acelerar operaciones sobre el historial:

git config --global core.commitGraph true
git config --global gc.writeCommitGraph true
git maintenance start

El fichero commit-graph cachea la estructura del DAG de commits y hace que git log --graph, git merge-base y las operaciones de alcance sean órdenes de magnitud más rápidas en proyectos con cientos de miles de commits.

rerere: reutilizar resoluciones de conflicto

reuse recorded resolution registra cómo resolviste un conflicto y aplica la misma resolución la siguiente vez que aparece el mismo diff conflictivo:

git config --global rerere.enabled true

Resulta especialmente útil en rebases largos y en ramas de larga duración que se van sincronizando con main semana tras semana.

git switch y git restore

Desde Git 2.23, los comandos git switch - cambiar de rama - y git restore - descartar cambios locales - sustituyen los usos sobrecargados de git checkout, que mezclaba ambas responsabilidades:

git switch -c feature/login
git restore --staged archivo.txt
git restore archivo.txt

Mejoras en git stash

En versiones recientes, git stash almacena internamente los stashes como commits normales bajo refs/stash, lo que permite inspeccionarlos con git log y facilita herramientas que analizan stashes pendientes en el repositorio.

Flujos de trabajo recomendados

Git Flow

Un modelo de ramificación que define roles claros para las ramas y procedimientos para fusionarlas.

• main: Código en producción.
• develop: Rama de integración para desarrollo.
• feature/: Ramas para nuevas funcionalidades.
• release/: Preparación de nuevas versiones.
• hotfix/: Correcciones urgentes en producción.

GitHub Flow

Más simple y adecuado para despliegues continuos.

• Trabajar siempre en ramas cortas basadas en main.
• Abrir pull requests para revisión y discusión antes de fusionar.

Integración con herramientas y servicios

GitHub

Plataforma que ofrece repositorios remotos y funcionalidades adicionales como issues, pull requests y wikis.

GitLab

Similar a GitHub, con características añadidas como integración continua (CI/CD) incorporada.

Bitbucket

Ofrece repositorios privados gratuitos y se integra bien con herramientas de Atlassian como Jira.

Consejos y buenas prácticas

• Commits atómicos: Realiza commits que contengan cambios relacionados y limitados en alcance.
• Mensajes claros: Utiliza mensajes de commit descriptivos que expliquen el "qué" y el "por qué".
• Revisión de código: Aprovecha las pull requests para revisar y mejorar el código antes de fusionarlo.
• Documentación: Mantén una documentación actualizada y utiliza el archivo README.md para explicar el proyecto.

Recursos adicionales

• Documentación oficial: git-scm.com/doc
• Pro Git Book: Libro completo y gratuito sobre Git.
• Try Git: Tutorial interactivo para aprender los fundamentos.