Programa
Ramas en Git representan líneas de desarrollo independientes, lo que permite a los desarrolladores trabajar simultáneamente en varias características o versiones de un proyecto.
Las ramas Git proporcionan una forma estructurada de gestionar los cambios en el código, permitiendo una integración fluida de nuevas funciones, correcciones de errores e ideas experimentales sin alterar el código base principal.
Tradicionalmente, utilizábamos el git checkout
comando para pasar de una rama a otra. Sin embargo, el comando checkout
nos permite hacer mucho más que simplemente cambiar de rama, lo que provoca cierta confusión y puede llevar a errores.
Introducido en Git 2.23 en agosto de 2019, el comando git switch
comando proporciona una forma más intuitiva de cambiar y crear nuevas ramas.
Cambiar y crear ramas con Git Switch
En los proyectos complejos, las prioridades cambian constantemente, y el flujo de trabajo suele ser no lineal. Normalmente, cada rama se centra en cambios específicos, lo que nos permite trabajar simultáneamente en varias funciones nuevas o correcciones de errores, cada una de las cuales se implementa en su rama.
Hay varias razones por las que podríamos necesitar pausar el trabajo en una función y desviar nuestra atención a otra rama, como por ejemplo:
- A la espera de una revisión del código.
- Encontrarte con un obstáculo y necesitar ayuda de un compañero.
- Abordar un hotfix que requiere atención inmediata.
Pasar de una rama a otra con eficacia es clave para que el desarrollo sea fluido y para que los cambios acaben donde deben. Con múltiples tareas y colaboración en equipo, tener una forma sencilla y fiable de cambiar de rama es importante.
Para cambiar a una rama existente utilizando el comando switch
, hacemos lo siguiente:
git switch <branch-name>
En el comando anterior, debe sustituirse por el nombre de la rama a la que queremos cambiar. Digamos que queremos trabajar en una nueva función ubicada en una rama existente llamada
feature-x
, entonces utilizaríamos el comando:
git switch feature-x
Conviértete en Ingeniero de Datos
Averiguar los nombres de las sucursales existentes
Si queremos listar las ramas disponibles, utilizamos el comando git branch
. La rama actual se mostrará con un asterisco junto a ella. Por ejemplo, si tenemos tres ramas locales llamadas main
, feature-x
, y bug-z
, y actualmente estamos en la rama main
, la salida sería:
* main
feature-x
bug-z
Cambiar a una sucursal remota
El comando anterior nos permite cambiar a una rama que ya tenemos en nuestra máquina local. Para pasar a una rama del repositorio remoto, necesitamos crear una versión local de la misma utilizando el siguiente comando:
git switch -c <local-branch-name> origin/<remote-branch-name>
Aquí, es el nombre que queremos que tenga la rama localmente, mientras que
es el nombre de la rama remota. En general, queremos utilizar el mismo nombre para evitar confusiones. Digamos que no tenemos la rama
feature-x
localmente. Entonces podemos crear una versión local y cambiar a ella, así:
git switch -c feature-x origin/feature-x
Cuando se utiliza el mismo nombre, Git proporciona una abreviatura del comando utilizando la opción --track
. Así que el comando anterior equivale a
git switch --track origin/feature-x
Para listar las ramas remotas, podemos utilizar el comando git branch -r
.
El repositorio local no hace un seguimiento automático de las ramas remotas. Por lo tanto, antes de listar o cambiar a una rama remota, es importante actualizar el repositorio local utilizando git fetch
.
Crear una nueva rama y cambiar a ella
Queremos crear una rama totalmente nueva para empezar a trabajar en una nueva función. En este caso, podemos utilizar la bandera -c
:
git switch -c <new-branch-name>
Sustituimos por el nombre de la sucursal. Por ejemplo, para crear una rama llamada
feature-y
hacemos lo siguiente:
git switch -c feature-y
Volver a la rama anterior
A menudo ocurre que, después de cambiar de rama para hacer algún trabajo, queremos volver a la rama en la que estábamos trabajando anteriormente. Git proporciona una forma abreviada de hacerlo mediante el comando
git switch -
Interruptor Git vs. Comprobación Git
El comando git checkout
ha estado en Git desde el principio. Antes de la introducción de git switch
en 2019, git checkout
era el comando que se utilizaba para cambiar entre ramas. Sin embargo, el alcance del comando git checkout
va más allá de la simple navegación entre ramas. Aquí tienes un desglose de las diferencias:
git switch
: Su finalidad es proporcionar una forma más intuitiva de cambiar y crear nuevas ramas. Su objetivo es simplificar el conjunto de comandos y reducir la confusión.
git checkout
: Un comando más versátil que puede utilizarse para cambiar de rama, pero también para comprobar archivos y restaurar el contenido de diferentes confirmaciones o ramas.
El diseño de git switch
hace que sea más difícil sobrescribir cambios accidentalmente. Tiene una sintaxis más explícita para cambiar de rama y crear ramas nuevas.
Como git checkout
hace varias cosas (cambiar de rama, restaurar archivos, etc.), hay más posibilidades de cometer errores al utilizarlo.
Interruptor Git: Errores comunes
Al gestionar sucursales, puedes encontrarte con algunos problemas comunes. Una de ellas es intentar crear una rama que ya existe localmente. Otro problema frecuente se produce al intentar cambiar de rama con cambios no comprometidos. Empecemos por explicar la primera.
La rama ya existe localmente
Cada sucursal local necesita un nombre único. Puedes utilizar git switch
para crear ramas locales de dos formas:
1. Para rastrear una rama remota:
git switch --track origin/<branch-name>
2. Para crear una nueva sucursal local:
git switch -c <branch-name>
En ambos casos, si ya existe una rama local llamada
, Git lanzará un error diciendo:
fatal: a branch named '<branch-name>' already exists

En este caso, podemos pasar a la rama sin crearla utilizando git switch
.
La rama actual tiene cambios no comprometidos
Git no nos permitirá cambiar de rama si la rama actual tiene cambios no comprometidos que serían sobrescritos por el cambio. En este caso, Git lanzará un error diciendo:
Please commit your changes or stash them before you switch branches.

Como indica el mensaje, para superar esta situación tenemos que confirmar primero nuestros cambios o almacenarlos. Si los cambios están listos para ser enviados al repositorio, debemos enviarlos utilizando:
git commit -m "Commit message"
Si queremos conservar los cambios pero aún no estamos preparados para confirmarlos, podemos guardarlos temporalmente utilizando el comando git stash
comando:
git stash
Si escondemos los cambios antes de cambiar de rama y queremos volver a aplicarlos cuando volvamos a la rama original, podemos utilizar el comando git stash pop
.
Alternativamente, también podemos decidir descartar los cambios utilizando la bandera --discard-changes
:
git switch --discard-changes <branch-name>
Ten cuidado antes de utilizar esta última opción, ya que los cambios se borrarán permanentemente.
Uso avanzado del interruptor Git
Cuando necesites crear ramas a partir de puntos concretos del historial de tu proyecto o manejar escenarios especiales, git switch
te ofrece funciones avanzadas para satisfacer estas necesidades.
Ramificación desde un punto concreto
Por defecto, al crear una rama con git switch
, el estado inicial de la nueva rama será el HEAD
de la rama en la que estamos actualmente.

Imagina que queremos iniciar una nueva rama a partir de una confirmación previa concreta. Cada confirmación se identifica mediante un único
, que podemos utilizar con el comando git switch
para crear una nueva rama a partir de esa confirmación. He aquí cómo hacerlo:
switch -c feature-y <hash>
Sustituye
por el hash real de la confirmación.

Cambiar a cabeza separada
Si queremos explorar o experimentar con una confirmación concreta sin afectar a la rama actual ni crear una rama nueva, podemos utilizar una cabeza separada con el comando
git switch --detach <hash>

Al separar la cabeza, podemos inspeccionar con seguridad el estado del repositorio en una confirmación concreta, ejecutar pruebas o hacer cambios temporales sin riesgo de que esos cambios se confirmen accidentalmente en la rama de trabajo actual. Los casos de uso más comunes son:
- Ver un estado antiguo: Si queremos inspeccionar o probar una confirmación anterior sin hacer cambios en la rama actual, podemos pasar a esa confirmación en estado separado.
- Cambios temporales: Si queremos experimentar con cambios sin afectar a ninguna rama, podemos hacer esos cambios en un estado de cabeza separada. Ten en cuenta que los nuevos commits que hagamos en este estado no pertenecerán a ninguna rama, y puede que tengamos que crear una rama nueva si queremos conservar esos commits.
- Fines de construcción/prueba: A veces, necesitamos construir o probar software en un commit específico. Pasar a un estado HEAD separado en esa confirmación nos permite hacerlo sin ningún impacto en la estructura de ramas del repositorio.
Forzar un cambio
Hemos aprendido que Git no nos permite cambiar de rama si hay cambios no comprometidos que puedan entrar en conflicto con la rama de destino. Si estamos seguros de que queremos descartar esos cambios y proceder al cambio, podemos forzarlo utilizando la opción -f
, así:
git switch -f <branch-name>
Hay que tener en cuenta algunas advertencias importantes.
- Cualquier cambio no comprometido se perderá sin previo aviso, pudiendo provocar la pérdida de trabajo si esos cambios no se han guardado en otro lugar.
- Utilizar indiscriminadamente
-f
puede fomentar la falta de disciplina, animando a los desarrolladores a eludir las prácticas adecuadas de control de versiones, como almacenar o confirmar cambios WIP (trabajo en curso). Esto podría dar lugar a un historial de repositorios caótico y complicar la colaboración. Por tanto, aunque git switch -f
ofrece rapidez y comodidad, debe utilizarse con criterio y conociendo bien los riesgos para mitigar los posibles inconvenientes.
Conclusión
El comando git switch
facilita el cambio y la creación de ramas en comparación con el antiguo comando git checkout
.
Simplifica el proceso y ayuda a reducir los errores, facilitando a los desarrolladores la gestión de su base de código.
Este comando ayuda a evitar problemas comunes, como sobrescribir cambios accidentalmente o confundir distintas funciones de git checkout
.
Adoptar este comando puede hacer que navegar por las ramas de Git sea más intuitivo y mejorar la colaboración dentro de los equipos de desarrollo.