O shell bash

Abreviação de “Bourne-Again Shell”, bash é um shell Unix . Originalmente lançado em 1989 como um substituto gratuito para o Bourne Shell , o bash faz parte do projeto GNU .

O Bash é o shell padrão no macOS , no Windows Subsystem para Linux e na maioria dos sistemas operacionais Linux .

Descrição

bash é um interpretador de linguagem de comando compatível com sh que executa comandos lidos a partir da entrada padrão ou de um arquivo. O bash também incorpora recursos úteis dos shells Korn e C ( ksh e csh ).

O bash deve ser uma implementação conforme da parte Shell e Utilitários da especificação IEEE POSIX (IEEE Standard 1003.1). O bash pode ser configurado para ser compatível com POSIX por padrão.

Sintaxe

  bash [ opções ] [ arquivo ]

Opções

Todas as opções de shell de caractere único documentadas na descrição do comando set builtin podem ser usadas como opções ao chamar o bash .

As seguintes opções também estão disponíveis:

O bash também interpreta várias opções de vários caracteres. Essas opções devem aparecer na linha de comando antes que as opções de caractere único sejam reconhecidas:

Argumentos

Se os argumentos permanecerem após o processamento da opção e nem a opção -c nem a opção -s tiver sido fornecida, o primeiro argumento será assumido como o nome de um arquivo que contém comandos do shell. Se o bash for chamado dessa maneira, $ 0 será definido como o nome do arquivo e os parâmetros posicionais serão definidos como os argumentos restantes. o bash lê e executa comandos deste arquivo e sai. O status de saída do bash é o status de saída do último comando executado no script. Se nenhum comando for executado, o status de saída será 0. Primeiro, é feita uma tentativa de abrir o arquivo no diretório atual e, se nenhum arquivo for encontrado, o shell pesquisará nos diretórios no PATH o script.

Invocação

Um shell de login é aquele cujo primeiro caractere do argumento zero é um – ou um iniciado com a opção –login .

Um shell interativo é aquele iniciado sem argumentos de não-opção e sem a opção -c cuja entrada e erro padrão estão conectados aos terminais (conforme determinado por isatty ), ou um iniciado com a opção -i . O PS1 (sequência do prompt de comando ) está definido e $ – inclui i se o bash for interativo, permitindo que um script de shell ou um arquivo de inicialização teste esse estado.

Os parágrafos a seguir descrevem como o bash executa seus arquivos de inicialização. Se algum dos arquivos existir, mas não puder ser lido, o bash reportará um erro. Tildes são expandidos em nomes de arquivos, conforme descrito abaixo em ” Expansão Tilde ” na seção ” Expansão “.

Quando o bash é chamado como um shell de logon interativo ou como um shell não interativo com a opção –login , ele primeiro lê e executa comandos do arquivo / etc / profile , se esse arquivo existir. Depois de ler esse arquivo, ele procura ~ / .bash_profile , ~ / .bash_login e ~ / .profile , nessa ordem, e lê e executa comandos do primeiro que existe e é legível. A opção –noprofile pode ser usada quando o shell é iniciado para inibir esse comportamento.

Quando um shell de login sai, o bash lê e executa comandos do arquivo ~ / .bash_logout , se existir.

Quando um shell interativo que não é um shell de login é iniciado, o bash lê e executa comandos de /etc/bash.bashrc e ~ / .bashrc , se esses arquivos existirem. Isso pode ser inibido usando a opção –norc . A opção –rcfile file forçará o bash a ler e executar comandos do arquivo em vez de /etc/bash.bashrc e ~ / .bashrc .

Quando o bash é iniciado de maneira não interativa, para executar um script de shell, por exemplo, ele procura a variável BASH_ENV no ambiente, expande seu valor se aparecer lá e usa o valor expandido como o nome de um arquivo para ler e executar . O Bash se comporta como se o seguinte comando tivesse sido executado:

  if [-n "$ BASH_ENV"];  então .  "$ BASH_ENV";  fi

mas o valor da variável PATH não é usado para procurar o nome do arquivo.

Se o bash for chamado com o nome sh , ele tentará imitar o comportamento de inicialização das versões históricas do sh o mais próximo possível, além de estar em conformidade com o padrão POSIX . Quando invocado como um shell de login interativo ou não-interativo com a opção –login , ele primeiro tenta ler e executar comandos de / etc / profile e ~ / .profile , nessa ordem. A opção –noprofile pode ser usada para inibir esse comportamento. Quando chamado como um shell interativo com o nome sh , o bash procura a variável ENV , expande seu valor se for definido e usa o valor expandido como o nome de um arquivo para ler e executar. Como um shell chamado sh não tenta ler e executar comandos de outros arquivos de inicialização, a opção –rcfile não tem efeito. Um shell não interativo chamado com o nome sh não tenta ler outros arquivos de inicialização. Quando chamado como sh , o bash entra no modo posix após a leitura dos arquivos de inicialização.

Quando o bash é iniciado no modo posix, como na opção de linha de comando –posix , ele segue o padrão POSIX para arquivos de inicialização. Nesse modo, shells interativos expandem a variável ENV e os comandos são lidos e executados a partir do arquivo cujo nome é o valor expandido. Nenhum outro arquivo de inicialização é lido.

O Bash tenta determinar quando está sendo executado com sua entrada padrão conectada a uma conexão de rede, como quando executada pelo daemon de shell remoto , geralmente rshd , ou pelo daemon de shell seguro sshd . Se o bash determinar que está sendo executado dessa maneira, ele lerá e executará comandos de ~ / .bashrc e ~ / .bashrc , se esses arquivos existirem e forem legíveis. Isso não será feito se invocado como sh . A opção –norc pode ser usada para inibir esse comportamento, e a opção –rcfile pode ser usada para forçar a leitura de outro arquivo, mas o rshd geralmente não chama o shell com essas opções ou permite que elas sejam especificadas.

Se o shell for iniciado com o ID do usuário (ou grupo) efetivo não igual ao ID do usuário (ou grupo) real e a opção -p não for fornecida, nenhum arquivo de inicialização será lido, as funções do shell não serão herdadas do ambiente, as variáveis ​​SHELLOPTS , BASHOPTS , CDPATH e GLOBIGNORE , se aparecerem no ambiente, são ignoradas e o ID do usuário efetivo é definido como o ID do usuário real. Se a opção -p for fornecida na chamada, o comportamento de inicialização será o mesmo, mas o ID do usuário efetivo não será redefinido.

Definições

Nas seções a seguir, esses termos são definidos da seguinte maneira:

Palavras reservadas

Palavras reservadas são aquelas que têm um significado especial para o shell. As seguintes palavras são reconhecidas como reservadas quando não estão entre aspas e a primeira palavra ou um comando simples (consulte a seção ” Gramática do Shell ” abaixo) ou a terceira palavra de um caso ou comando:

 !
 case
 do
 done
 elif
 else
 esac
 fi
 for
 function
 if
 in
 select
 then
 until
 while
 {
 }
 time
 [[
 ]]

Gramática do shell

Comandos simples

Um comando simples é uma sequência opcional de atribuições de variáveis, seguida por palavras e redirecionamentos separados em branco e finalizada por um operador de controle. A primeira palavra especifica o comando a ser executado e é passado como argumento zero. As palavras restantes são passadas como argumentos para o comando invocado.

O valor de retorno de um comando simples é seu status de saída ou 128 + n se o comando for finalizado pelo sinal n .

Tubulações

Um pipeline é uma sequência de um ou mais comandos separados por um dos operadores de controle | ou | & . O formato para um pipeline é:

  [hora [-p]] [!  ] comand [[|  ⎪  &] command2 ...]

A saída padrão do comando é conectada através de um tubo à entrada padrão do comando2 . Essa conexão é realizada antes de qualquer redirecionamento especificado pelo comando (consulte a seção ” Redirecionamento ” abaixo para obter detalhes). Se | & for usado, o erro padrão de comando será conectado à entrada padrão do command2 através do tubo; é uma abreviação de 2> & 1 | . Esse redirecionamento implícito do erro padrão é executado após qualquer redirecionamento especificado pelo comando.

O status de retorno de um pipeline é o status de saída do último comando, a menos que a opção pipefail esteja ativada. Se o pipefail estiver ativado, o status de retorno do pipeline será o valor do último comando (mais à direita) para sair com um status diferente de zero ou zero se todos os comandos forem encerrados com êxito. Se a palavra reservada ! precede um pipeline, o status de saída desse pipeline é a negação lógica do status de saída, conforme descrito acima. O shell aguarda que todos os comandos no pipeline sejam finalizados antes de retornar um valor.

Se a palavra tempo reservado preceder um pipeline, o tempo decorrido e o usuário e do sistema consumidos por sua execução serão relatados quando o pipeline terminar. A opção -p altera o formato de saída para o especificado pelo POSIX. Quando o shell está no modo posix, ele não reconhece o tempo como uma palavra reservada se o próximo token começar com um ‘ – ‘. A variável TIMEFORMAT pode ser definida como uma sequência de formato que especifica como as informações de tempo devem ser exibidas; consulte a descrição do TIMEFORMAT na seção ” Shell Variables ” abaixo para obter detalhes.

Quando o shell está no modo posix, o tempo pode ser seguido por uma nova linha. Nesse caso, o shell exibe o tempo total do usuário e do sistema consumido pelo shell e seus filhos. A variável TIMEFORMAT pode ser usada para especificar o formato das informações de hora.

Cada comando em um pipeline é executado como um processo separado (um subshell).

Listas

Uma lista é uma sequência de um ou mais pipelines separados por um dos operadores ; , & , && , ou || e opcionalmente encerrado por um de ; , & ou <nova-line> .

Desses operadores da lista, && e || ter igual precedência, seguido por ; e & , que têm igual precedência.

Uma sequência de uma ou mais novas linhas pode aparecer em uma lista em vez de um ponto e vírgula para delimitar comandos.

Se um comando é finalizado pelo operador de controle & , o shell executa o comando em segundo plano em uma subshell. O shell não espera o comando terminar e o status de retorno é 0. Comandos separados por a ; são executados sequencialmente; o shell aguarda que cada comando termine por sua vez. O status de retorno é o status de saída do último comando executado.

As listas AND e OR são sequências de um ou mais pipelines separados pelos && e || operadores de controle, respectivamente. As listas AND e OR são executadas com associatividade esquerda. Uma lista AND tem o formato

  command1 && command2

command2 é executado se, e somente se, command1 retorna um status de saída igual a zero.

Uma lista OR tem o formato

  command1 ||  command2

command2 é executado se e somente se command1 retornar um status de saída diferente de zero. O status de retorno das listas AND e OR é o status de saída do último comando executado na lista.

Comandos compostos

Um comando composto é um dos seguintes:

Veja a descrição do comando builtin de teste (na seção ” Comandos internos do shell ” abaixo) para obter informações sobre como lidar com parâmetros (isto é, parâmetros ausentes).

Quando os operadores == e ! = São usados, a sequência à direita do operador é considerada um padrão e corresponde de acordo com as regras descritas abaixo em Correspondência de Padrão. Se a opção de concha nocasematch estiver ativada, a correspondência será realizada sem considerar o caso de caracteres alfabéticos. O valor de retorno é 0 se a sequência corresponder ( == ) ou não ( ! = ) Ao padrão e 1 caso contrário. Qualquer parte do padrão pode ser citada para forçá-lo a corresponder como uma sequência.

Um operador binário adicional, = ~ , está disponível, com a mesma precedência que == e ! = . Quando usada, a sequência à direita do operador é considerada uma expressão regular estendida e correspondida de acordo (como no regex ). O valor de retorno é 0 se a sequência corresponder ao padrão e 1 caso contrário. Se a expressão regular estiver sintaticamente incorreta, o valor de retorno da expressão condicional será 2. Se a opção de concha nocasematch estiver ativada, a correspondência será realizada sem considerar o caso de caracteres alfabéticos. Qualquer parte do padrão pode ser citada para forçá-lo a corresponder como uma sequência. As cadeias correspondentes a subexpressões entre parênteses na expressão regular são salvas na variável de matriz BASH_REMATCH . O elemento BASH_REMATCH com índice 0 é a parte da sequência que corresponde à expressão regular inteira. O elemento BASH_REMATCH com o índice n é a parte da sequência que corresponde à nésima subexpressão entre parênteses.

As expressões podem ser combinadas usando os seguintes operadores, listados em ordem decrescente de precedência:

  ( expression )

Retorna o valor da expressão . Isso pode ser usado para substituir a precedência normal dos operadores.

  !  expression

Verdadeiro se a expressão for falsa.

  expression1 && expression2

Verdadeiro se expressão1 e expressão2 forem verdadeiras.

  expressão1 ||  expression2

Verdadeiro se expressão1 ou expressão2 for verdadeira.

O && e || operadores não avaliam expressão2 se o valor da expressão1 for suficiente para determinar o valor de retorno de toda a expressão condicional.

  para o nome [[in [ word ...]];  ] faça a lista ;  feito

A lista de palavras a seguir é expandida, gerando uma lista de itens. O nome da variável é definido para cada elemento desta lista, por sua vez, e a lista é executada toda vez. Se a palavra in for omitida, o comando for executa a lista uma vez para cada parâmetro posicional definido (consulte a seção ” Parâmetros ” abaixo). O status de retorno é o status de saída do último comando que é executado. Se a expansão dos itens a seguir resultar em uma lista vazia, nenhum comando será executado e o status de retorno será 0 .

  para (( expr1 ; expr2 ; expr3 ));  faça a lista ;  feito

Primeiro, a expressão aritmética expr1 é avaliada de acordo com as regras descritas abaixo em ” Expansão aritmética “. A expressão aritmética expr2 é então avaliada repetidamente até ser avaliada como zero. Cada vez que expr2 é avaliado como um valor diferente de zero, a lista é executada e a expressão aritmética expr3 é avaliada. Se alguma expressão for omitida, ela se comportará como se fosse avaliada como 1. O valor de retorno é o status de saída do último comando na lista que é executado ou falso se alguma das expressões for inválida.

  selecione o nome [na palavra ];  faça a lista ;  feito

A lista de palavras a seguir é expandida, gerando uma lista de itens. O conjunto de palavras expandidas é impresso no erro padrão, cada um precedido por um número. Se a palavra in for omitida, os parâmetros posicionais serão impressos (consulte a seção ” Parâmetros ” abaixo). O prompt do PS3 é exibido e uma linha é lida na entrada padrão. Se a linha consistir em um número correspondente a uma das palavras exibidas, o valor do nome será definido para essa palavra. Se a linha estiver vazia, as palavras e o prompt serão exibidos novamente. Se o EOF for lido, o comando será concluído. Qualquer outro valor lido faz com que o nome seja definido como nulo . A linha lida é salva na variável REPLY . A lista é executada após cada seleção até que um comando de interrupção seja executado. O status de saída de seleção é o status de saída do último comando executado na lista ou zero se nenhum comando foi executado.

  maiúsculas e minúsculas na lista [[(] padrão [| padrão ] ...) ;;  ] ... esac

Um comando case expande primeiro a palavra e tenta correspondê-la a cada padrão , usando as mesmas regras de correspondência da expansão do nome do caminho (consulte a seção ” Expansão do nome do caminho “, abaixo). A palavra é expandida usando expansão de til, expansão de parâmetro e variável, substituição aritmética, substituição de comando, substituição de processo e remoção de cotação. Cada padrão examinado é expandido usando expansão de til, expansão de parâmetro e variável, substituição aritmética, substituição de comando e substituição de processo. Se a opção de concha nocasematch estiver ativada, a correspondência será realizada sem considerar o caso de caracteres alfabéticos. Quando uma correspondência é encontrada, a lista correspondente é executada. Se o ;; Se o operador for usado, nenhuma correspondência subsequente será tentada após a primeira correspondência de padrão. Usando ; & no lugar de ;; faz com que a execução continue com a lista associada ao próximo conjunto de padrões s. Usando ;; & no lugar de ;; faz com que o shell teste a próxima lista de padrões na instrução, se houver, e execute qualquer lista associada em uma correspondência bem-sucedida. O status de saída é zero se nenhum padrão corresponder. Caso contrário, é o status de saída do último comando executado na lista .

  se lista ;  então lista ;  [ lista elif;  então lista ;  ] ... [outra lista ;  ] fi

A lista if é executada. Se o status de saída for zero, a lista então é executada. Caso contrário, cada lista elif será executada sucessivamente e, se o status de saída for zero, a lista correspondente será executada e o comando será concluído. Caso contrário, a lista else é executada, se presente. O status de saída é o status de saída do último comando executado ou zero se nenhuma condição testada for verdadeira.

  enquanto lista-1 ;  faça a lista 2 ;  feito até a lista 1 ;  faça a lista 2 ;  feito

O comando while executa continuamente a lista lista 2 , desde que o último comando na lista lista 1 retorne um status de saída zero. O comando até é idêntico ao comando while , exceto que o teste é negado; a lista-2 é executada desde que o último comando da lista-1 retorne um status de saída diferente de zero. O status de saída dos comandos while e till é o status de saída do último comando executado na lista-2 ou zero se nenhum foi executado.

Coprocesses

Um “coprocesso” é um comando do shell precedido pela palavra reservada do coproc . Um coprocesso é executado de forma assíncrona em um subshell, como se o comando tivesse sido finalizado com o operador & control, com um canal bidirecional estabelecido entre o shell de execução e o coprocesso.

O formato para um coprocesso é:

  Comando [ NAME ] coproc [ redirecionamentos ]

Isso cria um coprocesso chamado NAME . Se NAME não for fornecido, o nome padrão é COPROC . O NAME não deve ser fornecido se o comando for um comando simples (veja acima ); caso contrário, é interpretada como a primeira palavra do comando simples. Quando o coproc é executado, o shell cria uma variável de matriz (consulte a seção ” Matrizes ” abaixo) chamada NAME no contexto do shell em execução. A saída padrão do comando é conectada através de um canal a um descritor de arquivo no shell de execução, e esse descritor de arquivo é atribuído a NAME [0]. A entrada de comando padrão é conectada através de um canal a um descritor de arquivo no shell de execução, e esse descritor de arquivo é atribuído a NAME [1]. Esse canal é estabelecido antes de qualquer redirecionamento especificado pelo comando (consulte a seção ” Redirecionamento ” abaixo). Os descritores de arquivo podem ser utilizados como argumentos para shell comandos e redirecionamentos usando expansões de palavras padrão. O ID do processo do shell gerado para executar o coprocesso está disponível como o valor da variável NAME_PID . O comando wait builtin pode ser usado para aguardar a conclusão do coprocesso.

O status de retorno de um coprocesso é o status de saída do comando.

Definições de Função Shell

Uma função shell é um objeto chamado como um comando simples e executa um comando composto com um novo conjunto de parâmetros posicionais. As funções do shell são declaradas da seguinte maneira:

  name () comando-composto [ redirecionamento ]

  nome da função [()] comando-composto [ redirecionamento ]

Isso define uma função chamada nome . A função de palavra reservada é opcional. Se a palavra reservada da função for fornecida, os parênteses são opcionais. O corpo da função é o comando composto composto-comando (consulte a seção ” Comandos compostos ” acima). Esse comando geralmente é uma lista de comandos entre { e } , mas pode ser qualquer comando listado em Comandos compostos acima. O comando composto é executado sempre que o nome é especificado como o nome de um comando simples. Quaisquer redirecionamentos (consulte a seção ” Redirecionamento ” abaixo) especificados quando uma função é definida são executados quando a função é executada. O status de saída de uma definição de função é zero, a menos que ocorra um erro de sintaxe ou uma função somente leitura com o mesmo nome já exista. Quando executado, o status de saída de uma função é o status de saída do último comando executado no corpo. Consulte a seção ” Funções ” abaixo.

Comentários

Em um shell não interativo ou em um shell interativo no qual a opção interactive_comments para o shopt builtin está ativada (consulte a seção ” Comandos internos do shell ” abaixo), uma palavra iniciada com # faz com que essa palavra e todos os caracteres restantes nessa linha sejam ignorado. Um shell interativo sem a opção interactive_comments ativada não permite comentários. A opção interactive_comments está ativada por padrão em shells interativos.

Citação

A citação é usada para remover o significado especial de certos caracteres ou palavras do shell. A citação pode ser usada para desativar o tratamento especial de caracteres especiais, impedir que palavras reservadas sejam reconhecidas como tal e impedir a expansão de parâmetros.

Cada um dos metacaracteres listados acima na seção ” Definições ” tem um significado especial para o shell e deve ser citado para que ele se represente.

Quando as instalações de expansão do histórico de comandos estão sendo usadas (consulte a seção ” Expansão do histórico ” abaixo), o caractere de expansão do histórico, geralmente ! , deve ser citado para impedir a expansão do histórico.

Existem três mecanismos de citação: o caractere de escape, aspas simples e aspas duplas.

Uma barra invertida não citada ( \ ) é o caractere de escape. Ele preserva o valor literal do próximo caractere a seguir, com exceção de <newline> . Se um par \ <newline> aparecer e a barra invertida não estiver entre aspas, o \ <newline> será tratado como uma continuação de linha (ou seja, é removido do fluxo de entrada e efetivamente ignorado).

Incluir caracteres entre aspas simples preserva o valor literal de cada caractere dentro das aspas. Uma aspas simples pode não ocorrer entre aspas simples, mesmo quando precedida por uma barra invertida.

A inclusão de caracteres entre aspas duplas preserva o valor literal de todos os caracteres entre aspas, com exceção de $ , ` , \ e, quando a expansão do histórico estiver ativada ,! . Os caracteres $ e ` mantêm seu significado especial entre aspas duplas. A barra invertida mantém seu significado especial somente quando seguida por um dos seguintes caracteres: $ , ` , “ , \ ou <newline> . Uma citação dupla pode ser citada entre aspas duplas, precedendo-a com uma barra invertida. Se ativado, expansão do histórico será executada, a menos que um ! que apareça entre aspas duplas seja escapado usando uma barra invertida. A barra invertida que precede o ! não será removida.

Os parâmetros especiais * e @ têm significado especial entre aspas duplas (consulte a seção ” Parâmetros ” abaixo).

Palavras da forma $ ‘string’ são tratadas especialmente. A palavra se expande para cadeia, com caracteres de escape de barra invertida substituídos conforme especificado pelo padrão ANSI C. Seqüências de escape de barra invertida, se presentes, são decodificadas da seguinte maneira:

O resultado expandido é de aspas simples, como se o cifrão não estivesse presente.

Uma sequência de aspas duplas precedida por um sinal de dólar ( $ “string” ) fará com que a string seja traduzida de acordo com o código de idioma atual. Se o código do idioma atual for C ou POSIX , o cifrão será ignorado. Se a sequência for traduzida e substituída, a substituição será citada duas vezes.

Parâmetros

Um parâmetro é uma entidade que armazena valores. Pode ser um nome, um número ou um dos caracteres especiais listados abaixo em Parâmetros especiais. Uma variável é um parâmetro indicado por um nome. Uma variável tem um valor e zero ou mais atributos. Os atributos são atribuídos usando o comando declare builtin (consulte declarar abaixo na seção ” Comandos internos do shell “). Um parâmetro é definido se tiver sido atribuído um valor. A cadeia nula é um valor válido. Depois que uma variável é definida, ela pode ser desabilitada apenas usando o comando built-in não configurado (também documentado na seção ” Comandos internos do shell “).

Uma variável pode ser atribuída por uma declaração do formulário:

  nome = [ valor ]

Se o valor não for fornecido, a variável receberá uma sequência nula. Todos os valores passam por expansão de til, expansão de parâmetro e variável, substituição de comando, expansão aritmética e remoção de cotação (consulte a seção ” Expansão ” abaixo). Se a variável tiver seu atributo inteiro definido, o valor será avaliado como uma expressão aritmética, mesmo que a expansão $ ((…)) não seja usada (consulte a seção ” Expansão aritmética ” abaixo). A divisão de palavras não é executada, com exceção de ” $@ “, conforme explicado abaixo em Parâmetros especiais . A expansão do nome do caminho não é executada. As instruções de atribuição também podem aparecer como argumentos para os comandos alias , declare , typeset , export , readonly e builtin local .

No contexto em que uma instrução de atribuição está atribuindo um valor a uma variável de shell ou índice de matriz, o operador + = pode ser usado para acrescentar ou adicionar ao valor anterior da variável. Quando + = é aplicado a uma variável para a qual o atributo inteiro foi definido, o valor é avaliado como uma expressão aritmética e adicionado ao valor atual da variável, que também é avaliado. Quando + = é aplicado a uma variável de matriz usando atribuição composta (consulte ” Matrizes ” abaixo), o valor da variável não é desabilitado (como é o caso de usar = ) e novos valores são acrescentados à matriz, começando com um valor maior que o valor da matriz. índice máximo (para matrizes indexadas) ou adicionado como pares de valores-chave adicionais em uma matriz associativa. Quando aplicado a uma variável com valor de sequência, o valor é expandido e anexado ao valor da variável.

Parâmetros posicionais

Um parâmetro posicional é um parâmetro indicado por um ou mais dígitos, exceto o dígito único 0. Os parâmetros posicionais são atribuídos a partir dos argumentos do shell quando são chamados e podem ser reatribuídos usando o comando set builtin. Os parâmetros posicionais não podem ser atribuídos a com instruções de atribuição. Os parâmetros posicionais são substituídos temporariamente quando uma função shell é executada (consulte a seção ” Funções ” abaixo).

Quando um parâmetro posicional que consiste em mais de um dígito é expandido, ele deve ser colocado entre chaves (consulte a seção ” Expansão ” abaixo).

Parâmetros especiais

O shell trata vários parâmetros especialmente. Esses parâmetros podem ser referenciados apenas; a atribuição a eles não é permitida.

Variáveis ​​do shell

As seguintes variáveis ​​são definidas pelo shell:

As seguintes variáveis ​​são usadas pelo shell. Em alguns casos, o bash atribui um valor padrão a uma variável; esses casos são mencionados abaixo.

Matrizes

O Bash fornece variáveis ​​unidimensionais de array indexadas e associativas. Qualquer variável pode ser usada como uma matriz indexada; o declare builtin declarará explicitamente uma matriz. Não há limite máximo para o tamanho de uma matriz, nem qualquer requisito de que os membros sejam indexados ou atribuídos de forma contígua. Matrizes indexadas são referenciadas usando números inteiros (incluindo expressões aritméticas) e são baseadas em zero; matrizes associativas são referenciadas usando seqüências arbitrárias.

Uma matriz indexada é criada automaticamente se qualquer variável for atribuída ao uso do nome da sintaxe [ subscrito ] = valor . O subscrito é tratado como uma expressão aritmética que deve ser avaliada como um número. Se o índice subscrito for avaliado como um número menor que zero, ele será usado como um deslocamento de um número maior que o índice máximo da matriz (portanto, um índice subscrito -1 se refere ao último elemento da matriz). Para declarar explicitamente uma matriz indexada, use declare -a name (consulte a seção ” Comandos internos do shell ” abaixo). declare -um nome [ subscrito ] também é aceito; o subscrito é ignorado.

Matrizes associativas são criadas usando o nome -A declarar.

Os atributos podem ser especificados para uma variável de matriz usando os recursos declarar e somente leitura . Cada atributo se aplica a todos os membros de uma matriz.

As matrizes são atribuídas ao uso de atribuições compostas do nome do formulário = ( valor1 … valor ) , em que cada valor é do formato [ subscrito ] = sequência . As atribuições de matriz indexada não requerem colchete e subscrito. Ao atribuir a matrizes indexadas, se os colchetes opcionais e o subscrito forem fornecidos, esse índice será atribuído; caso contrário, o índice do elemento designado é o último índice atribuído pela instrução mais um. A indexação começa em zero.

Ao atribuir a uma matriz associativa, o subscrito é necessário.

Essa sintaxe também é aceita pelo declarar embutido. Elementos individuais da matriz podem ser atribuídos ao uso da sintaxe nome [ subscrito ] = valor introduzida acima.

Qualquer elemento de uma matriz pode ser referenciado usando $ { name [ subscript ]} . Os colchetes são necessários para evitar conflitos com a expansão do nome do caminho. Se subscrito for @ ou * , a palavra se expandirá para todos os membros do nome. Esses subscritos diferem apenas quando a palavra aparece entre aspas duplas. Se a palavra estiver entre aspas duplas, $ { name [*]} será expandida para uma única palavra com o valor de cada membro da matriz separado pelo primeiro caractere da variável especial IFS e $ { name [@]} expandirá cada elemento de nome para uma palavra separada. Quando não há membros da matriz, $ { name [@]} se expande para nada. Se a expansão de aspas duplas ocorrer em uma palavra, a expansão do primeiro parâmetro será associada à parte inicial da palavra original e a expansão do último parâmetro será associada à última parte da palavra original. Isso é análogo à expansão dos parâmetros especiais * e @ (consulte a seção ” Parâmetros especiais ” acima). $ {# name [ subscript ]} se expande para o comprimento de $ { name [ subscript ]} . Se subscrito for * ou @ , a expansão é o número de elementos na matriz. Referenciar uma variável de matriz sem um subscrito é equivalente a referenciar a matriz com um subscrito de 0.

Uma variável de matriz é considerada definida se um valor subscrito tiver sido atribuído a um índice. A cadeia nula é um valor válido.

O built-in não configurado é usado para destruir matrizes. nome não definido [ subscrito ] destrói o elemento da matriz no índice subscrito . Deve-se tomar cuidado para evitar efeitos colaterais indesejados causados ​​pela expansão do nome do caminho. nome não definido , em que nome é uma matriz, ou nome não definido [ subscrito ] , em que subscrito é * ou @ , remove a matriz inteira.

Os embutidos declarar , local e somente leitura aceitam, cada um, uma opção -a para especificar uma matriz indexada e uma opção -A para especificar uma matriz associativa. Se as duas opções forem fornecidas, -A terá precedência. A leitura incorporada aceita uma opção -a para atribuir uma lista de palavras lidas da entrada padrão a uma matriz. Os recursos internos definir e declarar exibem valores de matriz de uma maneira que permite que sejam reutilizados como atribuições.

Expansão

A expansão é realizada na linha de comando após ter sido dividida em palavras. Existem sete tipos de expansão executados: expansão de chaves, expansão de til, expansão de parâmetro e variável, substituição de comando, expansão aritmética, divisão de palavras e expansão de nome de caminho.

A ordem das expansões é: expansão de chaves, expansão de til, parâmetro, expansão variável e aritmética e substituição de comando (feita da esquerda para a direita), divisão de palavras e expansão do nome do caminho.

Em sistemas que podem suportá-lo, há uma expansão adicional disponível: substituição de processo.

Somente expansão de chaves, divisão de palavras e expansão de nome de caminho pode alterar o número de palavras da expansão; outras expansões expandem uma única palavra para uma única palavra. As únicas exceções são as expansões de ” $@ ” e ” $ { name [@]} “, conforme explicado acima (consulte a seção ” Parâmetros “).

Expansão de cinta

A expansão de chaves é um mecanismo pelo qual cadeias arbitrárias podem ser geradas. Esse mecanismo é semelhante à expansão do nome do caminho, mas os nomes de arquivos gerados não precisam existir. Os padrões a serem expandidos entre colchetes assumem a forma de um preâmbulo opcional, seguido por uma série de cadeias separadas por vírgula ou uma expressão de sequência entre um par de colchetes, seguido de um postscript opcional. O preâmbulo é prefixado para cada string contida entre chaves, e o postscript é anexado a cada string resultante, expandindo da esquerda para a direita.

As expansões de chaves podem ser aninhadas. Os resultados de cada sequência expandida não são classificados; a ordem da esquerda para a direita é preservada. Por exemplo, a {d, c, b} e se expande para ‘ ade ace abe ‘.

Uma expressão de sequência assume o formato { x .. y [.. incr ] } , em que x e y são números inteiros ou caracteres únicos e incr , um incremento opcional, é um número inteiro. Quando números inteiros são fornecidos, a expressão se expande para cada número entre x e y , inclusive. Os números inteiros fornecidos podem ser prefixados com 0 para forçar cada termo a ter a mesma largura. Quando x ou y começam com zero, o shell tenta forçar todos os termos gerados a conter o mesmo número de dígitos, preenchendo o zero quando necessário. Quando os caracteres são fornecidos, a expressão se expande para cada caractere lexicograficamente entre x e y , inclusive. Observe que ambos x e y devem ser do mesmo tipo. Quando o incremento é fornecido, ele é usado como a diferença entre cada termo. O incremento padrão é 1 ou -1, conforme apropriado.

A expansão entre chaves é executada antes de qualquer outra expansão e qualquer caractere especial para outras expansões é preservado no resultado. É estritamente textual. O Bash não aplica nenhuma interpretação sintática ao contexto da expansão ou ao texto entre os chavetas.

Uma expansão de chave formada corretamente deve conter chaves de abertura e fechamento sem aspas e pelo menos uma vírgula sem aspas ou uma expressão de sequência válida. Qualquer expansão de braçadeira formada incorretamente permanece inalterada. Um { ou , pode ser citado com uma barra invertida para impedir que seja considerado parte de uma expressão entre chaves. Para evitar conflitos com a expansão de parâmetros, a cadeia $ { não é considerada elegível para expansão de chaves.

Essa construção é normalmente usada como abreviação quando o prefixo comum das sequências a serem geradas é maior que no exemplo acima:

  mkdir / usr / local / src / bash / {velho, novo, dist, bugs}

ou

  raiz do chown /usr/{ucb/{ex,edit},lib/{ex?.?*,how_ex}}

A expansão entre chaves introduz uma ligeira incompatibilidade com as versões históricas do sh . O sh não trata chaves de abertura ou fechamento, especialmente quando elas aparecem como parte de uma palavra, e as preserva na saída. O Bash remove chaves das palavras como consequência da expansão da chave. Por exemplo, uma palavra inserida em sh como arquivo {1,2} aparece identicamente na saída. A mesma palavra é emitida como arquivo1 arquivo2 após a expansão por bash. Se desejar uma compatibilidade estrita com sh , inicie o bash com a opção + B ou desative a expansão de chave com a opção + B no comando set (consulte a seção ” Comandos internos do shell ” abaixo).

Expansão Tilde

Se uma palavra começar com um caractere de til sem aspas (‘ ~ ‘), todos os caracteres que precedem a primeira barra sem aspas (ou todos os caracteres, se não houver uma barra sem aspas) serão considerados um prefixo de til. Se nenhum dos caracteres no prefixo de til for citado, os caracteres no prefixo de til após o til serão tratados como um possível nome de login. Se este nome de login for a cadeia nula, o til será substituído pelo valor do parâmetro do shell HOME . Se HOME estiver desabilitado, o diretório inicial do usuário que está executando o shell será substituído. Caso contrário, o prefixo til será substituído pelo diretório inicial associado ao nome de login especificado.

Se o prefixo til é um ‘ ~ + ‘, o valor da variável shell PWD substitui o prefixo til. Se o prefixo til for um ‘ ~ – ‘, o valor da variável de shell OLDPWD , se estiver definido, será substituído. Se os caracteres que seguem o til no prefixo do til consistirem em um número N , opcionalmente prefixado por um ‘ + ‘ ou um ‘ – ‘, o prefixo do til será substituído pelo elemento correspondente da pilha de diretórios, como seria exibido pelos dirs internos chamados com o prefixo til como argumento. Se os caracteres que seguem o til no prefixo de til consistem em um número sem um ‘ + ‘ ou ‘ – ‘, ‘ + ‘ inicial é assumido.

Se o nome de login for inválido ou a expansão do til falhar, a palavra permanecerá inalterada.

Cada atribuição de variável é verificada quanto a prefixos de til sem aspas imediatamente após a : ou o primeiro = . Nesses casos, a expansão do til também é realizada. Consequentemente, pode-se usar nomes de arquivos com tildes em atribuições para PATH , MAILPATH e CDPATH , e o shell atribui o valor expandido.

Expansão de parâmetros

O caractere ‘ $ ‘ introduz expansão de parâmetro, substituição de comando ou expansão aritmética. O nome ou símbolo do parâmetro a ser expandido pode ser colocado entre chaves, que são opcionais, mas servem para proteger a variável a ser expandida dos caracteres imediatamente a seguir, que podem ser interpretados como parte do nome.

Quando chaves são usadas, a chave final correspondente é o primeiro ‘ } ‘ não escapado por uma barra invertida ou dentro de uma cadeia de caracteres citada, e não dentro de uma expansão aritmética incorporada, substituição de comando ou expansão de parâmetro.

Referência rápida: Aqui está a tabela descrevendo brevemente cada formulário de expansão do parâmetro bash e como ele se comporta, dependendo do valor do parâmetro .

Como você pode ver, se o formulário de expansão incluir dois pontos (” : “), há um comportamento alternativo quando o parâmetro é definido, mas seu valor é Nulo (que é equivalente à sequência vazia de aspas simples, ” ). If parameter is not set at all, behavior is the same with or without a colon.

The following descriptions go into a bit more detail:

 ${ parameter }

Here, the value of parameter is substituted. The braces are required when parameter is a positional parameter with more than one digit, or when parameter is followed by a character that is not to be interpreted as part of its name.

If the first character of parameter is an exclamation point ( ! ), a level of variable indirection is introduced. Bash uses the value of the variable formed from the rest of parameter as the name of the variable; this variable is then expanded and that value is used in the rest of the substitution, rather than the value of parameter itself. This is known as indirect expansion . The exceptions to this are the expansions of ${! prefix *} and ${! name [@]} described below. The exclamation point must immediately follow the left brace to introduce indirection.

In each of the cases below, word is subject to tilde expansion, parameter expansion, command substitution, and arithmetic expansion.

When not performing substring expansion, using the forms documented below, bash tests for a parameter that is unset or null. Omitting the colon results in a test only for a parameter that is unset, bypassing the test if the parameter is null.

 ${ parameter :- word }

Use Default Values. If parameter is unset or null, the expansion of word is substituted. Otherwise, the value of parameter is substituted.

 ${ parameter := word }

Assign Default Values. If parameter is unset or null, the expansion of word is assigned to parameter . The value of parameter is then substituted. Positional parameters and special parameters may not be assigned to in this way.

 ${ parameter :? word }

Display Error if Null or Unset. If parameter is null or unset, the expansion of word (or a message to that effect if word is not present) is written to the standard error and the shell, if it is not interactive, exits. Otherwise, the value of parameter is substituted.

 ${ parameter :+ word }

Use Alternate Value. If parameter is null or unset, nothing is substituted, otherwise the expansion of word is substituted.

 ${ parameter : offset }

 ${ parameter : offset : length }

Substring Expansion. Expands to up to length characters of parameter starting at the character specified by offset . If length is omitted, expands to the substring of parameter starting at the character specified by offset . The length and offset are arithmetic expressions (see the section ” Arithmetic Evaluation ” below). If offset evaluates to a number less than zero, the value is used as an offset from the end of the value of parameter . Arithmetic expressions starting with a – must be separated by whitespace from the preceding : to be distinguished from the Use Default Values expansion. If length evaluates to a number less than zero, and parameter is not @ and not an indexed or associative array, it is interpreted as an offset from the end of the value of parameter rather than a number of characters, and the expansion is the characters between the two offsets. If parameter is @ , the result is length positional parameters beginning at offset . If parameter is an indexed array name subscripted by @ or * , the result is the length members of the array beginning with ${ parameter [ offset ] } . A negative offset is taken relative to one greater than the maximum index of the specified array. Substring expansion applied to an associative array produces undefined results. Note that a negative offset must be separated from the colon by at least one space to avoid being confused with the :- expansion. Substring indexing is zero-based unless the positional parameters are used, in which case the indexing starts at 1 by default. If offset is 0, and the positional parameters are used, $0 is prefixed to the list.

 ${! prefix *}

 ${! prefix @}

Names matching prefix . Expands to the names of variables whose names begin with prefix , separated by the first character of the IFS special variable. When @ is used and the expansion appears within double quotes, each variable name expands to a separate word.

 ${! name [@]}

 ${! name [*]}

List of array keys. If name is an array variable, expands to the list of array indices (keys) assigned in name. If name is not an array, expands to 0 if name is set and null otherwise. When @ is used and the expansion appears within double quotes, each key expands to a separate word.

 ${# parameter }

Parameter length. The length in characters of the value of parameter is substituted. If parameter is * or @ , the value substituted is the number of positional parameters. If parameter is an array name subscripted by * or @ , the value substituted is the number of elements in the array.

 ${ parameter # word }

 ${ parameter ## word }

Remove matching prefix pattern. The word is expanded to produce a pattern just as in pathname expansion. If the pattern matches the beginning of the value of parameter , then the result of the expansion is the expanded value of parameter with the shortest matching pattern (the ” # ” case) or the longest matching pattern (the ” ## ” case) deleted. If parameter is @ or * , the pattern removal operation is applied to each positional parameter in turn, and the expansion is the resultant list. If parameter is an array variable subscripted with @ or * , the pattern removal operation is applied to each member of the array in turn, and the expansion is the resultant list.

 ${ parameter % word }

 ${ parameter %% word }

Remove matching suffix pattern. The word is expanded to produce a pattern just as in pathname expansion. If the pattern matches a trailing portion of the expanded value of parameter , then the result of the expansion is the expanded value of parameter with the shortest matching pattern (the ” % ” case) or the longest matching pattern (the ” %% ” case) deleted. If parameter is @ or * , the pattern removal operation is applied to each positional parameter in turn, and the expansion is the resultant list. If parameter is an array variable subscripted with @ or * , the pattern removal operation is applied to each member of the array in turn, and the expansion is the resultant list.

 ${ parameter / pattern / string }

Pattern substitution. The pattern is expanded to produce a pattern just as in pathname expansion. The Parameter is expanded and the longest match of pattern against its value is replaced with string. If pattern begins with / , all matches of pattern are replaced with string . Normally only the first match is replaced. If pattern begins with # , it must match at the beginning of the expanded value of parameter . If pattern begins with % , it must match at the end of the expanded value of parameter . If string is null, matches of pattern are deleted and the / following pattern may be omitted. If parameter is @ or * , the substitution operation is applied to each positional parameter in turn, and the expansion is the resultant list. If parameter is an array variable subscripted with @ or * , the substitution operation is applied to each member of the array in turn, and the expansion is the resultant list.

 ${ parameter ^ pattern }

 ${ parameter ^^ pattern }

 ${ parameter , pattern }

 ${ parameter ,, pattern }

Case modification. This expansion modifies the case of alphabetic characters in parameter . The pattern is expanded to produce a pattern just as in pathname expansion. The ^ operator converts lowercase letters matching pattern to uppercase; the , operator converts matching uppercase letters to lowercase. The ^^ and ,, expansions convert each matched character in the expanded value; the ^ and , expansions match and convert only the first character in the expanded value. If pattern is omitted, it is treated like a ? , which matches every character. If parameter is @ or * , the case modification operation is applied to each positional parameter in turn, and the expansion is the resultant list. If parameter is an array variable subscripted with @ or * , the case modification operation is applied to each member of the array in turn, and the expansion is the resultant list.

Substituição de comando

Command substitution allows the output of a command to replace the command name. There are two forms:

 $( command )

ou

 ` command `

Bash performs the expansion by executing command and replacing the command substitution with the standard output of the command, with any trailing newlines deleted. Embedded newlines are not deleted, but they may be removed during word splitting. The command substitution $(cat file) can be replaced by the equivalent but faster $(< file) .

When the old-style backquote form of substitution is used, backslash retains its literal meaning except when followed by $ , ` , or \ . The first backquote not preceded by a backslash terminates the command substitution. When using the $( command ) form, all characters between the parentheses make up the command; none are treated specially.

Command substitutions may be nested. To nest when using the backquoted form, escape the inner backquotes with backslashes.

If the substitution appears within double quotes, word splitting and pathname expansion are not performed on the results.

Arithmetic expansion

Arithmetic expansion allows the evaluation of an arithmetic expression and the substitution of the result. The format for arithmetic expansion is:

 $(( expression ))

The old format $[ expression ] is deprecated and will be removed in upcoming versions of bash.

The expression is treated as if it were within double quotes, but a double quote inside the parentheses is not treated specially. All tokens in the expression undergo parameter expansion, string expansion, command substitution, and quote removal. Arithmetic expansions may be nested.

The evaluation is performed according to the rules listed below under the section ” Arithmetic Evaluation .” If expression is invalid, bash prints a message indicating failure and no substitution occurs.

Process substitution

Process substitution is supported on systems that support named pipes ( FIFO s) or the /dev/fd method of naming open files. It takes the form of <( list ) or >( list ) . The process list is run with its input or output connected to a FIFO or some file in /dev/fd . The name of this file is passed as an argument to the current command as the result of the expansion. If the >( list ) form is used, writing to the file will provide input for list. If the <( list ) form is used, the file passed as an argument should be read to obtain the output of list.

When available, process substitution is performed simultaneously with parameter and variable expansion, command substitution, and arithmetic expansion.

Word splitting

The shell scans the results of parameter expansion, command substitution, and arithmetic expansion that did not occur within double quotes for word splitting.

The shell treats each character of IFS as a delimiter , and splits the results of the other expansions into words on these characters. If IFS is unset, or its value is exactly <space><tab><newline> , the default, then sequences of <space> , <tab> , and <newline> at the beginning and end of the results of the previous expansions are ignored, and any sequence of IFS characters not at the beginning or end serves to delimit words. If IFS has a value other than the default, then sequences of the whitespace characters space and tab are ignored at the beginning and end of the word, as long as the whitespace character is in the value of IFS (an IFS whitespace character). Any character in IFS that is not IFS whitespace, along with any adjacent IFS whitespace characters, delimits a field. A sequence of IFS whitespace characters is also treated as a delimiter. If the value of IFS is null, no word splitting occurs.

Explicit null arguments ( “” or ” ) are retained. Unquoted implicit null arguments, resulting from the expansion of parameters that have no values, are removed. If a parameter with no value is expanded within double quotes, a null argument results and is retained.

Note that if no expansion occurs, no splitting is performed.

Pathname expansion

After word splitting, unless the -f option has been set, bash scans each word for the characters * , ? , and [ . If one of these characters appears, then the word is regarded as a pattern, and replaced with an alphabetically sorted list of file names matching the pattern. If no matching file names are found, and the shell option nullglob is not enabled, the word is left unchanged. If the nullglob option is set, and no matches are found, the word is removed. If the failglob shell option is set, and no matches are found, an error message is printed and the command is not executed. If the shell option nocaseglob is enabled, the match is performed without regard to the case of alphabetic characters. Note that when using range expressions like [az] (see the next section, ” Pattern Matching “), letters of the other case may be included, depending on the setting of LC_COLLATE . When a pattern is used for pathname expansion, the character ” . ” at the start of a name or immediately following a slash must be matched explicitly, unless the shell option dotglob is set. When matching a pathname, the slash character must always be matched explicitly. In other cases, the ” . ” character is not treated specially. See the description of shopt below under the section ” Shell Builtin Commands ” for a description of the nocaseglob , nullglob , failglob , and dotglob shell options.

The GLOBIGNORE shell variable may be used to restrict the set of file names matching a pattern. If GLOBIGNORE is set, each matching file name that also matches one of the patterns in GLOBIGNORE is removed from the list of matches. The file names ” . ” and ” .. are always ignored when GLOBIGNORE is set and not null. However, setting GLOBIGNORE to a non-null value has the effect of enabling the dotglob shell option, so all other file names beginning with a ” . ” will match. To get the old behavior of ignoring file names beginning with a ” . “, make ” .* ” one of the patterns in GLOBIGNORE . The dotglob option is disabled when GLOBIGNORE is unset.

Pattern matching

Any character that appears in a pattern, other than the special pattern characters described below, matches itself. The NUL character may not occur in a pattern. A backslash escapes the following character; the escaping backslash is discarded when matching. The special pattern characters must be quoted if they are to be matched literally.

The special pattern characters have the following meanings:

Se a opção extglob shell estiver ativada usando o shopt embutido, vários operadores estendidos de correspondência de padrões serão reconhecidos. Na descrição seguinte, um padrão de lista é uma lista de um ou mais padrões separados por uma | . Padrões compostos podem ser formados usando um ou mais dos seguintes subpadrões:

Quote removal

After the preceding expansions, all unquoted occurrences of the characters \ , ‘ , and “ that did not result from one of the above expansions are removed.

Redirecionamento

Before a command is executed, its input and output may be redirected using a special notation interpreted by the shell. Redirection may also be used to open and close files for the current shell execution environment. The following redirection operators may precede or appear anywhere within a simple command or may follow a command. Redirections are processed in the order they appear, from left to right.

Each redirection that may be preceded by a file descriptor number may instead be preceded by a word of the form { varname } . In this case, for each redirection operator except >&- and <&- , the shell will allocate a file descriptor greater than 10 and assign it to varname . If >&- or <&- is preceded by { varname } , the value of varname defines the file descriptor to close.

In the following descriptions, if the file descriptor number is omitted, and the first character of the redirection operator is < , the redirection refers to the standard input (file descriptor 0). If the first character of the redirection operator is > , the redirection refers to the standard output (file descriptor 1).

The word following the redirection operator in the following descriptions, unless otherwise noted, is subjected to brace expansion, tilde expansion, parameter expansion, command substitution, arithmetic expansion, quote removal, pathname expansion, and word splitting. If it expands to more than one word, bash reports an error.

Note that the order of redirections is significant. For example, the command

 ls > dirlist 2>&1

directs both standard output and standard error to the file dirlist , while the command

 ls 2>&1 > dirlist

directs only the standard output to file dirlist , because the standard error was duplicated from the standard output before the standard output was redirected to dirlist .

Bash handles several filenames specially when they are used in redirections, as described in the following table:

A failure to open or create a file causes the redirection to fail.

Redirections using file descriptors greater than 9 should be used with care, as they may conflict with file descriptors the shell uses internally.

Note that the exec builtin command can make redirections take effect in the current shell.

Redirecting input

Redirection of input causes the file whose name results from the expansion of word to be opened for reading on file descriptor n , or the standard input (file descriptor 0) if n is not specified.

The general format for redirecting input is:

 [ n ]< word

Redirecting output

Redirection of output causes the file whose name results from the expansion of word to be opened for writing on file descriptor n , or the standard output (file descriptor 1) if n is not specified. If the file does not exist it is created; if it does exist it is truncated to zero size.

The general format for redirecting output is:

 [ n ]> word

If the redirection operator is > , and the noclobber option to the set builtin has been enabled, the redirection will fail if the file whose name results from the expansion of word exists and is a regular file. If the redirection operator is >| , or the redirection operator is > and the noclobber option to the set builtin command is not enabled, the redirection is attempted even if the file named by word exists.

Appending redirected output

Redirection of output in this fashion causes the file whose name results from the expansion of word to be opened for appending on file descriptor n , or the standard output (file descriptor 1) if n is not specified. If the file does not exist it is created.

The general format for appending output is:

 [ n ]>> word

Redirecting standard output and standard error

This construct allows both the standard output (file descriptor 1) and the standard error output (file descriptor 2) to be redirected to the file whose name is the expansion of word .

There are two formats for redirecting standard output and standard error:

 &> word

e

 >& word

Of the two forms, the first is preferred. This is semantically equivalent to

 > word 2>&1

Appending standard output and standard error

This construct allows both the standard output (file descriptor 1) and the standard error output (file descriptor 2) to be appended to the file whose name is the expansion of word .

The format for appending standard output and standard error is:

 &>> word

This is semantically equivalent to

 >> word 2>&1

Here documents

This type of redirection instructs the shell to read input from the current source until a line containing only delimiter (with no trailing blanks) is seen. All of the lines read up to that point are then used as the standard input for a command.

The format of here-documents is:

 <<[-] word here-document delimiter

No parameter expansion, command substitution, arithmetic expansion, or pathname expansion is performed on word. If any characters in word are quoted, the delimiter is the result of quote removal on word, and the lines in the here-document are not expanded. If word is unquoted, all lines of the here-document are subjected to parameter expansion, command substitution, and arithmetic expansion. In the latter case, the character sequence \<newline> is ignored, and \ must be used to quote the characters \ , $ , and ` .

If the redirection operator is <<- , then all leading tab characters are stripped from input lines and the line containing delimiter. This allows here-documents within shell scripts to be indented in a natural fashion.

Here strings

A variant of here documents, the format is:

 <<< word

The word is expanded and supplied to the command on its standard input.

Duplicating file descriptors

The redirection operator

 [ n ]<& word

is used to duplicate input file descriptors. If word expands to one or more digits, the file descriptor denoted by n is made to be a copy of that file descriptor. If the digits in word do not specify a file descriptor open for input, a redirection error occurs. If word evaluates to – , file descriptor n is closed. If n is not specified, the standard input (file descriptor 0) is used.

O operador

 [ n ]>& word

is used similarly to duplicate output file descriptors. If n is not specified, the standard output (file descriptor 1) is used. If the digits in word do not specify a file descriptor open for output, a redirection error occurs. As a special case, if n is omitted, and word does not expand to one or more digits, the standard output and standard error are redirected as described previously.

Moving file descriptors

The redirection operator

 [ n ]<& digit -

moves the file descriptor digit to file descriptor n , or the standard input (file descriptor 0) if n is not specified. The digit is closed after being duplicated to n .

Similarly, the redirection operator

 [ n ]>& digit -

moves the file descriptor digit to file descriptor n , or the standard output (file descriptor 1) if n is not specified.

Opening file descriptors for reading and writing

The redirection operator

 [ n ]<> word

causes the file whose name is the expansion of word to be opened for both reading and writing on file descriptor n , or on file descriptor 0 if n is not specified. If the file does not exist, it is created.

Pseudônimo, suposto nome

Aliases allow a string to be substituted for a word when it is used as the first word of a simple command. The shell maintains a list of aliases that may be set and unset with the alias and unalias builtin commands (see the section ” Shell Builtin Commands ” for details). The first word of each simple command, if unquoted, is checked to see if it has an alias. If so, that word is replaced by the text of the alias. The characters / , $ , ` , and = and any of the shell metacharacters or quoting characters listed above may not appear in an alias name. The replacement text may contain any valid shell input, including shell metacharacters. The first word of the replacement text is tested for aliases, but a word that is identical to an alias being expanded is not expanded a second time. This means that one may alias ls to ls -F , for instance, and bash does not try to recursively expand the replacement text. If the last character of the alias value is a blank, then the next command word following the alias is also checked for alias expansion.

Aliases are created and listed with the alias command, and removed with the unalias command.

There is no mechanism for using arguments in the replacement text. If arguments are needed, a shell function should be used (see the section ” Functions ” below).

Aliases are not expanded when the shell is not interactive, unless the expand_aliases shell option is set using shopt (see the description of shopt under the section ” Shell Builtin Commands ” below).

The rules concerning the definition and use of aliases are somewhat confusing. Bash always reads at least one complete line of input before executing any of the commands on that line. Aliases are expanded when a command is read, not when it is executed. Therefore, an alias definition appearing on the same line as another command does not take effect until the next line of input is read. The commands following the alias definition on that line are not affected by the new alias. This behavior is also an issue when functions are executed. Aliases are expanded when a function definition is read, not when the function is executed, because a function definition is itself a compound command. As a consequence, aliases defined in a function are not available until after that function is executed. To be safe, always put alias definitions on a separate line, and do not use alias in compound commands.

For almost every purpose, aliases are superseded by shell functions.

Funções

A shell function , defined as described above under the section ” Shell Grammar “, stores a series of commands for later execution. When the name of a shell function is used as a simple command name, the list of commands associated with that function name is executed. Functions are executed in the context of the current shell; no new process is created to interpret them (contrast this with the execution of a shell script). When a function is executed, the arguments to the function become the positional parameters during its execution. The special parameter # is updated to reflect the change. Special parameter 0 is unchanged. The first element of the FUNCNAME variable is set to the name of the function while the function is executing.

All other aspects of the shell execution environment are identical between a function and its caller with these exceptions: the DEBUG and RETURN traps (see the description of the trap builtin under the section ” Shell Builtin Commands ” below) are not inherited unless the function has been given the trace attribute (see the description of the declare builtin below) or the -o functrace shell option has been enabled with the set builtin (in which case all functions inherit the DEBUG and RETURN traps), and the ERR trap is not inherited unless the -o errtrace shell option has been enabled.

Variables local to the function may be declared with the local builtin command. Ordinarily, variables and their values are shared between the function and its caller.

The FUNCNEST variable, if set to a numeric value greater than 0, defines a maximum function nesting level. Function invocations that exceed the limit cause the entire command to abort.

If the builtin command return is executed in a function, the function completes and execution resumes with the next command after the function call. Any command associated with the RETURN trap is executed before execution resumes. When a function completes, the values of the positional parameters and the special parameter # are restored to the values they had before the function’s execution.

Function names and definitions may be listed with the -f option to the declare or typeset builtin commands. The -F option to declare or typeset will list the function names only (and optionally the source file and line number, if the extdebug shell option is enabled). Functions may be exported so that subshells automatically have them defined with the -f option to the export builtin. A function definition may be deleted using the -f option to the unset builtin. Note that shell functions and variables with the same name may result in multiple identically-named entries in the environment passed to the shell’s children. Care should be taken in cases where this may cause a problem.

Functions may be recursive. The FUNCNEST variable may be used to limit the depth of the function call stack and restrict the number of function invocations. By default, no limit is imposed on the number of recursive calls.

Arithmetic evaluation

The shell allows arithmetic expressions to be evaluated , under certain circumstances (see the let and declare builtin commands and the section ” Arithmetic Expansion “). Evaluation is done in fixed-width integers with no check for overflow, though division by 0 is trapped and flagged as an error. The operators and their precedence, associativity, and values are the same as in the C language . The following list of operators is grouped into levels of equal-precedence operators. The levels are listed in order of decreasing precedence.

Shell variables are allowed as operands; parameter expansion is performed before the expression is evaluated. Within an expression, shell variables may also be referenced by name without using the parameter expansion syntax. A shell variable that is null or unset evaluates to 0 when referenced by name without using the parameter expansion syntax. The value of a variable is evaluated as an arithmetic expression when it is referenced, or when a variable which has been given the integer attribute using declare -i is assigned a value. A null value evaluates to 0. A shell variable need not have its integer attribute turned on to be used in an expression.

Constants with a leading 0 are interpreted as octal numbers. A leading 0x or 0X denotes hexadecimal. Otherwise, numbers take the form [base#]n , where the optional base is a decimal number between 2 and 64 representing the arithmetic base, and n is a number in that base. If base# is omitted, then base 10 is used. The digits greater than 9 are represented by the lowercase letters, the uppercase letters, @ , and _ , in that order. If base is less than or equal to 36, lowercase and uppercase letters may be used interchangeably to represent numbers between 10 and 35.

Operators are evaluated in order of precedence. Sub-expressions in parentheses are evaluated first and may override the precedence rules above.

Conditional expressions

Conditional expressions are used by the [[ compound command and the test and [ builtin commands to test file attributes and perform string and arithmetic comparisons. Expressions are formed from the following unary or binary primaries. If any file argument to one of the primaries is of the form /dev/fd/n , then file descriptor n is checked. If the file argument to one of the primaries is one of /dev/stdin , /dev/stdout , or /dev/stderr , file descriptor 0, 1, or 2, respectively, is checked.

Unless otherwise specified, primaries that operate on files follow symbolic links and operate on the target of the link, rather than the link itself.

When used with [[ , the < and > operators sort lexicographically using the current locale. The test command sorts using ASCII ordering.

Simple command expansion

When a simple command is executed, the shell performs the following expansions, assignments, and redirections, from left to right.

1. The words that the parser has marked as variable assignments (those preceding the command name) and redirections are saved for later processing.
2. The words that are not variable assignments or redirections are expanded. If any words remain after expansion, the first word is taken to be the name of the command and the remaining words are the arguments.
3. Redirections are performed as described above under REDIRECTION.
4. The text after the = in each variable assignment undergoes tilde expansion, parameter expansion, command substitution, arithmetic expansion, and quote removal before being assigned to the variable.

If no command name results, the variable assignments affect the current shell environment. Otherwise, the variables are added to the environment of the executed command and do not affect the current shell environment. If any of the assignments attempts to assign a value to a readonly variable, an error occurs, and the command exits with a non-zero status.

If no command name results, redirections are performed, but do not affect the current shell environment. A redirection error causes the command to exit with a non-zero status.

If there is a command name left after expansion, execution proceeds as described below. Otherwise, the command exits. If one of the expansions contained a command substitution, the exit status of the command is the exit status of the last command substitution performed. If there were no command substitutions, the command exits with a status of zero.

Command execution

After a command has been split into words, if it results in a simple command and an optional list of arguments, the following actions are taken.

If the command name contains no slashes, the shell attempts to locate it. If there exists a shell function by that name, that function is invoked as described above in the section ” Functions .” If the name does not match a function, the shell searches for it in the list of shell builtins. If a match is found, that builtin is invoked.

If the name is neither a shell function nor a builtin, and contains no slashes, bash searches each element of the PATH for a directory containing an executable file by that name. Bash uses a hash table to remember the full pathnames of executable files (see hash under the section ” Shell Builtin Commands ” below). A full search of the directories in PATH is performed only if the command is not found in the hash table. If the search is unsuccessful, the shell searches for a defined shell function named command_not_found_handle . If that function exists, it is invoked with the original command and the original command’s arguments as its arguments, and the function’s exit status becomes the exit status of the shell. If that function is not defined, the shell prints an error message and returns an exit status of 127.

If the search is successful, or if the command name contains one or more slashes, the shell executes the named program in a separate execution environment. Argument 0 is set to the name given, and the remaining arguments to the command are set to the arguments given, if any.

If this execution fails because the file is not in executable format, and the file is not a directory, it is assumed to be a shell script, a file containing shell commands. A subshell is spawned to execute it. This subshell reinitializes itself, so that the effect is as if a new shell had been invoked to handle the script, with the exception that the locations of commands remembered by the parent (see hash below under the section ” Shell Builtin Commands “) are retained by the child.

Se o programa for um arquivo começando com #! , o restante da primeira linha especifica um intérprete para o programa. O shell executa o intérprete especificado em sistemas operacionais que não manipulam esse formato executável. Os argumentos para o intérprete consistem em um único argumento opcional após o nome do intérprete na primeira linha do programa, seguido pelo nome do programa, seguido pelos argumentos do comando, se houver.

Ambiente de execução de comando

O shell possui um ambiente de execução , que consiste no seguinte:

• arquivos abertos herdados pelo shell na chamada, modificados pelos redirecionamentos fornecidos ao exec incorporado
• o diretório de trabalho atual, conforme definido por cd , pushd ou popd ou herdado pelo shell na chamada
• a máscara do modo de criação de arquivo, conforme definido por umask ou herdado do pai do shell
• armadilhas atuais definidas por armadilha
• parâmetros de shell que são definidos por atribuição de variável ou com conjunto ou herdados do pai do shell no ambiente
• funções de shell definidas durante a execução ou herdadas do pai do shell no ambiente
• opções ativadas na chamada (por padrão ou com argumentos de linha de comando) ou por conjunto
• opções ativadas pelo shopt
• aliases de shell definidos com alias
• várias identificações de processo, incluindo tarefas de segundo plano, o valor de $$ e o valor de PPID

Quando um comando simples que não seja uma função interna ou shell deve ser executado, ele é chamado em um ambiente de execução separado que consiste no seguinte. Salvo indicação em contrário, os valores são herdados do shell.

• os arquivos abertos do shell, além de quaisquer modificações e adições especificadas por redirecionamentos para o comando
• o diretório de trabalho atual
• a máscara do modo de criação de arquivo
• variáveis ​​e funções do shell marcadas para exportação, juntamente com variáveis ​​exportadas para o comando, passadas no ambiente
• armadilhas capturadas pelo shell são redefinidas para os valores herdados do pai do shell e armadilhas ignoradas pelo shell são ignoradas

Um comando chamado neste ambiente separado não pode afetar o ambiente de execução do shell.

Substituição de comando, comandos agrupados entre parênteses e comandos assíncronos são chamados em um ambiente de subshell que é uma duplicata do ambiente do shell, exceto que os traps capturados pelo shell são redefinidos para os valores que o shell herdou do pai na chamada. Comandos internos que são chamados como parte de um pipeline também são executados em um ambiente de subshell. As alterações feitas no ambiente do subshell não podem afetar o ambiente de execução do shell.

Subshells gerados para executar substituições de comando herdam o valor da opção -e do shell pai. Quando não está no modo posix, o bash limpa a opção -e nesses subshells.

Se um comando for seguido por & e o controle de tarefa não estiver ativo, a entrada padrão padrão para o comando é o arquivo vazio / dev / null . Caso contrário, o comando invocado herda os descritores de arquivo do shell de chamada, conforme modificado pelos redirecionamentos.

Meio Ambiente

Quando um programa é chamado, é fornecida uma matriz de cadeias chamada ambiente . Esta é uma lista de pares nome-valor, no formato nome = valor .

O shell fornece várias maneiras de manipular o ambiente. Na chamada, o shell varre seu próprio ambiente e cria um parâmetro para cada nome encontrado, marcando-o automaticamente para exportação para processos filho. Os comandos executados herdam o ambiente. Os comandos export e declare -x permitem que parâmetros e funções sejam adicionados e excluídos do ambiente. Se o valor de um parâmetro no ambiente for modificado, o novo valor se tornará parte do ambiente, substituindo o antigo. O ambiente herdado por qualquer comando executado consiste no ambiente inicial do shell, cujos valores podem ser modificados no shell, menos pares removidos pelo comando unset, mais adições por meio dos comandos export e declare -x .

O ambiente para qualquer comando ou função simples pode ser aumentado temporariamente, prefixando-o com atribuições de parâmetros, conforme descrito acima na seção ” Parâmetros “. Essas instruções de atribuição afetam apenas o ambiente visto por esse comando.

Se a opção -k estiver configurada (consulte o comando set builtin abaixo), todas as designações de parâmetros serão colocadas no ambiente para um comando, não apenas aquelas que precedem o nome do comando.

Quando o bash chama um comando externo, a variável _ é definida como o nome completo do arquivo do comando e passada para esse comando em seu ambiente.

Status de saída

O status de saída de um comando executado é o valor retornado pela chamada do sistema waitpid ou função equivalente. Os status de saída ficam entre 0 e 255; no entanto, conforme explicado abaixo, o shell pode usar valores acima de 125 especialmente. Os status de saída dos shell builtins e comandos compostos também são limitados a esse intervalo. Sob certas circunstâncias, o shell usará valores especiais para indicar modos de falha específicos.

Para os propósitos do shell, um comando que sai com um status de saída zero foi bem-sucedido. Um status de saída zero indica sucesso. Um status de saída diferente de zero indica falha. Quando um comando termina em um sinal fatal N , o bash usa o valor de 128 + N como status de saída.

Se um comando não for encontrado, o processo filho criado para executá-lo retornará um status 127. Se um comando for encontrado, mas não for executável, o status de retorno será 126.

Se um comando falhar devido a um erro durante a expansão ou o redirecionamento, o status de saída será maior que zero.

Os comandos internos do shell retornam um status 0 (verdadeiro) se for bem-sucedido e diferente de zero (falso) se ocorrer um erro durante a execução. Todos os componentes internos retornam um status de saída 2 para indicar o uso incorreto.

O próprio Bash retorna o status de saída do último comando executado, a menos que ocorra um erro de sintaxe; nesse caso, ele sai com um valor diferente de zero. Veja também o comando exit builtin abaixo.

Signals

Quando o bash é interativo, na ausência de interceptações, ele ignora o SIGTERM (para que kill 0 não mate um shell interativo) e o SIGINT é capturado e tratado (para que a espera incorporada seja interrompida). Em todos os casos, o bash ignora SIGQUIT . Se o controle do trabalho estiver em vigor, o bash ignorará SIGTTIN , SIGTTOU e SIGTSTP .

Comandos não integrados executados pelo bash têm manipuladores de sinal definidos para os valores herdados pelo shell de seu pai. Quando o controle da tarefa não está em vigor, os comandos assíncronos ignoram SIGINT e SIGQUIT , além desses manipuladores herdados. Os comandos executados como resultado da substituição de comando ignoram os sinais de controle de tarefa gerados pelo teclado SIGTTIN , SIGTTOU e SIGTSTP .

O shell sai por padrão após o recebimento de um SIGHUP . Antes de sair, um shell interativo reenvia o SIGHUP para todos os trabalhos, em execução ou interrompidos. Os trabalhos interrompidos são enviados SIGCONT para garantir que eles recebam o SIGHUP . Para impedir que o shell envie o sinal para um trabalho específico, ele deve ser removido da tabela de trabalhos com o renegado interno (consulte a seção ” Comandos internos do shell ” abaixo) ou marcado para não receber SIGHUP usando disown -h .

Se a opção de shell huponexit tiver sido definida com shopt , o bash enviará um SIGHUP para todas as tarefas quando um shell de logon interativo sair.

Se o bash estiver aguardando a conclusão de um comando e receber um sinal para o qual uma captura foi configurada, a captura não será executada até que o comando seja concluído. Quando o bash está aguardando um comando assíncrono via a espera incorporada, a recepção de um sinal para o qual uma captura foi configurada fará com que a espera retorne imediatamente com um status de saída maior que 128, imediatamente após o qual a captura é executada.

Controle de trabalho

O controle de tarefas refere-se à capacidade de parar (suspender) seletivamente a execução de processos e continuar (retomar) sua execução posteriormente. Um usuário normalmente emprega esse recurso por meio de uma interface interativa fornecida em conjunto pelo driver de terminal e bash do kernel do sistema operacional.

O shell associa um trabalho a cada pipeline. Ele mantém uma tabela de trabalhos em execução no momento, que pode ser listada com o comando jobs . Quando o bash inicia um trabalho de forma assíncrona (em segundo plano), ele imprime uma linha parecida com:

  [1] 25647

indicando que esse trabalho é o número 1 e que o ID do último processo no pipeline associado a esse trabalho é 25647 . Todos os processos em um único pipeline são membros do mesmo trabalho. O Bash usa a abstração do trabalho como base para o controle do trabalho.

Para facilitar a implementação da interface do usuário para o controle de tarefas, o sistema operacional mantém a noção de um ID do grupo de processos do terminal atual. Os membros desse grupo de processos (processos cujo ID do grupo de processos é igual ao atual ID do grupo de processos do terminal) recebem sinais gerados pelo teclado, como SIGINT . Diz-se que esses processos estão em primeiro plano. Processos em segundo plano são aqueles cujo ID do grupo de processos difere do terminal; esses processos são imunes aos sinais gerados pelo teclado. Somente processos em primeiro plano têm permissão para ler ou, se o usuário especificar com stty tostop, gravar no terminal. Os processos em segundo plano que tentam ler (gravar para quando stty tostop está em vigor) recebem um sinal SIGTTIN ( SIGTTOU ) pelo driver de terminal do kernel, que, a menos que seja capturado, suspende o processo.

Se o sistema operacional no qual o bash estiver em execução suportar o controle de tarefas, o bash conterá recursos para usá-lo. Digitar o caractere de suspensão (normalmente ^ Z , Control-Z ) enquanto um processo está em execução faz com que o processo seja parado e retorna o controle ao bash. Digitar o caractere de suspensão atrasada (normalmente ^ Y , Control-Y ) faz com que o processo seja interrompido quando ele tenta ler a entrada do terminal e o controle retornado ao bash. O usuário pode então manipular o estado desse trabalho, usando o comando bg para continuar em segundo plano, o comando fg para continuar em primeiro plano ou o comando kill para matá-lo. A ^ Z entra em vigor imediatamente e tem o efeito colateral adicional de fazer com que a saída pendente e o cabeçote de impressão sejam descartados.

Existem várias maneiras de se referir a um trabalho no shell. O caractere % apresenta uma especificação de trabalho ( jobspec ). O número do trabalho n pode ser referido como % n . Um trabalho também pode ser referido usando um prefixo do nome usado para iniciá-lo ou uma substring que aparece em sua linha de comando. Por exemplo, % ce refere-se a um trabalho interrompido. Se um prefixo corresponder a mais de um trabalho, o bash reportará um erro. O uso de %? Ce , por outro lado, refere-se a qualquer trabalho que contenha a cadeia ce em sua linha de comando. Se a substring corresponder a mais de um trabalho, o bash reportará um erro. Os símbolos %% e % + referem-se à noção do shell do trabalho atual, que é o último trabalho parado enquanto estava em primeiro plano ou iniciado em segundo plano. O trabalho anterior pode ser referenciado usando % – . Se houver apenas um trabalho, % + e % – podem ser usados ​​para se referir a esse trabalho. Na saída referente aos trabalhos (por exemplo, a saída do comando jobs ), o trabalho atual é sempre marcado com um + e o trabalho anterior com um – . Um único % (sem especificação de trabalho que o acompanha) também se refere ao trabalho atual.

A nomeação de um trabalho pode ser usada para trazê-lo para o primeiro plano: % 1 é sinônimo de “fg% 1”, trazendo o trabalho 1 do segundo plano para o primeiro plano. Da mesma forma, ” % 1 & ” retoma a tarefa 1 em segundo plano, equivalente a ” bg% 1 “.

O shell aprende imediatamente sempre que um trabalho muda de estado. Normalmente, o bash aguarda até que esteja prestes a imprimir um prompt antes de relatar alterações no status de um trabalho para não interromper nenhuma outra saída. Se a opção -b para o comando set builtin estiver ativada, o bash reportará essas alterações imediatamente. Qualquer armadilha no SIGCHLD é executada para cada filho que sai.

Se uma tentativa de sair do bash for feita enquanto os trabalhos estiverem parados (ou, se a opção de shell checkjobs tiver sido ativada usando o shopt interno, em execução), o shell imprimirá uma mensagem de aviso e, se a opção checkjobs estiver ativada, listará os trabalhos e seus status. O comando jobs pode então ser usado para inspecionar seu status. Se uma segunda tentativa de saída for feita sem um comando intermediário, o shell não imprimirá outro aviso e os trabalhos interrompidos serão encerrados.

Prompting

Ao executar interativamente, o bash exibe o prompt primário PS1 quando estiver pronto para ler um comando, e o prompt secundário PS2 quando precisar de mais entradas para concluir um comando. O Bash permite que essas seqüências de caracteres de prompt sejam personalizadas inserindo vários caracteres especiais com escape de barra invertida que são decodificados da seguinte maneira:

O número do comando e o número do histórico geralmente são diferentes: o número do histórico de um comando é sua posição na lista do histórico, que pode incluir comandos restaurados do arquivo de histórico (consulte a seção ” Histórico “, abaixo), enquanto o número do comando é a posição na sequência de comandos executados durante a sessão atual do shell. Depois que a string é decodificada, ela é expandida via expansão de parâmetro, substituição de comando, expansão aritmética e remoção de cotação, sujeita ao valor da opção do prompt do prompt de comandos (consulte a descrição do comando shopt na seção ” Comandos internos do shell ” abaixo).

Leia a linha

Esta é a biblioteca que lida com a entrada de leitura ao usar um shell interativo, a menos que a opção –noediting seja fornecida na chamada do shell. A edição de linha também é usada ao usar a opção -e na leitura incorporada. Por padrão, os comandos de edição de linha são semelhantes aos do Emacs . Uma interface de edição de linha no estilo vi também está disponível. A edição de linha pode ser ativada a qualquer momento usando as opções -o emacs ou -o vi no conjunto interno (consulte a seção ” Comandos internos do shell ” abaixo). Para desativar a edição de linha depois que o shell estiver em execução, use as opções + o emacs ou + o vi no conjunto interno.

Notação Readline

Nesta seção, a notação no estilo Emacs é usada para indicar as teclas digitadas. As teclas de controle são indicadas pela tecla C , por exemplo, Cn significa Control-N . Da mesma forma, as meta chaves são indicadas pela tecla M , então Mx significa Meta-X . Nos teclados sem uma tecla meta, Mx significa ESC x , ou seja, pressione a tecla Escape e a tecla x . Isso faz do ESC o prefixo meta. A combinação MCx significa ESC-Control-x , ou pressione a tecla Escape e mantenha pressionada a tecla Control enquanto pressiona a tecla x .

Os comandos da linha de leitura podem receber argumentos numéricos, que normalmente atuam como uma contagem de repetição. Às vezes, porém, é o sinal do argumento que é significativo. Passar um argumento negativo para um comando que atua na direção para a frente (por exemplo, linha da morte ) faz com que esse comando atue na direção para trás. Os comandos cujo comportamento com argumentos se desvia disso são anotados abaixo.

Quando um comando é descrito como eliminador de texto, o texto excluído é salvo para possível recuperação futura (puxão). O texto morto é salvo em um anel de morte. Mortes consecutivas fazem com que o texto seja acumulado em uma unidade, que pode ser puxada de uma só vez. Os comandos que não matam texto separam os pedaços de texto no anel de matança.

Inicialização Readline

O Readline é personalizado, colocando comandos em um arquivo de inicialização (o arquivo inputrc ). O nome desse arquivo é obtido do valor da variável INPUTRC . Se essa variável não estiver definida, o padrão é ~ / .inputrc . Quando um programa que usa a biblioteca readline é iniciado, o arquivo de inicialização é lido e as associações de teclas e variáveis ​​são definidas. Existem apenas algumas construções básicas permitidas no arquivo de inicialização da linha de leitura. Linhas em branco são ignoradas. Linhas começando com um # são comentários. Linhas começando com $ indicam construções condicionais. Outras linhas indicam ligações de teclas e configurações variáveis.

As combinações de teclas padrão podem ser alteradas com um arquivo inputrc . Outros programas que usam essa biblioteca podem adicionar seus próprios comandos e ligações.

Por exemplo, colocando

  M-Control-u: argumento universal

ou

  C-Meta-u: Argumento universal

no inputrc , o MCu executaria o comando readline universal-argument .

Os seguintes nomes de caracteres simbólicos são reconhecidos: RUBOUT, DEL, ESC, LFD, NEWLINE, RET, RETURN, SPC, SPACE e TAB .

Além dos nomes de comando, a linha de leitura permite que as teclas sejam vinculadas a uma sequência que é inserida quando a tecla é pressionada (uma macro ).

Ligações de teclas Readline

A sintaxe para controlar as combinações de teclas no arquivo inputrc é simples. Tudo o que é necessário é o nome do comando ou o texto de uma macro e uma sequência de teclas à qual ele deve estar vinculado. O nome pode ser especificado de duas maneiras: como um nome de chave simbólico, possivelmente com prefixos Meta ou Controle , ou como uma sequência de chaves.

Ao usar o formulário keyname: function-name ou macro, keyname é o nome de uma chave digitada em inglês. Por exemplo:

  Control-u: argumento universal Meta-Rubout: backward-kill-word Control-o: "> output"

No exemplo acima, Cu está vinculado à função argumento universal, M-DEL está vinculado à função backward-kill-word e Co é obrigado a executar a macro expressa no lado direito (ou seja, para inserir o texto ” > output ” na linha).

Na segunda forma, “keyseq”: nome da função ou macro , keyseq difere do nome da chave acima, pois as cadeias que indicam uma sequência de teclas inteira podem ser especificadas colocando-a entre aspas duplas. Algumas escapes de teclas no estilo GNU Emacs podem ser usadas, como no exemplo a seguir, mas os nomes de caracteres simbólicos não são reconhecidos.

  "\ Cu": argumento universal "\ Cx \ Cr": re-read-init-file "\ e [11 ~": "Tecla de função 1"

Neste exemplo, Cu é novamente vinculado à função argumento universal. Cx Cr é vinculado à função re-read-init-file , e ESC [1 1 ~ é vinculado para inserir o texto ” Function Key 1 “.

O conjunto completo de seqüências de escape no estilo GNU Emacs é

Além das seqüências de escape no estilo GNU Emacs, está disponível um segundo conjunto de escapes de barra invertida:

Ao inserir o texto de uma macro , aspas simples ou duplas devem ser usadas para indicar uma definição de macro. O texto não citado é considerado um nome de função. No corpo da macro, as escapes de barra invertida descritas acima são expandidas. A barra invertida citará qualquer outro caractere no texto da macro, incluindo “ e ‘ .

O Bash permite que as ligações de teclas da linha de leitura atuais sejam exibidas ou modificadas com o comando bind builtin. O modo de edição pode ser alternado durante o uso interativo usando a opção -o no comando set builtin (consulte a seção ” Comandos internos do shell ” abaixo).

Variáveis ​​Readline

O Readline possui variáveis ​​que podem ser usadas para personalizar ainda mais seu comportamento. Uma variável pode ser definida no arquivo inputrc com uma declaração do formulário.

  definir valor do nome da variável

Exceto quando indicado, as variáveis ​​de linha de leitura podem ativar ou desativar os valores (sem considerar o caso). Nomes de variáveis ​​não reconhecidos são ignorados. Quando um valor variável é lido, os valores vazios ou nulos “, on ” (sem distinção entre maiúsculas e minúsculas) e ” 1 ” são equivalentes a Ativado . Todos os outros valores são equivalentes a Desativado . As variáveis ​​e seus valores padrão são:

Construções condicionais Readline

O Readline implementa um recurso semelhante em espírito aos recursos de compilação condicional do pré-processador C que permite que ligações de teclas e configurações variáveis ​​sejam executadas como resultado de testes. Existem quatro diretivas do analisador usadas.

  $ if Bash # Cite a palavra atual ou anterior "\ C-xq": "\ eb \" \ ef \ "" $ endif

  $ include / etc / inputrc

Procurando

O Readline fornece comandos para pesquisar no histórico de comandos (consulte a seção ” Histórico ” abaixo) as linhas que contêm uma sequência especificada. Existem dois modos de pesquisa: incremental e não incremental.

As pesquisas incrementais começam antes que o usuário termine de digitar a string de pesquisa. À medida que cada caractere da sequência de pesquisa é digitado, o readline exibe a próxima entrada do histórico correspondente à sequência digitada até o momento. Uma pesquisa incremental requer apenas o número de caracteres necessário para encontrar a entrada do histórico desejada. Os caracteres presentes no valor da variável isearch-terminators são usados ​​para finalizar uma pesquisa incremental. Se essa variável não tiver sido atribuída a um valor, os caracteres Escape e Control-J encerrarão uma pesquisa incremental. Control-G interromperá uma pesquisa incremental e restaurará a linha original. Quando a pesquisa é encerrada, a entrada do histórico que contém a sequência de pesquisa se torna a linha atual.

Para localizar outras entradas correspondentes na lista de histórico, digite Control-S ou Control-R conforme apropriado. Isso pesquisará para trás ou para frente no histórico a próxima entrada correspondente à sequência de pesquisa digitada até o momento. Qualquer outra sequência de teclas vinculada a um comando readline encerrará a pesquisa e executará esse comando. Por exemplo, uma nova linha encerrará a pesquisa e aceitará a linha, executando o comando da lista de histórico.

O Readline lembra a última cadeia de caracteres de pesquisa incremental. Se dois Control-Rs forem digitados sem nenhum caractere intermediário que defina uma nova sequência de caracteres de pesquisa, qualquer sequência de pesquisa lembrada será usada.

Pesquisas não incrementais leem toda a cadeia de pesquisa antes de começar a procurar linhas de histórico correspondentes. A sequência de pesquisa pode ser digitada pelo usuário ou fazer parte do conteúdo da linha atual.

Nomes de comando da linha de leitura

A seguir, é apresentada uma lista dos nomes dos comandos e das seqüências de teclas padrão às quais eles estão vinculados. Os nomes de comando sem uma sequência de teclas associada são ilimitados por padrão. Nas descrições a seguir, point refere-se à posição atual do cursor e mark refere-se a uma posição do cursor salva pelo comando set-mark . O texto entre o ponto e a marca é chamado de região .

Comandos para mover

Comandos para manipular a história

Comandos para alterar texto

Matar e puxar

Argumentos numéricos

Concluindo

Keyboard macros

Diversos

Programmable completion

When word completion is attempted for an argument to a command for which a completion specification (a compspec ) has been defined using the complete builtin (see the section ” Shell Builtin Commands ” below), the programmable completion facilities are invoked.

First, the command name is identified. If the command word is the empty string (completion attempted at the beginning of an empty line), any compspec defined with the -E option to complete is used. If a compspec has been defined for that command, the compspec is used to generate the list of possible completions for the word. If the command word is a full pathname, a compspec for the full pathname is searched for first. If no compspec is found for the full pathname, an attempt is made to find a compspec for the portion following the final slash. If those searches do not result in a compspec , any compspec defined with the -D option to complete is used as the default.

Once a compspec has been found, it is used to generate the list of matching words. If a compspec is not found, the default bash completion as described above under Completing is performed.

First, the actions specified by the compspec are used. Only matches which are prefixed by the word being completed are returned. When the -f or -d option is used for filename or directory name completion, the shell variable FIGNORE is used to filter the matches.

Any completions specified by a pathname expansion pattern to the -G option are generated next. The words generated by the pattern need not match the word being completed. The GLOBIGNORE shell variable is not used to filter the matches, but the FIGNORE variable is used.

Next, the string specified as the argument to the -W option is considered. The string is first split using the characters in the IFS special variable as delimiters. Shell quoting is honored. Each word is then expanded using brace expansion, tilde expansion, parameter and variable expansion, command substitution, and arithmetic expansion, as described above under the section ” Expansion .” The results are split using the rules described above under the section ” Word Splitting .” The results of the expansion are prefix-matched against the word being completed, and the matching words become the possible completions.

After these matches have been generated, any shell function or command specified with the -F and -C options is invoked. When the command or function is invoked, the COMP_LINE , COMP_POINT , COMP_KEY , and COMP_TYPE variables are assigned values as described above under the section ” Shell Variables .” If a shell function is being invoked, the COMP_WORDS and COMP_CWORD variables are also set. When the function or command is invoked, the first argument is the name of the command whose arguments are being completed, the second argument is the word being completed, and the third argument is the word preceding the word being completed on the current command line. No filtering of the generated completions against the word being completed is performed; the function or command has complete freedom in generating the matches.

Any function specified with -F is invoked first. The function may use any of the shell facilities, including the compgen builtin described below, to generate the matches. It must put the possible completions in the COMPREPLY array variable.

Next, any command specified with the -C option is invoked in an environment equivalent to command substitution. It should print a list of completions, one per line, to the standard output. Backslash may be used to escape a newline, if necessary.

After all of the possible completions are generated, any filter specified with the -X option is applied to the list. The filter is a pattern as used for pathname expansion; a & in the pattern is replaced with the text of the word being completed. A literal & may be escaped with a backslash; the backslash is removed before attempting a match. Any completion that matches the pattern will be removed from the list. A leading ! negates the pattern; in this case any completion not matching the pattern will be removed.

Finally, any prefix and suffix specified with the -P and -S options are added to each member of the completion list, and the result is returned to the readline completion code as the list of possible completions.

If the previously-applied actions do not generate any matches, and the -o dirnames option was supplied to complete when the compspec was defined, directory name completion is attempted.

If the -o plusdirs option was supplied to complete when the compspec was defined, directory name completion is attempted and any matches are added to the results of the other actions.

By default, if a compspec is found, whatever it generates is returned to the completion code as the full set of possible completions. The default bash completions are not attempted, and the readline default of filename completion is disabled. If the -o bashdefault option was supplied to complete when the compspec was defined, the bash default completions are attempted if the compspec generates no matches. If the -o default option was supplied to complete when the compspec was defined, readline’s default completion will be performed if the compspec (and, if attempted, the default bash completions) generate no matches.

When a compspec indicates that directory name completion is desired, the programmable completion functions force readline to append a slash to completed names which are symbolic links to directories, subject to the value of the mark-directories readline variable, regardless of the setting of the mark-symlinked-directories readline variable.

There is some support for dynamically modifying completions. This is most useful when used in combination with a default completion specified with complete -D . It’s possible for shell functions executed as completion handlers to indicate that completion should be retried by returning an exit status of 124. If a shell function returns 124, and changes the compspec associated with the command on which completion is being attempted (supplied as the first argument when the function is executed), programmable completion restarts from the beginning, with an attempt to find a new compspec for that command. This allows a set of completions to be built dynamically as completion is attempted, rather than being loaded all at once.

For instance, assuming that there is a library of compspecs , each kept in a file corresponding to the name of the command, the following default completion function would load completions dynamically:

 _completion_loader()
 {
      . "/etc/bash_completion.d/$1.sh" >/dev/null 2>&1 && return 124
 }
complete -D -F _completion_loader

História

When the -o history option to the set builtin is enabled, the shell provides access to the command history, the list of commands previously typed. The value of the HISTSIZE variable is used as the number of commands to save in a history list. The text of the last HISTSIZE commands (default 500) is saved. The shell stores each command in the history list prior to parameter and variable expansion (see the section ” Expansion ” above) but after history expansion is performed, subject to the values of the shell variables HISTIGNORE and HISTCONTROL .

On startup, the history is initialized from the file named by the variable HISTFILE (default ~/.bash_history ). The file named by the value of HISTFILE is truncated, if necessary, to contain no more than the number of lines specified by the value of HISTFILESIZE . When the history file is read, lines beginning with the history comment character followed immediately by a digit are interpreted as timestamps for the preceding history line. These timestamps are optionally displayed depending on the value of the HISTTIMEFORMAT variable. When an interactive shell exits, the last $HISTSIZE lines are copied from the history list to $HISTFILE . If the histappend shell option is enabled (see the description of shopt under the section ” Shell Builtin Commands ” below), the lines are appended to the history file, otherwise the history file is overwritten. If HISTFILE is unset, or if the history file is unwritable, the history is not saved. If the HISTTIMEFORMAT variable is set, time stamps are written to the history file, marked with the history comment character, so they may be preserved across shell sessions. This uses the history comment character to distinguish timestamps from other history lines. After saving the history, the history file is truncated to contain no more than HISTFILESIZE lines. If HISTFILESIZE is not set, no truncation is performed.

The builtin command fc (see the ” Shell Builtin Commands ” section below) may be used to list or edit and re-execute a portion of the history list. The history builtin may be used to display or modify the history list and manipulate the history file. When using command-line editing, search commands are available in each editing mode that provide access to the history list.

The shell allows control over which commands are saved on the history list. The HISTCONTROL and HISTIGNORE variables may be set to cause the shell to save only a subset of the commands entered. The cmdhist shell option, if enabled, causes the shell to attempt to save each line of a multi-line command in the same history entry, adding semicolons where necessary to preserve syntactic correctness. The lithist shell option causes the shell to save the command with embedded newlines instead of semicolons. See the description of the shopt builtin below under the section ” Shell Builtin Commands ” for information on set ting and unset ting shell options.

History expansion

The shell supports a history expansion feature that is similar to the history expansion in csh . This section describes what syntax features are available. This feature is enabled by default for interactive shells, and can be disabled using the +H option to the set builtin command (see the section ” Shell Builtin Commands ” below). Non-interactive shells do not perform history expansion by default.

History expansions introduce words from the history list into the input stream, making it easy to repeat commands, insert the arguments to a previous command into the current input line, or fix errors in previous commands quickly.

History expansion is performed immediately after a complete line is read, before the shell breaks it into words. It takes place in two parts. The first is to determine which line from the history list to use during substitution. The second is to select portions of that line for inclusion into the current one. The line selected from the history is the event, and the portions of that line that are acted upon are words. Various modifiers are available to manipulate the selected words. The line is broken into words in the same fashion as when reading input, so that several metacharacter-separated words surrounded by quotes are considered one word. History expansions are introduced by the appearance of the history expansion character, which is ! por padrão. Only backslash ( \ ) and single quotes can quote the history expansion character.

Several characters inhibit history expansion if found immediately following the history expansion character, even if it is unquoted: space , tab , newline , carriage return , and = . If the extglob shell option is enabled, ( will also inhibit expansion.

Several shell options settable with the shopt builtin may be used to tailor the behavior of history expansion. If the histverify shell option is enabled (see the description of the shopt builtin below), and readline is being used, history substitutions are not immediately passed to the shell parser. Instead, the expanded line is reloaded into the readline editing buffer for further modification. If readline is being used, and the histreedit shell option is enabled, a failed history substitution will be reloaded into the readline editing buffer for correction. The -p option to the history builtin command may be used to see what a history expansion will do before using it. The -s option to the history builtin may be used to add commands to the end of the history list without actually executing them, so that they are available for subsequent recall.

The shell allows control of the various characters used by the history expansion mechanism (see the description of histchars above under the section ” Shell Variables “). The shell uses the history comment character to mark history timestamps when writing the history file.

Event designators

An event designator is a reference to a command line entry in the history list. Unless the reference is absolute, events are relative to the current position in the history list.

Word designators

Word designators are used to select desired words from the event. A : separates the event specification from the word designator. It may be omitted if the word designator begins with a ^ , $ , * , – , or % . Words are numbered from the beginning of the line, with the first word being denoted by 0 (zero). Words are inserted into the current line separated by single spaces.

If a word designator is supplied without an event specification, the previous command is used as the event.

Modificadores

After the optional word designator, there may appear a sequence of one or more of the following modifiers , each preceded by a ‘ : ‘.

Shell builtin commands

Unless otherwise noted, each builtin command documented in this section as accepting options preceded by – accepts — to signify the end of the options. The : , true , false , and test builtins do not accept options and do not treat — specially. The exit , logout , break , continue , let , and shift builtins accept and process arguments beginning with – without requiring — . Other builtins that accept arguments but are not specified as accepting options interpret arguments beginning with – as invalid options and require — to prevent this interpretation.