Bash

Execução e inicialização

Existem dois principais modos de execução do Bash: interativo e não interativo. No modo interativo, as instruções para o shell são fornecidas diretamente pela linha de comandos. Nela, os usuários podem acessar comandos executados anteriormente, executá-los novamente ou modificá-los, utilizando teclas de atalho do Emacs ou do vi, bem como autocompletar instruções e nomes de arquivos. Já no modo não interativo, os comandos são lidos de um shell script ou inseridos durante a invocação do executável do Bash como uma string associada ao parâmetro -c.

Outros modos de execução incluem: sessões de login e de não-login, modo POSIX, e modo restrito. A depender do tipo de sessão, o Bash pode ser customizado por alguns arquivos, como:

• /etc/profile;
• ~/.bash_profile;
• ~/.bash_login;
• ~/.profile;
• ~/.bash_logout; e
• ~/.bashrc.

Em sessões de login, o arquivo /etc/profile, caso exista, é lido e seus comandos são executados pelo Bash. Após isso, ele procura pelos arquivos ~/.bash_profile, ~/.bash_login e ~/.profile, nessa ordem, e executa aquele que aparecer primeiro. Finalmente, com o término da sessão, ~/.bash_logout também é procurado e executado. Por sua vez, o arquivo ~/.bashrc é executado somente em sessões interativas que não sejam de login, mas ele é comumente inserido dentro do ~/.bash_profile como outra fonte de customizações para ser aplicado em qualquer tipo de sessão.

Sintaxe

As instruções fornecidas ao Bash são fragmentadas em tokens, que podem ser interpretados como palavras ou operadores. As palavras são consideradas as unidades sintáticas dos comandos, enquanto os operadores controlam a execução e o fluxo de dados das instruções. Palavras reservadas são tipos especiais de palavras que, diferentes de uma palavra comum, recebem significados específicos pelo Bash. Operadores, palavras reservadas e outros termos (que se expandem, por exemplo), podem ser transformados em textos literais através de três mecanismos:

• prefixando caracteres com uma barra inversa, o caractere de escape do Bash;
• envolvendo os termos com aspas simples, que preservam os valores literais de quaisquer caracteres; e
• envolvendo os termos com aspas duplas, que mantêm os significados dos caracteres $, `, \ e !.

Além disso, os códigos de escape ANSI podem ser utilizados na forma $'código', e sequências de caracteres iniciadas por uma cerquilha são ignoradas e consideradas comentários.

Comandos

Comandos no Bash podem ser simples — formados por sequências de palavras separadas por espaços em branco, em que a primeira palavra determina o comando a ser executado e as demais especificam seus argumentos — ou compostos, que são formados por estruturas de controle ou encadeamentos, opcionalmente agrupados entre:

• parênteses, que criam um subshell, um novo ambiente dentro do próprio shell; ou
• chaves, que não criam um subshell, executando as intruções no mesmo ambiente de invocação.

O Bash implementa alguns comandos internos, como cd, pwd e echo, e permite interagir com executáveis presentes no sistema, como scripts e arquivos binários. Shell scripts escritos em Bourne shell ou com sua própria sintaxe são suportados e podem ser executados diretamente pelo Bash como se fossem comandos.

Estruturas de controle

Dois ou mais comandos ou encadeamentos podem ser combinados em uma estrutura sequencial com ;, que é equivalente a, e intercambiável com, uma quebra de linha. Outros operadores também combinam comandos em listas:

• & envia o comando anterior para o segundo plano, executado de maneira assíncrona;
• && implementa a conjunção lógica e executa o próximo comando somente se o anterior não falhar; e
• || implementa a disjunção lógica e executa o próximo comando somente se o anterior falhar.

Os dois últimos têm maior prioridade sobre os primeiros, que são os únicos capazes de finalizar instruções. Outras estruturas de controle estão disponíveis, incluindo três estruturas de repetição: while, until e for. Esse pode expandir palavras e, para cada expansão, executar um bloco de comandos, mas também possui outra forma, semelhante ao seu equivalente na linguagem C. Em qualquer uma das três, os comandos internos continue e break podem ser utilizados para controlar ciclos de repetições ou interrompê-las completamente.

Por outro lado, existem cinco estruturas de seleção: if, case, select, (( ... )) e [[ ... ]]. Estruturas select permitem gerar menus para o usuário selecionar uma entre várias opções. Já as duas últimas permitem avaliar expressões aritméticas e condicionais, que podem ser envolvidas por parênteses (que alteram a ordem de operações), precedidas pelo sinal de exclamação (que inverte o resultado lógico), ou combinadas com os operadores de conjunção e disjunção.

Funções

Funções permitem agrupar comandos para serem executados como se fossem apenas um, porém, diferente dos operadores de agrupamento, elas são executadas no mesmo ambiente do shell e possibilitam identificar cada grupo com um nome para invocá-los múltiplas vezes. No Bash, elas podem ser definidas através da palavra reservada function ou precedendo cada sequência de procedimentos por um nome, seguido de um par de parênteses.

Cada função possui um escopo próprio, contendo parâmetros e variáveis locais, que podem sobrescrever campos em escopos anteriores temporariamente. Aliás, funções podem ser recursivas e conter o comando interno return, que as interrompem e retorna um status de saída.

Parâmetros

No Bash, parâmetros são entidades que armazenam valores, e variáveis são parâmetros identificados por um nome que têm zero ou mais atributos. A declaração de uma variável, determinada por uma expressão do tipo nome=valor, pode preceder qualquer comando, tornando-se visível apenas a ele, ou acompanhar estes comandos internos:

• alias, permitindo que seu conteúdo possa ser interpretado diretamente como um comando;
• declare e typeset, que configuram seus atributos e fornecem outra interface para declará-la;
• export, que a exporta como uma variável de ambiente;
• readonly, que a configura somente para leitura, impedindo que seja removida ou alterada; e
• local, que a declara localmente dentro de uma função.

Definições de variáveis podem ser revertidas somente pelo comando unset, enquanto aliases podem ser removidos usando unalias. Qualquer valor atribuído a uma variável é tratado como uma cadeia de caracteres, mas esse comportamento pode ser alterado por atributos que permitem interpretar valores como números inteiros, expandindo expressões aritméticas para atribuições automaticamente, ou como arranjos, que podem ser:

• indexados, cujos índices são números; ou
• associativos, cujos campos são identificados por strings arbitrárias.

Além de variáveis, existem parâmetros posicionais e especiais. Aos posicionais, são atribuídos os argumentos fornecidos pela linha de comandos ou às funções, e, ao invés de nomes, eles são identificados por números, que correspondem à posição de cada argumento. Fora esses, outros parâmetros recebem tratamentos especiais pelo Bash:

• * e @ expandem para os parâmetros posicionais, de maneiras diferentes;
• # expande para a quantidade de parâmetros posicionais;
• ? expande para o status de saída do último comando;
• - expande para o conjunto de opções e flags do shell;
• $ expande para o identificador de processo do shell;
• ! expande para o identificador do último processo colocado em segundo plano; e
• 0 expande para o nome do shell ou do script.

Entre aspas duplas, * expande para uma só palavra contendo os parâmetros posicionais separados pelo primeiro caractere armazenado na variável IFS, mas, fora delas, expande cada parâmetro para uma palavra separada, sujeita a expansões de nome de arquivo e também de divisão de palavras. Sob esse último tipo expansão, @ expande os parâmetro para palavras separadas, mas, sem essa divisão (em atribuições de valores a variáveis, por exemplo), expande para uma única palavra com os parâmetros separados por sinais de espaço. Fora de aspas duplas, as palavras expandidas por @ também são suscetíveis a expansões divisivas.

Expansões

Expansões são mecanismos que permitem transformar tokens em outros elementos, como listas de arquivos, comandos e argumentos, além de substituir expressões por resultados de operações aritméticas ou valores armazenados em variáveis, por exemplo. As seguintes expansões são suportadas pelo Bash:

• expansão de chaves, que gera múltiplas sequências de caracteres com prefixos e sufixos em comum;

$ echo a{d,c,b}e
ade ace abe

• expansão do til, substituído por um diretório de usuário;

$ echo ~/downloads/
/home/usuário/downloads/

• expansão de parâmetro, que expande e manipula valores de parâmetros;

$ var=123 && echo "${var}" ${var} "$var" $var
123 123 123 123

• substituição de comando, que substitui instruções pelas suas próprias saídas sem quebras de linha finais;

$ echo Permissões: "$(stat -c %a script)" ou $(stat -c %A script)
Permissões: 755 ou -rwxr-xr-x

• expressões aritméticas, que são validadas e substituídas pelos seus resultados;

$ echo "$((1 - 2 + 3))" = $((4 * 1 / 2))
2 = 2

• substituição de processos, que substitui saídas e entradas de comandos por referências a arquivos;

$ tac <(printf 'Imprime\nArquivo\nInverso\n')
Inverso
Arquivo
Imprime

• divisão de palavras, que separa o resultado de uma expansão em múltiplas palavras, desde que ela não esteja entre aspas;

$ var='Abc 123' && cat script
echo "Quantidade de argumentos: ${#}. 1: ${1}. 2: ${2}. 3: ${3}."
$ bash script "$var" $var
Quantidade de argumentos: 3. 1: Abc 123. 2: Abc. 3: 123.

• expansão de nome de arquivo, que expande padrões (globs), como *, ? e [...], para nomes de arquivos.

$ ls
notas.odt  notas.txt  notas.txt.bak
$ ls notas.txt*
notas.txt  notas.txt.bak

Após tudo isso, aspas e barras inversas fora de expansões e aspas simples são removidas.

Redirecionamentos

Antes de executar um comando, o Bash permite redirecionar seus fluxos padrão para outros arquivos, além de duplicar, abrir, fechar e mover descritores. Redirecionamentos no Bash são implementados por vários operadores, que são lidos em ordem, da esquerda para a direita, e podem aparecer antes, dentro e depois de cada comando:

• < e > redirecionam entrada e saída;
• >> anexa uma saída a um arquivo;
• << e <<< criam here documents e here strings;
• <& e >& duplicam e movem descritores de arquivo; e
• <> abre um descritor para leitura e escrita.

Todos esses operadores podem ser prefixados pelos números 0, 1 e 2, relacionados ao descritores padrão de entrada, de saída e de erro, nessa ordem. O caractere &, que faz referência a ambos os fluxos 1 e 2 simultaneamente, também pode ser usado com alguns desses operadores, ou substituído por uma duplicação do tipo 2>&1.

Localização

A internacionalização e tradução do Bash para outros idiomas diferentes do inglês é feita pelo Translation Project, que traduz o software para 41 idiomas diferentes, incluindo o português europeu e o português brasileiro. Apesar de utilizar apenas oito bits para indexar caracteres, o suporte do Readline a codificações multi-byte permite abranger alfabetos mais complexos no Bash, que se adapta ao locale e interpreta strings em sequências complexas automaticamente.

Bourne shell

Como uma alternativa ao Bourne shell (sh), o Bash implementa algumas funcionalidades extras. Por exemplo:

• a palavra reservada !;
• o comando interno command;
• atualizações para os comandos internos read, umask e test;
• expansão de chaves (herança do C shell);
• possibilidade de definir variáveis e funções com o mesmo nome;
• possibilidade de desativação ou reescrita de comandos internos;
• autocompletamento de comandos e nomes de arquivos;
• customização dos prompts e da linha de comandos; e
• correções de vulnerabilidades.

Korn shell

Tanto o Bash quanto o Korn shell (ksh) atendem às normas POSIX e são compatíveis com scripts sh. Algumas novidades adicionadas ao Bash são derivadas do ksh, o que garante algumas funcionalidades comuns para ambos, como:

• novas variáveis de ambiente que controlam o shell;
• expansão de comandos com $(...) e de expressões aritméticas com $((...));
• novos comandos internos, como getopts e let;
• expansão do til para diretórios de usuário (herança do C shell);
• controle de trabalhos com bg, fg, jobs, kill e wait;
• histórico e edição de linha de comandos com atalhos nos estilos Emacs e vi;
• aliases e a estrutura de seleção select;
• extensões para os comandos export e readonly; e
• variáveis locais restritas ao escopo de uma função.

Olá, mundo!

echo 'Olá, mundo!'

Sequência de Fibonacci

function fibo {
    # A opção `-i` associa o atributo inteiro às variáveis. Assim, cada
    # atribuição será validada como uma expressão aritmética.
    declare -i a=0 b=1 c

    for (( c="$1"; c > 1; c-- )); do
        echo -n "$a, "
        b="b + a"
        a="b - a"
    done

    (( c > 0 )) && echo "$a."
}

# Exibe "0, 1, 1, 2, 3, 5, 8, 13, 21, 34."
fibo 10