Ramas e historial

Una rama es una línea de desarrollo independiente. Te permite trabajar en una funcionalidad nueva sin tocar la versión principal (main), que permanece estable.

Analogía: un documento compartido. En vez de editar directamente la versión oficial (riesgo de romperlo todo), trabajas en una copia de trabajo (la rama). Cuando estás satisfecho, fusionas tus cambios en el original.

Por qué es esencial:

• Aislamiento: un trabajo experimental nunca rompe la versión estable.
• Colaboración: cada uno trabaja en su rama, sin molestarse.
• Organización: una rama = una funcionalidad o una corrección.

# Listar las ramas (la actual está marcada con un *)
git branch

# Crear una rama
git branch feature-connexion

# Cambiar de rama
git switch feature-connexion

# Crear Y cambiar en un solo comando (recomendado)
git switch -c feature-connexion

git switch es el comando moderno dedicado a las ramas. git checkout sigue funcionando pero hace demasiadas cosas a la vez — prefiere switch para las ramas.

🔧 Mini-ejercicio — Escribe el comando que crea la rama feature-login y cambia a ella en una sola operación.

git switch -c feature-login

Fusionar (merge) es integrar los cambios de una rama en otra — típicamente, traer tu funcionalidad terminada a main.

# 1. Situarse en la rama que va a RECIBIR los cambios
git switch main

# 2. Fusionar la rama de funcionalidad dentro
git merge feature-connexion

# Tras una fusión exitosa, se puede borrar la rama
git branch -d feature-connexion

Regla simple: te sitúas en la rama de destino (main), luego fusionas la rama origen dentro. «Estoy en main, aspiro feature».

🔧 Mini-ejercicio — Estás en feature-login y el trabajo está terminado. Escribe los dos comandos para fusionar esta rama en main.

git switch main
git merge feature-login

Un conflicto aparece cuando dos ramas han modificado la misma línea de un mismo archivo. Git no puede elegir por ti: te pide que decidas.

Git inserta marcadores en el archivo en conflicto:

<<<<<<< HEAD
texto de la rama actual (main)
=======
texto de la rama fusionada (feature)
>>>>>>> feature-connexion

Para resolver:

1. Abrir el archivo, elegir el contenido correcto (o combinar los dos).
2. Borrar los marcadores <<<<<<<, =======, >>>>>>>.
3. git add archivo y luego git commit para finalizar la fusión.

Un conflicto no es un error grave: es Git protegiéndote al negarse a adivinar. Mantén la calma, lee las dos versiones, quédate con la buena.

🔧 Mini-ejercicio — Cita los tres marcadores que Git inserta en un archivo en conflicto y que hay que borrar tras la resolución.

# Historial completo
git log

# Versión compacta (una línea por commit)
git log --oneline

# Con el grafo de las ramas y fusiones
git log --oneline --graph --all

# Ver las modificaciones de un commit
git show <hash>

# Ver quién modificó cada línea de un archivo
git blame fichier.txt

El historial Git es una máquina del tiempo. Bien usado (con buenos mensajes de commit), permite entender por qué el código está en su estado actual.

🔧 Mini-ejercicio — Escribe el comando que muestra el historial de forma compacta, con el grafo de las ramas y todas las ramas.

git log --oneline --graph --all

Question 1: ¿Para qué sirve una rama?

a) Para borrar el historial

b) Para desarrollar de forma aislada sin tocar la versión principal

c) Para conectarse a GitHub

d) Para compilar el código

Question 2: ¿Qué comando crea una rama Y cambia a ella?

a) git branch nom

b) git switch -c nom

c) git merge nom

d) git log nom

Question 3: Para fusionar feature en main, primero debo…

a) Situarme en feature y luego hacer git merge main

b) Situarme en main y luego hacer git merge feature

c) Borrar main

d) Hacer git init

Question 4: ¿Cuándo aparece un conflicto de fusión?

a) Cuando dos ramas modifican la misma línea del mismo archivo

b) En cada fusión, sistemáticamente

c) Cuando se crea una rama

d) Cuando se instala Git

Question 5: ¿Qué comando muestra el historial con el grafo de las ramas?

a) git status

b) git log --oneline --graph --all

c) git branch -d

d) git add .

Consigna

En un repositorio existente, crea una rama, haz un commit en ella, luego fusiónala en main y consulta el grafo.

Corrección — Secuencia de comandos esperada

# 1. Partir de main al día
git switch main

# 2. Crear y cambiar a una rama de funcionalidad
git switch -c feature-titre

# 3. Trabajar y commitear en la rama
echo "## Nueva sección" >> README.md
git add README.md
git commit -m "Añade una nueva sección al README"

# 4. Volver a main y fusionar
git switch main
git merge feature-titre

# 5. Limpiar la rama fusionada
git branch -d feature-titre

# 6. Visualizar el historial
git log --oneline --graph --all

Resultado esperado: el commit de la rama aparece en el historial de main, y git branch ya no lista feature-titre.

Este ciclo — crear una rama, trabajar, fusionar, borrar — es el flujo de trabajo diario de un desarrollador. Lo repetirás cientos de veces.

Puntos a recordar

1. Una rama = una línea de desarrollo aislada; main permanece estable.
2. git switch -c nom crea y cambia a una rama.
3. Fusionar: situarse en el destino (main), luego git merge origen.
4. Un conflicto aparece en las mismas líneas modificadas en los dos lados; se resuelve a mano.
5. git log --oneline --graph --all visualiza la historia y las ramas.

A continuación

Lección 08 — Repositorio remoto: compartir tu trabajo en línea y colaborar vía un servidor Git (GitHub).