Introducción

Ya sea porque estás aprendiendo a usar el control de versiones con Git, porque lo tienes oxidado y quieres refrescar tus conocimientos, o simplemente por curiosidad, en este artículo analizaremos los diez comandos más utilizados, así como varios ejemplos sobre su uso. ¡Seguro que aprendes algo!

Breve introducción a Git

Si estás leyendo esto es porque, o bien ya utilizas Git, o bien no lo estás utilizando, pero sí has oído hablar de él. Bien, pues aquí no vamos a hablar sobre la historia de esta herramienta ni sobre su impacto en el mundo del desarrollo, pero es importante que seas consciente de la importancia que tiene en el día a día de un desarrollador. Pues no es casualidad que en GitHub ya haya más de 100 millones de desarrolladores.

Así que, si todavía no dominas esta herramienta, te invito a aprender a utilizarla, ya que cambiará radicalmente tu productividad, ya sea para proyectos en solitario, como para trabajar en equipo. Existen múltiples cursos y plataformas gratuitas para aprender a usar esta herramienta de control de versiones, pero te recomiendo dos en concreto:

• Curso básico de Git en Codecademy para principiantes.
• El juego interactivo Oh My Git! te ayudará a poner en práctica los conceptos aprendidos de una manera dinámica y divertida.

A medida que vayas trabajando con Git, te darás cuenta de que utilizas unos comandos con más frecuencia que otros. Algunos, incluso, van quedando obsoletos y se desaconseja su uso, por lo que es interesante mantenerse actualizado por más que se domine la herramienta.

Sin más rodeos, analicemos uno a uno los diez comandos más usados.

1. git init

Es el comando más básico de Git y te permite inicializar el control de versiones en un directorio. Hay dos maneras distintas de usarlo de la manera más básica:

1. Para inicializar un repositorio en el directorio actual:

   git init
   

2. Para inicializar un repositorio en un nuevo directorio llamado mi-directorio:

   git init mi-directorio
   

Cambio de master a main

Tanto si llevas tiempo usando Git como sino, debes saber que antiguamente, las ramas principales de nuestros proyectos se llamaban master, pero hubo bastante polémica sobre esto y se terminó renombrando por main. Si bien es cierto que al crear un repositorio remoto en plataformas como GitHub la rama principal se llama main por defecto, para que esto sea así en tus repositorios locales, tienes que haber cambiado esa opción durante la instalación de Git.

Si cada vez que inicializas un repositorio local tu rama principal se llama master y te toca que cambiarlo manualmente, no te preocupes, pues este comando te permite definir el nombre de la rama principal incluso después de la instalación de Git:

git config --global init.defaultBranch main

Con este comando habrás establecido main como nombre por defecto de la rama principal las próximas veces que ejecutes el comando git init.

2. git clone

Este comando es utilizado para clonar repositorios remotos a tu dispositivo local. Por sí solo, no hace nada, pues siempre espera —como mínimo— la URL del repositorio a clonar. Estos son los usos posibles más comunes:

1. Para clonar un repositorio remoto al directorio actual manteniendo el nombre del directorio que lo contendrá:

   git clone https://github.com/usuario/repositorio.git
   

2. Para clonar un repositorio remoto al directorio actual cambiando el nombre del directorio que lo contendrá por mi-proyecto:

   git clone https://github.com/usuario/repositorio.git mi-proyecto
   

Es bastante común entrar al directorio del repositorio que acabas de clonar, por lo que puedes pedirle a la terminal que se ubique allí una vez finalizada la clonación con el siguiente comando:

git clone https://github.com/usuario/repositorio.git mi-proyecto && cd mi-proyecto

Clonación concreta

Un uso menos común pero no menos eficaz del comando git clone es el que te permite clonar solamente una rama del repositorio remoto. Si conoces el nombre de la rama remota puedes hacer la siguiente combinación, con la que estarías clonando solo la rama feature/issue-25:

git clone --single-branch --branch feature/issue-25 https://github.com/usuario/repositorio.git

Por último, si vas a trabajar con un repositorio remoto que ocupa mucho espacio o tiene un historial muy extenso que va a suponer un problema para ti, puedes usar el argumento --depth # para elegir la profundidad del historial que clonarás. Por ejemplo, para clonar un repositorio y traer únicamente el commit más reciente, puedes usar el siguiente comando:

git clone --depth 1 https://github.com/usuario/repositorio.git

3. git add

Este comando es utilizado para añadir cambios al área de preparación o staging. Existen tres formas muy comunes de emplearlo:

1. Para añadir todos los cambios al área de preparación:

   git add .
   

2. Para añadir únicamente el archivo mi-archivo al área de preparación:

   git add mi-archivo
   

3. Para añadir únicamente el directorio mi-directorio al área de preparación:

   git add mi-directorio
   

Sin embargo, existe una manera de añadir partes de un archivo al área de preparación y esto es algo que poca gente conoce. Es útil si quieres revisar desde la terminal los cambios que estás preparando, si prefieres preparar solo algunas partes del código de un archivo o incluso para resolver conflictos.

Con el siguiente comando podrás añadir cambios al área de preparación de manera interactiva:

git add --patch

4. git commit

Este comando va de la mano con el anterior, pues registra los cambios que hay en el área de preparación y crea un log en tu repositorio. El uso más común es el siguiente:

git commit -m "Mensaje del commit"

Sin embargo, existen otras maneras de utilizarlo. Por ejemplo, si prefieres detallar cambios y escribir el mensaje utilizando un editor de texto como Vim, puedes escribir solamente git commit y verás algo parecido a esto en tu terminal:

Argumento amend

Otro uso menos común de este comando es agregando el argumento --amend, que permite hacer cambios en el commit más reciente, ya sea en su contenido o solamente en el mensaje del mismo.

Supongamos que has olvidado escribir algo en el mensaje del commit más reciente:

git commit -m "Añade función para buscar"

Si quisieras corregirlo, bastaría con escribir el siguiente comando:

git commit --amend -m "Añade función para buscar artículos en el Blog"

También podría darse el caso de que hayas olvidado añadir el archivo mi-archivo.json al área de preparación del último commit. Mediante la siguiente combinación de comandos, podrías añadirlo posteriormente al commit más reciente, sin necesidad de registrar uno nuevo:

git add mi-archivo.json && git commit --amend

El comando anterior alterará solo el contenido del último commit, manteniendo su mensaje original.

5. git status

Este comando sirve para tener una visión global del estado de tu repositorio. Por ejemplo, te dirá todos aquellos cambios que no están en el área de preparación, todos aquellos que sí lo están, información sobre tu repositorio respecto al remoto (si es que la conoce), etc. Sus usos más comunes son los siguientes:

1. Para ver el estado actual del repositorio:

   git status
   

2. Para obtener una vista detallada del estado actual del repositorio:

   git status -v
   

Ten en cuenta que la respuesta del comando git status va de la mano con el archivo .gitignore de tu repositorio. Así que, si no quieres ver determinados archivos o directorios en los resultados, basta con que los añadas a tu lista de ignorados.

6. git push

Este comando es esencial para sincronizar los cambios locales con el repositorio remoto. Una vez que has completado commits en el repositorio local, puedes llevarlos al repositorio remoto.

Ten en cuenta que se subirán en la rama con el mismo nombre que la actual en el repositorio local. Si esta no existía, puedes hacer una Pull Request para fusionar los cambios en otra.

Este es el uso más común de este comando y sirve para publicar el estado actual de una rama local determinada en un repositorio remoto:

git push nombre-remoto nombre-rama

Con nombre-remoto le indicamos el nombre del remoto al que queramos publicar la rama, que suele ser origin. Además, nombre-rama debe ser reemplazado por el nombre de la rama que quieres publicar.

Conectar la rama local con la remota

Para no tener que introducir los argumentos cada vez que ejecutes el comando, primero tendrías que ejecutarlo con el argumento -u o --set-upstream. Después, simplemente podrías usar git push sin necesidad de añadir argumentos adicionales:

1. Primero estableces una conexión entre la rama local y la remota:

   git push -u nombre-remoto nombre-rama
   

2. La siguiente vez podrás ahorrarte los argumentos:

   git push
   

Un truco para publicar la rama actual sin necesidad de escribir su nombre es utilizar el argumento HEAD. Ahí va un ejemplo de cómo publicar la rama actual en el repositorio remoto origin:

git push -u origin HEAD

7. git fetch

Muchos usuarios no conocen la diferencia entre los comandos git fetch y git pull, que es el siguiente que veremos.

El comando git fetch consulta los últimos cambios del repositorio remoto, pero no los fusiona en tu repositorio local. Esto es muy útil si quieres revisarlos antes de traerlos a tu rama local.

Su sintaxis es muy sencilla:

git fetch nombre-remoto

Recuerda reemplazar nombre-remoto por el nombre de tu repositorio remoto. Habitualmente origin.

El comando consulta los cambios pero no los muestra. Para ello, puedes usar los comandos git log nombre-remoto/nombre-rama o git diff. Finalmente, si quieres descargar los cambios tras su revisión, debes usar el comando git merge.

8. git pull

El comando git pull es más agresivo que git fetch. Además de comprobar los últimos cambios en la rama remota, los fusiona en tu rama local. Se podría decir que combina la acción de los comandos git fetch y git merge.

En este caso, no es necesario especificar el nombre de la rama. Así que ten en cuenta, que se traerá los cambios desde la rama remota cuyo nombre sea el mismo que la rama local actual.

git pull nombre-remoto

Si quieres traer los posibles cambios de la rama main del remoto origin a tu rama main local, tendrías que ejecutar el siguiente comando:

git switch main && git pull origin

Con el comando git switch te aseguras de encontrarte en la rama indicada.

9. git switch

Como te comentaba en el ejemplo anterior, el comando git switch sirve para cambiar a la rama deseada. Se trata de un comando relativamente nuevo, que viene a evitar conflictos que surgían con el comando git checkout, el cual tiene otras aplicaciones.

El comando git switch simplica enormemente el proceso de navegar entre ramas:

1. Para cambiar a una rama existente:

   git switch nombre-rama
   

2. Para crear una nueva rama y ubicarse en ella:

   git switch -c nombre-rama
   

10. git branch

Este comando se suele utilizar para varios propósitos relacionados con la gestión de nuestras ramas, tanto locales como remotas.

1. Para obtener un listado de todas las ramas locales del proyecto:

   git branch
   

2. Para obtener un listado de todas las ramas remotas:

   git branch -r
   

3. Para obtener un listado de todas las ramas, tanto locales como remotas:

   git branch -a
   

4. Para crear una rama sin ubicarte en ella:

   git branch nombre-rama
   

Borrado de ramas

Este comando también se utiliza para borrar ramas. Esto es útil cuando quieres deshechar ramas que ya han sido fusionadas y no vas a tener que revisitar.

1. Para eliminar una rama que ya ha sido fusionada con la rama actual:

   git branch -d nombre-rama
   

2. Para forzar que se elimine una rama, incluso si sus cambios aún no se han fusionado:

   git branch -D nombre-rama
   

Borrado de todas las ramas excepto main

Adicionalmente, si trabajas en Windows, podrías haber acumulado varias ramas localmente y querer quedarte solo con la rama main. Te dejo el código para lograr esto de una manera simplificada:

1. Para crear una función de borrado de todas las ramas que no sean main y asignarle el alias gbd:

   Function Remove-AllBranchesExceptMain { git switch main; git branch | findstr /V /C:"main" | ForEach-Object { git branch -D $_.trim() } }; New-Alias -Name gbd -Value Remove-AllBranchesExceptMain
   

2. Para ejecutar la función:

   gbd
   

Abreviación de comandos

Tal vez no lo sepas y no lo estés utilizando, pero tu terminal de Bash te permite emplear el poderoso comando alias para hacer abreviaciones de comandos que utilizas con mucha frecuencia.

El proceso es sencillo: primero defines el alias y después lo utilizas como substituto del comando que estás abreviando. Te doy un ejemplo:

Con este comando abreviarás git commit -m por gc:

alias gc='git commit -m'

Tras reiniciar tu terminal, podrás utilizarlo de la siguiente forma:

gc "Mensaje del commit"