Git para Principiantes: Tutorial Paso a Paso

• 23/07/2025

Git para Principiantes: Guía Paso a Paso para Dominar el Control de Versiones

¿Alguna vez te has encontrado con la frustración de perder cambios importantes, arrepentirte de una modificación o luchar para colaborar eficazmente en un proyecto de código? Si eres programador, diseñador o emprendedor digital, sabes que la gestión de código puede ser un verdadero quebradero de cabeza sin la herramienta adecuada. Es aquí donde Git se convierte en tu mejor aliado.

Esta guía paso a paso de Git para principiantes está diseñada para acompañarte desde los conceptos más fundamentales hasta el dominio de los comandos Git básicos y las mejores prácticas. Te enseñaremos a aprender Git desde cero, optimizando tu flujo de trabajo y facilitando la colaboración en equipo. Prepárate para dominar Git y transformar tu manera de trabajar.

Con este tutorial Git en español, no solo comprenderás cómo usar los comandos, sino por qué son esenciales. Nuestro objetivo es que, al finalizar esta guía Git práctica, te sientas plenamente cómodo gestionando tu código, explorando el historial de cambios y colaborando sin sobresaltos. Verás que Git es fácil cuando se explica bien.

Únete a nuestra comunidad de Discord

¿Qué es Git y Por Qué Deberías Aprenderlo?

Git es un sistema de control de versiones distribuido (DVCS) de código abierto, diseñado para manejar proyectos de todos los tamaños —desde los más pequeños hasta los más complejos— con una velocidad y eficiencia notables. Fue creado por Linus Torvalds, la mente detrás de Linux, en 2005. A diferencia de otros sistemas centralizados, Git permite que cada desarrollador tenga una copia completa del historial del proyecto en su máquina local, lo que confiere una gran robustez y flexibilidad.

Pero, ¿por qué es tan crucial aprender Git hoy en día? La respuesta es clara: es una herramienta indispensable en el desarrollo de software moderno y en la gestión de proyectos digitales. Te permite rastrear cada cambio realizado en tu código, revertir a versiones anteriores si algo sale mal, y colaborar eficazmente con otros desarrolladores sin que sus trabajos se interfieran. Para cualquier programador, diseñador web o emprendedor digital que trabaje con código, saber usar Git es una habilidad fundamental.

Dominar Git te ofrece una serie de ventajas clave:

• - Historial Completo de Cambios: Git registra cada modificación, quién la hizo y cuándo. Esto te da la capacidad de volver atrás en el tiempo a cualquier versión anterior de tu código. Es como tener un "botón de deshacer" ilimitado para tu proyecto.

• - Colaboración Eficaz: Permite que múltiples desarrolladores trabajen en el mismo proyecto simultáneamente sin interferir entre sí. Los cambios se pueden fusionar de forma controlada, minimizando los conflictos.

• - Seguridad y Fiabilidad: Reduce el riesgo de perder código, ya que cada commit (una instantánea de tu proyecto) es como un "punto de guardado" seguro que puedes restaurar en cualquier momento.

• - Flexibilidad: Facilita la creación de ramas (branches) para experimentar con nuevas funcionalidades o corregir errores sin afectar a la versión principal y estable del proyecto.

• - Estándar de la Industria: La inmensa mayoría de empresas, equipos de desarrollo y proyectos de código abierto utilizan Git. Es la herramienta de control de versiones por excelencia y una habilidad exigida en el mercado laboral.

En resumen, qué es Git se traduce en una herramienta robusta para la gestión y versionado de código, esencial para mantener el orden, la seguridad y la eficiencia en cualquier proyecto de desarrollo. Es la base para una colaboración fluida y un desarrollo sin sobresaltos, ideal para cualquier desarrollador Git o principiante.

---

Instalación y Configuración de Git: Primeros Pasos Esenciales

Antes de sumergirnos en los comandos Git básicos, el primer paso es instalar Git en tu sistema operativo. El proceso es relativamente sencillo, pero varía ligeramente según si utilizas Windows, macOS o Linux. A continuación, te proporcionamos una guía paso a paso detallada para cada uno.

Una vez instalado, la configuración inicial de Git es crucial para que tus commits se identifiquen correctamente. Esto asegura que cada cambio que realices en un repositorio Git esté asociado a tu identidad.

Instalación en Windows

1. Descarga el instalador: Visita la página oficial de Git: git-scm.com/download/win. La descarga del archivo .exe comenzará automáticamente.

2. Ejecuta el instalador: Abre el archivo .exe descargado y sigue las instrucciones del asistente de instalación.

3. Opciones de instalación (recomendaciones):

   • - Se aconseja mantener la mayoría de las opciones por defecto, a menos que tengas necesidades específicas.

   • - Asegúrate de que las opciones "Git Bash Here" y "Git GUI Here" estén marcadas para facilitar el acceso desde el explorador de archivos.

   • - En "Adjusting your PATH environment", selecciona la opción recomendada "Git from the command line and also from 3rd-party software". Esto te permitirá usar Git desde cualquier terminal (CMD, PowerShell, etc.).

   • - Puedes elegir VS Code como tu editor de texto predeterminado si lo utilizas habitualmente.

4. Finaliza la instalación: Haz clic en "Install" y luego en "Finish".

Instalación en macOS

1. Usando Homebrew (Recomendado para desarrolladores):

   • - Si no tienes Homebrew (un gestor de paquetes para macOS), instálalo abriendo la Terminal y ejecutando:

     /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

   • - Una vez instalado Homebrew, instala Git con:

     brew install git

2. Usando Xcode Command Line Tools:

   • - macOS suele incluir las herramientas de línea de comandos de Xcode, que contienen Git. Si no las tienes, puedes instalarlas abriendo la Terminal y ejecutando:

     xcode-select --install

   • - Sigue las instrucciones en pantalla.

Instalación en Linux

Git suele estar preinstalado o disponible en los repositorios de software de la mayoría de las distribuciones de Linux.

1. Debian/Ubuntu:

   sudo apt update sudo apt install git

2. Fedora:

   sudo dnf install git

3. Arch Linux:

   sudo pacman -S git

Verificar la Instalación de Git

Después de la instalación, abre tu terminal preferida (Git Bash en Windows, Terminal en macOS/Linux) y ejecuta el siguiente comando para verificar que Git se ha instalado correctamente y para ver su versión:

git --version

Deberías ver una salida similar a git version 2.XX.X, confirmando que ya puedes usar Git.

Configuración Inicial de Git: Tu Nombre, Email y Editor Predeterminado

Una vez que Git está instalado, es fundamental configurar Git con tu identidad. Esto es lo primero que harás para que Git sepa quién eres cuando realices cambios en los repositorios.

Para configurar tu nombre de usuario, ejecuta los siguientes comandos en tu terminal, reemplazando Tu Nombre con tu nombre real:

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

Luego, configura tu dirección de correo electrónico, reemplazando [email protected] con tu email:

git config --global user.email "[email protected]"

Es vital usar la misma dirección de correo electrónico que utilizarás en plataformas de alojamiento de repositorios como GitHub o GitLab para que tus commits se vinculen correctamente a tu perfil.

La opción --global indica que esta configuración se aplicará a todos los repositorios Git en tu sistema. Si deseas una configuración diferente para un proyecto específico, puedes omitir --global y ejecutar los comandos dentro de la carpeta raíz de ese proyecto.

Finalmente, puedes configurar tu editor de texto predeterminado que Git utilizará para escribir mensajes de commit más largos o para resolver conflictos de fusión. Si utilizas Visual Studio Code, por ejemplo:

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

Para Sublime Text sería "subl -n -w", para Vim "vim", etc.

Puedes verificar tu configuración actual en cualquier momento con:

git config --list

Evita Problemas Comunes: Solución de Errores de Instalación de Git

Aunque la instalación de Git suele ser sencilla, ocasionalmente pueden surgir problemas. Aquí te presentamos algunos de los más comunes y sus soluciones, pensados para principiantes en Git:

• -

  Comando git no reconocido:

  • Causa: Git no se añadió correctamente a la variable de entorno PATH de tu sistema.

  • - Solución (Windows): Durante la instalación, asegúrate de seleccionar la opción para añadir Git a tu PATH. Si ya lo has instalado, puedes añadirlo manualmente desde la configuración de variables de entorno del sistema (busca "Editar las variables de entorno del sistema").

  • - Solución (macOS/Linux): Asegúrate de que la instalación se completó sin errores y que tu terminal está configurada para reconocer los ejecutables en /usr/local/bin (para Homebrew) o las rutas estándar. Cierra y vuelve a abrir tu terminal.

• Permisos de instalación insuficientes:

  • - Causa: Intentas instalar Git en un directorio sin los permisos necesarios.

  • - Solución: Ejecuta el instalador como administrador (Windows) o usa sudo (Linux/macOS) si es necesario para la instalación del gestor de paquetes (ej. sudo apt install git).

• Problemas con SSL/Certificados al clonar/hacer push:

  • - Causa: A veces, las redes corporativas o configuraciones de seguridad pueden interferir.

  • - Solución temporal (no recomendada a largo plazo):

    git config --global http.sslVerify false

    Esta opción deshabilita la verificación SSL y no es segura para entornos de producción. La solución adecuada sería configurar un proxy si estás detrás de uno, o pedir a tu administrador de red que ajuste las configuraciones de firewall.

• Configuración user.name o user.email incorrecta:

  • - Causa: Los commits se muestran con un nombre o email incorrecto.

  • - Solución: Vuelve a ejecutar los comandos git config --global user.name "Tu Nombre" y git config --global user.email "[email protected]" con la información correcta. Para cambiar un commit ya realizado, necesitarás opciones más avanzadas como git commit --amend o git rebase -i (fuera del alcance de esta guía para Git desde cero).

Tomarse el tiempo para una correcta instalación y configuración de Git te ahorrará muchos dolores de cabeza y te permitirá empezar a trabajar sin problemas. ¡Estás listo para el siguiente paso y comenzar a dominar Git!

---

Comandos Git Básicos para Principiantes: Tu Kit de Supervivencia

Una vez que Git está instalado y configurado, es hora de poner manos a la obra con los comandos Git básicos. Estos son los pilares de tu interacción diaria con el control de versiones. Aquí te explicaremos cómo usar Git con ejemplos prácticos para que puedas empezar a aplicar el versionado de código de inmediato.

Para nuestros ejemplos Git, vamos a imaginar que estamos creando la documentación para un nuevo proyecto de dCreations.es, llamado "dCreations-Docs".

Git Init: Cómo Inicializar un Repositorio Git Local

El comando git init es el primer paso para comenzar a usar Git en un proyecto. Convierte un directorio existente en un nuevo repositorio Git local, o crea uno nuevo y lo inicializa. Esencial para aprender Git.

¿Para qué sirve? Para que Git pueda empezar a rastrear los cambios en los archivos de un proyecto, es necesario "inicializar" ese proyecto como un repositorio Git.

Cómo usarlo:

1. Crea una nueva carpeta para tu proyecto (si no la tienes ya). Por ejemplo:

   mkdir dCreations-Docs
   cd dCreations-Docs

2. Dentro de esa carpeta, ejecuta git init:

   git init

Qué sucede: Al ejecutar git init, Git crea una subcarpeta oculta llamada .git dentro de tu directorio de proyecto. Esta carpeta contiene todos los metadatos necesarios para que Git funcione, incluyendo el historial de commits, las ramas, la configuración, etc. ¡Nunca borres ni modifiques manualmente la carpeta .git!

Initialized empty Git repository in /ruta/a/tu/proyecto/dCreations-Docs/.git/

Ahora tu proyecto dCreations-Docs es un repositorio Git local, listo para empezar a registrar cambios.

Git Add: Añadiendo Archivos al Área de Preparación (Staging Area)

El comando git add es fundamental para preparar los cambios que quieres guardar en tu historial. No guarda los cambios directamente, sino que los mueve a un "área de preparación" (también conocida como "staging area" o "índice"). Este es un paso intermedio crucial antes de realizar un commit.

¿Para qué sirve? Permite seleccionar específicamente qué cambios (archivos nuevos, modificados o eliminados) deseas incluir en tu próximo commit. Esto te da un control granular sobre tu historial de versiones y es clave para un buen flujo de trabajo Git.

Cómo usarlo: Vamos a crear un archivo en nuestro proyecto dCreations-Docs y añadirlo.

1. Crea un archivo de ejemplo:

   echo "# Bienvenid@ a dCreations Docs" > README.md
               echo "¡Hola mundo!" > index.html

2. Añadir un archivo específico al área de preparación:

   git add README.md

3. Añadir todos los archivos modificados/nuevos al área de preparación:

   git add .

   Este comando es muy común, ya que añade todos los cambios en el directorio de trabajo actual al área de preparación.

4. Añadir archivos solo si ya han sido rastreados (útil para modificaciones):

   git add -u

Qué sucede: Después de git add, los archivos seleccionados están listos para ser "guardados" en un commit. No se han guardado permanentemente aún; solo están esperando en el staging area.

Git Commit: Guardando Tus Cambios con Mensajes Significativos

El comando git commit es el corazón del control de versiones. Toma los cambios que has añadido al área de preparación (git add) y los guarda permanentemente en el historial de tu repositorio Git. Cada commit es una "instantánea" de tu proyecto en un momento dado, un hito seguro al que puedes regresar.

¿Para qué sirve? Para registrar una versión de tu proyecto en el historial de Git. Cada commit debe ir acompañado de un mensaje que describa de forma clara y concisa los cambios realizados. Este mensaje es vital para la trazabilidad y la colaboración.

Cómo usarlo: Después de haber añadido tus archivos al área de preparación con git add, puedes hacer un commit Git:

git commit -m "Mensaje descriptivo del commit"

La opción -m te permite proporcionar el mensaje del commit directamente en la línea de comando. Para mensajes más largos y estructurados, simplemente ejecuta git commit sin -m, y Git abrirá tu editor de texto predeterminado (configurado anteriormente) para que escribas el mensaje.

Ejemplo: Continuando con nuestro proyecto dCreations-Docs:

git add .
git commit -m "feat: Añadir archivos iniciales de documentación (README y index)"

Qué sucede: Git guarda los cambios como un nuevo commit en tu historial. Cada commit tiene un hash único (un identificador largo), el autor, la fecha y el mensaje que proporcionaste. Este es un punto seguro al que puedes regresar en el futuro.

Una buena práctica es que el mensaje del commit sea conciso (primera línea de menos de 50 caracteres) y descriptivo, indicando el tipo de cambio (ej. feat: para nuevas funcionalidades, fix: para correcciones de errores).

Git Status: Verificando el Estado de Tu Repositorio

El comando git status es tu mejor amigo para entender qué está pasando en tu repositorio Git. Te proporciona un resumen detallado del estado actual de tu directorio de trabajo y del área de preparación. Es el comando que usarás constantemente.

¿Para qué sirve? Para saber qué archivos han sido modificados, cuáles están listos para ser committeados (en el staging area), y cuáles son nuevos y aún no están siendo rastreados por Git. Es vital para saber dónde te encuentras en tu flujo de trabajo Git y qué acciones necesitas tomar a continuación.

Cómo usarlo: Simplemente ejecuta:

git status

Ejemplos de salidas:

1. Repositorio limpio (nada pendiente):

   On branch main
   Your branch is up to date with 'origin/main'.
   
   nothing to commit, working tree clean
   

   (Si aún no hay commits en la rama principal, te indicará "No commits yet". Una vez tengas commits y estés enlazado a un remoto, dirá "Your branch is up to date with 'origin/main'" y "nothing to commit, working tree clean").

2. Archivos nuevos sin rastrear: Si creas un nuevo archivo, por ejemplo styles.css:

   echo "body { color: blue; }" > styles.css
   git status

   Salida:

   On branch main
   Untracked files:
       (use "git add <file>..." to include in what will be committed)
       styles.css
   
   nothing added to commit but untracked files present (use "git add" to track)
   

   Git te informa de que styles.css es un "Untracked file" (archivo sin rastrear) y te sugiere usar git add para incluirlo.

3. Archivos modificados y en el área de preparación: Modificamos README.md y lo añadimos:

   echo "Más contenido sobre Git." >> README.md
   git add README.md
   git status

   Salida:

   On branch main
   Changes to be committed:
       (use "git restore --staged <file>..." to unstage)
       modified:   README.md
   

   Aquí, README.md está en el área de preparación, listo para el commit. Git incluso te da una pista para "unstage" (deshacer el add) si cambias de opinión.

4. Archivos modificados pero NO en el área de preparación: Modificamos index.html pero no lo añadimos:

   echo "<p>Contenido adicional para la web de dCreations.</p>" >> index.html
   git status

   Salida:

   On branch main
                       Changes not staged for commit:
                           (use "git add <file>..." to update what will be committed)
                           (use "git restore <file>..." to discard changes in working directory)
                           modified:   index.html
                       
                       no changes added to commit (use "git add" and/or "git commit -a)")
                       

   index.html ha sido modificado, pero esos cambios aún no están en el área de preparación. Git te sugiere git add para incluirlos.

Dominar git status te da la confianza para saber siempre el estado actual de tu proyecto y qué acciones necesitas tomar a continuación. Es una herramienta clave para un flujo de trabajo Git eficiente y una habilidad fundamental para cualquier desarrollador Git.

---

Trabajando con Repositorios Remotos: Git Push, Git Pull y Git Clone

Hasta ahora, hemos trabajado con un repositorio Git local en tu ordenador. Sin embargo, para colaborar con otros desarrolladores, compartir tu trabajo o para tener una copia de seguridad de tu proyecto en la nube, necesitas un repositorio remoto. Plataformas como GitHub, GitLab o Bitbucket son las más populares para alojar estos repositorios remotos.

Estos comandos son esenciales para interactuar con esos repositorios remotos, permitiéndote compartir tu trabajo y mantener tu copia local actualizada. Te guiarán en cómo usar Git en entornos colaborativos.

Git Clone: Copiando un Repositorio Remoto a Tu Ordenador

El comando git clone se utiliza para copiar un repositorio existente desde una ubicación remota (como GitHub) a tu máquina local. Es la forma más común de obtener una copia inicial de un proyecto Git.

¿Para qué sirve? Es la manera de obtener una copia completa de un proyecto Git existente. Descarga todo el historial del proyecto, todas sus ramas y establece automáticamente la conexión con el repositorio remoto original.

Cómo usarlo: Necesitarás la URL del repositorio remoto. Por ejemplo, si tienes un repositorio en GitHub:

git clone <URL_del_repositorio>

Ejemplo: Imagina que el repositorio de dCreations-Docs ya existe en GitHub en la URL https://github.com/dcreations/dCreations-Docs.git.

git clone https://github.com/dcreations/dCreations-Docs.git

Qué sucede:

1. Git creará una nueva carpeta con el nombre del repositorio (dCreations-Docs en este caso) en el directorio donde ejecutaste el comando.

2. Dentro de esa carpeta, descargará todos los archivos del proyecto y su historial completo.

3. Automáticamente configurará una conexión remota llamada origin que apunta a la URL del repositorio del que clonaste.

Cloning into 'dCreations-Docs'...
remote: Enumerating objects: 5, done.
remote: Counting objects: 100% (5/5), done.
remote: Compressing objects: 100% (3/3), done.
remote: Total 5 (delta 0), reused 0 (delta 0), pack-reused 0
Receiving objects: 100% (5/5), done.

Ahora tienes una copia local del proyecto dCreations-Docs y estás listo para empezar a trabajar en él y aplicar tu flujo de trabajo Git.

Git Push: Subiendo Tus Cambios a un Repositorio Remoto

El comando git push se utiliza para enviar los commits que has realizado en tu repositorio Git local al repositorio remoto.

¿Para qué sirve? Para compartir tus cambios con otros colaboradores y para tener una copia de seguridad actualizada de tu trabajo en la plataforma remota. Es fundamental para la sincronización y la colaboración en equipo.

Cómo usarlo: Una vez que hayas hecho commits en tu rama local, puedes subirlos al remoto:

git push <nombre_remoto> <nombre_rama>

Comúnmente, el nombre remoto es origin (el que Git configura por defecto al clonar) y la rama principal suele ser main o master.

Ejemplo: Si has hecho algunos commits en tu rama main local:

# Asegúrate de estar en la rama correcta, por ejemplo, main
git branch # Para verificar la rama actual
git push origin main

La primera vez que haces git push en una rama nueva, es posible que tengas que establecer el "upstream" (rama de seguimiento) con:

git push -u origin main

-u (o --set-upstream) le dice a Git que tu rama local main debe rastrear la rama main en origin. Después de esto, los git push futuros solo necesitarán git push (sin especificar origin main), lo que simplifica tu flujo de trabajo Git.

Qué sucede: Git intentará enviar tus commits al repositorio remoto. Si no hay conflictos y tu rama remota está actualizada, tus cambios se subirán exitosamente.

Enumerating objects: 7, done.
Counting objects: 100% (7/7), done.
Delta compression using up to 8 threads
Compressing objects: 100% (4/4), done.
Writing objects: 100% (4/4), 406 bytes | 406.00 KiB/s, done.
Total 4 (delta 0), reused 0 (delta 0), pack-reused 0
To https://github.com/dcreations/dCreations-Docs.git
   f3a6c1d..b8e9f0g  main -> main

Git Pull: Descargando Actualizaciones Desde un Repositorio Remoto

El comando git pull se utiliza para descargar los cambios desde un repositorio remoto y fusionarlos automáticamente con tu rama local actual.

¿Para qué sirve? Para mantener tu copia local del proyecto actualizada con los últimos cambios realizados por otros colaboradores en el repositorio remoto. Es esencial para la colaboración fluida y para evitar conflictos importantes.

Cómo usarlo:

git pull <nombre_remoto> <nombre_rama>

Comúnmente:

git pull origin main

Qué sucede: git pull es en realidad una combinación de dos operaciones internas de Git:

1. git fetch: Descarga los cambios del remoto a tu repositorio local, pero no los integra aún en tu directorio de trabajo.

2. git merge: Fusiona esos cambios descargados con tu rama local actual.

Si hay nuevos cambios en el remoto, Git los descargará y los aplicará a tu código.

remote: Enumerating objects: 3, done.
remote: Counting objects: 100% (3/3), done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 2 (delta 1), reused 0 (delta 0), pack-reused 0
Unpacking objects: 100% (2/2), done.
From https://github.com/dcreations/dCreations-Docs
   b8e9f0g..c1d2e3f  main       -> origin/main
Updating b8e9f0g..c1d2e3f
Fast-forward
 README.md | 2 ++
 1 file changed, 2 insertions(+)

Resolviendo Conflictos de Merge (Fusión) al Hacer Git Pull

Los conflictos de merge (o conflictos de fusión) son una parte normal del trabajo en equipo con Git. Ocurren cuando dos ramas han modificado la misma parte del mismo archivo, y Git no puede decidir automáticamente qué versión mantener. Es una habilidad clave a desarrollar para dominar Git.

¿Cuándo ocurren? Principalmente al hacer git pull (que incluye un merge implícito) o git merge explícitamente, si tu repositorio local tiene cambios que chocan con los del repositorio remoto.

Cómo identificarlos: Cuando ocurre un conflicto, Git te lo informará claramente en la terminal:

Auto-merging <nombre_archivo>
CONFLICT (content): Merge conflict in <nombre_archivo>
Automatic merge failed; fix conflicts and then commit the result.

Además, los archivos con conflictos contendrán marcadores especiales que indican las secciones conflictivas.

Cómo resolverlos (paso a paso):

1. Identifica los archivos en conflicto: git status te mostrará los archivos "unmerged" (sin fusionar).

2. Abre los archivos en conflicto en tu editor de texto: Verás marcadores como estos, que señalan las dos versiones que entran en conflicto:

    <<<<<<< HEAD
       Tu versión de la línea que está en tu rama actual.
       =======
       La versión remota de la línea o la versión de la rama que estás fusionando.
       >>>>>>> <hash_del_commit_remoto_o_nombre_de_rama>
   

   • - <<<<<<< HEAD: Marca el inicio de los cambios en tu rama actual (HEAD apunta a tu último commit).

   • - =======: Separa tus cambios de los cambios entrantes.

   • - >>>>>>> <hash_del_commit_remoto_o_nombre_de_rama>: Marca el final de los cambios de la rama que estás fusionando.

3. Edita el archivo manualmente: Decide qué versión quieres mantener o cómo combinar ambas. Elimina todos los marcadores <<<<<<<, ======= y >>>>>>>. Por ejemplo, si eliges la versión remota:

   La versión remota de la línea que quieres mantener. 

   O si combinas para crear una nueva línea:

   La mejor versión combinada y final de la línea tras el merge. 

4. Marca el conflicto como resuelto: Una vez que hayas editado el archivo y quitado los marcadores de conflicto, dile a Git que has resuelto el conflicto:

   git add <nombre_archivo_resuelto>

   Repite esto para todos los archivos en conflicto que git status te indique.

5. Completa el merge: Una vez que todos los conflictos estén marcados como resueltos (con git add para cada uno), haz un nuevo commit para finalizar el merge. Git te proporcionará un mensaje de commit predeterminado que puedes editar:

   git commit -m "Merge branch 'main' of https://github.com/dcreations/dCreations-Docs into main (resolving conflicts)"

   O simplemente git commit para abrir tu editor y revisar/modificar el mensaje.

Una vez committeado, el conflicto estará resuelto y el historial de versiones se actualizará. La práctica constante te ayudará a resolver conflictos de merge con mayor facilidad y a mejorar tu flujo de trabajo Git.

---

Ramas (Branches) en Git: Trabajo en Equipo y Experimentación Segura

Las ramas son una de las características más poderosas y útiles de Git, fundamentales para el trabajo en equipo y el desarrollo de nuevas funcionalidades. Una rama Git representa una línea de desarrollo independiente dentro de tu proyecto.

Imagina que tu proyecto es un árbol. La rama principal (generalmente main o master) es el tronco. Cuando quieres añadir una nueva característica, corregir un error o probar una idea, creas una "rama" que sale de ese tronco. Puedes trabajar en esa rama, hacer tus commits Git, y experimentar sin afectar al código principal y estable. Una vez que tu trabajo está completo, probado y listo, puedes "fusionar" (merge) esa rama de vuelta al tronco principal.

Git Branch: Creando, Listando y Eliminando Ramas

El comando git branch te permite gestionar las ramas Git en tu repositorio Git local.

¿Para qué sirve? Para ver las ramas existentes en tu proyecto, crear nuevas ramas o eliminar ramas que ya no necesitas.

Cómo usarlo:

1. Listar todas las ramas:

   git branch

   • - La rama actual en la que te encuentras se indicará con un asterisco (*).

   * main
         feature/nueva-funcionalidad
         bugfix/correccion-error
   

2. Crear una nueva rama:

    git branch <nombre_de_la_nueva_rama>

   Esto solo crea la rama, pero no te cambia a ella.

   Ejemplo: Vamos a crear una rama Git para desarrollar una nueva sección de preguntas frecuentes para dCreations-Docs.

   git branch feature/faq-section

3. Eliminar una rama: Puedes eliminar una rama una vez que su trabajo ha sido fusionado en otra rama y ya no es necesaria.

   git branch -d <nombre_de_la_rama_a_eliminar>

   • - -d significa "delete" (seguro). Git no te dejará eliminar una rama que no ha sido fusionada para evitar pérdida accidental de trabajo.

   • - Para forzar la eliminación de una rama (incluso si no está fusionada, con el riesgo de perder cambios): git branch -D <nombre_de_la_rama_a_eliminar>. ¡Usa -D con extrema precaución!

   Ejemplo: Después de fusionar feature/faq-section, podemos eliminarla:

   git branch -d feature/faq-section

Git Checkout: Navegando Entre Diferentes Ramas

El comando git checkout se usa para cambiar de una rama a otra, o para crear una nueva rama y cambiarte a ella instantáneamente. Es fundamental para trabajar con el control de versiones basado en ramas.

¿Para qué sirve? Para moverte entre las diferentes líneas de desarrollo de tu proyecto. Cuando cambias de rama, Git actualiza automáticamente tu directorio de trabajo para reflejar los archivos y el historial de esa rama.

Cómo usarlo:

1. Cambiar a una rama existente:

   git checkout <nombre_de_la_rama>

   Ejemplo: Cambiando a nuestra rama de FAQ:

   git checkout feature/faq-section

   Switched to branch 'feature/faq-section'
           

2. Crear una nueva rama y cambiarte a ella inmediatamente (atajo muy útil):

    git checkout -b <nombre_de_la_nueva_rama>

   • - -b es un atajo para git branch <nueva-rama> seguido de git checkout <nueva-rama>.

   Ejemplo: Creamos y cambiamos a una rama para corregir un bug:

    git checkout -b bugfix/header-error

   Switched to a new branch 'bugfix/header-error'
                   

Git Merge: Fusionando Cambios de una Rama a Otra

El comando git merge se utiliza para combinar el historial de una rama Git en otra. Es cómo se integran las nuevas funcionalidades o las correcciones de errores en la rama principal.

¿Para qué sirve? Cuando has terminado de trabajar en una rama (por ejemplo, una rama de funcionalidad o de corrección de errores) y deseas integrar esos cambios en la rama principal o en otra rama de desarrollo. Es un paso clave en cualquier flujo de trabajo Git.

Cómo usarlo:

1. Asegúrate de estar en la rama receptora de los cambios. Por ejemplo, si quieres fusionar feature/faq-section en main, primero debes estar en main:

   git checkout main

2. Ejecuta el comando git merge seguido del nombre de la rama que quieres fusionar en la rama actual:

   git merge <nombre_de_la_rama_a_fusionar>

Ejemplo: Hemos terminado la sección de FAQ en feature/faq-section y queremos fusionarla con main.

git checkout main
# Esto asegura que estás en la rama 'main'
# Si hay cambios recientes en 'main' en el remoto, haz un pull primero para evitar conflictos
git pull origin main
git merge feature/faq-section

Qué sucede: Git intentará combinar los cambios. Pueden ocurrir dos tipos de merge:

• - Fast-forward merge: Si la rama receptora (ej. main) no ha tenido nuevos commits desde que se creó la rama que se va a fusionar, Git simplemente "avanza" el puntero de la rama receptora hasta el último commit de la otra rama. No se crea un nuevo commit de merge.

  Updating b8e9f0g..c1d2e3f
  Fast-forward
     docs/faq.md | 10 ++++++++++
     1 file changed, 10 insertions(+)
  

• - Three-way merge (Merge commit): Si ambas ramas han divergido (han tenido commits nuevos independientemente desde que la rama de origen fue creada), Git creará un nuevo "commit de merge" que combina los historiales de ambas ramas.

  Merge made by the 'recursive' strategy.
      README.md | 2 ++
      1 file changed, 2 insertions(+)
  

  Si hay conflictos de merge, Git te lo indicará y deberás resolverlos manualmente antes de completar el commit de merge (como se explicó en la sección anterior).

Flujo de Trabajo con Ramas: Gitflow para Principiantes

Aunque existen varios flujos de trabajo Git (como GitHub Flow, GitLab Flow, Trunk-Based Development), el Gitflow es uno de los más estructurados y populares, especialmente para proyectos con ciclos de lanzamiento definidos. Para principiantes en Git, entender la lógica básica de las ramas es suficiente para empezar a dominar Git.

Conceptos clave del flujo de trabajo con ramas (simplificado):

1. main (o master): Esta rama siempre debe contener código estable, listo para producción. Los commits directos a main son raros y se desaconsejan.

2. develop: Esta rama es la principal para el desarrollo activo. Todos los nuevos features se fusionan aquí. Es el punto de integración para el trabajo diario.

3. Ramas de feature:

   • - Se crean a partir de develop para desarrollar una nueva funcionalidad o mejora.

   • - Nomenclatura común: feature/<nombre-de-la-funcionalidad> (ej. feature/user-authentication).

   • - Trabajas en esta rama, haces tus commits aisladamente.

   • - Una vez terminada y probada, se fusiona de vuelta a develop.

4. Ramas de hotfix:

   • - Se crean a partir de main (o master) para corregir errores críticos en producción que no pueden esperar a la próxima versión.

   • - Nomenclatura común: hotfix/<nombre-del-bug> (ej. hotfix/login-bug).

   • - Una vez corregido y probado, se fusiona tanto a main (para la corrección inmediata en producción) como a develop (para incorporar el fix al desarrollo futuro y evitar que reaparezca).

5. Ramas de release (opcional para principiantes):

   • - Se crean a partir de develop cuando el desarrollo de una nueva versión está completo y listo para ser probado para un lanzamiento.

   • - Aquí se realizan los últimos arreglos y se prepara el código para el despliegue. Una vez lista, se fusiona a main (para el lanzamiento) y también de vuelta a develop (para asegurar que cualquier ajuste final se incorpore al desarrollo continuo).

Este flujo de trabajo Git basado en ramas permite una gran flexibilidad y seguridad, ya que el desarrollo principal (develop) y la versión estable (main) están protegidos, y los cambios se integran de forma controlada.

---

Conclusión: Tu Camino para Dominar Git

Felicidades. Has completado una inmersión profunda en Git para principiantes, desde la instalación y configuración hasta los comandos Git básicos y la comprensión de los repositorios remotos y el potente concepto de las ramas. Ahora tienes las herramientas y el conocimiento para empezar a utilizar esta indispensable herramienta de control de versiones en tus proyectos.

Recuerda que la clave para dominar Git es la práctica constante. Crea tus propios proyectos, experimenta con los comandos, colabora con otros y no temas cometer errores. Git está diseñado precisamente para ayudarte a recuperarte de ellos. Con cada commit, cada pull y cada merge, te sentirás más cómodo y eficiente en tu flujo de trabajo Git.

En dCreations.es, estamos comprometidos a ofrecerte el mejor contenido para programadores, diseñadores y emprendedores digitales. Esperamos que este tutorial Git en español te haya sido de gran utilidad.

¿Listo para tu siguiente paso? Te animamos a explorar nuestros otros tutoriales y guías, o a poner en práctica lo aprendido creando tu primer repositorio Git en GitHub o GitLab. ¡El mundo del desarrollo te espera!