Man » Manual online de sh - documentação online detalhada para a página de manual de sh

🌍 ☰

SINTAXE
DESCRIÇÃO
STATUS DE SAÍDA
AMBIENTE
ARQUIVOS
VEJA TAMBÉM
HISTÓRICO
ERROS

dash — interpretador de comandos (shell)

SINTAXE

dash     [-aCefnuvxIimqVEbp]    [+aCefnuvxIimqVEbp]    [-o    option_name]    [+o    option_name]
[command_file [argument ...]]
dash -c [-aCefnuvxIimqVEbp] [+aCefnuvxIimqVEbp] [-o option_name] [+o option_name]  command_string
[command_name [argument ...]]
dash -s [-aCefnuvxIimqVEbp] [+aCefnuvxIimqVEbp] [-o option_name] [+o option_name] [argument ...]

DESCRIÇÃO

dash  é o interpretador de comandos padrão para o sistema. A versão atual de dash está em
processo de ser alterada para estar em conformidade com as especificações POSIX 1003.2 e 1003.2a
para o shell. Esta versão possui muitos recursos que a fazem parecer semelhante em alguns aspectos
ao shell Korn, mas não é um clone do shell Korn (veja ksh(1)). Apenas os recursos designados pelo
POSIX, mais algumas extensões Berkeley, estão sendo incorporados a este shell. Esta página de
manual não se destina a ser um tutorial ou uma especificação completa do shell.

Visão geral

O shell é um comando que lê linhas de um arquivo ou do terminal, interpreta-as e, geralmente, executa outros comandos. É o programa que está em execução quando um usuário faz login no sistema (embora um usuário possa selecionar um shell diferente com o comando chsh(1)). O shell implementa uma linguagem que possui construções de controle de fluxo, uma instalação de macro que fornece uma variedade de recursos, além de armazenamento de dados, juntamente com recursos integrados de histórico e edição de linha. Ele incorpora muitos recursos para auxiliar o uso interativo e tem a vantagem de que a linguagem interpretativa é comum tanto para uso interativo quanto não interativo (scripts de shell). Ou seja, os comandos podem ser digitados diretamente no shell em execução ou podem ser colocados em um arquivo e o arquivo pode ser executado diretamente pelo shell.

Invocação

Se nenhum argumento estiver presente e se a entrada padrão do shell estiver conectada a um terminal (ou se a flag -i estiver definida) e a opção -c não estiver presente, o shell é considerado um shell interativo. Um shell interativo geralmente solicita antes de cada comando e manipula erros de programação e comando de forma diferente (conforme descrito abaixo). Ao iniciar, o shell inspeciona o argumento 0 e, se ele começar com um traço ‘-’, o shell também será considerado um shell de login. Isso geralmente é feito automaticamente pelo sistema quando o usuário faz login pela primeira vez. Um shell de login primeiro lê os comandos dos arquivos /etc/profile e .profile, se eles existirem. Se a variável de ambiente ENV estiver definida na entrada de um shell interativo ou estiver definida no arquivo .profile de um shell de login, o shell em seguida, lê os comandos do arquivo nomeado em ENV. Portanto, um usuário deve colocar comandos que devem ser executados apenas no momento do login no arquivo .profile e comandos que são executados para cada shell interativo dentro do arquivo ENV. Para definir a variável ENV para algum arquivo, coloque a seguinte linha no arquivo .profile do seu diretório pessoal.

ENV=$HOME/.shinit; export ENV

substituindo “.shinit” por qualquer nome de arquivo que você desejar.

Se argumentos de linha de comando, além das opções, forem especificados, o shell tratará o primeiro argumento como o nome de um arquivo do qual ler os comandos (um script shell), e os argumentos restantes serão definidos como os parâmetros posicionais do shell ($1, $2, etc.). Caso contrário, o shell lê os comandos de sua entrada padrão.

Processamento da Lista de Argumentos

Todas as opções de uma única letra que possuem um nome correspondente podem ser usadas como um argumento para a opção -o. O comando set -o name é fornecido ao lado da opção de uma única letra na descrição abaixo. Especificar um traço “-” ativa a opção, enquanto usar um sinal de mais “+” a desativa. As seguintes opções podem ser definidas a partir da linha de comando ou com o comando interno set (descrito posteriormente).

-a allexport     Exportar todas as variáveis atribuídas.

-c               Ler os comandos da string de comando `command_string` em vez da entrada padrão. O parâmetro especial 0 será definido a partir do operando `command_name` e os parâmetros posicionais ($1, $2, etc.) serão definidos a partir dos operandos de argumento restantes.

-C noclobber     Não sobrescrever arquivos existentes com “>”.

-e errexit       Se não for interativo, sair imediatamente se algum comando não testado falhar. O status de saída de um comando é considerado explicitamente testado se o comando for usado para controlar um `if`, `elif`, `while` ou `until`; ou se o comando for o operando esquerdo de um operador “&&” ou “||”.

-f noglob        Desabilitar a expansão de nomes de arquivos.

-n noexec        Se não for interativo, ler os comandos, mas não executá-los. Isso é útil para verificar a sintaxe de scripts shell.

-u nounset       Escrever uma mensagem para o erro padrão ao tentar expandir uma variável que não está definida e, se o shell não for interativo, sair imediatamente.

-v verbose       O shell grava sua entrada no erro padrão conforme a lê. Útil para depuração.

-x xtrace        Gravar cada comando no erro padrão (precedido por um ‘+ ’) antes de ser executado. Útil para depuração.

-I ignoreeof     Ignorar EOFs da entrada quando interativo.

-i interactive   Forçar o shell a se comportar interativamente.

-l               Fazer com que o dash aja como se tivesse sido invocado como um shell de login.

-m monitor       Ligar o controle de tarefas (ligado automaticamente quando interativo).

-s stdin         Ler comandos da entrada padrão (ligado automaticamente se nenhum argumento de arquivo estiver presente). Esta opção não tem efeito quando definida após o shell já ter iniciado a execução (por exemplo, com `set`).

-V vi            Ativa o editor de linha de comando vi(1) interno (desativa -E se estiver definido).

-E emacs         Ativa o editor de linha de comando [emacs](filename}emacs.md)(1) interno (desativa -V se estiver definido).

-b notify        Ativa a notificação assíncrona da conclusão de trabalhos em segundo plano. (NÃO IMPLEMENTADO para 4.4alpha)

-p priviliged    Não tenta redefinir o ID de usuário efetivo se não corresponder ao ID de usuário. Isso não é definido por padrão para ajudar a evitar o uso incorreto por programas setuid root por meio de system(3) ou popen(3).

Estrutura Léxica

O shell lê a entrada em termos de linhas de um arquivo e a divide em palavras usando espaços em branco (espaços e tabulações) e em certas sequências de caracteres que são especiais para o shell, chamadas de "operadores". Existem dois tipos de operadores: operadores de controle e operadores de redirecionamento (seu significado é discutido posteriormente). A seguir, uma lista de operadores:

Operadores de controle: & && ( ) ; ;; | ||

Operadores de redirecionamento: < > >| << >> <& >& <<- <>

Aspas

As aspas são usadas para remover o significado especial de certos caracteres ou palavras para o shell, como operadores, espaços em branco ou palavras-chave. Existem três tipos de aspas: aspas simples correspondentes, aspas duplas correspondentes e barra invertida.

Barra Invertida

Uma barra invertida preserva o significado literal do caractere seguinte, com a exceção de ⟨nova linha⟩. Uma barra invertida que precede uma ⟨nova linha⟩ é tratada como uma continuação de linha.

Aspas Simples

Encerrar caracteres entre aspas simples preserva o significado literal de todos os caracteres (exceto aspas simples, tornando impossível colocar aspas simples em uma string entre aspas simples).

Aspas Duplas

Encerrar caracteres entre aspas duplas preserva o significado literal de todos os caracteres, exceto o sinal de dólar ($), a crase () e a barra invertida (\). A barra invertida dentro de aspas duplas é historicamente estranha e serve para dar escape apenas aos seguintes caracteres: $ " \ . Caso contrário, permanece literal.

Palavras Reservadas

As palavras reservadas são palavras que têm um significado especial para o shell e são reconhecidas no início de uma linha e após um operador de controle. As seguintes são palavras reservadas:

!       elif    fi      while   case
else    for     then    {       }
do      done    until   if      esac

Seu significado é discutido posteriormente.

Aliases

Um alias é um nome e um valor correspondente definidos usando o comando interno alias(1). Sempre que uma palavra reservada pode ocorrer (veja acima) e, após verificar as palavras reservadas, o shell verifica se a palavra corresponde a um alias. Se corresponder, ele a substitui no fluxo de entrada pelo seu valor. Por exemplo, se houver um alias chamado "lf" com o valor "ls -F", então a entrada:

lf foobar ⟨return⟩

se tornaria

ls -F foobar ⟨return⟩

Os aliases fornecem uma maneira conveniente para usuários iniciantes criarem atalhos para comandos sem ter que aprender como criar funções com argumentos. Eles também podem ser usados para criar código lexicalmente obscuro. Esse uso é desencorajado.

Comandos

O shell interpreta as palavras que lê de acordo com uma linguagem, cuja especificação está fora do escopo desta página de manual (consulte a BNF no documento POSIX 1003.2). Essencialmente, uma linha é lida e, se a primeira palavra da linha (ou após um operador de controle) não for uma palavra reservada, o shell reconheceu um comando simples. Caso contrário, um comando complexo ou alguma outra construção especial pode ter sido reconhecida.

Comandos Simples

Se um comando simples foi reconhecido, o shell executa as seguintes ações:

    As palavras iniciais do formulário "nome=valor" são removidas e atribuídas ao ambiente do comando simples. Os operadores de redirecionamento e seus argumentos (conforme descrito abaixo) são removidos e salvos para processamento.

    As palavras restantes são expandidas conforme descrito na seção chamada "Expansões", e a primeira palavra restante é considerada o nome do comando e o comando é localizado. As palavras restantes são consideradas os argumentos do comando. Se nenhum nome de comando resultar, as atribuições de variáveis "nome=valor" reconhecidas no item 1 afetarão o shell atual.

    Os redirecionamentos são executados conforme descrito na próxima seção.

Redirecionamentos

Os redirecionamentos são usados para alterar de onde um comando lê sua entrada ou envia sua saída. Em geral, os redirecionamentos abrem, fecham ou duplicam uma referência existente para um arquivo. O formato geral usado para redirecionamento é:

[n] redir-op arquivo

onde redir-op é um dos operadores de redirecionamento mencionados anteriormente. A seguir, está uma lista dos possíveis redirecionamentos. O [n] é um número opcional entre 0 e 9, como em '3' (não '[3]'), que se refere a um descritor de arquivo.

[n]> arquivo    Redireciona a saída padrão (ou n) para o arquivo.

[n]>| arquivo   O mesmo, mas substitui a opção -C.

[n]>> arquivo   Anexa a saída padrão (ou n) ao arquivo.

[n]< arquivo    Redireciona a entrada padrão (ou n) do arquivo.

[n1]<&n2    Copia o descritor de arquivo n2 como saída padrão (ou fd n1). fd n2.

[n]<&-  Fecha a entrada padrão (ou n).

[n1]>&n2    Copia o descritor de arquivo n2 como entrada padrão (ou fd n1). fd n2.

[n]>&-  Fecha a saída padrão (ou n).

[n]<> arquivo   Abre o arquivo para leitura e gravação na entrada padrão (ou n).

O seguinte redirecionamento é frequentemente chamado de "documento aqui".

[n]<< delimitador
texto-do-documento-aqui ...
delimitador

Todo o texto nas linhas subsequentes até o delimitador é salvo e disponibilizado para o comando na entrada padrão ou no descritor de arquivo n, se especificado. Se o delimitador especificado na linha inicial for citado, o texto-do-documento-aqui será tratado literalmente; caso contrário, o texto será submetido à expansão de parâmetros, substituição de comandos e expansão aritmética (conforme descrito na seção "Expansões"). Se o operador for " <<- " em vez de " << ", os espaços em branco à esquerda no texto-do-documento-aqui serão removidos.

Pesquisa e Execução

Existem três tipos de comandos: funções shell, comandos internos e programas normais – e o comando é pesquisado (pelo nome) nessa ordem. Cada um é executado de uma maneira diferente.

Quando uma função shell é executada, todos os parâmetros posicionais do shell (exceto $0, que permanece inalterado) são definidos para os argumentos da função shell. As variáveis que são explicitamente colocadas no ambiente do comando (colocando atribuições a elas antes do nome da função) são tornadas locais para a função e são definidas para os valores fornecidos. Em seguida, o comando fornecido na definição da função é executado. Os parâmetros posicionais são restaurados para seus valores originais quando o comando é concluído. Tudo isso ocorre dentro do shell atual.

Os comandos internos do shell são executados internamente ao shell, sem gerar um novo processo.

Caso contrário, se o nome do comando não corresponder a uma função ou comando interno, o comando é pesquisado como um programa normal no sistema de arquivos (conforme descrito na próxima seção). Quando um programa normal é executado, o shell executa o programa, passando os argumentos e o ambiente para o programa. Se o programa não for um arquivo executável normal (ou seja, se não começar com o "número mágico" cuja representação ASCII é "#!", então execve(2) retorna ENOEXEC), o shell interpretará o programa em um subshell. O subshell se reinicializará neste caso, de modo que o efeito será como se um novo shell tivesse sido invocado para lidar com o script shell ad-hoc, exceto que a localização dos comandos em cache localizados no shell pai será lembrada pelo filho.

Observe que versões anteriores deste documento e o próprio código-fonte referem-se de forma enganosa e esporádica a um script shell sem um número mágico como um "procedimento shell".

Pesquisa de Caminho

Ao localizar um comando, o shell primeiro verifica se existe uma função shell com esse nome. Em seguida, ele procura por um comando interno com esse nome. Se um comando interno não for encontrado, uma de duas coisas acontece:

*   Os nomes de comando que contêm uma barra são simplesmente executados sem realizar nenhuma pesquisa.

*   O shell pesquisa cada entrada em PATH, uma por vez, para o comando. O valor da variável PATH deve ser uma série de entradas separadas por dois pontos. Cada entrada consiste em um nome de diretório. O diretório atual pode ser indicado implicitamente por um nome de diretório vazio ou explicitamente por um único ponto.

Status de Saída do Comando

Cada comando tem um status de saída que pode influenciar o comportamento de outros comandos do shell. O paradigma é que um comando sai com zero para normal ou sucesso e diferente de zero para falha, erro ou uma indicação falsa. A página de manual de cada comando deve indicar os vários códigos de saída e o que eles significam. Além disso, os comandos internos retornam códigos de saída, assim como uma função shell executada.

Se um comando consiste inteiramente em atribuições de variáveis, o status de saída do comando é o do último comando de substituição, se houver, caso contrário, 0.

Comandos Complexos

Comandos complexos são combinações de comandos simples com operadores de controle ou palavras reservadas, criando um comando complexo maior. De forma mais geral, um comando é um dos seguintes:

comando simples

pipeline

lista ou lista composta

comando composto

definição de função

A menos que especificado de outra forma, o status de saída de um comando é o do último comando simples executado pelo comando.

Pipelines

Um pipeline é uma sequência de um ou mais comandos separados pelo operador de controle |. A saída padrão de todos os comandos, exceto o último, é conectada à entrada padrão do próximo comando. A saída padrão do último comando é herdada do shell, como de costume.

O formato para um pipeline é:

[!] command1 [| command2 ...]

A saída padrão de command1 é conectada à entrada padrão de command2. A entrada padrão, a saída padrão ou ambos de um comando são considerados atribuídos pelo pipeline antes de qualquer redirecionamento especificado por operadores de redirecionamento que fazem parte do comando.

Se o pipeline não estiver em segundo plano (discutido posteriormente), o shell aguarda que todos os comandos sejam concluídos.

Se a opção pipefail estiver habilitada quando o shell começar a executar o pipeline, o status de saída do pipeline é o status de saída do último comando especificado no pipeline que saiu com um status diferente de zero ou zero se todos os comandos no pipeline saíram com um status de zero. Se a opção pipefail não estiver habilitada, o status de saída do pipeline é o status de saída do último comando especificado no pipeline; os status de saída de quaisquer outros comandos não são usados. Se a palavra reservada ! preceder o pipeline, seu status de saída é o NÃO lógico do status de saída descrito acima.

Como a atribuição de pipeline da entrada padrão ou saída padrão ou ambos ocorre antes do redirecionamento, ele pode ser modificado por redirecionamento. Por exemplo:

$ command1 2>&1 | command2

envia a saída padrão e o erro padrão de command1 para a entrada padrão de command2.

Um terminador ; ou ⟨nova linha⟩ faz com que a AND-OR-lista precedente (descrita a seguir) seja executada sequencialmente; um & faz com que a AND-OR-lista precedente seja executada de forma assíncrona.

Observe que, ao contrário de alguns outros shells, cada processo no pipeline é um filho do shell que o invocou (a menos que seja um builtin do shell, caso em que ele é executado no shell atual - mas qualquer efeito que ele tenha no ambiente é apagado).

Comandos em Segundo Plano – &

Se um comando for terminado pelo operador de controle ampersand (&), o shell executará o comando de forma assíncrona – ou seja, o shell não aguardará que o comando termine antes de executar o próximo comando.

O formato para executar um comando em segundo plano é:

command1 & [command2 & ...]

Se o shell não for interativo, a entrada padrão de um comando assíncrono será definida como /dev/null.

Listas – Em Geral

Uma lista é uma sequência de zero ou mais comandos separados por quebras de linha, ponto e vírgula ou e comercial, e opcionalmente terminada por um desses três caracteres. Os comandos em uma lista são executados na ordem em que são escritos. Se um comando for seguido por um e comercial, o shell inicia o comando e prossegue imediatamente para o próximo comando; caso contrário, ele aguarda o término do comando antes de prosseguir para o próximo.

Operadores de Lista de Curto-Circuito

“&&” e “||” são operadores de lista “E-OU”. “&&” executa o primeiro comando e, em seguida, executa o segundo comando somente se o status de saída do primeiro comando for zero. “||” é semelhante, mas executa o segundo comando somente se o status de saída do primeiro comando for diferente de zero. “&&” e “||” têm a mesma prioridade.

Construtos de Controle de Fluxo – if, while, for, case

A sintaxe do comando if é

if list
then list
[ elif list
then    list ] ...
[ else list ]
fi

A sintaxe do comando while é

while list
do   list
done

As duas listas são executadas repetidamente enquanto o status de saída da primeira lista for zero. O comando until é semelhante, mas tem a palavra until no lugar de while, o que faz com que ele se repita até que o status de saída da primeira lista seja zero.

A sintaxe do comando for é

for variable [ in [ word ... ] ]
do   list
done

As palavras que seguem in são expandidas e, em seguida, a lista é executada repetidamente com a variável definida para cada palavra, uma de cada vez. Omitir in word ... é equivalente a in "$@".

A sintaxe dos comandos break e continue é

break [ num ]
continue [ num ]

Break termina o número especificado de loops for ou while mais internos. Continue continua com a próxima iteração do loop mais interno. Estes são implementados como comandos internos.

A sintaxe do comando case é

case word in
[(]pattern) list ;;
...
esac

O padrão pode realmente ser um ou mais padrões (veja “Padrões de Shell” descritos posteriormente), separados por caracteres “|”. O caractere “(” antes do padrão é opcional.

Agrupando Comandos

Os comandos podem ser agrupados escrevendo-se

(list)

ou

{ list; }

O primeiro executa os comandos em um subshell. Os comandos internos agrupados em (list) não afetarão o shell atual. A segunda forma não cria outro shell, portanto, é ligeiramente mais eficiente. Agrupar comandos dessa forma permite que você redirecione sua saída como se fossem um único programa:

{ printf " hello " ; printf " world\n" ; } > greeting

Observe que “}” deve seguir um operador de controle (aqui, “;”) para que seja reconhecido como uma palavra reservada e não como outro argumento de comando.

Funções

A sintaxe de uma definição de função é

name () command

Uma definição de função é uma instrução executável; quando executada, ela instala uma função chamada name e retorna um status de saída de zero. O comando é normalmente uma lista encerrada entre “{” e “}”.

As variáveis podem ser declaradas como locais a uma função usando o comando local. Isso deve aparecer como a primeira instrução de uma função, e a sintaxe é:

local [variável | -] ...

^ ocal é implementado como um comando interno.

Quando uma variável é tornada local, ela herda o valor inicial e os atributos de exportação e somente leitura da variável com o mesmo nome no escopo circundante, se houver. Caso contrário, a variável é inicialmente não definida. O shell usa escopo dinâmico, de modo que, se você tornar a variável x local para a função f, que então chama a função g, as referências à variável x feitas dentro de g se referirão à variável x declarada dentro de f, e não à variável global chamada x.

O único parâmetro especial que pode ser tornado local é "-". Tornar "-" local faz com que quaisquer opções do shell que sejam alteradas por meio do comando set dentro da função sejam restauradas para seus valores originais quando a função retornar.

A sintaxe do comando return é:

return [código de saída]

Ele encerra a função atualmente em execução. Return é implementado como um comando interno.

Variáveis e Parâmetros

O shell mantém um conjunto de parâmetros. Um parâmetro denotado por um nome é chamado de variável. Ao iniciar, o shell converte todas as variáveis de ambiente em variáveis do shell. Novas variáveis podem ser definidas usando o seguinte formato:

nome=valor

As variáveis definidas pelo usuário devem ter um nome consistindo apenas de letras, números e sublinhados - o primeiro dos quais não deve ser um número. Um parâmetro também pode ser denotado por um número ou um caractere especial, conforme explicado abaixo.

Parâmetros Posicionais

Um parâmetro posicional é um parâmetro denotado por um número (n > 0). O shell os define inicialmente com os valores de seus argumentos de linha de comando que seguem o nome do script do shell. O comando interno set também pode ser usado para definir ou redefini-los.

Parâmetros Especiais

Um parâmetro especial é um parâmetro denotado por um dos seguintes caracteres especiais. O valor do parâmetro é listado ao lado de seu caractere.

*            Expande para os parâmetros posicionais, começando em um. Quando a expansão ocorre dentro de uma string entre aspas duplas, ela se expande para um único campo com o valor de cada parâmetro separado pelo primeiro caractere da variável `IFS` ou por um espaço em branco se `IFS` não estiver definido.

@            Expande para os parâmetros posicionais, começando em um. Quando a expansão ocorre dentro de aspas duplas, cada parâmetro posicional se expande como um argumento separado. Se não houver parâmetros posicionais, a expansão de `@` gera argumentos zero, mesmo quando `@` estiver entre aspas duplas. Basicamente, isso significa que, por exemplo, se `$1` for "abc" e `$2` for "def ghi", então "$@" se expande para os dois argumentos:

"abc" "def ghi"

#            Expande para o número de parâmetros posicionais.

? Expande para o status de saída do pipeline mais recente.

- (Hífen.) Expande para os sinalizadores de opção atuais (os nomes de opção de letra única concatenados em uma string) especificados na invocação, pelo comando `set` ou implicitamente pelo shell.

$ Expande para o ID do processo do shell invocado. Um subshell mantém o mesmo valor de $ de seu processo pai.

! Expande para o ID do processo do comando de segundo plano mais recente executado a partir do shell atual. Para um pipeline, o ID do processo é o do último comando no pipeline.

0 (Zero.) Expande para o nome do shell ou script do shell.

Expansões de Palavras

Esta cláusula descreve as várias expansões que são executadas em palavras. Nem todas as expansões são executadas em cada palavra, conforme explicado posteriormente.

As expansões de til, expansões de parâmetros, substituições de comandos, expansões aritméticas e remoções de aspas que ocorrem dentro de uma única palavra são expandidas para um único campo. Apenas a divisão de campo ou a expansão de nome de caminho podem criar vários campos a partir de uma única palavra. A única exceção a essa regra é a expansão do parâmetro especial @ dentro de aspas duplas, conforme descrito acima.

A ordem da expansão de palavras é:

    Expansão de Til, Expansão de Parâmetros, Substituição de Comandos, Expansão Aritmética (todos ocorrem ao mesmo tempo).

    A divisão de campo é executada nos campos gerados na etapa (1), a menos que a variável IFS seja nula.

    Expansão de Nome de Caminho (a menos que `set -f` esteja em vigor).

    Remoção de Aspas.

O caractere $ é usado para introduzir a expansão de parâmetros, a substituição de comandos ou a avaliação aritmética.

Expansão de Til (substituindo o diretório inicial de um usuário)

Uma palavra começando com um caractere de til não citado (~) é submetida à expansão de til. Todos os caracteres até uma barra (/) ou o final da palavra são tratados como um nome de usuário e são substituídos pelo diretório inicial do usuário. Se o nome de usuário estiver ausente (como em ~/foobar), o til é substituído pelo valor da variável HOME (o diretório inicial do usuário atual).

Expansão de Parâmetros

O formato para expansão de parâmetros é o seguinte:

${expressão}

onde a expressão consiste em todos os caracteres até o "}" correspondente. Quaisquer "}" escapados por uma barra invertida ou dentro de uma string citada e caracteres em expansões aritméticas, substituições de comandos e expansões de variáveis incorporadas não são examinados para determinar o "}" correspondente.

A forma mais simples para expansão de parâmetros é:

${parâmetro}

O valor, se houver, do parâmetro é substituído.

O nome ou símbolo do parâmetro pode ser colocado entre chaves, o que é opcional, exceto para parâmetros posicionais com mais de um dígito ou quando o parâmetro é seguido por um caractere que pode ser interpretado como parte do nome. Se ocorrer uma expansão de parâmetros dentro de aspas duplas:

    A expansão de nome de caminho não é executada nos resultados da expansão.

O desmembramento de campo não é executado nos resultados da expansão, com a exceção de @.

Além disso, uma expansão de parâmetro pode ser modificada usando um dos seguintes formatos:

${parameter:-word}    Usar Valores Padrão. Se o parâmetro não estiver definido ou for nulo, a expansão de word é substituída; caso contrário, o valor de parâmetro é substituído.

${parameter:=word}    Atribuir Valores Padrão. Se o parâmetro não estiver definido ou for nulo, a expansão de word é atribuída ao parâmetro. Em todos os casos, o valor final do parâmetro é substituído. Apenas variáveis, não parâmetros posicionais ou parâmetros especiais, podem ser atribuídas desta forma.

${parameter:?[word]}  Indicar Erro se Nulo ou Não Definido. Se o parâmetro não estiver definido ou for nulo, a expansão de word (ou uma mensagem indicando que não está definido, se word for omitido) é gravada no erro padrão e o shell sai com um status de saída diferente de zero. Caso contrário, o valor de parâmetro é substituído. Um shell interativo não precisa sair.

${parameter:+word}    Usar Valor Alternativo. Se o parâmetro não estiver definido ou for nulo, nulo é substituído; caso contrário, a expansão de word é substituída.

Nas expansões de parâmetro mostradas anteriormente, o uso de dois pontos no formato resulta em um teste para um parâmetro que não está definido ou é nulo; a omissão dos dois pontos resulta em um teste para um parâmetro que só não está definido.

${#parameter}         Comprimento da String. O comprimento em caracteres do valor de parâmetro.

As quatro variedades a seguir de expansão de parâmetros fornecem processamento de substring. Em cada caso, a notação de correspondência de padrões (veja "Padrões de Shell"), em vez da notação de expressão regular, é usada para avaliar os padrões. Se o parâmetro for * ou @, o resultado da expansão não é especificado. Envolver toda a string de expansão de parâmetros em aspas duplas não faz com que os quatro caracteres de padrão a seguir sejam citados, enquanto citar caracteres dentro das chaves tem esse efeito.

${parameter%word}     Remover o Menor Sufixo de Padrão. A palavra é expandida para produzir um padrão. A expansão do parâmetro resulta em parâmetro, com a menor parte do sufixo correspondida pelo padrão excluída.

${parameter%%word}    Remover o Maior Sufixo de Padrão. A palavra é expandida para produzir um padrão. A expansão do parâmetro resulta em parâmetro, com a maior parte do sufixo correspondida pelo padrão excluída.

${parameter#word}     Remover o Menor Prefixo de Padrão. A palavra é expandida para produzir um padrão. A expansão do parâmetro resulta em parâmetro, com a menor parte do prefixo correspondida pelo padrão excluída.

${parameter##word}    Remover o Maior Prefixo de Padrão. A palavra é expandida para produzir um padrão. A expansão do parâmetro resulta em parâmetro, com a maior parte do prefixo correspondida pelo padrão excluída.

Substituição de Comando

A substituição de comando permite que a saída de um comando seja substituída no lugar do próprio nome do comando. A substituição de comando ocorre quando o comando é envolvido da seguinte forma:

$(comando)

ou (versão com "aspas graves"):

`comando`

O shell expande a substituição de comando executando o comando em um ambiente de subshell e substituindo a substituição de comando pela saída padrão do comando, removendo as sequências de uma ou mais quebras de linha no final da substituição. (As quebras de linha incorporadas antes do final da saída não são removidas; no entanto, durante a divisão de campos, elas podem ser traduzidas em espaços, dependendo do valor de IFS e das aspas em vigor.)

Expansão Aritmética

A expansão aritmética fornece um mecanismo para avaliar uma expressão aritmética e substituir seu valor. O formato para expansão aritmética é o seguinte:

$((expressão))

A expressão é tratada como se estivesse entre aspas duplas, exceto que uma aspa dupla dentro da expressão não é tratada de forma especial. O shell expande todos os tokens na expressão para expansão de parâmetros, substituição de comandos e remoção de aspas.

Em seguida, o shell trata isso como uma expressão aritmética e substitui o valor da expressão.

Divisão de Espaços (Divisão de Campos)

Após a expansão de parâmetros, substituição de comandos e expansão aritmética, o shell analisa os resultados das expansões e substituições que não ocorreram entre aspas duplas para divisão de campos e vários campos podem resultar.

O shell trata cada caractere de IFS como um delimitador e usa os delimitadores para dividir os resultados da expansão de parâmetros e substituição de comandos em campos.

Expansão de Caminho (Geração de Nome de Arquivo)

A menos que a flag -f esteja definida, a geração de nome de arquivo é executada após a conclusão da divisão de palavras. Cada palavra é vista como uma série de padrões, separados por barras. O processo de expansão substitui a palavra pelos nomes de todos os arquivos existentes cujos nomes podem ser formados substituindo cada padrão por uma string que corresponda ao padrão especificado. Existem duas restrições para isso: primeiro, um padrão não pode corresponder a uma string que contenha uma barra e, em segundo lugar, um padrão não pode corresponder a uma string que comece com um ponto, a menos que o primeiro caractere do padrão seja um ponto. A próxima seção descreve os padrões usados para Expansão de Caminho e o comando case.

Padrões do Shell

Um padrão consiste em caracteres normais, que correspondem a eles mesmos, e metacaráteres. Os metacaráteres são “!”, “*”, “?”, e “[”. Esses caracteres perdem seus significados especiais se forem colocados entre aspas. Quando a substituição de comando ou variável é executada e o sinal de dólar ou as aspas inversas não estão entre aspas duplas, o valor da variável ou a saída do comando é analisada em busca desses caracteres e eles são transformados em metacaráteres.

Um asterisco (“*”) corresponde a qualquer string de caracteres. Um ponto de interrogação corresponde a qualquer caractere único. Um colchete esquerdo (“[”) introduz uma classe de caracteres. O final da classe de caracteres é indicado por um (“]”); se o “]” estiver faltando, o “[” corresponderá a um “[” em vez de introduzir uma classe de caracteres. Uma classe de caracteres corresponde a qualquer um dos caracteres entre os colchetes. Uma faixa de caracteres pode ser especificada usando um hífen. A classe de caracteres pode ser complementada tornando um ponto de exclamação o primeiro caractere da classe de caracteres.

Para incluir um “]” em uma classe de caracteres, torne-o o primeiro caractere listado (após o “!”, se houver). Para incluir um sinal de menos, torne-o o primeiro ou o último caractere listado.

Comandos Internos

Esta seção lista os comandos internos, que são internos porque precisam realizar alguma operação que não pode ser realizada por um processo separado. Além destes, existem vários outros comandos que podem ser internos por questões de eficiência (por exemplo, printf(1), echo(1), test(1), etc.).

:

true Um comando nulo que retorna um valor de saída 0 (verdadeiro).

false Um comando nulo que retorna um valor de saída 1 (falso).

. file

Os comandos no arquivo especificado são lidos e executados pelo shell.

alias [nome[=string ...]]

Se nome=string for especificado, o shell define o alias nome com o valor string. Se apenas nome for especificado, o valor do alias nome é impresso. Sem argumentos, o comando interno alias imprime os nomes e valores de todos os aliases definidos (veja unalias).

bg [job] ...

Continue os trabalhos especificados (ou o trabalho atual, se nenhum trabalho for fornecido) em segundo plano.

command [-p] [-v] [-V] comando [arg ...]

Execute o comando especificado, mas ignore as funções do shell ao procurá-lo. (Isto é útil quando você tem uma função do shell com o mesmo nome de um comando interno.)

-p Procure o comando usando um PATH que garanta encontrar todos os utilitários padrão.

-V Não execute o comando, mas procure o comando e imprima a resolução da pesquisa do comando. Isso é o mesmo que o comando interno type.

-v Não execute o comando, mas procure o comando e imprima o caminho absoluto dos utilitários, o nome dos comandos internos ou a expansão dos aliases.

cd|chdir cd|chdir [-LP] [diretório]

Mude para o diretório especificado (padrão HOME). Se uma entrada para CDPATH aparecer no ambiente do comando cd ou a variável de ambiente CDPATH estiver definida e o nome do diretório não começar com uma barra, os diretórios listados em CDPATH serão pesquisados para o diretório especificado. O formato de CDPATH é o mesmo que o de PATH. Se um único hífen for especificado como o argumento, ele será substituído pelo valor de OLDPWD. O comando cd imprimirá o nome do diretório para o qual ele realmente mudou, se este for diferente do nome que o usuário forneceu. Eles podem ser diferentes porque o mecanismo CDPATH foi usado ou porque o argumento é um único hífen. A opção -P faz com que a estrutura de diretórios física seja usada, ou seja, todos os links simbólicos são resolvidos para seus respectivos valores. A opção -L desativa o efeito de quaisquer opções -P anteriores.

echo [-n] args...

Imprime os argumentos na saída padrão, separados por espaços. A menos que a opção -n esteja presente, uma nova linha é impressa após os argumentos.

Se alguma das seguintes sequências de caracteres for encontrada durante a saída, a sequência não será impressa. Em vez disso, a ação especificada será executada:

\b      Um caractere de retrocesso é impresso.

\c      A saída subsequente é suprimida. Isso é normalmente usado no final do último argumento para suprimir a nova linha final que o comando echo imprimiria.

\e      Imprime um caractere de escape (ESC).

\f      Imprime um avanço de página.

\n      Imprime um caractere de nova linha.

\r      Imprime um retorno de carro.

\t      Imprime um caractere de tabulação (horizontal).

\v      Imprime uma tabulação vertical.

\0digits

Imprime o caractere cujo valor é dado por dois a três dígitos octais. Se não houver dígitos, um caractere nulo é impresso.

\\      Imprime uma barra invertida.

Todas as outras sequências de barra invertida resultam em comportamento indefinido.

eval string ...

Concatena todos os argumentos com espaços. Em seguida, analisa novamente e executa o comando.

exec [comando arg ...]

A menos que o comando seja omitido, o processo do shell é substituído pelo programa especificado (que deve ser um programa real, não um builtin ou função do shell). Quaisquer redirecionamentos no comando exec são marcados como permanentes, para que não sejam desfeitos quando o comando exec terminar.

exit [exitstatus]

Termina o processo do shell. Se exitstatus for fornecido, ele será usado como o status de saída do shell; caso contrário, o status de saída do comando anterior será usado.

export name ...

export -p

Os nomes especificados são exportados para que apareçam no ambiente dos comandos subsequentes. A única maneira de remover a exportação de uma variável é removê-la. O shell permite que o valor de uma variável seja definido ao mesmo tempo em que é exportada, escrevendo

export name=value

Sem argumentos, o comando export lista os nomes de todas as variáveis exportadas. Com a opção -p especificada, a saída será formatada de forma adequada para uso não interativo.

fc [-e editor] [primeiro [último]]

fc -l [-nr] [primeiro [último]]

fc -s [antigo=novo] [primeiro]

O builtin fc lista, ou edita e reexecuta, comandos inseridos anteriormente em um shell interativo.

-e editor

Use o editor nomeado por editor para editar os comandos. A string do editor é um nome de comando, sujeito à pesquisa através da variável PATH. O valor na variável FCEDIT é usado como padrão quando -e não é especificado. Se FCEDIT for nulo ou não estiver definido, o valor da variável EDITOR será usado. Se EDITOR for nulo ou não estiver definido, ed(1) será usado como editor.

-l (ell)

Lista os comandos em vez de invocar um editor neles. Os comandos são escritos na sequência indicada pelos operandos primeiro e último, conforme afetado por -r, com cada comando precedido pelo número do comando.

-n     Suprime os números dos comandos ao listar com -l.

-r     Inverte a ordem dos comandos listados (com -l) ou editados (sem -l nem -s).

-s     Reexecuta o comando sem invocar um editor.

primeiro

último   Seleciona os comandos a serem listados ou editados. O número de comandos anteriores que podem ser acessados é determinado pelo valor da variável HISTSIZE. O valor de primeiro ou último ou ambos é um dos seguintes:

[+]número
Um número positivo que representa um número de comando; os números dos comandos podem ser exibidos com a opção -l.

-número
Um número decimal negativo que representa o comando que foi executado há número de comandos. Por exemplo, -1 é o comando imediatamente anterior.

string
Uma string que indica o comando mais recente inserido que começa com essa string.

Se o operando antigo=novo não for especificado também com -s, o formulário de string do operando primeiro não pode conter um sinal de igual embutido.

As seguintes variáveis de ambiente afetam a execução de fc:

FCEDIT    Nome do editor a ser usado.

HISTSIZE  O número de comandos anteriores que são acessíveis.

fg [job]

Move o trabalho especificado ou o trabalho atual para o primeiro plano.

getopts optstring var [arg ...]

O comando POSIX getopts, a não ser confundir com o utilitário getopt(1) derivado dos Bell Labs.

O primeiro argumento deve ser uma série de letras, cada uma das quais pode ser opcionalmente seguida por dois pontos para indicar que a opção requer um argumento. A variável especificada é definida para a opção analisada.

O comando getopts desaconselha o utilitário mais antigo getopt(1) devido ao seu tratamento de argumentos que contêm espaços em branco.

O builtin getopts pode ser usado para obter opções e seus argumentos de uma lista de parâmetros. Quando invocado, getopts coloca o valor da próxima opção da string de opção na lista na variável de shell especificada por var e seu índice na variável de shell OPTIND. Quando o shell é invocado, OPTIND é inicializado para 1. Para cada opção que requer um argumento, o builtin getopts o colocará na variável de shell OPTARG. Se uma opção não for permitida na string de opção, então OPTARG será desmarcado.

Por padrão, as variáveis $1, ..., $n são inspecionadas; se argumentos forem especificados, eles serão analisados em vez disso.

optstring é uma string de letras de opção reconhecidas (veja getopt(3)). Se uma letra for seguida por dois pontos, espera-se que a opção tenha um argumento que pode ou não ser separado dela por espaço em branco. Se um caractere de opção não for encontrado onde esperado, getopts definirá a variável var para “?”; getopts então desmarcará OPTARG e gravará a saída no erro padrão. Ao especificar dois pontos como o primeiro caractere de optstring, todos os erros serão ignorados.

Após a última opção, getopts retornará um valor diferente de zero e definirá var para “?”.

O seguinte fragmento de código mostra como processar os argumentos para um comando que pode receber as opções [a] e [b], e a opção [c], que requer um argumento.

while getopts abc: f
do
case $f in
a | b)  flag=$f;;
c)      carg=$OPTARG;;
\?)     echo $USAGE; exit 1;;
esac
done
shift $((OPTIND - 1))

Este código aceitará qualquer um dos seguintes como equivalente:

cmd -acarg arquivo arquivo
cmd -a -c arg arquivo arquivo
cmd -carg -a arquivo arquivo
cmd -a -carg -- arquivo arquivo

hash [comando ...]

hash -r

O shell mantém uma tabela hash que lembra as localizações dos comandos. Sem argumentos, o comando hash imprime o conteúdo desta tabela. As entradas que não foram acessadas desde o último comando cd são marcadas com um asterisco; é possível que essas entradas estejam inválidas.

Com argumentos, o comando hash remove os comandos especificados da tabela hash (a menos que sejam funções) e, em seguida, os localiza. A opção -r faz com que o comando hash exclua todas as entradas na tabela hash, exceto as funções.

jobs [-lp] [tarefa ...]

Exibe o status de todas ou apenas das tarefas especificadas: Por padrão, exibe o número da tarefa, o status atual (+/-), o estado da tarefa e seu comando de shell. -l Também exibe o PID do líder do grupo e apenas o PID e os comandos de shell dos outros membros da tarefa. -p Exibe apenas os PIDs do líder, um por linha.

kill [-s sigspec | -signum | -sigspec] [pid | tarefa ...]

Equivalente a kill(1), mas também pode ser especificada uma tarefa. Os sinais podem ser nomes sem o prefixo SIG ou números decimais; o padrão é TERM.

kill -l [signum | exitstatus]

Lista os nomes de sinal disponíveis sem o prefixo SIG. Se signum for especificado, exibe apenas o sigspec para esse sinal. Se exitstatus for especificado (> 128), exibe apenas o sigspec que o causou.

pwd [-LP]
comando interno que lembra qual é o diretório atual, em vez de recalculá-lo a cada vez. Isso o torna mais rápido. No entanto, se o diretório atual for renomeado, a versão interna do comando pwd continuará a imprimir o nome antigo do diretório. A opção -P faz com que o valor físico do diretório de trabalho atual seja exibido, ou seja, todos os links simbólicos são resolvidos para seus respectivos valores. A opção -L desativa o efeito de quaisquer opções -P anteriores.

read [-p prompt] [-r] variável [...]

O prompt é impresso se a opção -p for especificada e a entrada padrão for um terminal. Em seguida, uma linha é lida da entrada padrão. A nova linha final é excluída da linha e a linha é dividida conforme descrito na seção sobre divisão de palavras acima, e as partes são atribuídas às variáveis em ordem. Pelo menos uma variável deve ser especificada. Se houver mais partes do que variáveis, as partes restantes (juntamente com os caracteres em IFS que as separam) são atribuídas à última variável. Se houver mais variáveis do que partes, as variáveis restantes recebem uma string nula. O comando interno read indicará sucesso, a menos que EOF seja encontrado na entrada, caso em que a falha será retornada.

Por padrão, a menos que a opção -r seja especificada, a barra invertida “\” atua como um caractere de escape, fazendo com que o caractere seguinte seja tratado literalmente. Se uma barra invertida for seguida por uma nova linha, a barra invertida e a nova linha serão excluídas.

readonly name ...

readonly -p

Os nomes especificados são marcados como somente leitura, de modo que não possam ser modificados ou desdefinidos posteriormente. O shell permite que o valor de uma variável seja definido ao mesmo tempo em que é marcada como somente leitura, escrevendo

readonly name=value

Sem argumentos, o comando readonly lista os nomes de todas as variáveis somente leitura. Com a opção -p especificada, a saída será formatada de forma adequada para uso não interativo.

printf format [value]...

printf formata e imprime seus argumentos de acordo com o formato, uma string de caracteres que contém três tipos de objetos: caracteres simples, que são simplesmente copiados para a saída padrão, sequências de escape de caracteres que são convertidas e copiadas para a saída padrão e especificações de formato, cada uma das quais faz com que o próximo valor sucessivo seja impresso.

Cada valor é tratado como uma string se a especificação de formato correspondente for b, c ou s; caso contrário, é avaliado como uma constante C, com as seguintes adições: Um sinal de mais ou menos à esquerda é permitido. Se o caractere à esquerda for uma aspa simples ou dupla, o valor do próximo byte.

A string de formato é reutilizada quantas vezes forem necessárias até que todos os valores sejam consumidos. Quaisquer especificações de formato extras são avaliadas com zero ou a string nula.

As sequências de escape de caracteres estão na notação de barra invertida, conforme definido em ANSI X3.159-1989 (“ANSI C89”). Os caracteres e seus significados são os seguintes:

\a Escreva um caractere <bell>.

\b Escreva um caractere <backspace>.

\e Escreva um caractere <escape> (ESC).

\f Escreva um caractere <form-feed>.

\n Escreva um caractere <new-line>.

\r Escreva um caractere <carriage return>.

\t Escreva um caractere <tab>.

\v Escreva um caractere <vertical tab>.

\\ Escreva um caractere de barra invertida.

\num Escreva um caractere de 8 bits cujo valor ASCII seja o número octal de 1, 2 ou 3 dígitos.

Cada especificação de formato é introduzida pelo caractere de porcentagem (``%''). O restante da especificação de formato inclui, na seguinte ordem:

Zero ou mais dos seguintes sinalizadores:

# Um caractere `#' especificando que o valor deve ser impresso em uma forma ``alternativa''. Para os formatos b, c, d e s, esta opção não tem efeito.

Para o formato o, a precisão do número é aumentada para forçar o primeiro caractere da string de saída a ser um zero. Para o formato x (X), um resultado diferente de zero tem a string 0x (0X) prefixada. Para os formatos e, E, f, g e G, o resultado sempre conterá um ponto decimal, mesmo que nenhum dígito o siga (normalmente, um ponto decimal aparece apenas nos resultados desses formatos se um dígito seguir o ponto decimal). Para os formatos g e G, os zeros à direita não são removidos do resultado, como seriam de outra forma.

-       Um sinal de menos `-' que especifica o alinhamento à esquerda da saída no campo indicado;

+       Um caractere `+' que especifica que sempre deve ser colocado um sinal antes do número ao usar formatos assinados.

‘ ’     Um espaço que especifica que um espaço em branco deve ser deixado antes de um número positivo para um formato assinado. Um `+' tem precedência sobre um espaço se ambos forem usados;

0      Um zero `0' que indica que o preenchimento com zeros deve ser usado em vez do preenchimento com espaços em branco. Um `-' tem precedência sobre um `0' se ambos forem usados;

Largura do Campo: Uma string de dígitos opcional que especifica uma largura de campo; se a string de saída tiver menos caracteres do que a largura do campo, ela será preenchida com espaços em branco à esquerda (ou à direita, se o indicador de alinhamento à esquerda tiver sido fornecido) para completar a largura do campo (observe que um zero à esquerda é uma flag, mas um zero embutido faz parte de uma largura de campo);

Precisão:

Um ponto opcional, ‘.’, seguido por uma string de dígitos opcional que fornece uma precisão que especifica o número de dígitos a serem exibidos após o ponto decimal, para os formatos e e f, ou o número máximo de bytes a serem impressos de uma string (formatos b e s); se a string de dígitos estiver ausente, a precisão será tratada como zero;

Formato:

Um caractere que indica o tipo de formato a ser usado (um dos diouxXfwEgGbcs).

Uma largura de campo ou precisão pode ser ‘*’ em vez de uma string de dígitos. Nesse caso, um argumento fornece a largura do campo ou a precisão.

Os caracteres de formato e seus significados são:

diouXx      O argumento é impresso como um decimal assinado (d ou i), octal não assinado, decimal não assinado ou hexadecimal não assinado (X ou x), respectivamente.

f           O argumento é impresso no estilo [-]ddd.ddd, onde o número de dígitos após o ponto decimal é igual à especificação de precisão para o argumento. Se a precisão estiver ausente, 6 dígitos são fornecidos; se a precisão for explicitamente 0, nenhum dígito e nenhum ponto decimal são impressos.

eE          O argumento é impresso no estilo [-]d.ddde±dd, onde há um dígito antes do ponto decimal e o número depois é igual à especificação de precisão para o argumento; quando a precisão estiver ausente, 6 dígitos são produzidos. Uma letra E maiúscula é usada para um formato 'E'.

gG          O argumento é impresso no estilo f ou no estilo e (E), o que fornecer a precisão completa no espaço mínimo.

b           Os caracteres da string de argumento são impressos com sequências de escape de barra invertida expandidas. As seguintes sequências de escape de barra invertida adicionais são suportadas:

\c      Faz com que o dash ignore quaisquer caracteres restantes na string de operando que a contenha, quaisquer operando de string restantes e quaisquer caracteres adicionais no operando de formato.

\0num   Escreve um caractere de 8 bits cujo valor ASCII é o número octal de 1, 2 ou 3 dígitos, `num`.

c           O primeiro caractere do argumento é impresso.

s           Os caracteres da string do argumento são impressos até o final da string ou até que o número de bytes indicado pela especificação de precisão seja atingido; se a precisão for omitida, todos os caracteres na string são impressos.

%           Imprime um `%`; nenhum argumento é usado.

Em nenhum caso, uma largura de campo inexistente ou pequena causa o truncamento de um campo; o preenchimento ocorre apenas se a largura de campo especificada exceder a largura real.

set [{ -options | +options | -- }] arg ...

O comando set executa três funções diferentes.

Sem argumentos, ele lista os valores de todas as variáveis do shell.

Se opções forem fornecidas, ele define as opções especificadas ou as limpa, conforme descrito na seção chamada “Processamento da Lista de Argumentos”. Como caso especial, se a opção for -o ou +o e nenhum argumento for fornecido, o shell imprime as configurações de todas as suas opções. Se a opção for -o, as configurações são impressas em um formato legível para humanos; se a opção for +o, as configurações são impressas em um formato adequado para serem reinseridas no shell para afetar as mesmas configurações de opção.

Além dos nomes das opções listados na seção “Processamento da Lista de Argumentos”, as seguintes opções podem ser especificadas como argumentos para -o ou +o:

pipefail  Deriva o status de saída de um pipeline a partir dos status de saída de todos os comandos no pipeline, e não apenas do último comando, conforme descrito na seção “Pipelines”.

O terceiro uso do comando set é definir os valores dos parâmetros posicionais do shell para os argumentos especificados. Para alterar os parâmetros posicionais sem alterar nenhuma opção, use -- como o primeiro argumento para set. Se não houver argumentos, o comando set limpará todos os parâmetros posicionais (equivalente a executar shift $#).

shift [n]

Desloca os parâmetros posicionais n vezes. Um shift define o valor de $1 para o valor de $2, o valor de $2 para o valor de $3 e assim por diante, diminuindo o valor de $# em um. Se n for maior que o número de parâmetros posicionais, shift emitirá uma mensagem de erro e sairá com o status de retorno 2.

test expression

[ expression ]

O utilitário test avalia a expressão e, se ela avaliar como verdadeira, retorna um status de saída zero (verdadeiro); caso contrário, retorna 1 (falso). Se não houver expressão, test também retorna 1 (falso).

Todos os operadores e sinalizadores são argumentos separados para o utilitário test.

Os seguintes primários são usados para construir a expressão:

-b file       Verdadeiro se o arquivo existir e for um arquivo especial de bloco.

-c file       Verdadeiro se o arquivo existir e for um arquivo especial de caractere.

-d file       Verdadeiro se o arquivo existir e for um diretório.

-e file       Verdadeiro se o arquivo existir (independentemente do tipo).

-f file       Verdadeiro se o arquivo existir e for um arquivo regular.

-g arquivo   Verdadeiro se o arquivo existir e a flag de ID de grupo estiver definida.

-h arquivo   Verdadeiro se o arquivo existir e for um link simbólico.

-k arquivo   Verdadeiro se o arquivo existir e o bit "sticky" estiver definido.

-n string    Verdadeiro se o comprimento da string for diferente de zero.

-p arquivo   Verdadeiro se o arquivo for um pipe nomeado (FIFO).

-r arquivo   Verdadeiro se o arquivo existir e for legível.

-s arquivo   Verdadeiro se o arquivo existir e tiver um tamanho maior que zero.

-t descritor_de_arquivo

Verdadeiro se o arquivo cujo número de descritor de arquivo é descritor_de_arquivo estiver aberto e estiver associado a um terminal.

-u arquivo   Verdadeiro se o arquivo existir e a flag de ID de usuário estiver definida.

-w arquivo   Verdadeiro se o arquivo existir e for gravável. Verdadeiro indica apenas que a flag
de gravação está ativa. O arquivo não é gravável em um sistema de arquivos somente leitura, mesmo
que este teste indique verdadeiro.

-x arquivo   Verdadeiro se o arquivo existir e for executável. Verdadeiro indica apenas que a flag
de execução está ativa. Se o arquivo for um diretório, verdadeiro indica que o arquivo pode
ser pesquisado.

-z string    Verdadeiro se o comprimento da string for zero.

-L arquivo   Verdadeiro se o arquivo existir e for um link simbólico. Este operador é mantido para
compatibilidade com versões anteriores deste programa. Não dependa de sua existência; use -h em vez disso.

-O arquivo   Verdadeiro se o arquivo existir e seu proprietário corresponder ao ID de usuário
efetivo deste processo.

-G arquivo   Verdadeiro se o arquivo existir e seu grupo corresponder ao ID de grupo efetivo
deste processo.

-S arquivo   Verdadeiro se o arquivo existir e for um socket.

arquivo1 -nt arquivo2

Verdadeiro se arquivo1 e arquivo2 existirem e arquivo1 for mais recente que arquivo2, ou se arquivo1 existir, mas arquivo2 não.

arquivo1 -ot arquivo2

Verdadeiro se arquivo1 e arquivo2 existirem e arquivo1 for mais antigo que arquivo2, ou se arquivo2 existir, mas arquivo1 não.

arquivo1 -ef arquivo2

Verdadeiro se arquivo1 e arquivo2 existirem e se referirem ao mesmo arquivo.

string       Verdadeiro se a string não for a string nula.

s1 = s2      Verdadeiro se as strings s1 e s2 forem idênticas.

s1 != s2     Verdadeiro se as strings s1 e s2 não forem idênticas.

s1 < s2      Verdadeiro se a string s1 vier antes de s2 com base no valor ASCII de seus caracteres.

s1 > s2      Verdadeiro se a string s1 vier depois de s2 com base no valor ASCII de seus caracteres.

n1 -eq n2    Verdadeiro se os inteiros n1 e n2 forem algebricamente iguais.

n1 -ne n2    Verdadeiro se os inteiros n1 e n2 não forem algebricamente iguais.

n1 -gt n2    Verdadeiro se o inteiro n1 for algebricamente maior que o inteiro n2.

n1 -ge n2    Verdadeiro se o inteiro n1 for algebricamente maior ou igual ao inteiro n2.

n1 -lt n2    Verdadeiro se o inteiro n1 for algebricamente menor que o inteiro n2.

n1 -le n2    Verdadeiro se o inteiro n1 for algebricamente menor ou igual ao inteiro n2.

Esses operadores primários podem ser combinados com os seguintes operadores:

! expressão  Verdadeiro se a expressão for falsa.

expressão1 -a expressão2

Verdadeiro se ambas as expressões, expressão1 e expressão2, forem verdadeiras.

expressão1 -o expressão2

Verdadeiro se qualquer uma das expressões, expressão1 ou expressão2, for verdadeira.

(expressão) Verdadeiro se a expressão for verdadeira.

O operador -a tem maior precedência do que o operador -o.

times Imprime os tempos acumulados de usuário e sistema para o shell e para os processos executados a partir do shell. O status de retorno é 0.

trap [ação sinal ...]

Faz com que o shell analise e execute a ação quando qualquer um dos sinais especificados for recebido. Os sinais são especificados pelo número do sinal ou pelo nome do sinal. Se o sinal for 0 ou EXIT, a ação será executada quando o shell sair. A ação pode estar vazia (''), o que faz com que os sinais especificados sejam ignorados. Com a ação omitida ou definida como '-', os sinais especificados são definidos para sua ação padrão. Quando o shell cria um subshell, ele redefine os sinais capturados (mas não ignorados) para a ação padrão. O comando trap não tem efeito sobre os sinais que foram ignorados na entrada do shell. O comando trap sem argumentos faz com que ele grave uma lista de sinais e sua ação associada na saída padrão em um formato adequado como entrada para o shell que obtém os mesmos resultados de captura.

Exemplos:

trap

Lista os sinais capturados e sua ação correspondente

trap '' INT QUIT tstp 30

Ignora os sinais INT QUIT TSTP USR1

trap date INT

Imprime a data ao receber o sinal INT

type [nome ...]

Interpreta cada nome como um comando e imprime a resolução da pesquisa do comando. As resoluções possíveis são: palavra-chave do shell, alias, builtin do shell, comando, alias rastreado e não encontrado. Para aliases, a expansão do alias é impressa; para comandos e aliases rastreados, o caminho completo do comando é impresso.

ulimit [-H | -S] [-a | -tfdscmlpnvwr [valor]]

Consulta ou define os limites rígidos ou flexíveis nos processos ou define novos limites. A escolha entre o limite rígido (que nenhum processo pode violar e que não pode ser aumentado depois de ter sido diminuído) e o limite flexível (que faz com que os processos sejam sinalizados, mas não necessariamente interrompidos, e que pode ser aumentado) é feita com estes sinalizadores:

-H define ou consulta os limites rígidos

-S define ou consulta os limites flexíveis. Se nenhum de -H ou -S for especificado, o limite flexível é exibido ou ambos os limites são definidos. Se ambos forem especificados, o último vence.

O limite a ser interrogado ou definido é, então, escolhido especificando qualquer um destes sinalizadores:

-a mostra todos os limites atuais

-t mostra ou define o limite do tempo da CPU (em segundos)

-f mostra ou define o limite do maior arquivo que pode ser criado (em blocos de 512 bytes)

-d mostra ou define o limite do tamanho do segmento de dados de um processo (em kilobytes)

-s mostra ou define o limite do tamanho da pilha de um processo (em kilobytes)

-c mostra ou define o limite do maior tamanho de despejo de núcleo que pode ser produzido (em blocos de 512 bytes)

-m mostra ou define o limite da memória física total que pode estar em uso por um processo (em kilobytes)

-l mostra ou define o limite de quanta memória um processo pode bloquear com mlock(2) (em kilobytes)

-p Mostra ou define o limite do número de processos que este usuário pode ter em execução ao mesmo tempo.

-n Mostra ou define o limite do número de arquivos que um processo pode ter abertos ao mesmo tempo.

-v Mostra ou define o limite da quantidade total de memória virtual que pode estar em uso por um processo (em kilobytes).

-w Mostra ou define o limite do número total de bloqueios mantidos por um processo.

-r Mostra ou define o limite da prioridade de agendamento em tempo real de um processo.

Se nenhum destes for especificado, é o limite do tamanho do arquivo que é mostrado ou definido. Se um valor for especificado, o limite é definido para esse número; caso contrário, o limite atual é exibido.

Os limites de um processo arbitrário podem ser exibidos ou definidos usando o utilitário sysctl(8).

umask [mask]

Define o valor de umask (veja umask(2)) para o valor octal especificado. Se o argumento for omitido, o valor de umask é impresso.

unalias [-a] [name]

Se [name] for especificado, o shell remove esse alias. Se -a for especificado, todos os aliases são removidos.

unset [-fv] name ...

As variáveis e funções especificadas são removidas e não são mais exportadas. Se -f ou -v for especificado, a função ou variável correspondente é removida, respectivamente. Se um determinado nome corresponder a uma variável e a uma função, e nenhuma opção for fornecida, apenas a variável será removida.

wait [job]

Aguarde a conclusão do trabalho especificado e retorne o status de saída do último processo no trabalho. Se o argumento for omitido, aguarde a conclusão de todos os trabalhos e retorne um status de saída de zero.

Edição da Linha de Comando

Quando o dash está sendo usado interativamente a partir de um terminal, o comando atual e o histórico de comandos (veja fc em “Builtins”) podem ser editados usando a edição da linha de comando no modo vi. Este modo usa comandos, descritos abaixo, semelhantes a um subconjunto daqueles descritos na página man do vi. O comando ‘set -o vi’ habilita a edição no modo vi e coloca o sh no modo de inserção vi. Com o modo vi habilitado, o sh pode ser alternado entre o modo de inserção e o modo de comando. É semelhante ao vi: digitar ⟨ESC⟩ entra no modo de comando vi. Pressionar ⟨return⟩ enquanto estiver no modo de comando passará a linha para o shell.

STATUS DE SAÍDA

Erros que são detectados pelo shell, como um erro de sintaxe, farão com que o shell saia com um status de saída diferente de zero. Se o shell não for um shell interativo, a execução do arquivo do shell será abortada. Caso contrário, o shell retornará o status de saída do último comando executado ou, se o builtin exit for usado com um argumento numérico, ele retornará o argumento.

AMBIENTE

HOME Definido automaticamente por login(1) a partir do diretório de login do usuário no arquivo de senha (passwd(4)). Esta variável de ambiente também funciona como o argumento padrão para o builtin cd.

PATH O caminho de pesquisa padrão para executáveis. Veja a seção acima “Pesquisa de Caminho”.

CDPATH O caminho de pesquisa usado com o builtin cd.

MAIL       O nome de um arquivo de correio, que será verificado para verificar a chegada de novas mensagens. Substituído por MAILPATH.

MAILCHECK  A frequência, em segundos, com que o shell verifica a chegada de correio nos arquivos especificados por MAILPATH ou no arquivo MAIL. Se definido como 0, a verificação ocorrerá a cada prompt.

MAILPATH   Uma lista de nomes de arquivos separados por dois pontos “:”, para o shell verificar se há novas mensagens. Esta configuração de ambiente substitui a configuração MAIL. Existe um máximo de 10 caixas de correio que podem ser monitoradas simultaneamente.

PS1        A string de prompt primário, que por padrão é “$ ”, a menos que você seja o superusuário, caso em que o padrão é “# ”.

PS2        A string de prompt secundário, que por padrão é “> ”.

PS4        Saída antes de cada linha quando o rastreamento de execução (set -x) está habilitado, o padrão é “+ ”.

IFS        Separadores de campos de entrada. Normalmente, é definido para ⟨espaço⟩, ⟨tabulação⟩ e ⟨nova linha⟩. Consulte a seção “Divisão de espaço em branco” para obter mais detalhes.

TERM       A configuração de terminal padrão para o shell. Isso é herdado pelos processos filhos do shell e é usado nos modos de edição do histórico.

HISTSIZE   O número de linhas no buffer de histórico do shell.

PWD        O valor lógico do diretório de trabalho atual. Isso é definido pelo comando cd.

OLDPWD     O valor lógico anterior do diretório de trabalho atual. Isso é definido pelo comando cd.

PPID       O ID do processo do processo pai do shell.

ARQUIVOS

$HOME/.profile

/etc/profile

VEJA TAMBÉM

csh(1), echo(1), getopt(1), ksh(1), login(1), printf(1), test(1), getopt(3), passwd(5), environ(7), sysctl(8)

HISTÓRICO

dash é uma implementação compatível com POSIX de /bin/sh que visa ser o menor possível. dash é um descendente direto da versão NetBSD de ash (o Almquist SHell), portado para Linux no início de 1997. Foi renomeado para dash em 2002.

ERROS

Scripts do shell setuid devem ser evitados a todo custo, pois representam um risco significativo para a segurança.

PS1, PS2 e PS4 devem estar sujeitos à expansão de parâmetros antes de serem exibidos.