git switch

Definición

El comando git switch cambia la rama en la que estás trabajando. Introducido en Git 2.23, fue extraído del sobrecargado comando git checkout para hacer una sola tarea con claridad: mover HEAD a otra rama y actualizar el árbol de trabajo para que coincida. Todo lo relacionado con la restauración de archivos ahora vive en git restore, por lo que switch se mantiene enfocado exclusivamente en las ramas.

Esta página cubre el cambio a una rama existente, la creación de una rama al vuelo, el checkout de una rama remota, el traslado de cambios no confirmados, volver atrás con -, y en qué se diferencia git switch de git checkout.

Por qué existe git switch

Durante años, git checkout manejaba dos tareas no relacionadas: cambiar de rama y restaurar archivos en el árbol de trabajo. Esa sobrecarga facilitaba perder trabajo por accidente — git checkout <file> descartaba cambios silenciosamente, mientras que git checkout <branch> te llevaba a un lugar nuevo. Git 2.23 dividió las responsabilidades para que cada comando sea predecible: git switch se mueve entre ramas, y git restore recupera archivos. Ambos fueron introducidos juntos exactamente por esta razón. git checkout no está obsoleto y sigue funcionando, pero para el trabajo diario con ramas git switch es más claro y seguro.

Cambiar a una rama existente

Para moverte a una rama que ya existe, nómbrala:

git switch feature

HEAD apunta ahora a feature, y tu directorio de trabajo refleja el último commit de esa rama. Si tienes cambios no confirmados que serían sobreescritos, Git se detiene y te advierte en lugar de descartar el trabajo.

Crear y cambiar en un solo paso

Usa el indicador -c (crear) para crear una nueva rama y moverte a ella inmediatamente:

git switch -c new-feature

Este es el equivalente moderno de git checkout -b new-feature. También puedes basar la nueva rama en un punto de inicio específico:

git switch -c hotfix main

Aquí main es el punto de inicio: la nueva rama hotfix comienza en el mismo commit que main, pero ambas divergen de forma independiente a partir de ese momento. El punto de inicio puede ser cualquier nombre de rama, etiqueta o hash de commit.

Hacer checkout de una rama remota

Un caso muy común es empezar a trabajar en una rama que existe en el remoto pero que aún no existe localmente — por ejemplo, después de que un compañero de equipo hace push de una rama feature. Si el nombre no es ambiguo, simplemente cámbiala:

git fetch
git switch feature

Git detecta que no existe una rama feature local, encuentra un único origin/feature, y automáticamente crea una rama feature local que la rastrea. Esta conveniencia es el comportamiento --guess, que está activado por defecto. Para ser explícito, o cuando varios remotos tienen una rama con el mismo nombre, nombra la rama de seguimiento tú mismo:

git switch -c feature --track origin/feature

Llevar cambios no confirmados a otra rama

Por defecto, cambiar de rama con cambios no confirmados está bien siempre que esos cambios no entren en conflicto con la rama de destino — Git los mantiene en tu árbol de trabajo. Si fueran a sobreescribirse, Git se niega y te lo indica. Para llevar deliberadamente cambios locales en conflicto y fusionarlos en la nueva rama, agrega -m (--merge):

git switch -m other-branch

Si prefieres dejar los cambios a un lado limpiamente y reaplicarlos más tarde, usa git stash en lugar de forzar el cambio.

Opciones comunes

Volver a donde estabas

Un guion simple te devuelve a la rama en la que estabas antes:

git switch -

Esto resulta útil cuando estás alternando entre dos ramas y no quieres escribir sus nombres repetidamente.

Inspeccionar un commit sin una rama

Para examinar un commit antiguo sin mover ninguna rama, usa --detach. Esto te pone en estado HEAD desasociado — HEAD apunta directamente a un commit en lugar de a un nombre de rama:

git switch --detach 8f4c2a1

Puedes navegar e incluso compilar desde aquí, pero cualquier nuevo commit no está vinculado a una rama y puede perderse una vez que cambies. Si decides conservarlos, primero crea una rama con git switch -c <name>.

git switch vs git checkout

Ambos comandos pueden cambiar ramas, entonces ¿por qué preferir switch? Porque no puede tocar tus archivos por accidente. git checkout acepta tanto nombres de rama como rutas de archivo, lo que significa que un error tipográfico puede sobreescribir silenciosamente tu trabajo. git switch solo trabaja con ramas; si quieres descartar cambios en un archivo, acudes al claramente nombrado git restore.

# Old, overloaded way
git checkout main
git checkout -b feature

# Modern, explicit way
git switch main
git switch -c feature

Ten en cuenta que una cosa que git checkout puede hacer y git switch no puede es operar sobre archivos (git checkout -- file.txt). Eso es intencional: las operaciones con archivos ahora pertenecen a git restore.

Comandos relacionados

• git checkout — el comando antiguo y multipropósito que switch y restore reemplazaron.
• git restore — descarta o recupera cambios en archivos del árbol de trabajo.
• git branch — lista, crea, renombra y elimina ramas.
• git merge — combina el trabajo de otra rama una vez que hayas vuelto a la tuya.
• git stash — guarda cambios no confirmados antes de cambiar de rama.

Práctica