Como desenvolvedor, você provavelmente usa a CLI do Git (Interface de Linha de Comando) diariamente. No entanto, escrever os mesmos comandos repetidamente pode ser trabalhoso, especialmente quando os comandos são longos. É aí que entram os aliases do Git para ajudar.

Neste artigo, você aprenderá como simplificar seus comandos do Git usando aliases.

Sumário

Pré-requisitos

  • Conhecimento do Git.

  • Git Bash instalado (opcional, mas recomendado para usuários do Windows).

  • Um IDE como o VS Code (também é opcional).

O Que São Aliases do Git?

Os aliases do Git são atalhos personalizados para comandos existentes do Git, tornando tarefas comuns mais rápidas e fáceis. Eles permitem que você defina seus próprios comandos, permitindo personalizar atalhos exatamente como deseja.

Você tem duas opções principais para adicionar/criar aliases do git em sua configuração do git, usando seu arquivo de configuração do Git ou adicionando-os diretamente via CLI (terminal/linha de comando).

Esta opção envolve abrir seu arquivo de configuração global do git e adicionar seus aliases do git ao final do arquivo.

Como Configurar Seu Editor Preferido do Git

Configure seu editor de software Git padrão, por exemplo, eu uso o VS Code para editar meu arquivo de configuração do Git, mas você pode usar o editor de texto/editor de código que preferir.

Execute este comando para definir o Notepad como seu editor preferido no Windows (CMD/PowerShell):

git config --global core.editor "notepad"

Execute este comando para definir o VS Code como seu editor preferido no Windows & MacOS/Linux:

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

Para definir um editor padrão diferente, pesquise online por “Definir {editor} como editor padrão do Git” e substitua {editor} pelo aplicativo preferido.

Como Abrir o Arquivo de Configuração do Git

Abra o terminal de sua escolha e insira o seguinte comando. Isso abrirá o arquivo de configuração global do Git (git config —global), em modo de edição (-e).

git config --global -e

Você pode abrir o arquivo de configuração do git diretamente nos seguintes locais:

Mac Os: Diretório Home → mostrar arquivos ocultos (Cmd + Shift + H) → .gitconfig

Windows: C:\Usuários\SeuNomeDeUsuário\ → então mostrar arquivos ocultos (em Visualizar) → e encontrar .gitconfig

Linux: Diretório Home → mostrar arquivos ocultos (Ctrl + H) → .gitconfig

Como Adicionar um Alias do Git Via Seu Arquivo de Configuração

Se você está adicionando aliases do Git pela primeira vez, abra seu arquivo .gitconfig, adicione [alias] no final e liste seus atalhos abaixo. Isso informa ao Git que são aliases. Adicione seu alias preferido (o comando abreviado que deseja executar).

O formato de um alias do git é <alias> = <comando>, então temos:

co = checkout
cob = checkout -b

Explicação dos exemplos acima:

co = checkout isso mapeia o comando git checkout para um comando mais curto git co. Você então chamaria git co feature/123 no seu terminal.

Você não precisa digitar git na frente do comando, pois a configuração irá pré-fixar isso automaticamente, pois sabe que o comando que você está mapeando é um comando Git.

Nota: Quaisquer parâmetros passados para o comando serão aplicados apenas ao comando final chamado dentro do alias.

Mais aliases podem ser adicionados desta forma, mapeando atalhos para comandos git existentes. Salvar e fechar o arquivo fará com que os aliases estejam disponíveis no seu terminal.

Como Adicionar Aliases no CLI

Se você deseja uma abordagem mais simplificada para adicionar aliases do Git, você pode adicioná-los diretamente do terminal/linha de comando.

Pegando os exemplos acima, podemos adicioná-los diretamente da seguinte maneira:

O formato do comando é: git config --global alias.{alias} "{comando original}":

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

É tão simples assim!

Como Criar Comandos Personalizados para Atalhos Mais Complexos

Ok, isso parece ótimo, mas não é tão impressionante – estamos apenas removendo alguns caracteres. No entanto, podemos torná-los muito mais úteis, podemos criar nossos comandos usando comandos shell.

Vamos pegar o seguinte exemplo, um comando que eu uso muito!

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

Este alias combina vários comandos do Git em um único comando de shell. O caractere ! diz ao Git para tratá-lo como um comando de shell, e não como um comando Git padrão.

Sem o !, o Git trata o alias como um comando Git (por exemplo, checkout se torna git checkout). Com o !, o Git sabe que deve executá-lo como um comando de shell sem adicionar o git na frente.

Ao encadear esses comandos, podemos escrever aliases muito mais úteis. O acima fará o seguinte:

  • Primeiro, fazer checkout para o branch main.

  • Usando o operador &&, significa que os outros comandos só serão executados se o anterior tiver sido bem-sucedido.

  • Em segundo lugar, ele irá puxar as alterações do branch main.

  • Por fim, criar um novo branch a partir do branch main usando nosso outro alias git cob.

O comando final pode então aceitar parâmetros (como o comando Git original faria), então pode ser usado da seguinte maneira:

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

Como Usar Parâmetros em Todos os Comandos

Até agora, só fomos capazes de passar nossos parâmetros para o comando final do git em nosso alias. No entanto, e se quisermos passar parâmetros para alguns, se não todos, dos comandos dentro do alias? Podemos conseguir isso usando uma função shell.

Veja o seguinte exemplo:

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

Acima estamos usando uma função shell que processa os parâmetros de entrada.

Explicação:

  1. !f():

    • O ! diz ao Git para interpretar o alias como um comando shell em vez de um comando Git padrão.

    • f() define uma função shell f que nos permitirá executar múltiplos comandos em sequência.

  2. Tudo dentro de { } é o que será executado dentro da função f().

  3. git checkout \"\$1”\': Irá executar um comando Git parametrizado, onde \$1 é escapado e será substituído pelo 1º parâmetro passado para o alias. As sequências de escape \" ao redor de \$1 permitem nomes de branches com espaços.

  4. && é um operador lógico que garante que cada comando só seja executado se o anterior tiver êxito. Se git checkout "$1" falhar, os comandos seguintes não serão executados.

  5. git checkout -b \"\$2”\ : Cria um novo branch com o nome do segundo parâmetro como antes.

  6. ;: Marca o final da função f();

  7. f: O último f chama imediatamente a função de alias, o que significa que quando você chama o alias, ele declara a função e a chama imediatamente.

Uso:

git new-work development task/feat-123

Outros Aliases Úteis

[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

Resumo

co: Checkout no ramo fornecido → git co task/feat-123

cob: Cria um novo ramo a partir do ramo atual → git cob feature/123

s: Chama git status para visualizar o status do ramo git atual → git s

tidy-up: Exclui todos os ramos locais exceto o main → git tidy-up

latest: Obtém as últimas alterações do ramo remoto main → git latest

new-work: Cria um novo ramo (2º parâmetro) a partir do ramo do 1º parâmetro → git new-work main feat/123

git done: Faz push do ramo atual para o repositório remoto (origin) e define como ramo upstream. Isso pode ser útil quando você faz push do seu primeiro commit e recebe o erro:
fatal: O ramo atual não tem um ramo upstream. Para fazer push do ramo atual e definir o remoto como upstream, use git push --set-upstream origin

save: Simplesmente adicionará todos os arquivos modificados, os commitará, abrirá seu editor Git padrão e solicitará uma mensagem de commit → git save

savem: Fará como acima, mas em vez de abrir o seu editor, você pode passar uma mensagem de commit inline → git savem 'Tarefa123: adicionar index.html'

br: Este parece complicado, mas não é tão complicado quanto parece, mas destaca o poder dos aliases. Em essência, ele personaliza o formato de saída do git branch para exibir uma lista detalhada e colorida de branches, ordenados pela data do commit mais recente, ficará algo semelhante à imagem abaixo para cada branch que você tem localmente.

Aí está, uma introdução aos aliases do Git e alguns exemplos úteis de aliases que você pode adicionar como um começo à sua configuração.

Como sempre, se quiser conversar sobre isso, ou saber sobre futuros artigos, você pode me seguir no Twitter.