GitHub — Comandos y Flujo de Trabajo

🔧 Configuración Inicial

Instalar Git

Descarga e instala Git en tu sistema operativo.

              # Windows — descarga el instalador:

              https://git-scm.com/download/win

              # Mac — con Homebrew:

              brew install git

              # Linux (Ubuntu/Debian):

              sudo apt install git

Configurar Identidad

Estos datos aparecerán en cada commit que realices.

              # Nombre de usuario

              git config --global user.name "Tu Nombre"

              # Correo electrónico

              git config --global user.email "email@ejemplo.com"

              # Editor predeterminado (VS Code)

              git config --global core.editor "code --wait"

Verificar Configuración

Comprueba que tu configuración global esté correcta.

              # Ver toda la configuración

              git config --list

              # Ver solo el nombre

              git config user.name

              # Versión de Git instalada

              git --version

Crear Cuenta en GitHub

Regístrate y vincula tu cuenta local con GitHub via SSH o HTTPS.

              # Generar clave SSH

              ssh-keygen -t ed25519 -C "email@ejemplo.com"

              # Copiar clave pública al portapapeles

              cat ~/.ssh/id_ed25519.pub

              → Pega esta clave en GitHub › Settings › SSH Keys

Inicializar Repositorio

Convierte una carpeta en un repositorio Git rastreado.

              # Crear nuevo repositorio local

              git init

              # Clonar uno existente de GitHub

              git clone https://github.com/user/repo.git

              # Clonar en una carpeta específica

              git clone https://github.com/user/repo.git mi-proyecto

Archivo .gitignore

Indica a Git qué archivos o carpetas debe ignorar completamente.

              # Crear el archivo

              touch .gitignore

              # Ejemplo de contenido:

              node_modules/

              .env

              dist/

              *.log

              .DS_Store

📌 Comandos Esenciales — Referencia Rápida

Haz clic en cualquier fila para copiar el comando.

Comando	Descripción
git status	Muestra el estado actual del área de trabajo y staging.
git add .	Añade todos los cambios al área de preparación (staging).
git add <archivo>	Añade un archivo específico al staging.
git commit -m "mensaje"	Guarda los cambios del staging con un mensaje descriptivo.
git log --oneline	Muestra el historial de commits en formato compacto.
git log --graph --all --oneline	Historial con visualización gráfica de ramas.
git diff	Muestra las diferencias entre el working tree y el último commit.
git restore <archivo>	Descarta cambios no guardados de un archivo.
git reset HEAD <archivo>	Quita un archivo del staging sin borrar los cambios.
git stash	Guarda temporalmente cambios sin hacer commit.
git stash pop	Recupera el último stash guardado.

🌐 Comandos Remotos

Comando	Descripción
git remote add origin <url>	Vincula el repositorio local con uno remoto en GitHub.
git remote -v	Lista los remotos configurados con sus URLs.
git push origin main	Sube los commits locales a la rama main del remoto.
git push -u origin main	Push inicial: establece el upstream para futuros pushes simples.
git pull origin main	Descarga y fusiona cambios del repositorio remoto.
git fetch	Descarga los cambios remotos sin fusionarlos.

✓ Copiado al portapapeles

🔄 El Ciclo de Vida de un Cambio

🚀 Flujo Completo — Primer Proyecto

            # 1. Inicializar

            git init

            # 2. Ver qué ha cambiado

            git status

            # 3. Preparar todos los archivos

            git add .

            # 4. Crear el primer commit

            git commit -m "feat: proyecto inicial"

            # 5. Conectar con GitHub

            git remote add origin https://github.com/tu-usuario/tu-repo.git

            # 6. Subir al repositorio remoto

            git push -u origin main

            ✓ ¡Tu código ya está en GitHub!

🔁 Flujo Diario — Día a Día

☀️ Al Comenzar el Día

Sincroniza tu copia local con los últimos cambios del equipo antes de trabajar.

              git pull origin main

              # Descarga y fusiona novedades

🛠️ Mientras Trabajas

Haz commits pequeños y frecuentes. Es mejor muchos commits pequeños que uno gigante.

              git add src/componente.js

              git commit -m "fix: corrige error en login"

🌙 Al Terminar el Día

Sube todos tus cambios para que el equipo tenga acceso y tu trabajo quede guardado.

              git push origin main

              # Sube commits locales

🌿 Trabajar con Ramas

Crear y Cambiar de Rama

Las ramas permiten desarrollar features sin afectar el código principal.

              # Crear nueva rama

              git branch feature/login

              # Crear y cambiar en un paso

              git checkout -b feature/login

              # Forma moderna (Git 2.23+)

              git switch -c feature/login

Gestionar Ramas

Visualiza, renombra y elimina ramas locales y remotas.

              # Listar ramas locales

              git branch

              # Listar ramas remotas

              git branch -r

              # Eliminar rama (ya fusionada)

              git branch -d feature/login

              # Forzar eliminación

              git branch -D feature/login

Fusionar (Merge)

Incorpora los cambios de una rama en otra.

              # Ir a la rama destino

              git switch main

              # Fusionar la feature

              git merge feature/login

              # Subir el resultado

              git push origin main

Rebase

Alternativa al merge que mantiene el historial lineal y limpio.

              # Estar en la feature branch

              git switch feature/login

              # Reubicar sobre main

              git rebase main

              # Luego en main hacer fast-forward

              git switch main

              git merge feature/login

Resolver Conflictos

Cuando dos ramas modifican el mismo bloque de código, Git necesita tu ayuda.

              # Después de un merge con conflictos:

              CONFLICT (content): Merge conflict in

                src/index.js

              # 1. Edita el archivo y elige qué conservar

              # 2. Marca como resuelto

              git add src/index.js

              # 3. Finaliza el merge

              git commit

Deshacer Cambios

Revierte commits sin reescribir el historial público.

              # Revertir el último commit (seguro)

              git revert HEAD

              # Revertir un commit específico

              git revert abc1234

              # Volver a estado anterior (CUIDADO)

              git reset --hard HEAD~1

🗺️ Diagrama Visual de Ramas y Git Flow

En entornos profesionales, el código se administra mediante un flujo de trabajo estructurado llamado Git Flow o variaciones de este. Esto asegura que la rama principal (master) siempre contenga código listo para producción.

Descripción de Ramas

master / main

Es la rama de producción. Contiene el historial de manera oficial firmada. Ningún desarrollador debería hacer commit aquí directamente. Solo se actualiza mediante merges desde staging o hotfixes.

staging

La rama de pruebas (pre-producción). Todo el código terminado se junta aquí para realizar los tests finales (QA). Una vez aprobado, se comprime en release y fusiona hacia master.

develop

Es la rama principal de trabajo para los desarrolladores. Aquí se prueban y se unen todas las nuevas funcionalidades prevenientes de las ramas feature antes de ir a staging.

feature/*

Son ramas creadas exclusivamente a partir de develop para trabajar en una funcionalidad específica y aislada. Una vez terminados los cambios, estos se reintegran mediante un Merge devolviendo el trabajo a develop.

issue/* / hotfix/*

Ramas para resolución de incidencias. Creadas para parches o bugs. Dependiendo de la urgencia nacen de develop o master e insertan rápidamente la solución integrándose de nuevo a la línea crítica.

🏷️ Versionado Semántico (SemVer)

El versionado semántico es un estándar para dar significado a los números de versión de una aplicación (ej. 1.2.3). Esto permite que otros desarrolladores y herramientas entiendan rápidamente el impacto de una actualización.

1. MAJOR (X.0.0)

Se incrementa cuando realizas cambios incompatibles con las versiones anteriores. Es una "ruptura" que requiere adaptaciones en el código de quienes usan tu app.

.1. MINOR (0.Y.0)

Se incrementa cuando añades funcionalidad nueva de manera retrocompatible (sin romper lo existente). Es el número que sube tras completar una rama feature.

. .1 PATCH (0.0.Z)

Se incrementa cuando realizas correcciones de errores (bugfixes) que no afectan el funcionamiento general. Es el número que sube tras un hotfix o issue.

💡 Pro-Tip: Para marcar estas versiones en Git, usamos el comando git tag -a v1.0.0 -m "Versión estable" y luego subimos el tag con git push origin v1.0.0.

🔀 Pull Request — Flujo en GitHub

🌿

1. Crear Rama

Crea una rama nueva para tu feature o bugfix.

git switch -c feature/x

💾

2. Hacer Commits

Trabaja y registra tus cambios con commits descriptivos.

git commit -m "..."

☁️

3. Subir Rama

Publica tu rama en GitHub.

git push origin feature/x

📋

4. Abrir PR

En GitHub.com crea un Pull Request hacia main.

GitHub UI

✅

5. Revisión

Un compañero revisa el código y da su aprobación.

Code Review

🎉

6. Merge

Se fusiona la rama en main y se elimina la feature branch.

Merge & Delete

📝 Convención de Commits (Conventional Commits)

Formato estándar: <tipo>(<scope>): <descripción>

feat

Nueva Funcionalidad

Añade una nueva feature al proyecto. Ejemplo: feat(auth): agrega login con Google

fix

Corrección de Bug

Arregla un error en el código. Ejemplo: fix(api): corrige error 500 en endpoint /users

docs

Documentación

Cambios solo en documentación. Ejemplo: docs: actualiza README con instrucciones de deploy

style

Formato / Estilo

Cambios que no afectan la lógica (espacios, comas, prettier). Ejemplo: style: formatea archivos con prettier

refactor

Refactorización

Mejora de código sin cambiar funcionalidad. Ejemplo: refactor: extrae lógica de validación a utils.js

test

Tests

Añadir o corregir tests. Ejemplo: test: agrega unit tests al módulo de auth

chore

Tareas de Mantenimiento

Actualizar dependencias, configuraciones. Ejemplo: chore: actualiza dependencias npm

💡 Consejos y Buenas Prácticas

📦

Commits Atómicos

Cada commit debe representar un único cambio lógico. Evita "mega-commits" que mezclan múltiples cambios no relacionados.

🌿

Usa Ramas para Todo

Nunca trabajes directamente en main. Crea una rama por cada feature, bugfix o experimento.

🔄

Sincroniza Frecuentemente

Haz git pull antes de empezar a trabajar para evitar conflictos grandes al final.

✍️

Mensajes Claros

Escribe mensajes de commit en presente imperativo: "Agrega función X" no "Agregué función X".

🔒

Nunca Commit de Secretos

Jamás subas claves API, contraseñas o tokens. Usa .gitignore y variables de entorno.

📋

Documenta tu Repo

Todo buen proyecto tiene un README.md que explica qué hace, cómo instalarlo y cómo contribuir.

🏷️

Usa Tags para Versiones

Marca versiones estables con git tag v1.0.0 para identificar releases fácilmente.

🔍

Revisa Antes de Subir

Usa git diff y git status antes de cada commit para confirmar exactamente qué estás guardando.

🎯 Estrategias de Branching

⚡ GitHub Flow

Ideal para proyectos con despliegue continuo. Simple y efectivo para equipos pequeños.

main feature/x Pull Request

Solo existe main. Cada feature va en su propia rama y se fusiona via PR.

🌊 Git Flow

Ideal para proyectos con ciclos de release definidos. Más estructura, más complejidad.

main develop feature/x hotfix

Usa ramas develop para integrar features antes de subir a main.

🎋 Trunk-based

Todos los desarrolladores integran directamente en la rama principal frecuentemente.

main / trunk feature flags

Minimiza las ramas de larga duración. Favorece la integración continua (CI/CD).

GitHub — Guía Completa