Git Switch vs Git Checkout

Introducción

En este laboratorio, aprenderás las diferencias clave entre los comandos git switch y git checkout. Explorarás cuándo y por qué usar cada comando, junto con ejemplos prácticos y casos de uso para ayudarte a optimizar tu flujo de trabajo de Git.

Skills Graph

Entendiendo Git Checkout

El comando git checkout es un comando fundamental de Git que se utiliza para cambiar de rama (branch) o restaurar archivos del árbol de trabajo (working tree). Actualiza los archivos en tu directorio de trabajo para que coincidan con la versión en la rama o commit especificado.

Comencemos explorando cómo usar git checkout para cambiar entre ramas.

Primero, asegúrate de estar en el directorio del proyecto:

cd ~/project

Ahora, verifiquemos la rama actual. Por defecto, después de git init, estás en la rama main o master (dependiendo de tu configuración de Git). En la configuración de este laboratorio, creamos una feature-branch.

git branch

Deberías ver una salida similar a esta, indicando la rama actual con un asterisco:

  feature-branch
* main

Ahora, usa git checkout para cambiar a la feature-branch:

git checkout feature-branch

Verás una salida confirmando el cambio:

Switched to branch 'feature-branch'

Verifiquemos la rama actual nuevamente:

git branch

La salida ahora debería mostrar que estás en feature-branch:

* feature-branch
  main

Has utilizado con éxito git checkout para cambiar de rama.

Entendiendo Git Switch

El comando git switch es un comando más reciente introducido en Git 2.23, diseñado específicamente para cambiar de ramas (branches). Su objetivo es proporcionar una separación de responsabilidades más clara en comparación con el sobrecargado comando git checkout.

Usemos git switch para volver a la rama main.

Asegúrate de estar en el directorio del proyecto:

cd ~/project

Ahora, usa git switch para cambiar a la rama main:

git switch main

Verás una salida confirmando el cambio:

Switched to branch 'main'

Verifiquemos la rama actual nuevamente:

git branch

La salida ahora debería mostrar que estás en main:

* main
  feature-branch

Has utilizado con éxito git switch para cambiar de ramas. Observa que la salida es similar a git checkout al cambiar de ramas.

Creando y Cambiando de Ramas con Git Switch

Una de las características convenientes de git switch es la capacidad de crear una nueva rama (branch) y cambiar a ella en un solo comando utilizando la opción -c (o --create).

Creemos una nueva rama llamada development y cambiemos a ella.

Asegúrate de estar en el directorio del proyecto:

cd ~/project

Ahora, usa git switch -c para crear y cambiar a la rama development:

git switch -c development

Verás una salida indicando que se creó una nueva rama y que cambiaste a ella:

Switched to a new branch 'development'

Verifiquemos la rama actual y listemos todas las ramas:

git branch

La salida debería mostrar la nueva rama development e indicar que actualmente estás en ella:

  feature-branch
  main
* development

Esto demuestra cómo git switch -c simplifica el proceso de crear e inmediatamente trabajar en una nueva rama.

Restaurando Archivos con Git Checkout

Mientras que git switch se utiliza principalmente para cambiar de ramas (branches), git checkout conserva la funcionalidad para restaurar archivos. Esta es una diferencia clave en su uso previsto.

Realicemos un cambio en file1.txt y luego usemos git checkout para descartar los cambios y restaurar el archivo a su estado en la rama actual (development).

Asegúrate de estar en el directorio del proyecto:

cd ~/project

Añade algo de contenido a file1.txt:

echo "Additional content" >> file1.txt

Verifica el estado del archivo:

git status

La salida mostrará que file1.txt ha sido modificado:

On branch development
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   file1.txt

no changes added to commit (use "git add" and/or "git commit -a")

Ahora, usa git checkout -- para descartar los cambios locales en file1.txt:

git checkout -- file1.txt

Verifica el estado nuevamente:

git status

La salida ahora debería mostrar que no hay cambios en el directorio de trabajo (working directory):

On branch development
nothing to commit, working tree clean

Los cambios que realizaste en file1.txt han sido descartados, y el archivo ha sido restaurado a su estado en la rama development. Esta funcionalidad es manejada por git checkout, no por git switch.

Revisando un Commit Específico con Git Checkout

Otra funcionalidad retenida por git checkout es la capacidad de revisar (check out) un commit específico. Esto te coloca en un estado de "detached HEAD" (HEAD desacoplado), permitiéndote inspeccionar el proyecto en ese punto de la historia. git switch no tiene esta capacidad.

Primero, encontremos el hash del commit (commit hash) del commit inicial.

Asegúrate de estar en el directorio del proyecto:

cd ~/project

Visualiza el historial de commits:

git log --oneline

Verás una salida similar a esta, con los hashes de los commits:

<commit_hash_development> (HEAD -> development) Initial commit
<commit_hash_main> (main, feature-branch) Initial commit

Ten en cuenta que los hashes de los commits serán diferentes en tu entorno. Copia el hash del commit para el "Initial commit".

Ahora, usa git checkout seguido del hash del commit para revisar ese commit específico. Reemplaza <commit_hash> con el hash real que copiaste.

git checkout <commit_hash>

Verás una salida indicando que estás en un estado de detached HEAD:

Note: switching to '<commit_hash>'

You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by switching back to a branch.

If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -c with the switch command. Example:

  git switch -c <new-branch-name>

HEAD is now at <commit_hash> Initial commit

Ahora estás viendo el proyecto tal como estaba en el momento del commit inicial. Para regresar a una rama (branch), puedes usar git switch o git checkout para cambiar de nuevo a una rama como development o main.

Volvamos a la rama development usando git switch:

git switch development

Verás una salida confirmando el cambio:

Switched to branch 'development'

Has utilizado con éxito git checkout para explorar un commit específico y luego has regresado a una rama usando git switch.

Resumen de las Diferencias

Para resumir las diferencias clave entre git checkout y git switch:

• git switch: Se utiliza principalmente para cambiar entre ramas (branches). Es un comando más nuevo y enfocado para esta tarea específica. También puede crear una nueva rama y cambiar a ella (git switch -c).
• git checkout: Un comando más versátil que puede cambiar de ramas, pero también tiene la capacidad de revisar (check out) commits específicos (resultando en un HEAD desacoplado - detached HEAD) y restaurar archivos (git checkout -- <file>).

Si bien git checkout puede realizar el cambio de ramas, git switch es el comando recomendado para este propósito en las versiones más recientes de Git debido a su intención más clara y separación de responsabilidades (separation of concerns). Usa git checkout cuando necesites restaurar archivos o explorar commits específicos.

Ahora has explorado las funcionalidades principales tanto de git checkout como de git switch y comprendes cuándo usar cada comando en tu flujo de trabajo (workflow) de Git.

Resumen

En este laboratorio, has aprendido las diferencias entre los comandos git switch y git checkout. Practicaste el cambio de ramas (switching branches) usando ambos comandos, la creación de una nueva rama con git switch, la restauración de archivos con git checkout, y la revisión (checking out) de un commit específico con git checkout. Ahora comprendes los casos de uso previstos para cada comando y cómo contribuyen a un flujo de trabajo (workflow) de Git eficiente.