Fundamentos de Git: introducción al control de versiones y uso práctico

1. Introducción y motivación

Cuando escribes código o trabajas en un proyecto, es fundamental poder seguir los cambios y volver a una versión anterior cuando haga falta. ¡Ahí es donde entra Git!

2. ¿Qué es Git y por qué lo usamos?

• Deshacer: ¿Cometiste un error en tus cambios? Con Git puedes restaurar fácilmente estados anteriores.
• Trabajo en equipo: Varias personas pueden trabajar en el mismo proyecto sin pisarse unas a otras.
• Experimentación y confianza: Puedes probar una funcionalidad nueva sin romper el código base principal.

3. Instalación de Git y configuración inicial

• Descarga Git e instálalo para tu sistema operativo.
• Después de instalarlo, compruébalo ejecutando git --version en tu terminal.
• Configura tu nombre de usuario y tu email:

  Bash

  git config --global user.name "Adınız Soyadınız"
  git config --global user.email "[email protected]"

4. Conceptos básicos: Commit, Branch, Staging, HEAD, DAG

• Staging Area (Index): La zona donde preparas tus cambios antes de hacer commit.
• Commit: Un registro del estado de tu proyecto en un momento dado.
• Branch: Te permite abrir distintos caminos de desarrollo. La rama principal suele ser main o master.
• HEAD: Apunta a la rama en la que estás trabajando actualmente.
• DAG (Directed Acyclic Graph, grafo acíclico dirigido): Los commits se enlazan entre sí en una estructura de grafo dirigido y acíclico.

5. Comandos básicos de Git: primeros pasos

Crear un repositorio Git nuevo

git init

Convierte la carpeta actual en un proyecto Git.

Seguimiento de cambios

git status

Muestra los archivos modificados en tu directorio de trabajo y los archivos que están en staging.

Añadir archivos (staging)

git add dosya.txt

Añade un archivo concreto. Para todos los archivos:

git add .

Guardar cambios (commit)

git commit -m "Açıklama yazın"

Registra tus cambios de forma permanente.

Ver el historial

git log

Muestra la lista completa del historial de commits.

6. Ramas y estrategias de branching

• Rama principal (main/master): Código siempre estable y listo para producción.
• Feature Branch: Se crea para funcionalidades nuevas y se fusiona con la rama principal cuando está terminada.
• Hotfix/Release Branch: Se usa para correcciones urgentes de errores o para preparar una versión.

Estrategias de branching populares

• Git Flow: Usa las ramas main, develop, feature, release y hotfix para proyectos complejos.
• GitHub Flow: Un flujo de trabajo sencillo basado en la rama main y en ramas feature de corta duración.

7. Trabajar con repositorios remotos y GitHub

• Repositorio remoto (Remote): Una copia alojada en plataformas como GitHub o GitLab.
• Añadir un repositorio remoto:

  Bash

  git remote add origin <repo-adresi>
  git push -u origin main

• Traer los últimos cambios de un repositorio remoto:

  Bash

  git pull

• Clonar un proyecto existente en tu ordenador:

  Bash

  git clone <repo-adresi>

8. Otros comandos de uso frecuente

• git branch: Lista las ramas existentes.
• git checkout -b yeni-ozellik: Crea una rama nueva y cambia a ella.
• git merge <dal>: Fusiona la rama indicada con la rama actual.

9. Merge vs Rebase, conflictos y resoluciones

¿Cómo se produce un conflicto de merge? (escenario y ejemplo)

Escenario: Dos personas hacen cambios distintos en exactamente la misma línea de un archivo.

1. Existe un archivo en la rama main:

   txt

   mesaj.txt:
   Merhaba dünya!

2. En la rama feature-a, se modifica esta línea:

   txt

   mesaj.txt:
   Merhaba Copilot!

3. En la rama feature-b, se modifica la misma línea de otra manera:

   txt

   mesaj.txt:
   Merhaba insan!

4. Primero se fusiona feature-a con la rama main. Después se intenta fusionar feature-b con main. Como hay dos cambios en conflicto en la misma línea, Git lanza un conflicto de merge.

Comandos de merge/rebase y resolución de conflictos

Merge

git merge feature-branch

Fusiona dos ramas. Conserva el historial de commits completo.

Rebase

git rebase main

Mueve tu rama a la punta de la rama main, lo que da un historial lineal más limpio.

Conflictos de merge/rebase

• Cuando se produce un conflicto, aparecen en el archivo los marcadores <<<<<<<, ======= y >>>>>>>.
• Resuelve manualmente las líneas en conflicto y luego ejecuta:

  Bash

  git add <dosya>
  git commit

• No puedes completar un commit hasta que se resuelvan los conflictos.

10. Errores comunes y cómo recuperarse (en detalle)

1. Hacer commit en la rama equivocada

Escenario: Creías que estabas trabajando en una feature branch, pero hiciste commit directamente en main (o al revés).

Solución:

1. Busca el hash del commit:

   Bash

   git log --oneline

2. Cambia a la rama de destino:

   Bash

   git checkout main

3. Aplica el commit a la rama principal:

   Bash

   git cherry-pick <commit-hash>

4. Elimina el commit de la rama equivocada:

   Bash

   git checkout feature
   git reset --hard HEAD~1

2. Eliminar un commit por accidente

Escenario: Se perdió un commit durante un git reset --hard o una operación de rebase.

Solución:

1. Busca el hash del commit:

   Bash

   git reflog

2. Recupera el commit perdido en una rama nueva:

   Bash

   git checkout -b kurtarma <commit-hash>

3. Falta un commit después de un merge o rebase

Escenario: Algunos commits desaparecieron después de un merge o rebase.

Solución:

1. Encuentra el hash del commit con git reflog.
2. Recupera el commit creando una rama nueva:

   Bash

   git branch kayip-commit <commit-hash>

3. Si hace falta, fusiónalo de nuevo o aplícalo con cherry-pick en tu rama de destino.

4. Eliminar un archivo por accidente

Escenario: Borraste un archivo y quieres restaurarlo antes de hacer commit.

Solución:

• Para restaurarlo al estado que tenía en el último commit:

  Bash

  git checkout HEAD -- dosya.txt

• Para restaurarlo desde un commit anterior:

  Bash

  git checkout <commit-hash> -- dosya.txt

5. No poder resolver un conflicto de merge

Escenario: Borraste por accidente los marcadores de conflicto (<<<<<<<, =======, >>>>>>>) y corrompiste el archivo.

Solución:

• Para restablecer el archivo y resolver el conflicto desde cero:

  Bash

  git checkout --ours dosya.txt   # Keeps your changes
  git checkout --theirs dosya.txt # Keeps incoming changes

• Después puedes retomar el proceso de merge.

Errores comunes y métodos de recuperación (tabla resumen)

11. Escenarios reales y colaboración en equipo

• Fork y PR: Hacer un fork del proyecto de otra persona y enviar un pull request con tus cambios.
• Upstream Sync: Traer las actualizaciones del repositorio original para mantener tu fork al día.
• Code Review: Revisar los cambios de código mediante PR antes de fusionarlos.

12. Temas avanzados

Squash

Escenario: Hiciste 5 commits pequeños en una feature branch, pero quieres fusionarlos con la rama principal como un único commit.

Ejemplo detallado:

1. La rama feature/login tiene los siguientes commits:
   • feat: kullanıcı adı inputu eklendi
   • fix: input typo düzeltildi
   • feat: şifre inputu eklendi
   • fix: şifre inputu typo düzeltildi
   • style: inputlara margin eklendi
2. Antes de fusionar con main, quieres combinarlos en un solo commit:

   Bash

   git checkout feature/login
   git rebase -i HEAD~5

3. En el editor interactivo, deja el primer commit como pick y cambia los demás a squash. Edita el mensaje del commit y guarda.
4. Resultado: Todos los cambios se combinan en un único commit. Ahora puedes fusionar con main.

Cherry-pick

Escenario: Quieres elegir un commit concreto de otra rama y aplicarlo a tu rama actual.

Ejemplo detallado:

1. Se hizo commit de una corrección urgente en hotfix/bugfix:
   • fix: login bug düzeltildi (hash del commit: a1b2c3d)
2. Estás trabajando en feature/profile y quieres aplicar esta corrección:

   Bash

   git checkout feature/profile
   git cherry-pick a1b2c3d

3. Resultado: Solo ese commit concreto se aplica a tu rama actual. Tu código queda actualizado.

Revert

Escenario: Creaste un commit incorrecto en la rama principal, pero no quieres reescribir el historial.

Ejemplo detallado:

1. Se eliminó un archivo por error en main:
   • commit hash: d4e5f6g
2. Para deshacer este commit:

   Bash

   git checkout main
   git revert d4e5f6g

3. Resultado: El archivo eliminado se restaura y se crea un nuevo commit de revert.

Reset

Escenario: Hiciste 3 commits innecesarios y quieres eliminarlos por completo.

Ejemplo detallado:

1. Commits recientes:
   • fix: typo
   • test: test kodu
   • debug: console.log eklendi
2. Para borrar los últimos 3 commits:

   Bash

   git reset --hard HEAD~3

3. Resultado: El repositorio vuelve al estado de hace 3 commits. Esos commits y cambios se descartan por completo.

Reflog

Escenario: Eliminaste por accidente una rama o un commit y quieres recuperarlo.

Ejemplo detallado:

1. Un commit desapareció tras ejecutar git reset --hard.
2. Para localizar el commit perdido:

   Bash

   git reflog
   # Find the old commit hash in the output (e.g. 9z8y7x6)
   git checkout -b kurtarma 9z8y7x6

3. Resultado: El commit perdido se restaura en una rama nueva.

Stash

Escenario: Necesitas cambiar de rama con urgencia mientras trabajas, pero no quieres hacer commit de un trabajo sin terminar.

Ejemplo detallado:

1. Estás en feature/search con cambios sin commitear.
2. Necesitas cambiar a la rama principal:

   Bash

   git stash
   git checkout main
   # Once done, switch back to your feature branch
   git checkout feature/search
   git stash pop

3. Resultado: Tus cambios se restauran de forma segura sin perder nada de trabajo.

.gitignore y .gitattributes

Escenario: Tu proyecto contiene archivos que no deberían rastrearse, como la salida del build o claves secretas.

Ejemplo detallado:

1. Tienes carpetas o archivos como node_modules/, .env o dist/.
2. Añádelos a tu archivo .gitignore:

   txt

   node_modules/
   .env
   dist/

3. Resultado: Git ignorará estos archivos.
4. Usa .gitattributes para configurar los finales de línea, por ejemplo:

   txt

   * text=auto

Hooks

Escenario: Quieres ejecutar pruebas automáticas antes de cada commit.

Ejemplo detallado:

1. Abre o crea .git/hooks/pre-commit.
2. Añade el siguiente script:

   Bash

   #!/bin/sh
   npm test

3. Haz el archivo ejecutable:

   Bash

   chmod +x .git/hooks/pre-commit

4. Resultado: Las pruebas automáticas se ejecutan antes de cada commit; si fallan, el commit se cancela.

Submodules

Escenario: Quieres incluir otro repositorio Git (por ejemplo, una librería compartida) como submódulo en tu proyecto.

Ejemplo detallado:

1. Para añadir una librería compartida:

   Bash

   git submodule add https://github.com/ornek/ortak-kutuphane.git libs/ortak-kutuphane

2. Para actualizar el submódulo:

   Bash

   git submodule update --remote

3. Resultado: El submódulo queda integrado en tu proyecto y se mantiene actualizado.

Shallow Clone y LFS

Escenario 1: Un repositorio es muy grande y solo quieres descargar rápidamente la última instantánea.

Ejemplo detallado:

1. Para clonar solo el último commit:

   Bash

   git clone --depth=1 https://github.com/ornek/buyuk-repo.git

2. Resultado: Solo se descarga la última revisión en lugar de todo el historial.

Escenario 2: Tu repositorio contiene archivos grandes (por ejemplo, vídeos o datasets) que ralentizan Git.

Ejemplo detallado:

1. Configura Git LFS:

   Bash

   git lfs install
   git lfs track "*.mp4"
   git add .gitattributes
   git add video.mp4
   git commit -m "LFS ile video eklendi"

2. Resultado: LFS gestiona los archivos grandes y tu repositorio principal sigue siendo rápido.

13. Preguntas frecuentes y recursos

Preguntas frecuentes

Recursos y lecturas adicionales

• Pro Git Book
• Atlassian Git Tutorials
• Oh Shit, Git!?!
• GitHub Learning Lab
• Git Branching