Como desenvolvedor, você provavelmente usa o Git CLI (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 de 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 que você adapte os atalhos exatamente como deseja.

Você tem duas opções principais para adicionar/criar aliases do git na 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 a abertura do seu arquivo de configuração global do git e anexando seus aliases do git ao final do arquivo.

Como Definir Seu Editor de Git Preferido

Defina o software editor padrão do seu Git configuração, por exemplo, eu uso o VS Code para editar meu arquivo de configuração do Git, mas você pode usar qualquer 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 e 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 seu terminal de 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 ocultos (Cmd + Shift + H) → .gitconfig

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

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

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

Se você está adicionando aliases do Git pela primeira vez, abra seu arquivo .gitconfig, adicione [alias] no final e então 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 git é <alias> = <comando>, então temos:

co = checkout
cob = checkout -b

Explicação dos exemplos acima:

co = checkout mapeia o comando git checkout para um comando mais curto git co. Em seguida, você chamaria git co feature/123 no seu terminal.

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

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

Mais aliases podem ser adicionados dessa forma, mapeando atalhos para comandos Git existentes. Salvar e fechar o arquivo tornará os aliases 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 de dentro 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 é realmente impressionante – estamos apenas removendo alguns caracteres. No entanto, podemos torná-los muito mais úteis, podemos criar nossos comandos usando comandos de shell.

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

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

Este alias combina múltiplos comandos 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 git na frente.

Ao encadear esses comandos, podemos escrever aliases muito mais úteis. O acima mencionado irá:

  • Primeiramente, verificar a ramificação 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 da ramificação main.

  • Por fim, criar uma nova ramificação a partir da ramificação main usando nosso outro alias git cob.

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

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 git final em nosso alias. No entanto, e se quisermos passar parâmetros para alguns, se não todos os comandos dentro do alias? Podemos conseguir isso usando uma função de shell.

Veja o exemplo a seguir:

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

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

Explicação:

  1. !f():

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

    • f() define uma função de shell f que nos permitirá executar vários 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 está escapado e será substituído pelo 1º parâmetro passado para o alias. As sequências de escape \" em torno de $1 permitem nomes de branch com espaços.

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

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

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

  7. f: O último f chama imediatamente a função 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: Faz checkout da ramificação especificada → git co task/feat-123

cob: Cria uma nova ramificação a partir da ramificação atual → git cob feature/123

s: Chama git status para visualizar o status da ramificação atual do git → git s

tidy-up: Deleta todas as ramificações locais exceto a main → git tidy-up

latest: Obtém as últimas alterações da ramificação remota main → git latest

new-work: Cria uma nova ramificação (2º parâmetro) a partir da ramificação do 1º parâmetro → git new-work main feat/123

git done: Faz push da ramificação atual para o repositório remoto (origin) e a define como a ramificação upstream. Isso pode ser útil ao fazer push do seu primeiro commit e receber o erro:
fatal: A ramificação atual não tem uma ramificação upstream. Para fazer push da ramificação atual e definir a remota como upstream, use git push --set-upstream origin

save: Simplesmente adiciona todos os arquivos alterados, os commita, abre o editor Git padrão e solicita uma mensagem de commit → git save

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

br: Este parece complicado, mas não é tão complicado quanto parece, mas destaca o poder dos aliases. Em essência, personaliza o formato de saída do git branch para exibir uma lista detalhada e colorida de branches, ordenada pela data do commit mais recente, irá parecer algo como a 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 para sua configuração.

Como sempre, se quiser conversar sobre isso, ou ficar por dentro de futuros artigos, pode me seguir no Twitter.