# Trabajar en dos cosas a la vez

URL canónica: https://missyera.com/guias/git-desde-cero/ramas/
Última actualización: 2026-11-17
Autora: Gera Flores (Miss Yera)

> **Respuesta corta**
>
> Una rama es un nombre que apunta a un commit. Nada más. Lo que a mí me confundió años es que suena a copiar la carpeta, y no se copia nada: cambiar de rama es mover un puntero y que Git te acomode los archivos. Por eso es instantáneo aunque el proyecto sea enorme 🌿

Capítulo 10 de 33 del libro [Git desde cero](https://missyera.com/guias/git-desde-cero.md).

![Grafo de commits donde tras el commit B la historia se separa en dos caminos: uno sigue a C y es main, que queda estable, y otro sigue a D y E, que es la rama nueva donde se trabaja.](https://missyera.com/static/diagramas/webp/git-10-ramas.webp)

*Una rama no copia archivos ni ocupa espacio: es un nombre apuntando a un commit. Por eso crear una y borrarla cuesta lo mismo que escribir el comando.*

## Para qué sirven

Estás con el reporte nuevo y llega un arreglo urgente. Con una sola rama tienes las dos cosas mezcladas en la misma carpeta y no puedes entregar una sin la otra.

Con ramas trabajas en dos líneas de tiempo distintas y saltas entre ellas.

```bash
mkdir tienda
cd tienda
git init -q
printf 'ciudad,monto\nLima,1200\n' > ventas.csv
git add ventas.csv
git commit -q -m "Primeras ventas de Lima"
git branch
```

```text
* main
```

Una sola rama, `main`, y el asterisco dice que estás en ella.

## Crear y entrar, en un solo movimiento

```bash
git switch -c reporte-por-canal
git branch
```

```text
Switched to a new branch 'reporte-por-canal'
  main
* reporte-por-canal
```

El `-c` es de crear. Ojo con esto porque es donde más gente se tropieza: `git branch nombre` crea la rama pero **no te lleva a ella**, y terminas haciendo los commits en el sitio equivocado.

Trabajo aquí:

```bash
printf 'canal\nbodega\n' > canales.csv
git add canales.csv
git commit -q -m "Se agrega el catalogo de canales"
git log --oneline
```

```text
c516683 Se agrega el catalogo de canales
54da6e2 Primeras ventas de Lima
```

## Y ahora el salto

```bash
git switch main
ls
git log --oneline
```

```text
Switched to branch 'main'
ventas.csv
54da6e2 Primeras ventas de Lima
```

Aquí está la magia: `canales.csv` **no está**. No se borró, está en la otra rama. Tu carpeta cambia de contenido según dónde estés parada, y por eso hay que mirar en qué rama estás antes de empezar a trabajar 🧭

Hago el arreglo urgente aquí, tranquila:

```bash
printf 'Arequipa,890\n' >> ventas.csv
git add ventas.csv
git commit -q -m "Urgente, entran las ventas de Arequipa"
git log --all --oneline --graph
```

```text
* 1976933 Urgente, entran las ventas de Arequipa
| * c516683 Se agrega el catalogo de canales
|/
* 54da6e2 Primeras ventas de Lima
```

Dos líneas de tiempo que salieron del mismo punto. Juntarlas es el capítulo 11.

## Borrar una rama

```bash
git switch -c prueba
git switch main
git branch -d prueba
git branch
```

```text
Switched to a new branch 'prueba'
Switched to branch 'main'
Deleted branch prueba (was 1976933).
* main
  reporte-por-canal
```

Se borró sin quejarse porque no tenía nada que perder. Pero si la rama tiene commits que no están en ningún otro sitio, Git se planta:

```bash
git branch -d reporte-por-canal
```

```
error: the branch 'reporte-por-canal' is not fully merged.
If you are sure you want to delete it, run 'git branch -D reporte-por-canal'
```

*Not fully merged*: ahí dentro hay trabajo que no está en `main`. Ese aviso ha salvado muchísimo trabajo, y por eso la `-D` mayúscula conviene tratarla con el mismo respeto que `reset --hard`.

La trampa

Te piden un cambio urgente en el reporte de ventas mientras estás a medias con otra cosa. Creas la rama para el arreglo urgente y te pones a trabajar.

```
$ git branch arreglo-urgente
$ nano reporte.py         # haces el arreglo
$ git add reporte.py
$ git commit -m "Arreglo urgente del reporte"
$ git branch

  arreglo-urgente
* main
```

**Qué está mal**

El commit se fue a `main`, no a la rama 🌿

`git branch` **crea** la rama pero no te lleva a ella. Es la diferencia entre poner un marcador en el mapa y caminar hasta ahí. Fíjate en el asterisco de la salida: sigue en `main`.

Por eso en este libro siempre uso `git switch -c`, que crea y entra en el mismo movimiento. `git branch` a secas lo dejo solo para listar.

Si ya te pasó no perdiste nada: el commit existe, solo está en la rama equivocada. Con lo del capítulo 7 y una rama nueva se mueve de sitio.

## Comprueba que se entendió

Comprueba que lo tienes

Estás en una rama, haces `git switch main` y un archivo tuyo desaparece de la carpeta. ¿Qué pasó?

- Se borró y hay que recuperarlo
- Está en la otra rama, vuelve y aparece
- Git lo mandó al stash
- Hay que hacer un merge para recuperarlo

## Ejercicios

**1. Vuelve a tu rama y comprueba**

Regresa a la rama del reporte y mira que el archivo está.

```bash
git switch reporte-por-canal
ls
```

```text
Switched to branch 'reporte-por-canal'
canales.csv
ventas.csv
```

Ahí estaba, sano y salvo. Cambiar de rama es gratis y no pierde nada, y eso es lo que hay que interiorizar.

**2. Y que aquí falta lo urgente**

Mira el CSV de ventas en esta rama.

```bash
cat ventas.csv
```

```text
ciudad,monto
Lima,1200
```

Arequipa no está, porque ese commit vive en `main`. Las dos ramas tienen versiones distintas del mismo archivo y las dos son correctas.

**3. Una rama por cada cosa**

Crea una tercera rama para el catálogo de clientes y haz un commit ahí.

```bash
git switch main
git switch -c catalogo-clientes
printf 'bodega,ciudad\nBodega Sol,Lima\n' > clientes.csv
git add clientes.csv
git commit -q -m "Se agrega el catalogo de bodegas"
git branch
```

```text
Switched to branch 'main'
Switched to a new branch 'catalogo-clientes'
* catalogo-clientes
  main
  reporte-por-canal
```

Tres ramas, tres asuntos separados. Este es el flujo normal de cualquier proyecto con más de una persona.

**4. Mira el árbol completo**

Dibuja todas las ramas a la vez.

```bash
git log --all --oneline --graph
```

```text
* 4152b62 Se agrega el catalogo de bodegas
* 1976933 Urgente, entran las ventas de Arequipa
| * c516683 Se agrega el catalogo de canales
|/
* 54da6e2 Primeras ventas de Lima
```

Se ve el tronco común y de dónde sale cada rama. Este dibujo es lo que uso para explicarle Git a alguien en dos minutos 🎨

**5. En qué rama estoy**

Pregunta solo el nombre de la rama actual.

```bash
git branch --show-current
```

```text
catalogo-clientes
```

Un comando de una línea que evita la mitad de los accidentes. Yo lo tengo puesto en la propia terminal para verlo siempre.

**6. Qué ramas ya están juntas con main**

Lista las ramas cuyo trabajo ya está en la rama actual.

```bash
git switch main
git branch --merged
```

```text
Switched to branch 'main'
* main
```

Solo aparece `main`, porque las otras dos tienen commits propios. Este comando dice cuáles se pueden borrar sin pensarlo.

**7. Intenta borrar una rama con trabajo dentro**

Prueba a borrar la del catálogo de clientes.

```bash
git branch -d catalogo-clientes
```

```
error: the branch 'catalogo-clientes' is not fully merged.
If you are sure you want to delete it, run 'git branch -D catalogo-clientes'
```

Git te frena y te dice cómo insistir si de verdad quieres. Ese "si estás segura" es de las mejores cosas que tiene 🛑

## Lo que te llevas

**Una rama es un nombre que apunta a un commit. Cambiar de rama no copia nada, mueve un puntero.**

## Preguntas frecuentes

### ¿Qué es una rama en Git?

Una línea de trabajo paralela. Te llevas una copia de la historia, trabajas ahí sin tocar lo que funciona, y cuando está listo se junta.

### ¿Cómo creo una rama?

Con git switch -c y el nombre. La versión antigua es git checkout -b y hace lo mismo.

### ¿Qué hace git merge?

Junta el trabajo de una rama con otra. Si las dos tocaron la misma línea, aparece un conflicto y hay que decidir a mano cuál se queda.

### ¿Cuál es la diferencia entre git pull y git fetch?

fetch trae lo que hay en el remoto y no toca tus archivos. pull hace lo mismo y además lo junta con lo tuyo. Cuando algo sale raro, fetch primero y mirar.

## Seguir leyendo

- Anterior: [Por qué tu repositorio pesa quinientos megas](https://missyera.com/guias/git-desde-cero/ignorar-archivos.md)
- Siguiente: [Juntar dos ramas y entender el conflicto](https://missyera.com/guias/git-desde-cero/fusionar-y-conflictos.md)

## Contacto

- Diagnóstico de 30 minutos con Miss Yera: https://calendly.com/soymissyera/reunion-con-yera
- Correo: hola@missyera.com
- Esta página en HTML: https://missyera.com/guias/git-desde-cero/ramas/
- Índice de todas las páginas en texto: https://missyera.com/llms-index.txt
