Bem-vindo à aula 74 do nosso curso de Shell Script! Hoje vamos mergulhar em dois recursos poderosos do Bash que podem transformar sua experiência no terminal: aliases e funções. Se você já se pegou digitando comandos longos repetidamente ou desejou ter atalhos personalizados, esta aula é para você. Vamos aprender a criar atalhos simples com alias e funções mais complexas que podem receber argumentos e executar múltiplos comandos. Ao final, você terá um arsenal de dicas produtivas para turbinar seu dia a dia.

Dominar aliases e funções é essencial para qualquer usuário de Linux que busca eficiência. Enquanto aliases são ótimos para substituições rápidas de comandos, funções oferecem flexibilidade para lógica condicional, loops e manipulação de parâmetros. Vamos explorar ambos em detalhes, com exemplos práticos que você pode copiar e adaptar para seu próprio .bashrc.

Criando aliases

Um alias é um atalho que define uma palavra ou sequência de caracteres para representar um comando (ou uma cadeia de comandos). Quando você digita o alias no terminal, o Bash o expande para o comando associado. A sintaxe básica é:

alias nome='comando'

Por exemplo, para criar um atalho para ls -la, você pode fazer:

alias ll='ls -la'

A partir de então, digitar ll no terminal executará ls -la. Os aliases são uma forma rápida de economizar tempo, mas têm limitações: eles não aceitam argumentos de forma direta (embora você possa incluir argumentos fixos no comando). Para atalhos que precisam de parâmetros, as funções são mais adequadas.

Para criar aliases permanentes, você deve adicioná-los ao arquivo de configuração do seu shell, geralmente ~/.bashrc (para Bash). Após editar o arquivo, use source ~/.bashrc para aplicar as mudanças na sessão atual. É importante lembrar que aliases definidos na linha de comando são temporários e desaparecem ao fechar o terminal.

Outro ponto importante: para remover um alias, use unalias nome. E para ver todos os aliases ativos, digite alias sem argumentos. Isso é útil para auditar suas configurações.

Funções no .bashrc

Funções no Bash são blocos de código que podem ser chamados pelo nome, como se fossem comandos. Elas podem receber argumentos, ter variáveis locais e incluir lógica mais complexa. A sintaxe básica é:

nome_da_funcao() {
    comandos
}

Ou usando a palavra-chave function (opcional):

function nome_da_funcao() {
    comandos
}

Dentro da função, você pode acessar os argumentos usando $1, $2, etc., e o número total de argumentos com $#. Por exemplo, uma função que cria um diretório e entra nele:

mkcd() {
    mkdir -p "$1"
    cd "$1"
}

Assim, ao digitar mkcd meu_projeto, o comando cria o diretório meu_projeto (se não existir) e muda para ele. Isso é muito mais flexível que um alias, pois podemos usar o argumento passado.

Funções podem ser definidas tanto na linha de comando quanto no .bashrc. Para torná-las permanentes, adicione-as ao arquivo. Lembre-se de que funções são carregadas apenas em novas sessões ou após source ~/.bashrc. Uma boa prática é agrupar funções relacionadas em seções comentadas no arquivo para facilitar a manutenção.

Além disso, funções podem chamar outras funções e até a si mesmas (recursão), o que abre muitas possibilidades. No entanto, para scripts complexos, é melhor criar um arquivo separado e carregá-lo, mas para atalhos pessoais, o .bashrc é suficiente.

Atalhos produtivos

Combinando aliases e funções, você pode criar atalhos que economizam tempo e reduzem erros de digitação. Aqui estão algumas ideias comuns que muitos usuários adotam:

  • Navegação rápida: aliases como ..='cd ..', ...='cd ../..', ou funções para ir para diretórios de projeto frequentes.
  • Atalhos para comandos longos: por exemplo, gs='git status', gp='git pull', glog='git log --oneline --graph'.
  • Comandos com opções padrão: grep='grep --color=auto' para destacar resultados, ou ls='ls --color=auto'.
  • Funções para tarefas repetitivas: como extrair arquivos de vários formatos, fazer backup de um diretório com timestamp, ou iniciar um ambiente de desenvolvimento.

Por exemplo, uma função para extrair qualquer tipo de arquivo compactado:

extract() {
    if [ -f "$1" ]; then
        case "$1" in
            *.tar.bz2) tar xjf "$1" ;;
            *.tar.gz)  tar xzf "$1" ;;
            *.tar)     tar xf "$1" ;;
            *.tbz2)    tar xjf "$1" ;;
            *.tgz)     tar xzf "$1" ;;
            *.zip)     unzip "$1" ;;
            *.rar)     unrar x "$1" ;;
            *)         echo "'$1' não suportado" ;;
        esac
    else
        echo "'$1' não é um arquivo válido"
    fi
}

Essa função verifica a extensão do arquivo e executa o comando adequado. É um exemplo de como funções podem encapsular lógica condicional.

Outra dica produtiva é usar alias para corrigir erros comuns de digitação, como sl='ls' (quem nunca digitou sl no lugar de ls?). Isso pode evitar frustrações.

Exemplos

Vamos consolidar o que aprendemos com alguns exemplos práticos que você pode adicionar ao seu .bashrc. Lembre-se de testar cada um e adaptar conforme suas necessidades.

Exemplo 1: Aliases básicos

# Listagem com cores e detalhes
alias ls='ls --color=auto'
alias ll='ls -la'
alias la='ls -A'

# Navegação
alias ..='cd ..'
alias ...='cd ../..'
alias ~='cd ~'

# Git
alias gs='git status'
alias ga='git add'
alias gc='git commit -m'
alias gp='git pull'
alias gl='git log --oneline --graph'

Exemplo 2: Funções úteis

# Criar e entrar em diretório
mkcd() {
    mkdir -p "$1"
    cd "$1"
}

# Backup de um arquivo com timestamp
backup() {
    if [ -f "$1" ]; then
        cp "$1" "$1.$(date +%Y%m%d_%H%M%S).bak"
        echo "Backup criado: $1.$(date +%Y%m%d_%H%M%S).bak"
    else
        echo "Arquivo não encontrado: $1"
    fi
}

# Extrator universal (como acima)
extract() {
    if [ -f "$1" ]; then
        case "$1" in
            *.tar.bz2) tar xjf "$1" ;;
            *.tar.gz)  tar xzf "$1" ;;
            *.tar)     tar xf "$1" ;;
            *.tbz2)    tar xjf "$1" ;;
            *.tgz)     tar xzf "$1" ;;
            *.zip)     unzip "$1" ;;
            *.rar)     unrar x "$1" ;;
            *)         echo "'$1' não suportado" ;;
        esac
    else
        echo "'$1' não é um arquivo válido"
    fi
}

# Atualizar sistema (Debian/Ubuntu)
up() {
    sudo apt update && sudo apt upgrade -y
}

Exemplo 3: Função com argumentos opcionais

# Saudação personalizada
greet() {
    if [ -n "$1" ]; then
        echo "Olá, $1!"
    else
        echo "Olá, mundo!"
    fi
}

Esses exemplos mostram a versatilidade das funções. Você pode criar funções para praticamente qualquer tarefa repetitiva.

Boas práticas e observações finais

Ao criar aliases e funções, siga estas boas práticas:

  • Comente seu código: adicione comentários explicando o que cada alias/função faz, para facilitar a manutenção futura.
  • Nomeie de forma clara: use nomes curtos mas significativos, evitando conflitos com comandos existentes.
  • Teste antes de tornar permanente: experimente na linha de comando antes de adicionar ao .bashrc.
  • Organize por seções: se seu .bashrc crescer, separe por categorias (ex: aliases, funções, personalizações).
  • Use aspas simples em aliases: para evitar expansão de variáveis no momento da definição.

Lembre-se de que aliases e funções são específicos do shell Bash. Se você usa outros shells, a sintaxe pode variar. Além disso, ao compartilhar scripts, evite depender de aliases, pois eles não são exportados para subshells por padrão; prefira funções ou scripts completos.

Com essas ferramentas, seu terminal se torna muito mais produtivo. Experimente criar seus próprios atalhos e ajuste conforme seu fluxo de trabalho. A prática leva à perfeição!

Exercícios

  1. Crie um alias chamado cls que limpe a tela (equivalente a clear). Teste no terminal e depois adicione ao seu .bashrc.

    2. ✓ Resposta: 
    alias cls='clear'
  2. Escreva uma função chamada find_in que receba dois argumentos: um diretório e um termo de busca, e que use grep -r para procurar o termo dentro do diretório. Exemplo: find_in /etc passwd deve procurar 'passwd' em /etc.

    3. ✓ Resposta: 
    find_in() {
    grep -r "$2" "$1"
}
  3. Crie um alias chamado ports que liste as portas em escuta no sistema usando ss -tlnp (ou netstat se preferir).

    4. ✓ Resposta: 
    alias ports='ss -tlnp'
  4. Escreva uma função mkbackup que receba um arquivo e crie uma cópia com a extensão .bak e a data atual no formato AAAAMMDD_HHMMSS (use date +%Y%m%d_%H%M%S).

    5. ✓ Resposta: 
    mkbackup() {
    if [ -f "$1" ]; then
        cp "$1" "$1.$(date +%Y%m%d_%H%M%S).bak"
    else
        echo "Arquivo não encontrado: $1"
    fi
}
  5. Explique a diferença entre alias e função e dê um exemplo onde uma função é mais adequada que um alias.

    6. ✓ Resposta: Aliases são simples substituições de texto, sem suporte a argumentos dinâmicos. Funções podem receber argumentos, ter lógica condicional e loops. Exemplo: mkcd precisa do nome do diretório como argumento, então é melhor como função.

Referências