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.
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.
