Crear y cambiar de rama en Git sin perder tu trabajo

Llevas dos semanas haciendo commits directamente en main. Todo funciona, y justo por eso te da miedo tocar nada. Quieres probar una idea que quizá rompa medio proyecto, pero no te atreves porque ese código es el bueno. Aquí es donde entra crear una rama en Git: una zona aparte donde experimentar sin arriesgar lo que ya está bien. Te explico qué es una rama de verdad, cómo crear una y cómo moverte entre ellas con git branch, git switch y git checkout, sin perder una sola línea por el camino.

Para seguir este post necesitas saber hacer un commit. Si ya has escrito git add y git commit alguna vez, vas sobrado.

¿Qué es una rama en Git, en realidad?

Una rama en Git es un puntero movible que apunta a un commit concreto. Olvídate de carpetas, de copias de tus archivos o de un ZIP del proyecto: una rama es solo una etiqueta que dice “el trabajo de esta línea va por aquí”.

Piensa en tu historial de commits como una fila de fotos, cada commit es una foto del proyecto en un momento dado. Una rama es un post-it pegado en una de esas fotos. Cuando haces un commit nuevo, el post-it se despega solo y se pega en la foto más reciente. Por eso decimos que el puntero es movible: te sigue mientras trabajas.

main es una rama como cualquier otra. Lo único especial es que es la que Git crea por defecto. Y hay un segundo puntero, HEAD, que marca en qué rama estás ahora mismo. Cuando creas una rama nueva, Git solo escribe un puntero más apuntando al mismo commit. Nada se copia. Por eso crear una rama es instantáneo aunque tu proyecto tenga miles de archivos.

Si quieres el modelo completo de cómo encajan ramas, commits y punteros, lo tienes en la guía completa de ramas en Git. Aquí vamos a lo práctico: los comandos.

¿Cómo veo las ramas que ya tengo?

El comando git branch, sin nada más detrás, lista todas las ramas locales de tu repositorio. La rama en la que estás ahora aparece marcada con un asterisco.

# Lista todas las ramas locales del proyecto
git branch

En un proyecto recién empezado, la salida será algo así:

* main

El nombre exacto de esa primera rama, main o master, depende de cómo tengas configurado Git; hoy lo habitual es main, así que no te asustes si en tu máquina ves master. Ese asterisco es lo importante. Te dice dónde está HEAD, es decir, en qué rama caerán tus próximos commits. Si mañana tienes cinco ramas, este comando te dice de un vistazo en cuál estás parado antes de tocar nada. Acostúmbrate a lanzarlo cuando dudes.

¿Cómo creo una rama nueva?

El comando git branch nombre crea una rama nueva a partir del commit en el que estás, pero no te cambia a ella. Sigues exactamente donde estabas.

# Crea una rama llamada 'nueva-funcion' a partir de donde estás ahora
git branch nueva-funcion

Git no imprime nada si todo va bien. Y aquí está la trampa que pilla a casi todo el mundo al empezar. Si vuelves a listar las ramas, verás las dos, pero el asterisco no se ha movido:

* main
  nueva-funcion

Has creado la rama, sí. Pero sigues en main. Cualquier commit que hagas ahora va a main, no a nueva-funcion. Ese es el motivo por el que git branch solo se usa para crear ramas que vas a dejar aparcadas, o para listar. Para trabajar en la rama nueva, primero tienes que cambiarte a ella.

¿Cómo me cambio a otra rama?

El comando git switch nombre te mueve a una rama que ya existe y actualiza los archivos de tu directorio de trabajo para que coincidan con esa rama.

# Te mueve a la rama 'nueva-funcion' y ajusta tus archivos a esa rama
git switch nueva-funcion

La salida te confirma el cambio:

Switched to branch 'nueva-funcion'

¿Qué significa eso de “actualiza los archivos”? Que Git reescribe tu directorio de trabajo para que se vea como la rama a la que has saltado. Si nueva-funcion tiene un archivo que no está en main, aparece. Si en main habías borrado algo que en la otra rama existe, vuelve. Aquí no hay magia ni peligro: cada rama tiene su propia foto del proyecto, y switch te pone delante de la foto correcta. Tus commits guardados no se tocan, solo cambia lo que ves en el editor.

Ahora tus commits caen en nueva-funcion. main sigue intacto, tal cual lo dejaste, esperándote.

El atajo: crear y cambiar en un solo comando

Crear con un comando y cambiarte con otro funciona, pero casi nunca quieres crear una rama para dejarla vacía. Quieres crearla y empezar a trabajar en ella ya. Para eso está git switch -c nombre, que hace las dos cosas de una vez: crea la rama y te cambia a ella.

# Crea la rama 'arreglo-login' y te cambia a ella en un solo paso
git switch -c arreglo-login

La -c es de “create”. La salida cambia ligeramente respecto al switch normal, porque ahora la rama es nueva:

Switched to a new branch 'arreglo-login'

Existe un equivalente más antiguo que verás en muchísimos tutoriales: git checkout -b nombre. Hace exactamente lo mismo, crea la rama y te cambia a ella.

# El clásico: crea 'arreglo-login' y te cambia, igual que switch -c
git checkout -b arreglo-login

Los dos comandos producen el mismo resultado. La diferencia está en cuál conviene usar hoy.

¿git switch o git checkout, cuál uso?

Usa git switch. Es más claro y hace una sola cosa: moverte entre ramas. git checkout sigue siendo válido, pero es un comando muy cargado que también sirve para descartar cambios en archivos, recuperar versiones antiguas y más cosas. Esa sobrecarga es justo lo que hace que un principiante se equivoque y descarte trabajo sin querer.

Git separó esa responsabilidad en dos comandos nuevos, git switch para cambiar de rama y git restore para descartar cambios. git switch apareció en Git 2.23 (2019) y hoy es un comando estable y recomendado. Si en algún tutorial lo ves descrito como “experimental”, ese dato está desactualizado.

Aquí tienes los cuatro comandos de este post en una tabla, para que veas de un golpe qué hace cada uno:

Comando	¿Crea la rama?	¿Te cambia a ella?
git branch arreglo-login	Sí	No, sigues donde estabas
git switch arreglo-login	No, la rama debe existir ya	Sí
git switch -c arreglo-login	Sí	Sí, en un solo paso
git checkout -b arreglo-login	Sí (versión clásica)	Sí

Con esto ya puedes moverte. Antes de ver qué pasa cuando algo sale mal, prueba tú mismo el gesto de crear una rama y cambiarte a ella en este ejercicio interactivo, sin salir de esta página:

Cargando ejercicio...

Errores comunes al empezar con ramas

Crear la rama y creer que ya estás en ella

Es el fallo número uno. Haces git branch mi-idea, te pones a programar convencido de que estás en la rama nueva, y en realidad todos tus commits están cayendo en main. Cuando te das cuenta, tu “experimento” está mezclado con el código bueno. La regla para no caer: después de git branch, lanza git branch otra vez y mira dónde está el asterisco. O directamente usa git switch -c y te ahorras el problema.

Cambios sin commitear que bloquean el cambio

Si intentas cambiar de rama con trabajo a medias que pisaría archivos de la otra rama, Git te frena en seco:

error: Your local changes to the following files would be overwritten by checkout:
	src/login.ts
Please commit your changes or stash them before you switch branches.
Aborting

Git hace esto para protegerte de perder trabajo. Te está diciendo que tienes cambios sin guardar que se perderían al saltar. (Fíjate en que el mensaje menciona checkout aunque hayas escrito git switch: por debajo comparten el mismo mecanismo, así que verás esa palabra en el aviso.) La solución más simple para un junior: haz un commit de lo que tienes y luego cámbiate. Cuando tengas más práctica, aprenderás git stash, que aparca los cambios temporalmente. Por ahora, commitea y sigue.

La rama ya existe

Si intentas crear una rama con un nombre que ya está usado, Git no la sobrescribe ni te avisa a medias, corta directamente:

fatal: a branch named 'arreglo-login' already exists

Elige otro nombre, o si querías volver a esa rama, usa git switch arreglo-login sin la -c, porque ya existe.

Trabajar semanas enteras sin salir de main

No es un error de comando, es un error de hábito, y es el más caro. Cuanto más tiempo pasas acumulando cambios sueltos en main, más difícil es separar lo que funciona de lo que estabas probando. Crea una rama en cuanto empieces algo que no sea trivial. Cuesta un comando y te ahorra tardes enteras de desenredar código.

El siguiente paso: usar la rama y cerrarla

Crear y cambiar de rama es el principio del ciclo. Una vez tienes tu rama con commits, el paso natural es devolver ese trabajo a main, y eso se hace con un merge: lo tienes explicado paso a paso en git merge explicado. Y cuando la rama ya cumplió su función, conviene quitarla de en medio para no acumular ramas viejas, algo que cubrimos en cómo borrar una rama en Git. Crear, trabajar, fusionar y borrar: ese es el ciclo de vida completo de una rama.

Si quieres practicar todo esto con ejercicios guiados, sin instalar nada y corrigiéndote sobre la marcha, en el curso Git de cero a profesional tienes ramas, merges y resolución de conflictos con ejemplos interactivos como el de arriba. Es la forma más rápida de que estos gestos se te queden en los dedos.

Un concepto nuevo cada semana

Suscribirme

Preguntas Frecuentes

¿Crear una rama en Git copia todos mis archivos?

No. Una rama es solo un puntero a un commit, así que crear una rama en Git no duplica nada en tu disco. Por eso es una operación instantánea, tanto si tu proyecto tiene diez archivos como si tiene diez mil. Lo único que Git escribe es un puntero nuevo apuntando al commit donde estabas.

¿Pierdo mi trabajo al cambiar de rama?

No pierdes nada de lo que hayas commiteado. Cada rama guarda su propia línea de commits, y al volver la encuentras exactamente igual. El único momento delicado son los cambios sin commitear: si tienes trabajo a medias y saltas a otra rama, Git te avisará o te bloqueará antes de dejarte perder algo. La costumbre sana es commitear antes de cambiarte.

¿Debería usar git switch o git checkout para crear una rama?

Usa git switch -c nombre. Es el comando moderno, estable desde hace años, y hace solo lo que esperas: crear la rama y cambiarte a ella. git checkout -b nombre da el mismo resultado y lo verás mucho en tutoriales antiguos, así que conviene reconocerlo, pero para escribir tú, switch es la opción más segura.

¿Cómo debería nombrar mis ramas?

Con nombres cortos y descriptivos que digan qué hay dentro, en minúsculas y separando palabras con guiones:

# Bien: dice de qué va la rama de un vistazo
git switch -c arreglo-login-caducado

# Evítalo: espacios y acentos dan problemas en la terminal
git switch -c "Login Móvil"

Un buen nombre de rama es el que, semanas después, te dice de un vistazo para qué era sin tener que abrirla.