Git checkout te permite acceder a di­fe­re­n­tes ramas o crear otras nuevas, y también trabajar con ramas remotas.

Dominios web
Compra y registra tu dominio ideal
  • Gratis SSL Wildcard para tra­n­s­fe­re­n­cias de datos más seguras
  • Gratis registro privado para más pri­va­ci­dad

¿Qué es git checkout?

Si revisamos la co­m­pa­ra­ti­va de Git y SVN, se puede ver que el primero ofrece una opción muy útil para dividir el proyecto en di­fe­re­n­tes ramas. Estas líneas de de­sa­rro­llo separadas permiten que las personas in­vo­lu­cra­das trabajen si­mu­l­tá­nea­me­n­te o de forma in­de­pe­n­die­n­te en varios aspectos del de­sa­rro­llo y realicen cambios sin correr el riesgo de dañar todo el proyecto. Los equipos pueden trabajar fá­ci­l­me­n­te en paralelo gracias a que los nuevos de­sa­rro­llos se co­m­prue­ban primero de forma autónoma y solo entonces se fusionan. Git checkout es un comando de Git que permite navegar entre di­fe­re­n­tes ramas.

Esto permite a los de­sa­rro­lla­do­res se­le­c­cio­nar cualquier rama de un proyecto y trabajar en ella. Si hacen cambios, se guardan en el historial del proyecto. Git checkout actualiza el di­re­c­to­rio de trabajo de una rama y todos los nuevos commits se registran en la rama actual. Esto significa que git checkout no es una acción de solo lectura, sino que es es­pe­cia­l­me­n­te adecuada para realizar cambios im­po­r­ta­n­tes. Las ventajas de esta forma de trabajar se co­n­ce­n­tran, sobre todo, en el ámbito de la seguridad. No solo permite cambiar de rama con rapidez, sino que evita que los posibles errores tengan un impacto negativo en el de­sa­rro­llo general del proyecto.

Sintaxis y fu­n­cio­na­li­dad de git checkout

La sintaxis de git checkout es siempre la misma. Escribes el comando mo­di­fi­ca­do por ciertas in­di­ca­cio­nes, tal y como te mo­s­tra­re­mos a co­n­ti­nua­ción. Si quieres saber más sobre la es­tru­c­tu­ra básica y los co­no­ci­mie­n­tos ne­ce­sa­rios para usar Git, nuestro tutorial de Git te ayudará. Cómo utilizar git checkout:

git checkout <rama_de_ejemplo></rama_de_ejemplo>

El fu­n­cio­na­mie­n­to de este comando se explica rá­pi­da­me­n­te. Con git checkout y la opción co­rre­s­po­n­die­n­te, abandonas la ruta en la que estás tra­ba­ja­n­do ac­tua­l­me­n­te y pasas a otra rama en en la que rea­li­za­rás todas las pruebas y mo­di­fi­ca­cio­nes en esta instancia de tu proyecto. Mediante git checkout también puedes dejar esta parte de nuevo y trabajar en tu rama main o en otra rama.

Cambiar a una rama existente con git checkout

El uso más sencillo de git checkout es el cambio descrito de una rama existente a la siguiente. Si no sabes qué ramas están di­s­po­ni­bles, puedes pedir esta in­fo­r­ma­ción con el comando git branch. El resultado es el siguiente:

git branch
main
rama_uno
rama_dos
rama_tres

Ahora sabes que hay otras tres ramas además de la principal. Si quieres cambiar a la rama “rama_dos”, por ejemplo, utiliza el comando git checkout. El resultado se ve así:

git branch
main
rama_uno
rama_dos
rama_tres
git checkout <rama_dos></rama_dos>

Ahora puedes seguir tra­ba­ja­n­do en la “rama_dos”. Para revisar los comandos más im­po­r­ta­n­tes, échale un vistazo a nuestro útil resumen de Git en PDF psara descargar.

Cambiar a una nueva rama con git checkout

También tienes la opción de cambiar a ramas que aún no existen. No­r­ma­l­me­n­te, usarías el comando git branch para crear una rama adicional, por ejemplo, usando “git branch rama_cuatro”. A co­n­ti­nua­ción, podrías cambiar a esta rama de nuevo con git checkout. En lugar de llevar a cabo estos dos pasos, también puedes completar el proceso de una sola vez. Para ello, usa la opción “-b”. Así es como se ve en el código:

git checkout -b <rama_cuatro></rama_cuatro>

Con este comando indicas a Git que ejecute primero git branch y luego git checkout. Es decir, la nueva rama se crea primero y luego se pasa a ella di­re­c­ta­me­n­te. Por defecto, el HEAD actual se utiliza como base para la nueva rama. Si quieres cambiarlo, añade un parámetro adicional al comando anterior. A co­n­ti­nua­ción, un ejemplo:

git checkout -b <rama_cuatro> <rama_uno></rama_uno></rama_cuatro>

De esta forma, “rama_uno” es la base de la nueva “rama_cuatro”.

Git checkout para re­po­si­to­rios remotos

Si usas re­po­si­to­rios remotos en un equipo, cada uno de ellos contendrá sus propias ramas. El acceso a los re­po­si­to­rios remotos también tiene lugar a través de git checkout. Para ello, primero tienes que acceder al contenido de la rama co­rre­s­po­n­die­n­te:

git fetch --all

En las versiones más antiguas de Git, hay que crear una rama propia basada en la rama remota:

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

En las nuevas versiones, este paso in­te­r­me­dio ha dejado de ser necesario. Puedes utilizar una rama remota como rama local:

git checkout <rama_remota></rama_remota>
Consejo

¿Detección y co­n­fi­gu­ra­ción au­to­má­ti­ca del marco? Con Deploy Now de IONOS, consigues una co­n­fi­gu­ra­ción rápida, flujos de trabajo op­ti­mi­za­dos, es­ca­la­bi­li­dad flexible y una ar­qui­te­c­tu­ra de seguridad robusta. Empieza ahora gratis.

Ir al menú principal