Si desarrollas software hoy en día, usas Git con casi toda probabilidad (y si no, deberías usarlo: sí, incluso aunque trabajes en soledad).
El caso es que Git es una herramienta que, aunque tiene interfaces gráficas, muchos desarrolladores utilizan desde la línea de comandos. No sólo eso: es indispensable conocer su manejo desde la terminal ya que hay cosas avanzadas o problemas que debemos resolver que solo lograremos yendo a esa ventanita de comandos de texto del sistema.
El caso es que muchos de esos comandos que emplearemos a menudo tienen muchos parámetros, o son difíciles de recordar o debemos combinar varios de ellos a la vez. Por eso, resulta de mucha utilidad establecer atajos o "alias", para facilitarnos la vida y de paso aumentar mucho nuestra productividad.
En este artículo te voy a mostrar cómo gestionarlos y unos cuantos que defino siempre en mis equipos de trabajo para mejorar mucho mi productividad.
Gestionar "Alias" en Git
Esos atajos en Git a los que me refiero se llaman alias, y se establecen a nivel global para poder utilizarlos desde cualquier sitio.
Para crear un alias en Git debemos utilizar el comando config. Por ejemplo:
git config --global alias.p 'push'
En este caso estamos definiendo un alias llamado simplemente p, que es un atajo para el comando push, que enviará los commits locales al repositorio remoto.
Fíjate en que hemos utilizado el switch --global, de modo que lo estamos definiendo para todo el equipo, no solo para el repositorio en el que nos encontramos ahora posicionados.
Una vez definido, podemos hacer un "push" simplemente escribiendo:
git p
¡Nos ahorramos escribir 3 letras! 😆 Vale, no es mucho, pero por algo podemos empezar. Quédate un poco más y ya verás alias más interesantes que este primer ejemplo simple.
Bien... Podemos conocer los alias que tenemos definidos actualmente escribiendo:
git config --global --get-regexp alias
que mostrará en tu terminal todos los alias y los comandos para los que sirven de atajo.
Finalmente, puedes eliminar alias con el comando unset:
git config --global --unset alias.p
que eliminará el alias indicado (p en este caso).
Nota: los alias se almacenan en el archivo de configuración global del sistema, que puedes encontrar en la ruta %userprofile%\.gitconfig en Windows o en ~/.gitconfig en Linux/macOS. Podemos editar directamente ese archivo en lugar de utilizar los comandos que acabamos de ver, pero ¡cuidadito!
Ahora que ya sabemos manejar alias, vamos a crear unos cuantos para subir de nivel nuestra productividad con Git...
1.- Hacer checkouts
Una tarea muy común en Git es cambiar de rama o examinar un commit usando el comando checkout. Este comando es largo (8 letras) y además complicado de escribir en español, por lo que un alias como este:
git config --global alias.co 'checkout'
nos vendrá muy bien.
Ahora podemos escribir simplemente:
git co develop/v2.3
para cambiarnos a la rama de desarrollo de la versión 2.3 de la aplicación que estamos desarrollando (suponiendo que les llamemos de ese modo develop/vx.y, claro).
O también podemos usar un simple guion como parámetro:
git co -
para movernos a la anterior rama en la que estuviésemos posicionados (¡toma truco!).
2.- Listar ramas remotas
Salvo que queramos crear ramas locales propias (ver punto siguiente), lo más habitual es que queramos crear una rama local que "trackee" una rama remota, de modo que nos traigamos sus cambios y luego todos los que hagamos localmente queden reflejados en el repositorio remoto cuando hagamos push.
Pero para esto, primero tenemos que saber qué ramas remotas tenemos disponibles y cuáles de ellas ya tenemos en local. Este alias nos ayudará:
git config --global alias.lb 'branch -a'
que se usaría como:
git lb
Esto nos mostrará un listado de todas las ramas disponibles en el repositorio actual, tanto locales como remotas ("lb" es de "List Branches", o sea, listar ramas).
Si lo que queremos es ver tan sólo qué ramas remotas tenemos disponibles, podemos definir este otro alias:
git config --global alias.lrb 'ls-remote'
que nos mostraría un listado de todas las ramas y tags remotos que haya (lrb = List Remote Branches).
3.- Crear ramas y cambiar a éstas
Aunque lo anterior está muy bien, generalmente, para lo que más usaremos el comando checkout es para crear nuevas ramas y empezar a trabajar con ellas, por lo que a lo mejor preferirás definir otro alias de esta manera:
git config --global alias.cb 'checkout -b'
que se usaría así:
git cb NuevaRama
que lo que hará será crear una nueva rama local y cambiarte a ella para seguir trabajando (lo de "cb" es por Create Branch, o sea, crear rama).
De todos modos, desde la versión 2.23 tenemos un comando mucho más útil para hacer lo mismo: switch. Este es específico para cambiar de ramas y nos ayuda más que usar git branch y git checkout ya que lo que hace es cambiar a una rama local, pero también crearla y seguir a una remota en caso de que exista. Por ello, salvo que estés usando por algún motivo una versión antigua de Git, mi recomendación sería definir el alias cb, así:
git config --global alias.cb 'switch'
De este modo, si queremos crear una nueva rama o simplemente cambiarnos a una versión local de una rama remota será mucho más fácil (en este caso "cb" es por Change Branch, o sea, cambiar de rama, que de paso la crea si es necesario). Si el nombre de rama que le pasamos no existe en local pero sí en remoto, ya de manera automática nos creará la rama local y empezará a "trackear" la rama remota desde la local, sin que tengamos que lanzar comandos largos y complicados, como pasaba antes con branch y checkout.
4.- Añadir todos los cambios
Lo primero que hay que hacer antes de un commit es añadir los archivos que necesitamos al área de staging de Git, mediante el comando git add -A. Esto añade todos los archivos nuevos, modificados y eliminados y los deja listos para hacer el commit.
Si queremos ahorrarnos todo eso puedes crear el alias:
git config --global alias.aa 'add -A'
y simplemente escribir:
git aa
cuando quieras añadir todos los cambios al área de staging (lo de "aa" es de "Add All", pero puedes usar lo que prefieras, o incluso solo una "a" para hacer git a y listo).
Este acorta muy poco el comando, pero como se usa tanto a lo largo del día tiene un impacto importante en acelerar el trabajo...
5.- Deshacer el último commit local
Algo bastante común es que hagamos un commit y nos demos cuenta de que nos hemos olvidado de algo, o hemos metido cosas de más, etc.... En ese caso lo suyo es que, si no hemos enviado el commit al repositorio remoto todavía, usemos un reset para deshacerlo y dejar todos los archivos cambiados en el área de staging. antes de repetir el commit como lo necesitemos. O sea, volver a dejarlo todo como antes de hacer el commit, para poder rehacerlo a nuestro gusto (te lo explico aquí junto a más cosas).
Si definimos este alias:
git config --global alias.rlc 'reset HEAD^ --soft'
Ahora un simple:
git rlc
y adiós commit erróneo.
Nota: yo a este alias le llamo rlc porque es la abreviatura de Reset Last Commit, o deshacer el último commit. y me acuerdo con facilidad. En este y todos los demás ejemplos crea alias que tengan sentido para ti y te resulten fáciles de recordar ¿vale?
Otro clásico es que estemos trabajando mucho tiempo en un commit, la cosa se complique, no demos con el resultado esperado y decidamos abandonar. En ese caso lo que nos suele interesar es dejarlo todo tal cual estaba antes de empezar a trabajar, de modo que se deshagan todos los cambios y aquí no ha pasado nada...
En este caso podemos definir otro alias muy similar al anterior, pero más destructivo, ya que no solo deshace el commit, sino que también deshace todos los cambios que hubiera (incluyendo recuperar archivos borrados):
git config --global alias.rlc 'reset HEAD^ --hard'
Un problema menos 😉
6.- Enviar todos los cambios al remoto, con un mensaje: el 3 en 1
Si hay algo que hacemos constantemente en Git es precisamente esta combinación de pasos:
- Añadir todos los cambios al staging
- Hacer commit de dichos cambios
- Enviar todo al servidor con
push
Esto implica hacer uso de 3 comandos concretos (add, commit y push) con sus correspondientes parámetros, y en ese orden.
Por eso, mi alias favorito y el que sin duda utilizo más, consiste en crear la combinación de todos esos pasos en uno solo. A ese alias le llamo send.
La forma de definirlo implica combinar más de un comando, cuando hasta ahora habíamos utilizado solo 1.
En los alias de Git podemos combinar más de un comando, pero para ello debemos ejecutarlos como comandos de terminal, es decir, no como hemos hecho hasta ahora poniendo el nombre de un comando de Git, sino que debemos usar el propio comando git completo. Es decir, lo que tenemos que hacer es crear un pequeño script que se ejecutará al invocar al alias.
Esto en Git se hace mediante el prefijo ! delante del contenido del alias.
Así, por ejemplo, si quisiésemos hacer un add y un commit con un mensaje genérico podríamos hacer por ejemplo esto:
git config --global alias.wip '!git add -A && git commit -m "WIP"'
Nota: fíjate en que el texto va entre comillas simples dos veces, no comillas dobles. Es decir, estamos "escapeando" las comillas con otras comillas. Los && se usan para ejecutar tareas en serie, una tras otra.
Esto es muy útil pues nos permite crear un commit con todos los cambios actuales y el mensaje "WIP" (de Work In Progress, es decir, Trabajo en progreso, que es una abreviatura muy habitual para indicar que el trabajo actual está en marcha, pero no hemos terminado.
Incluso podríamos añadir al final un && git push para que enviase el commit al repo remoto.
Pero ¿y si queremos personalizar el mensaje que vamos a asignar al commit? En ese caso necesitaremos un parámetro, ya que no nos vale poner uno al final puesto que eso se pasaría al script que estamos definiendo, no a Git como hasta ahora.
La solución pasa por definir una función dentro del alias y luego llamarla, usando los expansores de parámetros de la terminal para tomar sus valores por posición.
Lo vemos mejor con un ejemplo que, como digo, yo uso a todas horas, y es este alias:
git config --global alias.send '! send() { git add -A && git commit -m \"$1\" && git push ; }; send'
En este caso lo que hemos hecho en el alias es definir una función send que lo que hace es ejecutar los 3 comandos de Git que necesitamos, expandiendo el valor del primer parámetro que se le pasa (el mensaje que nos interesa) metiéndolo entre comillas para que quede anotado como mensaje del commit. Finalmente se llama a esta función, que es la que recibe verdaderamente el parámetro.
Con esta definición podemos hacer simplemente:
git send "El mensaje de mi commit"
cuando queramos de un solo golpe, añadir todos los cambios, hacer el commit y enviarlo al servidor. El alias define la función send, la llama y es ésta la que recibe el parámetro. el $1 representa el primer parámetro que le pasemos, y si necesitásemos más se los podríamos pasar y serían el $2, $3 y así sucesivamente.
Superútil y este sí que nos puede ahorrar mucho tiempo.
¡Espero que te resulte útil!
Fecha de publicación: