Git switch: Qué es, para qué sirve y cómo cambiar de rama

Git ofrece diferentes comandos para trabajar con ramas, pero uno de los más útiles y sencillos es git switch. Este comando fue incorporado para facilitar una tarea muy común: cambiar entre ramas de un repositorio sin utilizar opciones adicionales de otros comandos más complejos.

Si estás aprendiendo Git, dominar git switch te permitirá moverte entre distintas versiones de un proyecto de forma rápida, segura y organizada. En esta guía aprenderás qué es, para qué sirve, cómo usarlo desde la terminal de Visual Studio Code, cómo hacerlo desde la interfaz gráfica de VS Code, cuándo conviene utilizarlo y cuáles son sus diferencias con git checkout.

Git switch qué es para qué sirve y cómo cambiar de rama

Índice

1. ¿Qué es Git switch?

git switch es un comando diseñado específicamente para cambiar de una rama a otra dentro de un repositorio Git.

Antes de su aparición, la mayoría de los desarrolladores utilizaban git checkout para realizar esta tarea. Sin embargo, git checkout también sirve para muchas otras funciones, como restaurar archivos o desplazarse a commits antiguos, lo que podía generar confusión entre quienes recién comenzaban.

Con git switch, Git separó claramente ambas responsabilidades:

git switch → Cambiar y administrar ramas.
git restore → Restaurar archivos.
git checkout → Mantener compatibilidad y realizar tareas más avanzadas.

Como resultado, git switch es mucho más fácil de aprender y reduce la posibilidad de cometer errores.

2. ¿Para qué sirve Git switch?

Su principal objetivo es cambiar la rama activa del proyecto.

Cuando cambias de rama, Git reemplaza automáticamente el contenido de tu carpeta de trabajo por la versión correspondiente a esa rama.

Esto permite trabajar en diferentes funcionalidades sin afectar el resto del proyecto.

Algunos usos muy habituales son:

Cambiar entre la rama principal (main) y una rama de desarrollo.
Continuar una funcionalidad que habías dejado pendiente.
Revisar una corrección realizada por otro integrante del equipo.
Probar una nueva característica sin modificar la rama principal.
Volver rápidamente a una rama anterior.

3. ¿Cómo saber en qué rama te encuentras?

Antes de cambiar de rama es recomendable verificar cuál está activa.

Utiliza el siguiente comando:

git branch

La salida será similar a esta:

* main
  desarrollo
  login

El asterisco (*) indica la rama actual.

4. ¿Cómo cambiar de rama desde la terminal de VS Code?

Una vez que hayas creado una nueva rama con el comando git branch, el siguiente paso será cambiarte a ella para comenzar a trabajar. Esto puedes hacerlo fácilmente desde la terminal integrada de Visual Studio Code siguiendo estos pasos.

Paso 1. Abrir la terminal de Visual Studio Code

Con tu proyecto abierto en VS Code, abre la terminal integrada. Para ello tienes dos opciones:

Haz clic en Terminal > New Terminal desde el menú superior.
O utiliza el atajo de teclado Ctrl + Ñ.

Al abrirse la terminal, verifica que te encuentras dentro de la carpeta de tu repositorio Git. Si has seguido los pasos de este curso, la terminal ya estará ubicada en el directorio correcto.

Paso 2. Ejecutar el comando `git switch`

Ahora escribe el comando git switch seguido del nombre de la rama a la que deseas cambiar.

Por ejemplo, si la rama se llama desarrollo, ejecuta:

git switch desarrollo
Lenguaje del código: JavaScript (javascript)

Después de presionar Enter, Git cambiará automáticamente a esa rama y mostrará un mensaje similar al siguiente:

Switched to branch 'desarrollo'
Lenguaje del código: JavaScript (javascript)

Este mensaje confirma que el cambio se realizó correctamente.

Paso 3. Verificar que el cambio se realizó correctamente

Aunque Git muestra un mensaje de confirmación, también puedes comprobar en qué rama te encuentras ejecutando:

git branch

La salida será similar a esta:

  main
* desarrollo

El asterisco (*) indica la rama activa. En este ejemplo, significa que ahora estás trabajando en la rama desarrollo.

Paso 4. Continuar trabajando en la nueva rama

A partir de este momento, todos los cambios que realices (crear archivos, modificar código o eliminar contenido) quedarán registrados únicamente en esa rama. Esto te permite desarrollar nuevas funcionalidades, corregir errores o realizar pruebas sin afectar el contenido de la rama principal (main).

Cuando necesites volver a la rama principal, simplemente ejecuta:

git switch main
Lenguaje del código: JavaScript (javascript)

Podrás cambiar de una rama a otra tantas veces como sea necesario, siempre que no existan cambios pendientes que puedan generar conflictos. Este es uno de los comandos que más utilizarás durante el desarrollo de cualquier proyecto con Git.

4.1. Cambiar a la rama anterior

Git recuerda la última rama en la que estabas.

Puedes regresar rápidamente utilizando:

git switch -
Lenguaje del código: JavaScript (javascript)

Este pequeño atajo resulta muy útil cuando alternas continuamente entre dos ramas.

Por ejemplo:

main
↓
git switch desarrollo
↓
git switch -
↓
main
Lenguaje del código: JavaScript (javascript)

Muchos desarrolladores utilizan este comando decenas de veces al día.

4.2. Crear una rama nueva y cambiar a ella automáticamente

También es posible crear una rama y cambiar a ella con un solo comando.

git switch -c nueva-rama
Lenguaje del código: JavaScript (javascript)

Ejemplo:

git switch -c formulario-contacto
Lenguaje del código: JavaScript (javascript)

Git realizará dos acciones:

Creará la rama.
Cambiará automáticamente a ella.

Es equivalente a ejecutar:

git branch formulario-contacto
git switch formulario-contacto
Lenguaje del código: JavaScript (javascript)

Pero mucho más rápido.

5. ¿Cómo cambiar de rama sin usar la terminal?

Visual Studio Code permite hacerlo mediante su interfaz gráfica.

Los pasos son:

Abrir el proyecto en VS Code.
Observar la barra inferior izquierda.
Hacer clic sobre el nombre de la rama actual.
Se abrirá la lista de ramas disponibles.
Seleccionar la rama deseada.

En pocos segundos VS Code cambiará automáticamente de rama y actualizará todos los archivos.

Este método resulta ideal para quienes están dando sus primeros pasos con Git.

6. ¿Qué ocurre con los archivos al cambiar de rama?

Cuando ejecutas git switch, Git modifica automáticamente el contenido de tu carpeta de trabajo para mostrar el estado exacto de esa rama.

Por ejemplo:

En main existe el archivo index.html.
En la rama login existe además login.js.

Al cambiar:

git switch login
Lenguaje del código: JavaScript (javascript)

Aparecerá automáticamente login.js.

Si vuelves a main:

git switch main
Lenguaje del código: JavaScript (javascript)

Ese archivo desaparecerá porque no pertenece a esa rama.

Esto demuestra que cada rama mantiene su propio historial y su propio conjunto de cambios.

7. ¿Qué sucede si tengo cambios sin guardar?

Aquí es donde Git protege tu trabajo.

Si los cambios realizados entran en conflicto con la rama a la que deseas cambiar, Git mostrará un mensaje similar a:

Please commit your changes or stash them before you switch branches.
Lenguaje del código: JavaScript (javascript)

En ese caso puedes:

Realizar un commit.
Guardar temporalmente los cambios con git stash.
Descartarlos si ya no los necesitas.

De esta manera Git evita que pierdas información.

¿Qué es Git stash?

git stash es un comando de Git que permite guardar temporalmente los cambios que aún no has confirmado con un commit, dejando tu directorio de trabajo limpio para poder realizar otras tareas, como cambiar de rama.

Es una herramienta muy útil cuando estás trabajando en una funcionalidad, pero necesitas interrumpirla para corregir un error en otra rama o revisar algún cambio urgente. En lugar de hacer un commit incompleto, puedes guardar esos cambios de forma temporal utilizando git stash.

Más adelante, cuando quieras continuar con ese trabajo, podrás recuperar todos los cambios exactamente donde los dejaste.

Por ejemplo, si Git no te permite cambiar de rama porque tienes modificaciones pendientes, puedes ejecutar:

git stash

De esta forma, Git almacenará temporalmente esos cambios y dejará el directorio de trabajo limpio. Luego podrás cambiar de rama con git switch y, cuando regreses, recuperar tu trabajo utilizando el comando correspondiente.

En resumen, git stash funciona como una «pausa temporal» para tus cambios, permitiéndote cambiar de contexto sin perder el trabajo realizado.

8. Ejemplo práctico de uso

Imagina que estás desarrollando un sitio web.

Actualmente trabajas en la rama principal:

main

Decides crear una nueva funcionalidad para agregar un formulario de contacto.

Creas la rama:

git switch -c formulario
Lenguaje del código: JavaScript (javascript)

Durante varios días realizas modificaciones únicamente allí.

Mientras tanto aparece un error urgente en producción.

Simplemente vuelves a:

git switch main
Lenguaje del código: JavaScript (javascript)

Corriges el problema, realizas el commit correspondiente y luego regresas a continuar el formulario:

git switch formulario
Lenguaje del código: JavaScript (javascript)

Todo el trabajo permanece perfectamente organizado.

Este es precisamente el flujo de trabajo que utilizan la mayoría de los equipos de desarrollo.

9. Git switch vs git checkout

Tanto git switch como git checkout permiten cambiar de una rama a otra, por lo que es normal que muchas personas piensen que son exactamente el mismo comando. Sin embargo, aunque pueden realizar esta tarea, existen diferencias importantes entre ambos.

La principal diferencia es que git switch fue creado exclusivamente para trabajar con ramas, mientras que git checkout es un comando multipropósito que también permite restaurar archivos y desplazarse a commits anteriores.

Durante muchos años, git checkout fue el único comando disponible para cambiar de rama. Con el paso del tiempo, Git incorporó nuevos comandos como git switch y git restore para que cada uno tuviera una función específica y resultara más sencillo de aprender.

9.1. ¿Qué hace git switch?

El comando git switch está pensado únicamente para administrar ramas. Con él puedes:

Cambiar de una rama a otra.
Crear una nueva rama y cambiar automáticamente a ella utilizando la opción -c.
Volver rápidamente a la rama anterior mediante git switch -.

Al estar enfocado en una sola tarea, es un comando más intuitivo y reduce la posibilidad de cometer errores.

9.2. ¿Qué hace git checkout?

git checkout es un comando mucho más versátil. Además de cambiar de rama, también puede utilizarse para:

Cambiar a un commit específico mediante su hash.
Entrar temporalmente en estado Detached HEAD.
Restaurar archivos a una versión anterior (aunque actualmente se recomienda utilizar git restore para esta tarea).

Precisamente por tener tantas funciones, su sintaxis puede resultar más difícil de comprender para quienes están comenzando con Git.

¿Qué es el estado Detached HEAD?

Una de las diferencias entre git switch y git checkout es que este último permite desplazarse a un commit específico utilizando su hash. Cuando haces esto, Git entra en un estado conocido como Detached HEAD.

En condiciones normales, el puntero HEAD apunta a la rama en la que estás trabajando, por ejemplo main o desarrollo. Sin embargo, al ejecutar un comando como el siguiente:

git checkout a1b2c3d

Git deja de apuntar a una rama y pasa a apuntar directamente a ese commit. Es decir, te encuentras visualizando una versión concreta del proyecto, pero ya no estás trabajando sobre ninguna rama.

Este estado resulta muy útil para revisar cómo era el proyecto en un momento determinado, analizar el código de una versión anterior o realizar pruebas sin modificar el historial de las ramas existentes.

Es importante tener en cuenta que, si realizas cambios mientras estás en estado Detached HEAD y luego cambias de rama sin guardar esos cambios en una nueva rama o mediante un commit adecuado, podrías perder ese trabajo.

Por este motivo, el estado Detached HEAD suele utilizarse principalmente para consultar versiones anteriores del proyecto o realizar tareas puntuales, mientras que el desarrollo habitual se realiza siempre dentro de una rama utilizando comandos como git switch.

9.3. Comparación entre git switch y git checkout

Git switch	Git checkout
Su función principal es cambiar de rama.	Es un comando con múltiples funciones.
Tiene una sintaxis más sencilla.	Su sintaxis puede ser más compleja.
Es el comando recomendado para trabajar con ramas.	Se utiliza principalmente por compatibilidad y tareas avanzadas.
Reduce la posibilidad de errores.	Requiere conocer mejor las distintas opciones del comando.

9.4. Ejemplo práctico

Con ambos comandos puedes cambiar a la rama desarrollo:

Usando git switch:

git switch desarrollo
Lenguaje del código: JavaScript (javascript)

Usando git checkout:

git checkout desarrollo

En ambos casos el resultado será el mismo: Git cambiará a la rama desarrollo.

9.5. ¿Cuál deberías utilizar?

Si estás aprendiendo Git o comienzas un proyecto nuevo, la recomendación es utilizar git switch para cambiar de rama. Es el comando moderno, tiene una sintaxis más clara y fue diseñado específicamente para esta tarea.

Por otro lado, git checkout sigue siendo un comando muy importante porque aún aparece en numerosos proyectos, tutoriales y documentación, además de ser necesario para realizar algunas operaciones avanzadas, como desplazarse a un commit específico.

En resumen, ambos comandos continúan siendo válidos, pero si tu objetivo es únicamente cambiar de rama, git switch es la opción más recomendable por ser más simple, específica y fácil de entender

10. Errores comunes

10.1. Intentar cambiar a una rama inexistente

Si escribes:

git switch pruebas
Lenguaje del código: JavaScript (javascript)

y la rama no existe, Git mostrará un error indicando que no puede encontrarla.

Puedes comprobar las ramas disponibles con:

git branch

10.2. Tener cambios que generan conflictos

Si existen modificaciones incompatibles, Git impedirá el cambio para proteger tu trabajo.

Antes deberás realizar un commit, utilizar git stash o descartar los cambios.

10.3. Confundir git switch con git restore

Es un error muy habitual.

Recuerda la diferencia:

git switch cambia de rama.
git restore recupera archivos.
git checkout puede realizar ambas tareas, además de otras funciones.

Memorizar esta diferencia hará que tu flujo de trabajo sea mucho más sencillo.

11. Buenas prácticas

Para evitar problemas durante el desarrollo, es recomendable seguir estas prácticas:

Comprueba siempre en qué rama estás antes de comenzar a trabajar.
Realiza commits frecuentes antes de cambiar de rama.
Utiliza nombres descriptivos para las ramas.
Mantén la rama main estable.
Usa git switch para trabajar con ramas y reserva git checkout para tareas avanzadas.

12. Resumen

git switch es uno de los comandos más importantes del flujo de trabajo moderno con Git. Su objetivo es facilitar el cambio entre ramas de forma clara, segura y sencilla, evitando la complejidad que durante años tuvo git checkout.

Si comienzas a utilizar Git desde cero, incorporar git switch a tu rutina te ayudará a organizar mejor tus desarrollos, trabajar en varias funcionalidades al mismo tiempo y adoptar las prácticas recomendadas por la comunidad. A medida que avances en tu aprendizaje, descubrirás que cambiar de rama correctamente es una habilidad fundamental para cualquier proyecto, tanto individual como colaborativo.