Usar ramas

Git Checkout

En esta página, se analiza el comando git checkout. Se abordarán ejemplos de uso y casos extremos. En términos de Git, "checkout" (extraer) es el acto de cambiar entre diferentes versiones de una entidad objetivo. El comando git checkout opera sobre tres entidades distintas: archivos, confirmaciones y ramas. Además de esta definición, se utiliza habitualmente la expresión "checking out" o "extraer" para referirse al acto de ejecutar el comando git checkout. En el tema sobre cómo deshacer cambios, explicamos cómo puede usarse git checkout para ver confirmaciones antiguas. El eje central de la mayor parte de este documento serán las operaciones de extracción en las ramas.

Los cambios de rama se asemejan al cambio de confirmaciones y archivos antiguos, ya que el directorio de trabajo se actualiza para reflejar la rama o revisión seleccionada. Sin embargo, los cambios nuevos se guardan en el historial del proyecto, es decir, no se trata de una operación de solo lectura.

Cambio de rama

El comando git checkout te permite desplazarte entre las ramas creadas por git branch. Al extraer una rama, se actualizan los archivos en el directorio de trabajo para reflejar la versión almacenada en esa rama y se indica a Git que registre todas las confirmaciones nuevas en dicha rama. Puedes contemplar todo esto como una forma de seleccionar la línea de desarrollo en la que trabajas.

Disponer de una rama específica para cada nueva función supone un cambio drástico en comparación con el flujo de trabajo tradicional de SVN. Hace que resulte ridículamente sencillo probar nuevos experimentos sin temor a arruinar las funciones existentes y permite trabajar al mismo tiempo en muchas funciones que no guardan relación entre sí. Además, las ramas facilitan varios flujos de trabajo colaborativos.

En ocasiones, el comando git checkout puede confundirse con git clone. La diferencia entre ambos comandos estriba en que el segundo recupera código de un repositorio remoto, mientras que el primero cambia entre versiones de código que ya se encuentran en el sistema local.

Uso: ramas existentes

Si damos por sentado que el repositorio en el que trabajas contiene ramas preexistentes, puedes cambiar de una de estas ramas a otra con git checkout. Para saber qué ramas están disponibles y cuál es el nombre de la rama actual, ejecuta git branch.

$> git branch 
main 
another_branch 
feature_inprogress_branch 
$> git checkout feature_inprogress_branch

En el ejemplo anterior, se muestra cómo ver una lista de ramas disponibles ejecutando el comando git branch y cómo cambiar a una rama específica, en este caso, la rama feature_inprogress_branch.

Nuevas ramas

El comando git checkout se usa habitualmente junto con git branch. El comando git branch permite crear una rama nueva. Si quieres empezar a trabajar en una nueva función, puedes crear una rama nueva a partir de la rama main con git branch new_branch. Una vez creada, puedes usar git checkout new_branch para cambiar a esa rama. Además, el comando git checkout acepta el argumento -b, que actúa como un práctico método que creará la nueva rama y cambiará a ella al instante. Puedes trabajar en varias funciones en un solo repositorio alternando de una a otra con git checkout.

git checkout -b <new-branch>

En el ejemplo anterior, se crea y se extrae la rama simultáneamente. La opción -b es una marca muy útil que hace que Git ejecute git branch antes de hacer lo propio con git checkout .

git checkout -b <new-branch> <existing-branch>

De manera predeterminada, git checkout -b basará la rama new-branch en el HEAD actual. No obstante, git checkout puede combinarse con un parámetro opcional para ramas adicionales. En el ejemplo anterior, se añade existing-branch>, que basa new-branch en existing-branch y no en el HEAD actual.

Conmutación de ramas

Pasar de una rama a otra es una operación sencilla. Al ejecutar lo siguiente, el HEAD apuntará al extremo de .

git checkout <branchname>

Git realiza un seguimiento del historial de operaciones de extracción en el registro de referencias. Puedes ejecutar git reflog para ver el historial.

Aplicación del comando git checkout con una rama remota

Al colaborar con un equipo, se utilizan con frecuencia repositorios remotos. Estos repositorios pueden alojarse y compartirse, o bien pueden ser una copia local de otro compañero. Cada repositorio remoto contendrá su propio conjunto de ramas. Para cambiar a una rama remota, primero tienes que extraer el contenido de la rama.

git fetch --all

En las versiones modernas de Git, puedes cambiar a la rama remota como si fuera una rama local.

git checkout <remotebranch>

En las versiones anteriores de Git, se debe crear una nueva rama basada en la remote.

git checkout -b <remotebranch> origin/<remotebranch>

Además, puedes cambiar a una nueva rama local y restablecerla en la última confirmación de las ramas remotas.

git checkout -b <branchname>
git reset --hard origin/<branchname>

HEADS desasociados

Ahora que hemos visto los tres usos principales de git checkout con las ramas, es hora de analizar el estado detached HEAD. Recuerda que el HEAD es la forma en la que Git hace referencia a la instantánea actual. De forma interna, el comando git checkout simplemente actualiza el HEAD para que apunte a la rama o la confirmación especificadas. Cuando apunta a una rama, Git no objeta nada, pero cuando extraes una confirmación, pasa al estado detached HEAD.

Se trata de una advertencia que indica que todo lo que haces está "desconectado" del resto del desarrollo de tu proyecto. Si empezaras a desarrollar una función mientras el estado fuera detached HEAD, no habría ninguna rama que te permitiera volver a ella. Cuando inevitablemente extrajeras otra rama (por ejemplo, para fusionar tu función), no habría forma de hacer referencia a la función:

HEAD asociado o desasociado

La cuestión es que el desarrollo siempre debe llevarse a cabo en una rama, nunca en un HEAD desasociado. De este modo, te aseguras de tener siempre una referencia para las nuevas confirmaciones. Sin embargo, si solo estás mirando una confirmación anterior, da igual que te encuentres en el estado detached HEAD o no.

Resumen

Esta página se centra en el uso del comando git checkout al cambiar de una rama a otra. En resumen, cuando se emplea en las ramas, git checkout modifica el objetivo de la referencia HEAD. Puede utilizarse para crear ramas, pasar de una a otra y extraer ramas remotas. El comando git checkout es una herramienta esencial para el funcionamiento normal de Git. Se contrapone a git merge. Los comandos git checkout y git merge resultan fundamentales para posibilitar los flujos de trabajo de Git.

¿Listo para probar las ramas?

Prueba este tutorial interactivo.

Comienza ahora