Cómo simplificar tus comandos de Git con alias

Este artículo es una traducción y adaptación del contenido original escrito por Grant Riordan en su blog. Puedes leer la versión original aquí.

Como desarrollador probablemente uses Git CLI (Command Line Interface) diariamente. Sin embargo, escribir los mismos comandos viejos diariamente, puede ser laborioso, especialmente cuando los comandos son largos. Aquí es donde entra en juego los alias de Git para ayudarte.

En este artículo, aprenderás cómo simplificar tus comandos de Git utilizando alias.

Requisitos previos

• Conocimientos de Git

• Git Bash instalado (opcional, pero recomendado para usuarios de Windows)

• Un editor como VS Code (también es opcional)

¿Qué son los alias en Git?

Los alias en Git son accesos directos personalizados para comandos existentes de Git, lo que hace que las tareas comunes sean más rápidas y sencillas. Te permiten definir tus propios comandos, adaptando los atajos exactamente como quieras.

Tienes dos opciones principales para agregar o crear alias en tu configuración de Git: usar el archivo de configuración de Git o añadirlos directamente desde la CLI (terminal/línea de comandos).

Cómo agregar alias en Git mediante el archivo de configuración global (recomendado)

Esta opción consiste en abrir tu archivo de configuración global de Git y agregar tus alias de Git al final del archivo.

Cómo configurar tu editor de Git preferido

Configura tu editor de Git predeterminado; por ejemplo, yo uso VS Code para editar mi archivo de configuración de Git, pero puedes usar cualquier editor de texto o de código que prefieras.

Ejecuta este comando para establecer Notepad como tu editor preferido en Windows (CMD/PowerShell):

git config --global core.editor "notepad"

Ejecuta este comando para establecer VS Code como tu editor preferido en Windows y macOS/Linux:

git config --global core.editor "code --wait"

Para establecer un editor predeterminado diferente, busca en Internet “Set {editor} as default Git editor” y reemplaza {editor} con la aplicación que prefieras.

Puedes abrir el archivo de configuración de Git directamente desde las siguientes ubicaciones:

• Mac OS: Directorio de inicio → mostrar archivos ocultos (Cmd + Shift + H) → .gitconfig

• Windows: C:\\Users\\TuUsuario\\ → luego mostrar archivos ocultos (en Vista) → y busca .gitconfig

• Linux: Directorio de inicio → mostrar archivos ocultos (Ctrl + H) → .gitconfig

Cómo agregar un alias en Git mediante el archivo de configuración

Si estás agregando alias de Git por primera vez, abre tu archivo .gitconfig, añade [alias] al final y luego escribe tus atajos debajo. Esto le indica a Git que se trata de alias. Después, agrega tu alias preferido (el comando abreviado que deseas ejecutar).

El formato de un alias en Git es <alias> = <comando>, por lo tanto tenemos:

co = checkout
cob = checkout -b

Explicación del ejemplo anterior:

co = checkout esto asigna el comando git checkout a una versión más corta: git co. Luego podrías ejecutar en tu terminal git co feature/123

No necesitas escribir git delante del comando, ya que la configuración lo antepone automáticamente al reconocer que el comando que estás mapeando pertenece a Git.

Nota: Cualquier parámetro que pases al comando se aplicará únicamente al comando final ejecutado dentro del alias.

Puedes agregar más alias de esta misma manera, asignando atajos a comandos existentes de Git. Una vez que guardes y cierres el archivo, los alias estarán disponibles en tu terminal.

Cómo agregar alias desde la línea de comandos (CLI)

Si quieres una forma más ágil de agregar alias en Git, puedes añadirlos directamente desde la terminal o línea de comandos.

Tomando los ejemplos anteriores, podemos agregarlos directamente de la siguiente manera:

El formato del comando es: git config --global alias.{alias} "{comando original}":

git config --global alias.co "checkout"
#or
git config --global alias.cob "checkout -b"

¡Así de fácil!

Cómo crear comandos personalizados para atajos más complejos

Está bien, esto se ve bien, pero en realidad no es tan impresionante: solo estamos acortando unos pocos caracteres. Sin embargo, podemos hacerlos mucho más útiles si creamos nuestros comandos usando comandos de shell.

Tomemos el siguiente ejemplo, un comando que uso con frecuencia:

new-work = !git checkout main && git pull && git cob

Este alias combina varios comandos de Git en un solo comando de shell. El carácter ! indica a Git que lo trate como un comando de shell, no como un comando estándar de Git.

Sin el !, Git trata el alias como un comando de Git (por ejemplo, checkout se convierte en git checkout). Con el !, Git sabe que debe ejecutarlo como un comando de shell, sin anteponer git.

Al encadenar estos comandos, podemos crear alias mucho más útiles. El alias anterior hará lo siguiente:

• Primero, cambia a la rama principal (main).

• Al usar el operador &&, los demás comandos solo se ejecutarán si el comando anterior se realizó correctamente.

• En segundo lugar, descargará los cambios más recientes de la rama main.

• Finalmente, creará una nueva rama a partir de main usando nuestro otro alias git cob.

El comando final también puede aceptar parámetros (como lo haría el comando original de Git), por lo que puede usarse de la siguiente manera:

git new-work 'feature/new-work-from-main'

Cómo usar parámetros en todos los comandos

Hasta ahora, solo hemos podido pasar parámetros al comando final de Git dentro de nuestro alias. Sin embargo, ¿Qué pasa si queremos pasar parámetros a algunos, o incluso a todos, los comandos dentro del alias? Podemos lograrlo usando una función de shell.

Tomemos el siguiente ejemplo:

new-work = "!f() { git checkout \\"$1\\" && git pull && git checkout -b \\"$2\\"; }; f"

En el ejemplo anterior, estamos usando una función de shell que procesa los parámetros de entrada.

Explicación:

1. !f():

   • El ! indica a Git que interprete el alias como un comando de shell, en lugar de un comando estándar de Git.

   • f() define una función de shell llamada f, que nos permite ejecutar múltiples comandos en secuencia.

2. Todo lo que está dentro de las llaves { } será ejecutado dentro de la función f().

3. git checkout \\"$1"'\\: Ejecutará un comando Git parametrizado, donde $1 será reemplazado por el primer parámetro pasado al alias. Las comillas \\" permiten nombres de ramas con espacios.

4. && es un operador lógico que asegura que cada comando solo se ejecute si el comando anterior fue exitoso. Si git checkout "$1" falla, los comandos siguientes no se ejecutarán.

• git checkout -b \\"$2"\\: Crea una nueva rama con el nombre del segundo parámetro, como en ejemplos anteriores.

• ; Marca el final de la función f().

• f Llama inmediatamente a la función f, por lo que al ejecutar el alias, se declara la función y se ejecuta de inmediato.

Uso:

git new-work development task/feat-123

Otros alias útiles

[alias]
    co = checkout
    cob = checkout -b
    s = status
    tidy-up = !git checkout main && git branch | grep -v "main" | xargs git branch -D
    latest = !git checkout main && git pull
    new-work = "!f() { git checkout \\"$1\\" && git pull && git checkout -b \\"$2\\"; }; f"
    done = !git push -u origin HEAD
    save = !git add -A && git commit
    saveM = !git add -A && git commit -m
    br = branch --format='%(HEAD) %(color:yellow)%(refname:short)%(color:reset) - %(contents:subject) %(color:green)(%(committerdate:relative)) [%(authorname)]' --sort=-committerdate

Resumen

• co: Cambia a la rama indicada → git co task/feat-123

• cob: Crea una nueva rama desde la rama actual → git cob feature/123

• s: Ejecuta git status para ver el estado de la rama actual → git s

• tidy-up: Elimina todas las ramas locales excepto main → git tidy-up

• latest: Obtiene los últimos cambios de la rama main remota → git latest

• new-work: Crea una nueva rama (2º parámetro) a partir de la rama indicada en el 1º parámetro → git new-work main feat/123

• git done: Hace push de la rama actual al repositorio remoto (origin) y la establece como rama upstream. Útil cuando haces el primer commit y aparece el error:

  fatal: The current branch has no upstream branch. To push the current branch and set the remote as upstream, use git push --set-upstream origin

• save: Agrega todos los archivos modificados y realiza un commit, abriendo tu editor de Git predeterminado para ingresar el mensaje de commit → git save

• savem: Igual que el anterior, pero en lugar de abrir el editor, permite pasar el mensaje de commit directamente → git savem 'Task123: add index.html'

• br: Aunque parece complicado, no lo es tanto y demuestra el poder de los alias. Personaliza el formato de salida de git branch para mostrar una lista detallada y con colores de las ramas, ordenadas por fecha del último commit. El resultado se verá algo como la imagen que se muestra, para cada rama que tengas localmente.

Ahí lo tienes: una introducción a los alias en Git y algunos ejemplos útiles que puedes agregar como punto de partida en tu configuración.

Como siempre, si quieres comentar sobre el tema o enterarte de futuros artículos, puedes seguirme en Twitter.

Nota: Este artículo fue traducido y adaptado de Grant Riordan, contenido original en freeCodeCamp. Consulta el artículo original aquí.

---

De Colombia para el mundo ❤️