Git

Git

temas

¿Qué es Git?

Git es un sistema de control de versiones distribuido que permite gestionar y rastrear los cambios realizados en archivos y proyectos a lo largo del tiempo.
Fue creado por Linus Torvalds en 2005 para el desarrollo del kernel de Linux.

Diferencias con otros sistemas de control de versiones:

¿Para qué se usa?

Git se utiliza principalmente para:

Contextos ideales:

¿Qué puedo construir con Git?

Aunque Git no es un lenguaje de programación ni una herramienta de construcción de software, sirve como base para organizar cualquier proyecto.
Con Git puedes estructurar y versionar proyectos como:

En otras palabras, Git no construye el proyecto, pero lo mantiene organizado, versionado y seguro.

¿Cuándo es más conveniente usarlo?

Git es más conveniente cuando:

Puede no ser necesario si:

Buenas prácticas recomendadas

Para mantener un flujo de trabajo eficiente y limpio, sigue estas prácticas:

1. Commits pequeños y descriptivos:

2. Uso adecuado de ramas:

3. Evitar subir archivos innecesarios:

4. Actualizar tu rama antes de fusionar (pull/rebase):

5. Revisar código antes de fusionar (Pull Request/Code Review):

Resumen final

✅ Fortalezas principales:

⚠️ Debilidades principales:

🛠️ Cuándo usarlo:

🚫 Cuándo evitarlo:

Temas

Conceptos relacionados

Al trabajar con Git, es importante conocer algunos conceptos clave que forman la base del control de versiones:

Repositorio (Repository):

Espacio donde se almacena el historial completo de un proyecto, incluyendo archivos, commits, ramas y etiquetas.
Puede ser:

Commit:

Un "snapshot" o captura del estado de los archivos en un momento específico.
Cada commit incluye un mensaje descriptivo y un identificador único.

Branch (Rama):

Línea de desarrollo independiente que permite trabajar en nuevas características o correcciones sin afectar la rama principal.

Merge (Fusión):

Proceso de unir los cambios de una rama a otra, normalmente para integrar nuevas funcionalidades o arreglos.

Pull y Push:

Clone:

Crear una copia completa de un repositorio remoto en tu máquina local.

Fork:

Copiar un proyecto a tu cuenta para trabajar en él de forma independiente, útil en proyectos open source.

Stash:

Guardar temporalmente cambios no confirmados para trabajar en otra tarea y luego recuperarlos.

Tag (Etiqueta):

Marca utilizada para señalar puntos importantes en el historial, como versiones estables (v1.0.0).

.gitignore:

Archivo que define qué elementos no deben ser rastreados por Git, como dependencias o archivos temporales.

🔼 temas

Herramientas recomendadas

Existen diversas herramientas que facilitan el uso de Git y mejoran la productividad, tanto en entornos gráficos como en línea de comandos:

Plataformas en la nube

Clientes de escritorio

CLI y terminal

Complementos para editores y entornos de desarrollo (IDE)

Visual Studio Code:

JetBrains (WebStorm, IntelliJ, PyCharm, etc.):

Integración de Git nativa con soporte visual y herramientas avanzadas.

Herramientas de integración y automatización

🔼 temas

Comandos

Esta sección resume los comandos más comunes de Git, agrupados por categorías, con ejemplos y explicaciones rápidas.

1. Configuración inicial

# Configura Git antes de usarlo por primera vez:
git config --global user.name "Tu Nombre"
git config --global user.email "tuemail@example.com"

# Ver la configuración actual:
git config --list

# Definir editor por defecto (opcional):
git config --global core.editor "code --wait"

2. Crear o clonar repositorios

git init                          # Inicializar un repositorio nuevo.
git clone <URL-del-repositorio>   # Clonar un repositorio existente.

3. Estados y seguimiento de cambios

git status                    # Ver el estado actual del repositorio.
git diff                      # Ver los cambios en archivos.
git diff --staged             # Ver cambios en el staging area.

4. Staging area y commits

git add archivo.js                         # Agregar archivos al staging area.
git add .                                  # Agregar todos los archivos modificados.
git commit -m "feat: nueva funcionalidad"  # Confirmar cambios con un mensaje.
git commit --amend                         # Modificar el último commit (sin crear uno nuevo.

5. Ramas (branches)

git branch                      # Ver todas las ramas
git branch nombre-rama          # Crear una nueva rama
git branch -d nombre-rama       # Eliminar una rama local
git branch -m nomViejo nomNvo   # RENOMBRAR rama / posicionado en otras rama

git checkout -b nombre-rama     # Crear y cambiar a rama nueva
git switch -c nomb              #
git checkout nombre-rama        # Cambiar de rama
git switch                      #

6. Sincronización con repositorio remoto

git remote -v                                # Ver repositorios remotos
git remote add origin <URL-del-repositorio>  # Agregar un repositorio remoto
git fetch                                    # Descargar cambios sin fusionar
git pull origin main                         # Descargar y fusionar cambios
git push origin nombre-rama                  # Subir cambios a la rama remota
git push --all origin                        # Subir todas las ramas locales

7. Fusión e integración

git merge nombre-rama        # Fusionar una rama en la actual
git rebase main              # Rebase (reestructurar historial)
git add archivo_conflicto.js # Resolver conflictos después de merge/rebase
git commit

8. Stash (guardar cambios temporalmente)

git stash                       # Guardar cambios sin hacer commit
git stash list                  # Ver lista de stashes guardados
git stash pop                   # Recuperar y aplicar el último stash
git stash apply stash@{0}       # Aplicar un stash específico (sin borrarlo)

9. Logs e historial

git log                         # Ver historial de commits
git log --oneline               # Historial resumido
git log --oneline --graph --all # Ver historial con gráfico
git log -- archivo.js           # Ver cambios en un archivo específico

10. Reset y revert

git checkout -- archivo.js        # Deshacer cambios en archivos sin stage
git reset archivo.js              # Quitar archivos del staging area (sin borrar cambios)
git revert <ID-del-commit>        # Revertir un commit seguro (repositorio compartido)
git reset --hard <ID-del-commit>  # Reset para volver a un commit previo (destructivo)

11. Limpiar archivos no rastreados

git clean -f                         # Eliminar archivos no rastreados
git clean -fd                        # Eliminar también carpetas

⚠️ Precaución: Estos archivos se eliminan permanentemente.

12. Tags (etiquetas)

git tag v1.0.0                        # Crear un tag
git tag -a v1.0.0 -m "Versión 1.0.0"  # Crear un tag con mensaje (annotated tag)
git tag                               # Listar tags existentes
git push origin --tags                # Subir tags al remoto

13. Cherry-pick

Aplicar un commit específico de otra rama:

git cherry-pick <ID-del-commit>

14. Alias útiles

Simplificar comandos con alias globales:

git config --global alias.st status
git config --global alias.cm "commit -m"
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.lg "log --oneline --graph --all"

Uso ejemplo:

git st    # en lugar de git status
git cm "mensaje"
git lg

15. Modifico commit

 git commit --amend     # vuelvo al ultimo commit y lo puedo modificar el NOMBRE/DESCRIPCIÓN
 git rebase -i head~3   # te muestra los ultimo commit a los que puedes volver / edit: para volver

 pick 8442d96 commit 03
 edit a6863b6 commit 04 # vuelve
 pick f8284fe Ultimo commit

 git rebase --continue      # inicializar

🔼 temas

Conceptos Claves

🟢 Básico

1. Qué es Git y en qué se diferencia de otros sistemas de control de versiones como SVN o Mercurial?

Git es un sistema de control de versiones distribuido que permite a múltiples desarrolladores trabajar en el mismo proyecto sin depender de un único servidor central.

A diferencia de SVN o Mercurial, Git:

2. Explica la diferencia entre los estados de un archivo en Git: untracked, modified, staged y committed.

3. ¿Cuál es la diferencia entre git clone y git fork y en qué contexto usarías cada uno?

Uso recomendado:

4. Describe la función de los comandos git fetch, git pull y git push.

5. Si accidentalmente borras un archivo en tu proyecto, ¿cómo lo recuperarías usando Git?

git checkout -- nombre_del_archivo

O si el archivo estaba eliminado pero no has hecho commit:

git restore nombre_del_archivo

Si ya hiciste commit y lo subiste, puedes usar:

git checkout commit_id -- nombre_del_archivo

🟡 Intermedio

6. Explica la diferencia entre git merge y git rebase. ¿En qué situaciones usarías uno u otro?

Uso recomendado:

git commit --amend -m "Nuevo mensaje corregido"

8. Durante un git pull, encuentras un conflicto de merge. Describe el proceso paso a paso para resolverlo correctamente.

  1. Identificar archivos en conflicto:
    git status
  2. Editar manualmente los archivos para resolver conflictos.
  3. Marcar los archivos como resueltos:
    git add archivo_resuelto
  4. Completar el merge:
    git commit

9. ¿Qué hace el comando git stash y cómo se recupera el trabajo guardado en un stash específico?

Un detached HEAD ocurre cuando revisas un commit directamente en lugar de una rama.
Para volver a una rama normal:

git checkout nombre_de_rama

🔴 Avanzado

11. ¿Cuál es la diferencia entre un branch local y uno remoto? ¿Cómo sincronizarías un branch local que está desactualizado respecto al remoto?

Para sincronizar:

git fetch
git merge origin/nombre_de_rama

O directamente:

git pull

12. ¿Cómo usarías git bisect para encontrar un commit que introdujo un bug en el proyecto?

  1. Iniciar bisect:
    git bisect start
  2. Marcar commit bueno:
    git bisect good commit_id
  3. Marcar commit malo:
    git bisect bad commit_id
  4. Git va probando commits hasta encontrar el problemático.
  5. Finalizar:
    git bisect reset

13. Explica la diferencia entre git reset, git revert y git restore. ¿En qué casos elegirías cada uno?

Uso recomendado:

14. En un proyecto con muchos colaboradores, ¿qué estrategias seguirías para mantener un historial de commits limpio y entendible?

15. Describe cómo configurar y usar hooks en Git, y da un ejemplo práctico de un hook que podría mejorar la calidad del código.

Los hooks son scripts que se ejecutan automáticamente en ciertos eventos de Git.

Configuración:

  1. Ubicación: .git/hooks/
  2. Crear un archivo como pre-commit y darle permisos de ejecución:
    chmod +x .git/hooks/pre-commit

Ejemplo práctico (validar lint antes de commit):

#!/bin/sh
npm run lint
if [ $? -ne 0 ]; then
  echo "❌ Lint falló. Corrige los errores antes de hacer commit."
  exit 1
fi

Esto evita que se suba código con errores de estilo.