mksh - Online na nuvem

PROGRAMA:

NOME

Obrigado, sh - Shell MirBSD Korn

SINOPSE

Obrigado [- + abCefhiklmnprUuvXx] [-T [!]tty | -] [- + o opção] [-c corda | -s | lima
[argumento ...]]
nome embutido [argumento ...]

DESCRIÇÃO

Obrigado é um interpretador de comandos destinado ao uso interativo e em script de shell. Seu
a linguagem de comando é um superconjunto da linguagem shell sh (C) e amplamente compatível com o
shell Korn original. Às vezes, esta página de manual pode fornecer conselhos sobre scripts; Enquanto ele
às vezes leva shell scripting portátil ou vários padrões em consideração todos
as informações são apresentadas em primeiro lugar com Obrigado em mente e deve ser considerada como tal.

Eu estou an Android do utilizador, so o que é mksh?
Obrigado é um interpretador de comandos / shell UNIX, semelhante a COMMAND.COM or CMD.EXE, Que possui
foi incluído no Android Open Source Project por um tempo. Basicamente, é um programa
que é executado em um terminal (janela do console), recebe a entrada do usuário e executa comandos ou scripts,
o que também pode ser solicitado por outros programas, mesmo em segundo plano. Qualquer privilégio
pop-ups que você pode encontrar não são, portanto, Obrigado problemas, mas perguntas por algum outro
programa que o utiliza.

Invocação
A maioria dos builtins pode ser chamada diretamente, por exemplo, se um link apontar de seu nome para o
Concha; nem todos fazem sentido, foram testados ou funcionam de todo.

As opções são as seguintes:

-c corda Obrigado irá executar o (s) comando (s) contido (s) em corda.

-i Shell interativo. Um shell que lê comandos da entrada padrão é
“Interativo” se esta opção for usada ou se a entrada padrão e o erro padrão
estão ligados a um tty(4). Um shell interativo tem controle de trabalho habilitado, ignora
os sinais SIGINT, SIGQUIT e SIGTERM, e imprime prompts antes de ler a entrada
(veja os parâmetros PS1 e PS2). Ele também processa o parâmetro ENV ou o
mkshrc arquivo (veja abaixo). Para shells não interativos, o rastrear tudo opção está ativada
por padrão (veja o conjunto comando abaixo).

-l Shell de login. Se o nome de base com o qual o shell é chamado (ou seja, argv [0]) começa com
'-' ou se esta opção for usada, o shell é considerado um shell de login; Vejo
Comece arquivos abaixo.

-p Concha privilegiada. Um shell é "privilegiado" se o ID de usuário real ou ID de grupo o fizer
não corresponde ao ID de usuário efetivo ou ID de grupo (consulte getuid(2) e ficar idôneo(2)).
Limpar a opção privilegiada faz com que o shell defina seu ID de usuário efetivo
(ID do grupo) para seu ID de usuário real (ID do grupo). Para outras implicações, consulte Comece
arquivos. Se o shell for privilegiado e este sinalizador não estiver explicitamente definido, o
A opção “privilegiada” é desmarcada automaticamente após o processamento dos arquivos de inicialização.

-r Shell restrito. Um shell é “restrito” se esta opção for usada. A seguir
restrições entram em vigor após o shell processar qualquer perfil e ENV
arquivos:

· A cd (E chdir) o comando está desativado.
· Os parâmetros SHELL, ENV e PATH não podem ser alterados.
· Os nomes dos comandos não podem ser especificados com caminhos absolutos ou relativos.
· A -p opção do comando embutido comando não pode ser usado.
· Redirecionamentos que criam arquivos não podem ser usados ​​(ou seja, '>', '> |', '>>', '<>').

-s O shell lê comandos da entrada padrão; todos os argumentos não opcionais são
parâmetros posicionais.

-T nome O Spawn Obrigado na tty(4) dispositivo fornecido. Os caminhos nome, / dev / ttyCname e
/ dev / ttyname são tentadas em ordem. A menos que nome começa com um ponto de exclamação
('!'), isso é feito em um subshell e retorna imediatamente. Se nome é um traço
('-'), desconecte-o do terminal de controle (daemonise).

Além do acima, as opções descritas no conjunto comando embutido também pode ser usado
na linha de comando: ambos [- + abCefhkmnuvXx] E [- + o opção] pode ser usado para uma única letra
ou opções longas, respectivamente.

Se nem o -c nem o -s opção é especificada, o primeiro argumento sem opção especifica
o nome de um arquivo do qual o shell lê os comandos. Se não houver argumentos não opcionais, o
o shell lê comandos da entrada padrão. O nome do shell (ou seja, o conteúdo de
$ 0) é determinado da seguinte forma: se o -c opção é usada e há um argumento de não opção,
é usado como o nome; se os comandos estão sendo lidos de um arquivo, o arquivo é usado como o
nome; caso contrário, o nome de base com o qual o shell foi chamado (ou seja, argv [0]) é usado.

O status de saída do shell é 127 se o arquivo de comando especificado na linha de comando puder
não ser aberto, ou diferente de zero se um erro fatal de sintaxe ocorreu durante a execução de um
roteiro. Na ausência de erros fatais, o status de saída é o do último comando
executado, ou zero, se nenhum comando for executado.

Comece arquivos
Para a localização real desses arquivos, consulte ARQUIVOS. Um shell de login processa o sistema
perfil primeiro. Um shell privilegiado então processa o perfil suid. Um login não privilegiado
o shell processa o perfil do usuário a seguir. Um shell interativo não privilegiado verifica o valor
do parâmetro ENV após submetê-lo a parâmetro, comando, aritmética e til ('~')
substituição; se não estiver definido ou vazio, o perfil mkshrc do usuário será processado; caso contrário, se um arquivo
cujo nome é o resultado da substituição existe, é processado; a não existência é silenciosa
ignorado. Um shell privilegiado, em seguida, perde privilégios se nenhum dos dois -p opção dada no
linha de comando nem definido durante a execução dos arquivos de inicialização.

Command sintaxe
O shell começa a analisar sua entrada removendo quaisquer combinações barra invertida-nova linha, então
quebrando em palavras. Palavras (que são sequências de caracteres) são delimitadas por não aspas
caracteres de espaço em branco (espaço, tabulação e nova linha) ou metacaracteres ('<', '>', '|', ';', '(',
')', e '&'). Além de delimitar palavras, espaços e tabulações são ignorados, enquanto novas linhas
geralmente delimitam comandos. Os metacaracteres são usados ​​na construção do seguinte tokens:
'<', '<&', '<<', '<<<', '>', '> &', '>>', '&>', etc. são usados ​​para especificar redirecionamentos (consulte
Input / output redirecionamento abaixo); '|' é usado para criar pipelines; '| &' é usado para criar co-
processos (ver Co-processos abaixo); ';' é usado para separar comandos; '&' é usado para criar
pipelines assíncronos; '&&' e '||' são usados ​​para especificar a execução condicional; ';;', '; &'
e '; |' são usados ​​em casas afirmações; '((..))' é usado em expressões aritméticas; e
por último, '(..)' é usado para criar subshells.

Espaços em branco e metacaracteres podem ser citados individualmente usando uma barra invertida ('\') ou em
grupos usando aspas duplas ('"') ou simples (“ '”). Observe que os caracteres a seguir são
também tratados de forma especial pela casca e devem ser citados se quiserem se representar:
'\', '"', '' ',' # ',' $ ','` ',' ~ ',' {','} ',' * ','? 'e' ['. primeiros três destes
são os personagens citados acima (veja Citando abaixo); '#', se usado no
início de uma palavra, introduz um comentário - tudo após o '#' até o mais próximo
nova linha é ignorada; '$' é usado para introduzir parâmetro, comando e aritmética
substituições (ver Substituição abaixo); '`' introduz uma substituição de comando de estilo antigo
(Vejo Substituição abaixo); '~' inicia uma expansão de diretório (veja Til expansão abaixo); '{'
e '}' delimitar csh(1) alternâncias de estilo (ver Cinta expansão abaixo); e finalmente, '*',
'?', e '[' são usados ​​na geração do nome do arquivo (ver Envie o nome padrões abaixo).

À medida que palavras e tokens são analisados, o shell cria comandos, dos quais existem dois
tipos: comandos simples, normalmente programas que são executados e comandos compostos, tal
as para e if declarações, construções de agrupamento e definições de função.

Um comando simples consiste em alguma combinação de atribuições de parâmetros (ver parâmetros
abaixo), redirecionamentos de entrada / saída (ver Input / output redirecionamentos abaixo), e palavras de comando;
a única restrição é que as atribuições de parâmetros vêm antes de quaisquer palavras de comando. O
palavras de comando, se houver, definem o comando a ser executado e seus argumentos. O
comando pode ser um comando embutido em shell, uma função ou um comando externo (ou seja, um comando separado
arquivo executável localizado com o parâmetro PATH; Vejo Command execução abaixo).
Observe que todas as construções de comando têm um status de saída: para comandos externos, isso está relacionado
para o status retornado por esperar(2) (se o comando não puder ser encontrado, o status de saída é
127; se não puder ser executado, o status de saída é 126); o status de saída de outro comando
construções (comandos integrados, funções, comandos compostos, pipelines, listas, etc.) são todos
bem definidos e são descritos onde o construto é descrito. O status de saída de um
comando que consiste apenas em atribuições de parâmetros é o da última substituição de comando
executado durante a atribuição de parâmetro ou 0 se não houver substituições de comando.

Os comandos podem ser encadeados usando o caractere '|' token para formar pipelines, nos quais o
saída padrão de cada comando, mas o último é canalizado (ver tubo(2)) para a entrada padrão de
o seguinte comando. O status de saída de um pipeline é o de seu último comando, a menos que
que o falha na tubulação opção está definida (veja lá). Todos os comandos de um pipeline são executados separadamente
subcamadas; isso é permitido pelo POSIX, mas difere de ambas as variantes do AT&T UNIX ksh, Onde
todos, exceto o último comando, foram executados em subshells; Veja o ler descrição de builtin para
implicações e soluções alternativas. Um pipeline pode ser prefixado por '!' palavra reservada que
faz com que o status de saída do pipeline seja complementado logicamente: se o status original
era 0, o status complementado será 1; se o status original não era 0, o complementado
o status será 0.

listas de comandos podem ser criados separando pipelines por qualquer um dos seguintes tokens:
'&&', '||', '&', '| &' e ';'. Os dois primeiros são para execução condicional: “cmd1 && cmd2"
executado cmd2 apenas se o status de saída de cmd1 é zero; '||' é o oposto - cmd2 is
executado apenas se o status de saída de cmd1 é diferente de zero. '&&' e '||' tem igual precedência
que é maior do que '&', '| &' e ';', que também têm precedência igual. Observação
que o '&&' e '||' operadores são "associativos à esquerda". Por exemplo, ambos
os comandos imprimirão apenas "bar":

$ false && echo foo || barra de eco
$ true || echo foo && echo bar

O token '&' faz com que o comando anterior seja executado de forma assíncrona; isto é, a concha
inicia o comando, mas não espera que ele seja concluído (o shell mantém o controle do
status de comandos assíncronos; Vejo Trabalho ao controle abaixo). Quando um comando assíncrono é
iniciado quando o controle de trabalho é desabilitado (ou seja, na maioria dos scripts), o comando é iniciado com
sinais SIGINT e SIGQUIT ignorados e com entrada redirecionada de / dev / null (Contudo,
redirecionamentos especificados no comando assíncrono têm precedência). O operador '| &'
inicia um co-processo que é um tipo especial de processo assíncrono (ver Co-processos
abaixo). Observe que um comando deve seguir o '&&' e '||' operadores, embora não precise
siga '&', '| &' ou ';'. O status de saída de uma lista é o do último comando executado,
com exceção de listas assíncronas, para as quais o status de saída é 0.

Os comandos compostos são criados usando as seguintes palavras reservadas. Essas palavras são apenas
reconhecidos se não estiverem citados e se forem usados ​​como a primeira palavra de um comando (ou seja,
eles não podem ser precedidos por atribuições de parâmetros ou redirecionamentos):

caso mais função então! (
faça esac se tempo [[((
feito fi em até {
elif para selecionar enquanto}

Nas seguintes descrições de comandos compostos, listas de comandos (denotadas como Lista) que são
seguido por palavras reservadas deve terminar com um ponto e vírgula, uma nova linha ou um (sintaticamente
correto) palavra reservada. Por exemplo, todos os itens a seguir são válidos:

$ {echo foo; barra de eco; }
$ {echo foo; barra de eco }
$ {{echo foo; barra de eco; }}

Isso não é válido:

$ {echo foo; barra de eco}

(Lista)
Execute Lista em uma subcamada. Não há maneira implícita de passar mudanças de ambiente de
um subshell de volta ao seu pai.

{ Lista; }
Construção composta; Lista é executado, mas não em um subshell. Observe que '{' e '}'
são palavras reservadas, não metacaracteres.

casas palavra dentro [[(] de cinto de segurança [| de cinto de segurança] ...) Lista terminator] ...esac
A casas declaração tenta combinar palavra contra um especificado de cinto de segurança; O Lista
associado ao primeiro padrão correspondido com sucesso é executado. Padrões usados ​​em
casas declarações são as mesmas usadas para padrões de nome de arquivo, exceto que o
restrições relativas a '.' e '/' são eliminados. Observe que qualquer espaço sem aspas antes
e depois que um padrão é removido; qualquer espaço dentro de um padrão deve ser colocado entre aspas. Tanto o
palavra e os padrões estão sujeitos a parâmetro, comando e substituição aritmética,
bem como substituição de til.

Por razões históricas, colchetes abertos e fechados podem ser usados ​​em vez de in e esac por exemplo,
casas $ foo { *) eco Barra ;; }.

A lista terminators são:

';;' Encerre após a lista.

'; &' Caem na próxima lista.

'; |' Avalie as restantes tuplas da lista de padrões.

O status de saída de um casas declaração é a do executado Lista; se não Lista is
executado, o status de saída é zero.

para nome [dentro palavra ...]; Faz Lista; feito
Para cada palavra na lista de palavras especificada, o parâmetro nome está definido para a palavra e
Lista É executado. Se in não é usado para especificar uma lista de palavras, os parâmetros posicionais
($ 1, $ 2, etc.) são usados ​​em seu lugar. Por razões históricas, chaves abertas e fechadas podem ser
usado em vez de do e feito por exemplo, para i; { eco $ i; }. O status de saída de um para
declaração é o último status de saída de Lista; E se Lista nunca é executado, o status de saída
é zero.

if Lista; então Lista; [elif Lista; então Lista;] ... [senão Lista;]
Se o status de saída do primeiro Lista é zero o segundo Lista É executado; de outra forma,
que o Lista seguindo o elif, se houver, é executado com consequências semelhantes. Eu cai
as listas seguindo o if e elifs falhar (ou seja, sair com status diferente de zero), o Lista
seguindo o outro É executado. O status de saída de um if declaração é aquela de não
condicional Lista que é executado; se não não condicional Lista é executado, a saída
o status é zero.

selecionar nome [dentro palavra ...]; Faz Lista; feito
A selecionar declaração fornece um método automático de apresentar ao usuário um menu
e selecionando a partir dele. Uma lista enumerada do especificado palavra(s) é impresso em
erro padrão, seguido por um prompt (PS3: normalmente '#?'). Um número correspondente a
uma das palavras enumeradas é então lida a partir da entrada padrão, nome está definido para o
palavra selecionada (ou não definida se a seleção não for válida), REPLY é definido para o que foi lido
(espaço inicial / final é removido), e Lista É executado. Se uma linha em branco (ou seja,
zero ou mais octetos IFS) é inserido, o menu é reimpresso sem executar Lista.

Quando Lista for concluído, a lista enumerada será impressa se REPLY for NULL, o prompt será
impresso e assim por diante. Este processo continua até que um fim de arquivo seja lido, uma interrupção
é recebido, ou um quebrar instrução é executada dentro do loop. Se “na palavra ...” é
omitido, os parâmetros posicionais são usados ​​(ou seja, $ 1, $ 2, etc.). Para histórico
razões, colchetes abertos e fechados podem ser usados ​​em vez de do e feito por exemplo, selecionar i; {
eco $ i; }. O status de saída de um selecionar declaração é zero se um quebrar declaração é
usado para sair do loop, diferente de zero caso contrário.

até Lista; Faz Lista; feito
Isso funciona como enquanto, exceto que o corpo é executado apenas enquanto o status de saída de
o primeiro Lista é diferente de zero.

enquanto Lista; Faz Lista; feito
A enquanto é um loop pré-verificado. Seu corpo é executado tão frequentemente quanto o status de saída de
o primeiro Lista é zero. O status de saída de um enquanto declaração é o último status de saída
da Lista no corpo do loop; se o corpo não for executado, o status de saída é
zero.

função nome { Lista; }
Define a função nome (Vejo Funções abaixo). Observe que os redirecionamentos especificados
depois que uma definição de função é realizada sempre que a função é executada, não quando
a definição da função é executada.

nome() comando
Quase o mesmo que função (Vejo Funções abaixo). Espaço em branco (espaço ou tabulação) depois
nome será ignorado na maioria das vezes.

função nome() { Lista; }
O mesmo que nome() (baterism). O função palavra-chave é ignorada.

tempo [-p] [oleoduto]
A Command execução seção descreve o tempo palavra reservada.

(( expressão ))
A expressão aritmética expressão é avaliado; equivalente a “deixar a expressão” (ver
Aritmética expressões e os votos de deixar comando, abaixo) em uma construção composta.

[[ expressão ]]
Semelhante ao teste e [ ... ] comandos (descritos mais tarde), com o seguinte
exceções:

· A divisão de campo e a geração de nome de arquivo não são executadas em argumentos.

· A -a (E e -o Operadores (OR) são substituídos por '&&' e '||', respectivamente.

· Operadores (por exemplo '-f',' = ','! ') deve estar sem aspas.

· Substituições de parâmetros, comandos e aritméticas são realizadas como as expressões são
a avaliação da expressão avaliada e preguiçosa é usada para '&&' e '||' operadores.
Isso significa que na seguinte declaração, $ ( é avaliado se e somente se
o arquivo Foo existe e é legível:

$ [[-r foo && $ (

· O segundo operando das expressões '! =' E '=' são um subconjunto de padrões (por exemplo
a comparação [[ foobar = f * r ]] sucesso). Isso funciona até mesmo indiretamente:

$ bar = foobar; baz = 'f * r'
$ [[$ bar = $ baz]]; echo $?
$ [[$ bar = "$ baz"]]; echo $?

Talvez surpreendentemente, a primeira comparação foi bem-sucedida, enquanto a segunda não.
Isso não se aplica a todos os metacaracteres extglob, atualmente.

Citando
Aspas são usadas para evitar que o shell trate caracteres ou palavras de maneira especial. Há
três métodos de citação. Primeiro, '\' cita o seguinte caractere, a menos que esteja no
fim de uma linha, caso em que tanto o '\' quanto a nova linha são removidos. Em segundo lugar, um único
citação (“'”) cita tudo até a próxima aspa simples (pode abranger linhas). Terceiro, um
aspas duplas ('"') aspas todos os caracteres, exceto '$', '`' e '\', até o próximo sem escape
citação dupla. '$' e '`' entre aspas duplas têm seu significado usual (ou seja, parâmetro,
aritmética ou substituição de comando), exceto que nenhuma divisão de campo é realizada nos resultados
de substituições entre aspas, e a forma antiga de substituição de comando tem
barra invertida-aspas para aspas duplas ativadas. Se um '\' dentro de uma string entre aspas duplas é
seguido por '\', '$', '`' ou '"', é substituído pelo segundo caractere; se for seguido
por uma nova linha, tanto o '\' quanto a nova linha são removidos; caso contrário, tanto o '\' quanto o
caracteres a seguir não foram alterados.

Se uma string entre aspas simples for precedida por um '$' sem aspas, expansão de barra invertida no estilo C (consulte
abaixo) é aplicado (mesmo os caracteres de aspas simples dentro podem ser escapados e não terminam
a corda então); o resultado expandido é tratado como qualquer outra string entre aspas simples. Se um
string entre aspas duplas é precedida por um '$' sem aspas, o '$' é simplesmente ignorado.

Barra invertida expansão
Em locais onde as barras invertidas são expandidas, certos C e AT&T UNIX ksh ou GNU bater estilo
escapes são traduzidos. Estes incluem '\ a', '\ b', '\ f', '\ n', '\ r', '\ t', '\ U #########',
'\ u ####' e '\ v'. Para '\ U #########' e '\ u ####', “#” significa um dígito hexadecimal, desse
pode haver nenhum até quatro ou oito; esses escapes traduzem um ponto de código Unicode para UTF-8.
Além disso, '\ E' e '\ e' se expandem para o caractere de escape.

No impressão modo integrado, '\ "', '\' 'e' \? ' são explicitamente excluídos; sequências octais
deve ter nenhum até três dígitos octais “#” prefixados com o dígito zero ('\ 0 ###');
as sequências hexadecimais '\ x ##' são limitadas a nenhum até dois dígitos hexadecimais “#”; Ambas
as sequências octal e hexadecimal são convertidas em octetos brutos; '\ #', onde # não é nenhuma das opções acima,
se traduz em \ # (as barras invertidas são mantidas).

A expansão da barra invertida no modo de estilo C difere ligeiramente: as sequências octais '\ ###' devem ter
nenhum dígito zero prefixando de um a três dígitos octais “#” e produz octetos brutos;
sequências hexadecimais '\ x # *' avidamente consomem tantos dígitos hexadecimais “#” quanto podem e
termine com o primeiro dígito não hexadecimal; estes traduzem um ponto de código Unicode para
UTF-8. A sequência '\ c #', onde “#” é qualquer octeto, se traduz em Ctrl- # (que basicamente
significa, '\ c?' torna-se DEL, tudo o mais é bit a bit ANDed com 0x1F). Finalmente, '\ #', onde
# não é nenhuma das opções acima, traduz-se em # (tem a barra invertida cortada), mesmo que seja um
nova linha.

Alias
Existem dois tipos de apelidos: apelidos de comando normais e apelidos controlados. Aliases de comando
são normalmente usados ​​como uma mão curta para um comando longo ou freqüentemente usado. A casca se expande
apelidos de comando (ou seja, substitui o nome do apelido por seu valor) quando lê a primeira palavra
de um comando. Um alias expandido é reprocessado para verificar se há mais aliases. Se um comando
alias termina em um espaço ou tab, a palavra a seguir também é verificada para expansão de alias. O
o processo de expansão do alias para quando uma palavra que não é um alias é encontrada, quando uma palavra entre aspas
for encontrado, ou quando uma palavra de alias que está sendo expandida for encontrada. Aliases são
especificamente um recurso interativo: embora funcionem em scripts e no
linha de comando em alguns casos, aliases são expandidos durante a lexing, então seu uso deve estar em um
separar a árvore de comando de sua definição; caso contrário, o alias não será encontrado.
Visivelmente, listas de comandos (separadas por ponto e vírgula, nas substituições de comando também por nova linha)
pode ser uma mesma árvore de análise.

Os seguintes aliases de comando são definidos automaticamente pelo shell:

autoload = '\ typeset -fu'
funções = '\ typeset -f'
hash = '\ alias interno -t'
histórico = '\ builtin fc -l'
integer = '\ typeset -i'
local = '\ typeset'
login = '\ exec login'
nameref = '\ typeset -n'
nohup = 'nohup'
r = '\ builtin fc -e -'
type = '\ builtin whence -v'

Os aliases rastreados permitem que o shell se lembre de onde encontrou um comando específico. O primeiro
sempre que o shell faz uma pesquisa de caminho para um comando que está marcado como um alias rastreado, ele salva
o caminho completo do comando. Na próxima vez que o comando é executado, o shell verifica o
caminho salvo para verificar se ele ainda é válido e, caso positivo, evita repetir a busca do caminho.
Os aliases rastreados podem ser listados e criados usando aliás -t. Observe que alterar o PATH
parâmetro limpa os caminhos salvos para todos os aliases rastreados. Se o rastrear tudo opção está definida
(isto é, conjunto -o rastrear tudo or conjunto -h), o shell rastreia todos os comandos. Esta opção está definida
automaticamente para shells não interativos. Para shells interativos, apenas o seguinte
os comandos são rastreados automaticamente: gato(1) cc(1) chmod(1) cp(1) dados(1) ed(1)
emacs(1) grep(1) ls(1) fazer(1) mv(1) pr(1) rm(1) sede(1) sh(1) vi(1), e que(1).

Substituição
A primeira etapa que o shell dá ao executar um comando simples é realizar substituições em
as palavras do comando. Existem três tipos de substituição: parâmetro, comando e
aritmética. Substituições de parâmetros, que são descritas em detalhes na próxima seção,
assumir a forma $nome ou $ {...}; as substituições de comando assumem a forma $ (comando) ou
(obsoleto) `comando`ou (executado no ambiente atual) $ { comando;} e tira
traçando novas linhas; e as substituições aritméticas assumem a forma $ ((expressão)). Analisando o
a substituição do comando do ambiente atual requer um espaço, tabulação ou nova linha após a abertura
chave e que a chave de fechamento seja reconhecida como uma palavra-chave (ou seja, é precedida por uma nova linha
ou ponto e vírgula). Eles também são chamados de funsubs (substituições de função) e se comportam como
funções naquele local e retorno trabalho, e naquele saída termina o shell pai; Concha
opções são compartilhadas.

Outra variante de substituição são os valsubs (substituições de valor) $ {|comando;} que são
também executado no ambiente atual, como funsubs, mas compartilha sua E / S com o pai;
em vez disso, eles avaliam para qualquer que seja a variável local de expressão REPLY, inicialmente vazia
definido para dentro do comandos.

Se uma substituição aparecer fora das aspas duplas, os resultados da substituição são
geralmente sujeito a palavra ou divisão de campo de acordo com o valor atual do IFS
parâmetro. O parâmetro IFS especifica uma lista de octetos que são usados ​​para quebrar uma string
em várias palavras; quaisquer octetos do espaço definido, guia e nova linha que aparecem no IFS
os octetos são chamados de “espaços em branco IFS”. Sequências de um ou mais octetos de espaço em branco IFS, em
combinação com zero ou um octeto de espaço em branco não IFS, delimita um campo. Como um caso especial,
os espaços em branco IFS à esquerda e à direita são eliminados (ou seja, nenhum campo vazio à esquerda ou à direita é
criado por ele); o espaço em branco não IFS à esquerda ou à direita cria um campo vazio.

Exemplo: Se IFS estiver definido como “ : ”, E VAR é definido como
“ UMA : B :: D ”, a substituição por $ VAR resulta em quatro campos: 'A',
'B', '' (um campo vazio) e 'D'. Observe que se o parâmetro IFS for definido como vazio
string, nenhuma divisão de campo é feita; se não estiver definido, o valor padrão de espaço, tabulação e
newline é usado.

Além disso, observe que a divisão de campo se aplica apenas ao resultado imediato do
substituição. Usando o exemplo anterior, a substituição de $ VAR: E resulta no
campos: 'A', 'B', '' e 'D: E', não 'A', 'B', '', 'D' e 'E'. Este comportamento é POSIX
compatível, mas incompatível com algumas outras implementações de shell que fazem divisão de campo
na palavra que continha a substituição ou use IFS como um delimitador de espaço em branco geral.

Os resultados da substituição são, a menos que especificado de outra forma, também sujeitos à expansão da chave
e expansão do nome do arquivo (consulte as seções relevantes abaixo).

Uma substituição de comando é substituída pela saída gerada pelo comando especificado que é
executado em um subshell. Por $ (comando) e $ {|comando;} e $ { comando;} substituições, normal
as regras de citação são usadas quando comando é analisado; no entanto, para o obsoleto `comando`forma, um
'\' seguido por qualquer um de '$', '`' ou '\' é removido (como é '"' quando a substituição é parte
de uma string com aspas duplas); uma barra invertida '\' seguida por qualquer outro caractere permanece inalterada.
Como um caso especial em substituições de comandos, um comando do formuláriolima é interpretado para
significa substituir o conteúdo de lima. Observe que $ ( tem o mesmo efeito que $ (gato foo).

Observe que alguns shells não usam um analisador recursivo para substituições de comando, levando a
falha para certas construções; para ser portátil, use como solução alternativa 'x = $ (cat) << "EOF"' (ou o
manutenção de nova linha 'x = << "EOF"' extensão) em vez de meramente slurp a string. IEEE Std 1003.1
(“POSIX.1”) recomenda o uso de declarações de caso da forma 'x = $ (case $ foo em (bar) echo $ bar
;; (*) echo $ baz ;; esac) 'em vez disso, o que funcionaria, mas não serviria de exemplo para este
problema de portabilidade.

x = $ (case $ foo em bar) echo $ bar ;; *) echo $ baz ;; esac)
# acima falha ao analisar em shells antigos; abaixo está a solução alternativa
x = $ (eval $ (cat)) << "EOF"
caso $ foo em bar) echo $ bar ;; *) echo $ baz ;; esac
EOF

As substituições aritméticas são substituídas pelo valor da expressão especificada. Para
exemplo, o comando impressão $ ((2 + 3 * 4)) exibe 14. Veja Aritmética expressões para uma
descrição de uma expressão.

parâmetros
Os parâmetros são variáveis ​​de shell; eles podem receber valores atribuídos e seus valores podem ser acessados
usando uma substituição de parâmetro. Um nome de parâmetro é um dos únicos especiais
parâmetros de pontuação ou caracteres de dígito descritos abaixo, ou uma letra seguida por zero ou
mais letras ou dígitos ('_' conta como uma letra). A última forma pode ser tratada como matrizes
anexando um índice de matriz da forma [expr] Onde expr é uma expressão aritmética.
Índices de matriz em Obrigado estão limitados ao intervalo de 0 a 4294967295, inclusive. Aquilo é,
eles são um inteiro sem sinal de 32 bits.

As substituições de parâmetros assumem a forma $nome, $ {nome} ou $ {nome[expr]} Onde nome é um
nome do parâmetro. Substituição de todos os elementos da matriz por $ {nome[*]} e $ {nome[@]} funciona
equivalente a $ * e $ @ para parâmetros posicionais. Se a substituição for realizada em um
parâmetro (ou um elemento de parâmetro de matriz) que não está definido, uma string nula é substituída
a menos que conjunto de substantivos opção (conjunto -o conjunto de substantivos or conjunto -u) é definido, caso em que ocorre um erro.

Os parâmetros podem ser atribuídos a valores de várias maneiras. Primeiro, o shell define implicitamente
alguns parâmetros como '#', 'PWD' e '$'; esta é a única maneira de o caractere único especial
parâmetros são definidos. Em segundo lugar, os parâmetros são importados do ambiente do shell em
comece. Terceiro, os parâmetros podem receber valores na linha de comando: por exemplo, FOO = bar
define o parâmetro “FOO” para “bar”; múltiplas atribuições de parâmetros podem ser dadas em um único
linha de comando e eles podem ser seguidos por um comando simples, caso em que as atribuições são
em vigor apenas para a duração do comando (tais atribuições também são exportadas; consulte
abaixo para as implicações disso). Observe que tanto o nome do parâmetro quanto o '=' devem ser
sem aspas para que o shell reconheça uma atribuição de parâmetro. A construção FOO + = baz É também
reconhecido; os valores antigos e novos são imediatamente concatenados. A quarta forma de configuração
um parâmetro está com o exportar, global, somente leitura e formatado comandos; ver o deles
descrições no Command execução seção. Quinto, para e selecionar loops definir parâmetros
bem como o obter opções, ler e conjunto -A comandos. Por último, os parâmetros podem ser atribuídos
valores usando operadores de atribuição dentro de expressões aritméticas (ver Aritmética expressões
abaixo) ou usando o $ {nome=valor} forma de substituição do parâmetro (veja abaixo).

Parâmetros com o atributo de exportação (definido usando o exportar or formatado -x comandos, ou por
atribuições de parâmetros seguidos de comandos simples) são colocados no ambiente (ver
ambiente(7)) de comandos executados pelo shell como nome=valor pares. A ordem em que os parâmetros
aparecem no ambiente de um comando não é especificado. Quando o shell é inicializado,
extrai parâmetros e seus valores de seu ambiente e define automaticamente a exportação
atributo para esses parâmetros.

Modificadores podem ser aplicados ao $ {nome} forma de substituição de parâmetro:

${nome:-palavra}
If nome é definido e não NULL, ele é substituído; de outra forma, palavra é substituído.

${nome:+palavra}
If nome está definido e não NULL, palavra é substituído; caso contrário, nada é substituído.

${nome:=palavra}
If nome é definido e não NULL, ele é substituído; caso contrário, é atribuído palavra e
o valor resultante de nome é substituído.

${nome:?palavra}
If nome é definido e não NULL, ele é substituído; de outra forma, palavra é impresso em
erro padrão (precedido por nome:) e ocorre um erro (normalmente causando o encerramento
de um script de shell, função ou script originado usando o caractere '.' construídas em). Se palavra is
omitido, a string “parâmetro nulo ou não definido” é usada em seu lugar. Atualmente um bug,
if palavra é uma variável que se expande para a string nula, a mensagem de erro também é
impresso.

Observe que, para todos os itens acima, palavra é realmente considerado citado, e análise especial
regras se aplicam. As regras de análise também diferem quanto ao fato de a expressão estar entre aspas: palavra
então usa as regras de aspas duplas, exceto para as próprias aspas duplas ('"') e o fechamento
chave, que, se houver escape da barra invertida, será aplicada a remoção da citação.

Nos modificadores acima, o ':' pode ser omitido, caso em que as condições dependem apenas de
nome sendo definido (em oposição a definir e não NULL). Se palavra é necessário, parâmetro, comando,
aritmética e substituição de til são executadas nele; E se palavra não é necessário, não é
avaliado.

As seguintes formas de substituição de parâmetro também podem ser usadas (se nome é um array, o
elemento com a chave “0” será substituído no contexto escalar):

$ {#nome}
O número de parâmetros posicionais se nome é '*', '@' ou não especificado; de outra forma
o comprimento (em caracteres) do valor da string do parâmetro nome.

$ {#nome[*]}
$ {#nome[@]}
O número de elementos na matriz nome.

$ {%nome}
A largura (em colunas da tela) do valor da string do parâmetro nome, ou -1 se
${nome} contém um caractere de controle.

$ {!nome}
O nome da variável referida por nome. Isto será nome exceto quando nome is
uma referência de nome (variável ligada), criada pelo nomeref comando (que é um apelido
para formatado -n).

$ {!nome[*]}
$ {!nome[@]}
Os nomes dos índices (chaves) na matriz nome.

${nome#de cinto de segurança}
${nome##de cinto de segurança}
If de cinto de segurança corresponde ao início do valor do parâmetro nome, o texto correspondente é
eliminado do resultado da substituição. Um único '#' resulta no mais curto
partida, e duas delas resultam na partida mais longa. Não pode ser aplicado a um vetor
($ {*} ou $ {@} ou $ {array [*]} ou $ {array [@]}).

${nome%de cinto de segurança}
${nome%%de cinto de segurança}
Como $ {.. # ..} substituição, mas exclui do final do valor. Não pode ser
aplicado a um vetor.

${nome/padrão / string}
${nome/#padrão / string}
${nome/%padrão / string}
${nome//padrão / string}
A partida mais longa de de cinto de segurança no valor do parâmetro nome é substituído por corda
(excluído se corda está vazia; a barra final ('/') pode ser omitida nesse caso).
Uma barra inicial seguida por '#' ou '%' faz com que o padrão seja ancorado no
início ou fim do valor, respectivamente; vazio não ancorado de cinto de seguranças causa não
substituição; uma única barra inicial ou o uso de um de cinto de segurança que corresponde ao vazio
string faz com que a substituição ocorra apenas uma vez; duas barras iniciais causam todos
ocorrências de correspondências no valor a ser substituído. Não pode ser aplicado a um vetor.
Implementado de forma ineficiente, pode ser lento.

${nome:postar:len}
O primeiro len personagens de nome, começando na posição postar, são substituídos. Ambos
postar e:len são opcionais. Se postar é negativo, a contagem começa no final do
corda; se for omitido, o padrão é 0. Se len é omitido ou maior que o
comprimento da corda restante, tudo isso é substituído. Ambos postar e len e guarante que os mesmos estão
avaliadas como expressões aritméticas. Atualmente, postar deve começar com um espaço,
abrindo parênteses ou dígito a ser reconhecido. Não pode ser aplicado a um vetor.

${nome@ #}
O hash (usando o algoritmo BAFH) da expansão de nome. Isso também é usado
internamente para os hashtables do shell.

${nome@Q}
Uma expressão entre aspas segura para reentrada, cujo valor é o valor de nome
parâmetro, é substituído.

Observe que de cinto de segurança pode precisar de um padrão de globbing estendido (@ (...)), único ('...') ou duplo
("...") citação escapando, a menos que -o sh é definido.

Os seguintes parâmetros especiais são configurados implicitamente pelo shell e não podem ser configurados diretamente
usando atribuições:

! ID de processo do último processo em segundo plano iniciado. Se nenhum processo em segundo plano tiver
foi iniciado, o parâmetro não está definido.

# O número de parâmetros posicionais ($ 1, $ 2, etc.).

$ O PID do shell ou o PID do shell original se for um subshell. Fazer NÃO
use este mecanismo para gerar nomes de arquivos temporários; Vejo mktemp(1) em vez disso.

- A concatenação das opções atuais de uma única letra (consulte o conjunto comando abaixo
para obter uma lista de opções).

? O status de saída do último comando não assíncrono executado. Se o último comando
foi morto por um sinal, $? é definido como 128 mais o número do sinal, mas no máximo 255.

0 O nome do shell, determinado da seguinte maneira: o primeiro argumento para Obrigado Se fosse
invocado com o -c opção e argumentos foram fornecidos; caso contrário, o lima argumento, se
foi fornecido; ou então o nome de base com o qual o shell foi chamado (ou seja, argv [0]). $ 0
também é definido com o nome do script atual ou o nome da função atual,
se foi definido com o função palavra-chave (ou seja, uma função de estilo de shell Korn).

1 .. 9 Os primeiros nove parâmetros posicionais que foram fornecidos ao shell, função ou
script originado usando o '.' construídas em. Outros parâmetros posicionais podem ser
acessado usando $ {número}.

* Todos os parâmetros posicionais (exceto 0), ou seja, $ 1, $ 2, $ 3, ...
Se usado fora das aspas duplas, os parâmetros são palavras separadas (que estão sujeitas
para a divisão de palavras); se usado entre aspas duplas, os parâmetros são separados por
primeiro caractere do parâmetro IFS (ou a string vazia se IFS for NULL).

@ Igual a $*, a menos que seja usado entre aspas duplas, caso em que uma palavra separada é
gerado para cada parâmetro posicional. Se não houver parâmetros posicionais, não
palavra é gerada. $@ pode ser usado para acessar argumentos, literalmente, sem perder
Argumentos NULL ou argumentos de divisão com espaços.

Os seguintes parâmetros são definidos e / ou usados ​​pelo shell:

_ (sublinhado) Quando um comando externo é executado pelo shell, este parâmetro
é definido no ambiente do novo processo para o caminho do executado
comando. No uso interativo, este parâmetro também é definido no shell pai para
a última palavra do comando anterior.

BASHPID O PID do shell ou subshell.

CDPATH Como PATH, mas usado para resolver o argumento para o cd comando embutido. Observação
que se CDPATH estiver definido e não contiver '.' ou um elemento de string vazio, o
o diretório atual não é pesquisado. Também o cd o comando embutido irá mostrar
o diretório resultante quando uma correspondência é encontrada em qualquer caminho de pesquisa diferente do
caminho vazio.

COLUNAS Definido para o número de colunas no terminal ou janela. Sempre definido, padrões
a 80, a menos que o valor conforme relatado por chiqueiro(1) é diferente de zero e lógico o suficiente
(o mínimo é 12x3); semelhante para LINES. Este parâmetro é usado pelo
modos de edição de linha interativa, e pelo selecionar, conjunto -o e matar -l comandos
para formatar colunas de informação. Importando do meio ambiente ou desarmando
este parâmetro remove a ligação com o tamanho real do terminal em favor do
valor fornecido.

ENV Se este parâmetro for definido após a execução de qualquer arquivo de perfil, o
o valor expandido é usado como um arquivo de inicialização do shell. Normalmente contém função
e definições de alias.

ERRNO Valor inteiro do shell erro variável. Indica o motivo do último
falha na chamada do sistema. Ainda não implementado.

EXECSHELL Se definido, este parâmetro é assumido como contendo o shell que deve ser usado para
executar comandos que execvo(2) falha ao executar e que não começa com um
“#!concha" seqüência.

FCEDIT O editor usado pelo fc comando (veja abaixo).

FPATH Como PATH, mas usado quando uma função indefinida é executada para localizar o arquivo
definir a função. Também é pesquisado quando um comando não pode ser encontrado usando
CAMINHO. Ver Funções abaixo para obter mais informações.

HISTFILE O nome do arquivo usado para armazenar o histórico de comandos. Quando atribuído ou não definido,
o arquivo é aberto, o histórico é truncado e carregado do arquivo; subseqüente
novos comandos (possivelmente consistindo em várias linhas) são acrescentados uma vez que eles
compilado com sucesso. Além disso, várias invocações do shell irão compartilhar
histórico se todos os seus parâmetros HISTFILE apontarem para o mesmo arquivo.

Note: Se HISTFILE não estiver definido ou vazio, nenhum arquivo de histórico será usado. Isto é
diferente de AT&T UNIX ksh.

HISTSIZE O número de comandos normalmente armazenados para histórico. O padrão é 2047. Faça
não definir esse valor para valores absurdamente altos, como 1000000000 porque Obrigado pode
então, não aloque memória suficiente para o histórico e não será iniciado.

HOME O diretório padrão para o cd comando e o valor substituído por um
não qualificado ~ (Vejo Til expansão abaixo).

Separador de campo interno IFS, usado durante a substituição e pelo ler comando, para
divida os valores em argumentos distintos; normalmente definido como espaço, tabulação e nova linha.
See Substituição acima para obter detalhes.

Note: Este parâmetro não é importado do ambiente quando o shell é
iniciado.

KSHEGID O id de grupo efetivo do shell.

KSHGID O ID de grupo real do shell.

KSHUID O ID de usuário real do shell.

KSH_VERSION O nome e a versão do shell (somente leitura). Veja também os comandos de versão
in Emacs edição modo e Vi edição modo seções, abaixo.

LINENO O número da linha da função ou script de shell que está sendo
executado.

LINHAS Defina o número de linhas no terminal ou janela. Sempre definido, o padrão é
24. Veja COLUNAS.

ÉPOCA
Tempo desde a época, conforme retornado por obterhoradodia(2), formatado como decimal
tv_sec seguido por um ponto ('.') e tv_usec preenchido com exatamente seis casas decimais
dígitos.

OLDPWD O diretório de trabalho anterior. Não definido se cd não mudou com sucesso
diretórios desde o início do shell, ou se o shell não sabe onde está.

OPTARG Ao usar obter opções, ele contém o argumento para uma opção analisada, se
requer um.

OPTIND O índice do próximo argumento a ser processado ao usar obter opções. Atribuindo 1
a este parâmetro causa obter opções para processar argumentos desde o início
na próxima vez que for invocado.

PATH Uma lista separada por dois pontos (ponto e vírgula em OS / 2) de diretórios que são pesquisados
ao procurar comandos e arquivos originados usando o '.' comando (veja abaixo).
Uma string vazia resultante de dois pontos à esquerda ou à direita, ou dois adjacentes
dois pontos, é tratado como um '.' (o diretório atual).

PGRP O ID do processo do líder do grupo de processos do shell.

PIPESTATUS Uma matriz contendo os códigos de nível de erro (status de saída), um por um, do último
pipeline executado em primeiro plano.

PPID O ID do processo do pai do shell.

PS1 O prompt principal para shells interativos. Parâmetro, comando e aritmética
substituições são realizadas, e '!' é substituído pelo comando atual
número (veja o fc comando abaixo). Um literal '!' pode ser colocado no prompt por
colocando '!!' no PS1.

O prompt padrão é '$' para usuários não root, '#' para root. Se Obrigado is
invocado por root e PS1 não contém um caractere '#', o valor padrão
será usado mesmo se PS1 já existir no ambiente.

A Obrigado distribuição vem com uma amostra ponto.mkshrc contendo um sofisticado
exemplo, mas você pode gostar do seguinte (observe que
$ {HOSTNAME: = $ (hostname)} e a cláusula de distinção root-vs-user são (em
este exemplo) executado no momento da atribuição PS1, enquanto $ USER e $ PWD são
escapou e, portanto, será avaliado cada vez que um prompt for exibido):

PS1 = '$ {USER: = $ (id -un)}' "@ $ {HOSTNAME: = $ (hostname)}: \ $ PWD $ (
if ((USER_ID)); então imprima \ $; else print \ #; fi) "

Observe que, como os editores de linha de comando tentam descobrir por quanto tempo o prompt
é (para que saibam a que distância está da borda da tela), códigos de escape no
prompt tendem a bagunçar as coisas. Você pode dizer ao shell para não contar com certeza
sequências (como códigos de escape) prefixando seu prompt com um caractere
(como Ctrl-A) seguido por um retorno de carro e delimitando o escape
códigos com este personagem. Quaisquer ocorrências desse personagem no prompt são
não impresso. A propósito, não me culpe por este hack; é derivado do
original ksh88(1), que imprimiu o caractere delimitador de forma que você estava fora do
sorte se você não tiver caracteres não imprimíveis.

Uma vez que barras invertidas e outros caracteres especiais podem ser interpretados pelo shell,
para definir PS1, escape a própria barra invertida ou use aspas duplas. O
o último é mais prático. Este é um exemplo mais complexo, evitando diretamente
insira caracteres especiais (por exemplo, com ^V no modo de edição emacs), que
incorpora o diretório de trabalho atual, em vídeo reverso (a cor funcionaria,
também), na string de prompt:

x = $ (imprimir \\ 001)
PS1 = "$ x $ (imprimir \\ r) $ x $ (tput so) $ x \ $ PWD $ x $ (tput se) $ x>"

Devido a uma forte sugestão de David G. Korn, Obrigado agora também suporta o
seguinte formulário:

PS1=$'\1\r\1\e[7m\1$PWD\1\e[0m\1> '

String de prompt secundária do PS2, por padrão '>', usada quando mais entrada é necessária para
complete um comando.

Prompt PS3 usado pelo selecionar declaração ao ler uma seleção do menu. O padrão
é '#? '.

PS4 Usado para prefixar comandos que são impressos durante o rastreamento de execução (consulte o conjunto
-x comando abaixo). Substituições de parâmetros, comandos e aritméticas são
executado antes de ser impresso. O padrão é '+'. Você pode querer configurá-lo
para '[$ EPOCHREALTIME]' em vez disso, para incluir carimbos de data / hora.

PWD O diretório de trabalho atual. Pode ser não definido ou NULL se o shell não souber
onde está.

RANDOM Cada vez que RANDOM é referenciado, é atribuído um número entre 0 e 32767
de um PRNG Linear Congruencial primeiro.

Parâmetro padrão REPLY para o ler comando se nenhum nome for fornecido. Também usado em
selecionar loops para armazenar o valor que é lido da entrada padrão.

SECONDS O número de segundos desde o início do shell ou, se o parâmetro foi
atribuído um valor inteiro, o número de segundos desde a atribuição mais o
valor que foi atribuído.

TMOUT Se definido como um número inteiro positivo em um shell interativo, ele especifica o máximo
número de segundos que o shell irá esperar pela entrada após imprimir o primário
prompt (PS1). Se o tempo for excedido, o shell sai.

TMPDIR Os arquivos de shell temporários do diretório são criados em. Se este parâmetro não for
definido, ou não contém o caminho absoluto de um diretório gravável, temporário
os arquivos são criados em / Tmp.

USER_ID O ID de usuário efetivo do shell.

Til expansão
A expansão de til, que é feita em paralelo com a substituição de parâmetro, é feita em palavras
começando com um '~' não citado. Os caracteres após o til, até o primeiro '/', se
any, são considerados um nome de login. Se o nome de login estiver vazio, '+' ou '-', o valor de
o parâmetro HOME, PWD ou OLDPWD é substituído, respectivamente. Caso contrário, a senha
arquivo é pesquisado para o nome de login, e a expressão til é substituída pelo usuário
diretório inicial. Se o nome de login não for encontrado no arquivo de senha ou se houver citação ou
a substituição do parâmetro ocorre no nome de login, nenhuma substituição é executada.

Em atribuições de parâmetros (como aqueles que precedem um comando simples ou aqueles que ocorrem no
argumentos de aliás, exportar, global, somente leitura e formatado), a expansão do til é feita após
qualquer atribuição (isto é, após o sinal de igual) ou após dois pontos não citados (':'); nomes de login
também são delimitados por dois pontos.

O diretório inicial de nomes de login previamente expandidos são armazenados em cache e reutilizados. o aliás -d
comando pode ser usado para listar, alterar e adicionar a este cache (por exemplo aliás -d
fac = / usr / local / instalações; cd ~ fac / bin).

Cinta expansão (alternância)
As expressões de chave assumem a seguinte forma:

prefixo{str1, ...,strN}sufixo

As expressões são expandidas para N palavras, cada uma das quais é a concatenação de prefixo, stri,
e sufixo (por exemplo, “a {c, b {X, Y}, d} e” se expande para quatro palavras: “ace”, “abXe”, “abYe” e “ade”).
Conforme observado no exemplo, as expressões de colchetes podem ser aninhadas e as palavras resultantes não são
classificado. As expressões de colchetes devem conter uma vírgula sem aspas (',') para que a expansão ocorra (por exemplo
{} e {foo} não são expandidos). A expansão da cinta é realizada após a substituição do parâmetro
e antes da geração do nome do arquivo.

Envie o nome padrões
Um padrão de nome de arquivo é uma palavra que contém um ou mais '?', '*', '+', '@' Ou '!'
caracteres ou sequências “[..]”. Uma vez que a expansão da chave foi realizada, o shell substitui
padrões de nome de arquivo com os nomes classificados de todos os arquivos que correspondem ao padrão (se não
os arquivos coincidirem, a palavra não será alterada). Os elementos do padrão têm o seguinte significado:

? Corresponde a qualquer caractere único.

* Corresponde a qualquer sequência de octetos.

[..] Corresponde a qualquer um dos octetos dentro dos colchetes. Intervalos de octetos podem ser especificados por
separar dois octetos por um '-' (por exemplo, “[a0-9]” corresponde à letra 'a' ou qualquer dígito).
Para representar a si mesmo, um '-' deve ser colocado entre aspas ou o primeiro ou o último octeto
na lista de octetos. Da mesma forma, um ']' deve ser colocado entre aspas ou o primeiro octeto da lista
se é para representar a si mesmo em vez do fim da lista. Também um '!' aparecendo
no início da lista tem um significado especial (veja abaixo), para representá-lo
deve ser citado ou aparecer mais tarde na lista.

[! ..] Semelhante a [..], exceto que corresponde a qualquer octeto que não esteja entre colchetes.

*(de cinto de segurança| ... |de cinto de segurança)
Corresponde a qualquer string de octetos que corresponda a zero ou mais ocorrências do especificado
padrões. Exemplo: o padrão * (foo|Barra) corresponde às strings “”, “foo”, “bar”,
“Foobarfoo”, etc.

+(de cinto de segurança| ... |de cinto de segurança)
Corresponde a qualquer string de octetos que corresponda a uma ou mais ocorrências do especificado
padrões. Exemplo: o padrão + (foo|Barra) corresponde às strings "foo", "bar",
“Foobar”, etc.

?(de cinto de segurança| ... |de cinto de segurança)
Corresponde à string vazia ou a uma string que corresponda a um dos padrões especificados.
Exemplo: o padrão ? (foo|Barra) corresponde apenas às strings “”, “foo” e “bar”.

@(de cinto de segurança| ... |de cinto de segurança)
Corresponde a uma string que corresponde a um dos padrões especificados. Exemplo: o padrão
@ (foo|Barra) corresponde apenas às strings “foo” e “bar”.

!(de cinto de segurança| ... |de cinto de segurança)
Corresponde a qualquer string que não corresponda a um dos padrões especificados. Exemplos:
de cinto de segurança ! (foo|Barra) corresponde a todas as strings, exceto “foo” e “bar”; o padrão ! (*)
não corresponde a nenhuma string; o padrão ! (?) * corresponde a todas as strings (pense nisso).

Observe que globbing complicado, especialmente com alternativas, é lento; usando separado
as comparações podem (ou não) ser mais rápidas.

Observe que Obrigado (E por exemplo) nunca corresponde a '.' e '..', mas AT&T UNIX kshBourne she GNU
bater fazer.

Observe que nenhum dos elementos do padrão acima corresponde a um ponto ('.') No início de um
nome do arquivo ou uma barra ('/'), mesmo se forem usados ​​explicitamente em uma sequência [..]; também o
nomes '.' e '..' nunca são correspondidos, mesmo pelo padrão '. *'.

Se o markdirs opção for definida, todos os diretórios que resultam da geração do nome do arquivo são
marcado com um final '/'.

Input / output redirecionamento
Quando um comando é executado, sua entrada padrão, saída padrão e erro padrão (arquivo
descritores 0, 1 e 2, respectivamente) são normalmente herdados do shell. Três
exceções a isso são comandos em pipelines, para os quais entrada padrão e / ou padrão
saída são aqueles configurados pelo pipeline, comandos assíncronos criados quando o controle de trabalho é
desativado, para o qual a entrada padrão é inicialmente definida para ser de / dev / null, e comandos para
em que qualquer um dos seguintes redirecionamentos foi especificado:

>lima A saída padrão é redirecionada para lima. Se lima não existe, é criado;
se existir, é um arquivo normal, e o nocturno opção está definida, um erro
ocorre; caso contrário, o arquivo será truncado. Observe que isso significa o comando cmd
<foo > foo vai abrir Foo para ler e, em seguida, truncar quando abrir para
escrevendo, antes cmd tem a chance de realmente ler Foo.

>|lima Igual a >, exceto que o arquivo é truncado, mesmo se o nocturno opção está definida.

>>lima Igual a >, exceto se lima existe ao qual é anexado em vez de ser truncado.
Além disso, o arquivo é aberto no modo anexar, portanto, as gravações sempre vão para o final do
arquivo (ver aberto(2)).

<lima A entrada padrão é redirecionada de lima, que é aberto para leitura.

<>lima Igual a <, exceto que o arquivo é aberto para leitura e gravação.

<<marcador Depois de ler a linha de comando contendo este tipo de redirecionamento (chamado de
“Aqui documento”), o shell copia as linhas da fonte de comando em um
arquivo temporário até uma linha correspondente marcador está lido. Quando o comando é
executado, a entrada padrão é redirecionada do arquivo temporário. Se marcador
não contém caracteres entre aspas, o conteúdo do arquivo temporário é processado
como se estivesse entre aspas cada vez que o comando é executado, então o parâmetro,
comando, e as substituições aritméticas são realizadas, junto com a barra invertida ('\')
escapa para '$', '`', '\' e '\ newline', mas não para '"'. Se houver vários aqui
os documentos são usados ​​na mesma linha de comando e são salvos em ordem.

Se nenhum marcador é fornecido, o documento aqui termina no próximo << e substituição
será realizado. Se marcador é apenas um conjunto de “''” simples ou duplo '""'
aspas sem nada no meio, o documento aqui termina na próxima linha vazia
e a substituição não será realizada.

<< -marcador Igual a <<, exceto as guias iniciais são removidas das linhas no documento aqui.

<<palavra Igual a <<, exceto que palavra is o documento aqui. Isso é chamado de aqui
string.

<&fd A entrada padrão é duplicada do descritor de arquivo fd. fd pode ser um número,
indicando o número de um descritor de arquivo existente; a letra 'p', indicando
o descritor de arquivo associado à saída do co-processo atual; ou o
caractere '-', indicando que a entrada padrão deve ser fechada. Observe que fd is
limitado a um único dígito na maioria das implementações de shell.

>&fd Igual a <&, exceto que a operação é feita na saída padrão.

&>lima Igual a >lima 2> e 1. Este é um GNU obsoleto (legado) bater extensão suportada
by Obrigado que também suporta o número fd explícito anterior, por exemplo,
3 e>lima é o mesmo que 3>lima 2> e 3 in Obrigado mas um erro de sintaxe em GNU bater.

&> |lima, & >>lima, &> &fd
Igual a >|lima, >>limaou >&fd, Seguido por 2> e 1, como acima. Estes são Obrigado
extensões.

Em qualquer um dos redirecionamentos acima, o descritor de arquivo que é redirecionado (ou seja, padrão
entrada ou saída padrão) pode ser explicitamente dada precedendo o redirecionamento com um número
(portável, apenas um único dígito). Parâmetro, comando e substituições aritméticas, til
substituições e (se o shell for interativo) geração de nome de arquivo são todas realizadas em
que o lima, marcador e fd argumentos de redirecionamentos. Observe, no entanto, que os resultados de qualquer
a geração de nome de arquivo é usada apenas se um único arquivo for correspondido; se vários arquivos corresponderem, o
palavra com os caracteres de geração de nome de arquivo expandido. Observe que no restrito
shells, redirecionamentos que podem criar arquivos não podem ser usados.

Para comandos simples, os redirecionamentos podem aparecer em qualquer lugar no comando; para comandos compostos
(if declarações, etc.), quaisquer redirecionamentos devem aparecer no final. Redirecionamentos são processados
depois que os pipelines são criados e na ordem em que são fornecidos, o seguinte imprimirá um
erro com um número de linha anexado a ele:

$ cat / foo / bar 2> & 1> / dev / null | pr -n -t

Os descritores de arquivo criados por redirecionamentos de E / S são privados para o shell.

Aritmética expressões
Expressões aritméticas inteiras podem ser usadas com o deixar comando, dentro de expressões $ ((..)),
dentro de referências de array (por exemplo nome[expr]), como argumentos numéricos para o teste comando, e como
o valor de uma atribuição a um parâmetro inteiro. Aviso: Isso também afeta implícito
conversão para inteiro, por exemplo, feito pelo deixar comando. Nunca usar usuário não verificado
entrada, por exemplo, do meio ambiente, em aritmética!

As expressões são calculadas usando aritmética com sinais e o mksh_ari_t tipo (um assinado de 32 bits
inteiro), a menos que comecem com um único caractere '#', caso em que usam mksh_uari_t (a
Inteiro sem sinal de 32 bits).

As expressões podem conter identificadores de parâmetros alfanuméricos, referências de matriz e números inteiros
constantes e podem ser combinados com os seguintes operadores C (listados e agrupados em
ordem crescente de precedência):

Operadores unários:

+ -! ~ ++ -

Operadores binários:

,
= + = - = * = / =% = <<< = >>> = << = >> = & = ^ = | =
||
&&
|
^
&
==! =
<<=>> =
<<< >>> << >>
+ -
* /%

Operadores ternários:

?: (a precedência é imediatamente superior à atribuição)

Operadores de agrupamento:

()

As constantes e expressões inteiras são calculadas usando uma largura de exatamente 32 bits, assinada ou
unsigned, digite com wraparound silencioso em estouro de inteiro. Constantes inteiras podem ser
especificado com bases arbitrárias usando a notação base#número, Onde base é um decimal
inteiro especificando a base, e número é um número na base especificada. Adicionalmente,
inteiros de base 16 podem ser especificados prefixando-os com '0x' (não diferencia maiúsculas de minúsculas) em todos
formas de expressões aritméticas, exceto como argumentos numéricos para o teste comando embutido.
Prefixar números com um único dígito zero ('0') não causa interpretação como octal, como
isso é inseguro de fazer.

Como um especial Obrigado extensão, os números à base de um são tratados como (8 bits
transparente) pontos de código ASCII ou Unicode, dependendo do shell modo utf8 bandeira (atual
contexto). O AT&T UNIX ksh93 sintaxe de “'x'” em vez de “1 # x” também é suportada. Observação
que bytes NUL (valor integral de zero) não podem ser usados. Um parâmetro não definido ou vazio
avalia como 0 no contexto de inteiro. No modo Unicode, os octetos brutos são mapeados no intervalo
EF80..EFFF como em OPTU-8, que está no PUA e foi atribuído pelo CSUR para este uso. Se
mais de um octeto no modo ASCII, ou uma sequência de mais de um octeto não formando um
e a sequência mínima CESU-8 é passada, o comportamento é indefinido (geralmente, o shell aborta
com um erro de análise, mas raramente é bem-sucedido, por exemplo, na sequência C2 20). É por isso que você
deve sempre usar o modo ASCII, a menos que você saiba que a entrada é UTF-8 bem formado no
intervalo de 0000..FFFD se você usar este recurso, ao contrário de ler -a.

Os operadores são avaliados da seguinte forma:

+ unário
O resultado é o argumento (incluído para integridade).

unário -
Negação.

! NOT lógico; o resultado é 1 se o argumento for zero, 0 se não for.

~ NÃO aritmética (bit a bit).

++ Incremento; deve ser aplicado a um parâmetro (não a um literal ou outra expressão).
O parâmetro é incrementado em 1. Quando usado como um operador de prefixo, o resultado
é o valor incrementado do parâmetro; quando usado como um operador postfix,
o resultado é o valor original do parâmetro.

-- Igual a ++, exceto que o parâmetro é diminuído em 1.

, Separa duas expressões aritméticas; o lado esquerdo é avaliado primeiro,
então a direita. O resultado é o valor da expressão à direita
lado.

= Atribuição; a variável à esquerda é definida com o valor à direita.

+ = - = * = / =% = <<< = >>> = << = >> = & = ^ = | =
Operadores de atribuição.var><op> =expr> é o mesmo quevar> =var><op><expr>,
com qualquer precedência de operador emexpr> preservado. Por exemplo, “var1 * = 5 +
3 ”é o mesmo que especificar“ var1 = var1 * (5 + 3) ”.

|| OR lógico; o resultado é 1 se qualquer argumento for diferente de zero, 0 se não for. O
o argumento direito é avaliado apenas se o argumento esquerdo for zero.

&& Logical AND; o resultado é 1 se ambos os argumentos forem diferentes de zero, 0 se não forem. O
o argumento direito é avaliado apenas se o argumento esquerdo for diferente de zero.

| Aritmética (bit a bit) OU.

^ XOR aritmético (bit a bit) (OU exclusivo).

& Aritmética (bit a bit) AND.

== Igual; o resultado é 1 se ambos os argumentos forem iguais, 0 se não forem.

! = Diferente; o resultado é 0 se ambos os argumentos forem iguais, 1 caso contrário.

<Menor que; o resultado é 1 se o argumento esquerdo for menor que o direito, 0 se
não.

<=>> =
Menor ou igual, maior que, maior ou igual. Ver <.

<<< >>>
Gire para a esquerda (direita); o resultado é semelhante ao deslocamento (ver <<) exceto que o
bits deslocados em uma extremidade são deslocados na outra extremidade, em vez de zero
ou assinar bits.

<< >> Shift esquerda (direita); o resultado é o argumento da esquerda com seus bits deslocados para a esquerda
(à direita) pelo valor fornecido no argumento correto.

+ - * /
Adição, subtração, multiplicação e divisão.

% Restante; o resultado é o resto simétrico da divisão da esquerda
argumento pela direita. Para obter o módulo matemático de “a mod b ”, use o
fórmula “(a% b + b)% b”.

<argumento1>?argumento2>:argumento3>
E seargumento1> é diferente de zero, o resultado éargumento2>; caso contrário, o resultado éargumento3>.
O argumento sem resultado não é avaliado.

Co-processos
Um co-processo (que é um pipeline criado com o operador '| &') é um processo assíncrono
em que o shell pode escrever (usando impressão -p) e ler (usando ler -p) A entrada
e a saída do co-processo também pode ser manipulada usando > & p e <& p redirecionamentos,
respectivamente. Uma vez que um co-processo tenha sido iniciado, outro não pode ser iniciado até que o co-
saídas do processo ou até que a entrada do co-processo seja redirecionada usando um exec n> & p
redirecionamento. Se a entrada de um co-processo for redirecionada desta forma, o próximo co-processo será
iniciado irá compartilhar a saída com o primeiro co-processo, a menos que a saída do
o co-processo foi redirecionado usando um exec n<& p redirecionamento.

Algumas notas sobre co-processos:

· A única maneira de fechar a entrada do co-processo (para que o co-processo leia um fim de arquivo) é
para redirecionar a entrada para um descritor de arquivo numerado e, em seguida, fechar esse descritor de arquivo:
exec 3> & p; exec 3> & -

· Para que os co-processos compartilhem uma saída comum, o shell deve manter a gravação
parte do tubo de saída aberta. Isso significa que o fim do arquivo não será detectado até
todos os co-processos que compartilham a saída do co-processo foram encerrados (quando todos eles saem, o
shell fecha sua cópia do tubo). Isso pode ser evitado redirecionando a saída para um
descritor de arquivo numerado (pois isso também faz com que o shell feche sua cópia). Observe que
este comportamento é ligeiramente diferente do shell Korn original que fecha sua cópia
da parte de gravação da saída do co-processo quando o co-processo mais recente começou
(em vez de quando todos os co-processos de compartilhamento) são encerrados.

· impressão -p irá ignorar os sinais SIGPIPE durante as gravações se o sinal não estiver sendo capturado ou
ignorado; o mesmo é verdade se a entrada do co-processo foi duplicada para outro arquivo
descritor e impressão -un é usado.

Funções
As funções são definidas usando o shell Korn função nome da função sintaxe ou o
Shell Bourne / POSIX nome da função() sintaxe (veja abaixo a diferença entre os dois
formulários). As funções são como.-Scripts (ou seja, scripts originados usando o '.' Integrado) em que
eles são executados no ambiente atual. No entanto, ao contrário dos scripts., Argumentos de shell
(ou seja, os parâmetros posicionais $ 1, $ 2, etc.) nunca são visíveis dentro deles. Quando a casca é
determinando a localização de um comando, as funções são pesquisadas após especial embutido
comandos, antes de builtins e o PATH é pesquisado.

Uma função existente pode ser excluída usando não definido -f nome da função. Uma lista de funções pode
ser obtido usando formatado +f e as definições de função podem ser listadas usando formatado -f.
A autoload comando (que é um apelido para formatado -fu) pode ser usado para criar indefinido
funções: quando uma função indefinida é executada, o shell procura o caminho especificado em
o parâmetro FPATH para um arquivo com o mesmo nome da função que, se encontrada, é lida
e executado. Se depois de executar o arquivo a função nomeada for considerada definida, o
função é executada; caso contrário, a pesquisa normal do comando é continuada (ou seja, o shell
pesquisa a tabela de comandos internos regulares e PATH). Observe que se um comando não for encontrado
usando PATH, é feita uma tentativa de carregar automaticamente uma função usando FPATH (este é um não documentado
recurso do shell Korn original).

As funções podem ter dois atributos, "trace" e "export", que podem ser definidos com formatado -pés
e formatado -fx, respectivamente. Quando uma função rastreada é executada, o shell xtrace
opção é ativada para a duração da função. O atributo de “exportação” das funções é
atualmente não usado. No shell Korn original, as funções exportadas são visíveis para o shell
scripts que são executados.

Uma vez que as funções são executadas no ambiente shell atual, as atribuições de parâmetros feitas
as funções internas ficam visíveis após a conclusão da função. Se este não for o desejado
efeito, o formatado O comando pode ser usado dentro de uma função para criar um parâmetro local. Observação
aquele AT&T UNIX ksh93 usa escopo estático (um escopo global, um escopo local por função)
e permite variáveis ​​locais apenas em funções de estilo Korn, enquanto Obrigado usa escopo dinâmico
(escopos aninhados de localidade variável). Observe que os parâmetros especiais (por exemplo $$, $!) não pode ser
com escopo definido desta forma.

O status de saída de uma função é o do último comando executado na função. UMA
função pode ser feita para terminar imediatamente usando o retorno comando; isso também pode ser usado
para especificar explicitamente o status de saída.

Funções definidas com o função palavras reservadas são tratadas de forma diferente no seguinte
formas de funções definidas com o () notação:

· O parâmetro $ 0 é definido com o nome da função (funções de estilo Bourne deixam $ 0
intocado).

· As atribuições de parâmetros que precedem as chamadas de função não são mantidas no ambiente de shell
(a execução de funções do estilo Bourne manterá as atribuições).

· OPTIND é salvo / redefinido e restaurado na entrada e saída da função, obter opções pode ser
usado corretamente dentro e fora da função (funções de estilo Bourne deixam OPTIND
intocado, então usando obter opções dentro de uma função interfere com o uso obter opções fora da
função).

· Opções de shell (conjunto -o) têm escopo local, ou seja, as alterações dentro de uma função são redefinidas após
sua saída.

No futuro, as seguintes diferenças também podem ser adicionadas:

· Um ambiente de trap / sinal separado será usado durante a execução das funções. Isto
significará que as armadilhas definidas dentro de uma função não afetarão as armadilhas e sinais do shell
que não são ignorados no shell (mas podem estar presos) terão seu efeito padrão em
uma função.

· O trap EXIT, se definido em uma função, será executado após o retorno da função.

Command execução
Após a avaliação dos argumentos da linha de comando, redirecionamentos e atribuições de parâmetros, o
o tipo de comando é determinado: um comando interno especial, uma função, um comando interno normal ou
o nome de um arquivo a ser executado encontrado usando o parâmetro PATH. As verificações são feitas no
acima da ordem. Comandos embutidos especiais diferem de outros comandos em que o PATH
parâmetro não é usado para encontrá-los, um erro durante sua execução pode causar um erro
shell interativo para sair e atribuições de parâmetro que são especificadas antes do comando
são mantidos após a conclusão do comando. Os comandos integrados regulares são diferentes apenas no
o parâmetro PATH não é usado para localizá-los.

O original ksh e POSIX diferem um pouco em quais comandos são considerados especiais ou
regular.

Utilitários integrados especiais POSIX:

., :, quebrar, continuar, avaliação, exec, saída, exportar, somente leitura, retorno, conjunto, mudança, vezes, armadilha,
não definido

Adicional Obrigado comandos que mantêm atribuições:

builtin, global, fonte, formatado, esperar

Embutidos que não são especiais:

[, aliás, bg, vincular, gato, cd, comando, eco, falso, fc, fg, obter opções, empregos, matar, deixar, impressão,
pwd, ler, caminho real, rebatizar, dormir, suspender, teste, verdadeiro, ulimit, umask, Unalias, donde

Uma vez que o tipo de comando foi determinado, qualquer atribuição de parâmetro de linha de comando é
executado e exportado durante o comando.

O seguinte descreve os comandos integrados especiais e regulares e os comandos reservados semelhantes
palavras:

. lima [arg ...]
Isso é chamado de comando “ponto”. Execute os comandos em lima na corrente
ambiente. O arquivo é procurado nos diretórios de PATH. Se os argumentos são
dado, os parâmetros posicionais podem ser usados ​​para acessá-los enquanto lima está a ser
executado. Se nenhum argumento for fornecido, os parâmetros posicionais são aqueles do
ambiente em que o comando é usado.

: [...]
O comando nulo. O status de saída é definido como zero.

[ expressão ]
See teste.

aliás [-d | -t [-r] + -x] [-p] [+] [nome [=valor] ...]
Sem argumentos, aliás lista todos os apelidos. Para qualquer nome sem valor, o
alias existente é listado. Qualquer nome com um valor define um alias (ver Alias
acima).

Ao listar apelidos, um dos dois formatos é usado. Normalmente, os aliases são listados como
nome=valor, Onde valor é citado. Se as opções forem precedidas de '+' ou um '+'
é fornecido na linha de comando, apenas nome é impresso.

A -d opção faz com que os aliases de diretório que são usados ​​na expansão do til sejam listados
ou definir (ver Til expansão acima).

Se o -p opção for usada, cada alias é prefixado com a string “alias”.

A -t opção indica que os aliases rastreados devem ser listados / configurados (valores especificados
na linha de comando são ignorados para aliases rastreados). O -r opção indica que
todos os aliases rastreados devem ser redefinidos.

A -x conjuntos de opções (+x limpa) o atributo de exportação de um alias ou, se nenhum nome for
dado, lista os aliases com o atributo de exportação (exportar um alias não tem
efeito).

bg [trabalho ...]
Retome o (s) trabalho (s) interrompido (s) especificado (s) em segundo plano. Se nenhum trabalho for especificado, %+
é assumido. Ver Trabalho ao controle abaixo para obter mais informações.

vincular [-l]
As ligações atuais são listadas. Se o -l bandeira é dada, vincular em vez disso, lista o
nomes das funções às quais as teclas podem ser associadas. Ver Emacs edição modo para mais
informações.

vincular [-m] corda=[substituto] ...
vincular corda=[comando de edição] ...
O comando de edição especificado está vinculado ao dado corda, que deve consistir em um
caractere de controle opcionalmente precedido por um dos dois caracteres de prefixo e
opcionalmente sucedido por um caractere til. Futura entrada do corda irá fazer com que o
comando de edição a ser invocado imediatamente. Se o -m sinalizador é dado, o especificado
entrada corda será posteriormente substituído imediatamente pelo dado substituto corda
que pode conter comandos de edição, mas não outras macros. Se um postfix de til é
dado, um til após um ou dois prefixos e o caractere de controle é ignorado,
qualquer outro caractere final será processado posteriormente.

Os caracteres de controle podem ser escritos usando a notação circunflexa, ou seja, ^ X representa Ctrl-X.
Observe que embora apenas dois caracteres de prefixo (geralmente ESC e ^ X) sejam suportados,
algumas sequências de vários caracteres podem ser suportadas.

As seguintes ligações padrão mostram como as teclas de seta, home, end e tecla delete
em um BSD wsvt25, xterm-xfree86 ou terminal de tela GNU estão ligados (é claro que alguns
as sequências de escape não funcionarão muito bem):

vincular '^ X' = prefixo-2
vincular '^ [[' = prefixo-2
vincular '^ XA' = histórico de atualização
vincular '^ XB' = histórico de down
vincular '^ XC' = forward-char
vincular '^ XD' = backward-char
vincular '^ X1 ~' = início da linha
vincular '^ X7 ~' = início da linha
vincular '^ XH' = início da linha
vincular '^ X4 ~' = fim de linha
vincular '^ X8 ~' = fim de linha
vincular '^ XF' = fim de linha
vincular '^ X3 ~' = delete-char-forward

quebrar [nível]
Saia do nívelo interior para, selecionar, atéou enquanto loop. nível o padrão é 1.

builtin [--] comando [arg ...]
Execute o comando integrado comando.

gato [-u] [lima ...]
Leia os arquivos sequencialmente, na ordem da linha de comando, e grave-os na saída padrão.
Se um lima é um único traço ('-') ou ausente, lido da entrada padrão. Para direto
chamadas embutidas, o POSIX -u opção é suportada como um no-op. Para chamadas do shell, se
todas as opções são fornecidas, um externo gato(1) utilitário é preferível ao embutido.

cd [-L] [dir]
cd -P [-e] [dir]
chdir [-eLP] [dir]
Defina o diretório de trabalho para dir. Se o parâmetro CDPATH for definido, ele lista o
caminho de pesquisa para o diretório que contém dir. Um caminho NULL significa o atual
diretório. Se dir é encontrado em qualquer componente do caminho de pesquisa CDPATH diferente do
Caminho NULL, o nome do novo diretório de trabalho será gravado na saída padrão.
If dir está faltando, o diretório inicial HOME é usado. Se dir é '-', o anterior
diretório de trabalho é usado (consulte o parâmetro OLDPWD).

Se o -L opção (caminho lógico) é usado ou se o físico opção não está definida (consulte o
conjunto abaixo), referências a '..' em dir são relativos ao caminho usado para chegar a
o diretório. Se o -P opção (caminho físico) é usado ou se o físico opção
definido, '..' é relativo à árvore de diretórios do sistema de arquivos. O PWD e OLDPWD
os parâmetros são atualizados para refletir o diretório de trabalho atual e antigo,
respectivamente. Se o -e opção é definida para travessia do sistema de arquivos físico e PWD
não pôde ser definido, o código de saída é 1; maior que 1 se ocorreu um erro, 0
de outra forma.

cd [-eLP] velho novo
chdir [-eLP] velho novo
A corda novo é substituído por velho no diretório atual, e o shell
tenta mudar para o novo diretório.

comando [-pVv] cmd [arg ...]
Se nem o -v nem -V opção é dada, cmd é executado exatamente como se comando tinha
não foi especificado, com duas exceções: em primeiro lugar, cmd não pode ser uma função de shell; e
em segundo lugar, os comandos embutidos especiais perdem sua especialidade (ou seja, redirecionamento e
erros de utilitário não fazem com que o shell saia e as atribuições de comando não são
permanente).

Se o -p opção for fornecida, um caminho de pesquisa padrão é usado em vez do valor atual
de PATH, cujo valor real depende do sistema.

Se o -v opção é fornecida, em vez de executar cmd, informações sobre o que seria
executado é fornecido (e o mesmo é feito para arg ...) Para builtins, funções e
palavras-chave, seus nomes são simplesmente impressos; para aliases, um comando que os define é
impresso; para utilitários encontrados pesquisando o parâmetro PATH, o caminho completo do
o comando é impresso. Se nenhum comando for encontrado (ou seja, a busca do caminho falha), nada é
impresso e comando sai com um status diferente de zero. O -V opção é como o -v
opção, exceto que é mais prolixo.

continuar [nível]
Salta para o início do nívelo interior para, selecionar, atéou enquanto loop.
nível o padrão é 1.

eco [-UMA] [arg ...]
Atenção: este utilitário não é portátil; usar o shell Korn embutido impressão ao invés.

Imprime seus argumentos (separados por espaços) seguidos por uma nova linha, para o padrão
saída. A nova linha é suprimida se algum dos argumentos contiver a barra invertida
seqüência '\ c'. Veja o impressão comando abaixo para uma lista de outras sequências de barra invertida
que são reconhecidos.

As opções são fornecidas para compatibilidade com scripts de shell BSD. O -n opção
suprime a nova linha final, -e permite a interpretação da barra invertida (um ambiente autônomo, uma vez que
isso normalmente é feito), e -E suprime a interpretação da barra invertida.

Se o posix or sh opção está definida ou esta é uma chamada embutida direta, apenas a primeira
argumento é tratado como uma opção, e apenas se for exatamente “-n”. Barra invertida
a interpretação está desabilitada.

avaliação comando ...
Os argumentos são concatenados (com espaços entre eles) para formar uma única string
que o shell analisa e executa no ambiente atual.

exec [-a argv0] [-c] [comando [arg ...]]
O comando é executado sem bifurcação, substituindo o processo de shell. Isto é
atualmente absoluto, ou seja exec nunca retorna, mesmo se o comando Não foi encontrado. O
-a opção permite definir um valor argv [0] diferente, e -c limpa o ambiente
antes de executar o processo filho, exceto para a variável _ e atribuições diretas.

Se nenhum comando for dado, exceto para o redirecionamento de I / O, o redirecionamento de I / O é permanente
e o shell não é substituído. Quaisquer descritores de arquivo maiores que 2 que são abertos
or dup(2) 'd desta forma não são disponibilizados para outros comandos executados (ou seja
comandos que não são integrados ao shell). Observe que o shell Bourne é diferente
aqui; ele passa esses descritores de arquivo adiante.

saída [estado]
O shell sai com o status de saída especificado. Se estado não é especificado, a saída
status é o valor atual do $? parâmetro.

exportar [-p] [parâmetro[=valor]]
Define o atributo de exportação dos parâmetros nomeados. Os parâmetros exportados são passados ​​em
o ambiente para comandos executados. Se os valores forem especificados, os parâmetros nomeados
também são atribuídos.

Se nenhum parâmetro for especificado, todos os parâmetros com o conjunto de atributos de exportação são
impresso um por linha; seus nomes ou, se um '-' sem letra de opção for
pares especificados, nome = valor ou, com -p, exportar comandos adequados para reentrada.

falso Um comando que sai com um status diferente de zero.

fc [-e editor | -l [-n]] [-r] [primeiro [último]]
primeiro e último selecione comandos do histórico. Os comandos podem ser selecionados pelo histórico
número (números negativos retrocedem da linha atual, mais recente) ou um
string especificando o comando mais recente começando com aquela string. O -l opção
lista o comando na saída padrão e -n inibe os números de comando padrão.
A -r opção inverte a ordem da lista. Sem -l, os comandos selecionados são
editado pelo editor especificado com o -e opção, ou se não -e é especificado, o
editor especificado pelo parâmetro FCEDIT (se este parâmetro não for definido, / bin / ed is
usado) e, em seguida, executado pelo shell.

fc -e - | -s [-g] [velho=novo] [prefixo]
Reexecute o comando selecionado (o comando anterior por padrão) após realizar
a substituição opcional de velho com novo. Se -g é especificado, todas as ocorrências de
velho são substituídos por novo. O significado de -e - e -s é idêntico: execute novamente o
comando selecionado sem invocar um editor. Este comando geralmente é acessado com
o predefinido: aliás r = 'fc -e -'

fg [trabalho ...]
Retome o (s) trabalho (s) especificado (s) em primeiro plano. Se nenhum trabalho for especificado, %+ is
assumido. Ver Trabalho ao controle abaixo para obter mais informações.

obter opções string de opção nome [arg ...]
Usado por procedimentos de shell para analisar os argumentos especificados (ou parâmetros posicionais,
se nenhum argumento for fornecido) e para verificar as opções legais. string de opção contém o
letras de opção que obter opções é reconhecer. Se uma letra for seguida por dois pontos, o
espera-se que a opção tenha um argumento. Opções que não aceitam argumentos podem ser
agrupados em um único argumento. Se uma opção leva um argumento e a opção
caractere não é o último caractere do argumento em que se encontra, o restante do
o argumento é considerado o argumento da opção; caso contrário, o próximo argumento é
o argumento da opção.

Toda vez obter opções é invocado, ele coloca a próxima opção no parâmetro shell nome
e o índice do argumento a ser processado pela próxima chamada para obter opções no
parâmetro de shell OPTIND. Se a opção foi introduzida com um '+', a opção colocada
in nome é prefixado com um '+'. Quando uma opção requer um argumento, obter opções lugares
no parâmetro de shell OPTARG.

Quando uma opção ilegal ou um argumento de opção ausente é encontrado, um ponto de interrogação
ou dois pontos são colocados em nome (indicando uma opção ilegal ou argumento ausente,
respectivamente) e OPTARG é definido como o caractere de opção que causou o problema.
Além disso, se string de opção não começa com dois pontos, um ponto de interrogação é colocado em
nome, OPTARG não está definido e uma mensagem de erro é impressa no erro padrão.

Quando o fim das opções é encontrado, obter opções saídas com uma saída diferente de zero
status. As opções terminam no primeiro argumento (argumento sem opção) que não começa
com um '-', ou quando um argumento '-' é encontrado.

A análise de opções pode ser redefinida configurando OPTIND para 1 (isso é feito automaticamente
sempre que o shell ou um procedimento de shell é invocado).

Aviso: Alterar o valor do parâmetro de shell OPTIND para um valor diferente de 1 ou
analisar diferentes conjuntos de argumentos sem redefinir OPTIND, pode levar a
resultados.

global ...
See formatado.

hash [-r] [nome ...]
Sem argumentos, quaisquer nomes de caminho de comando executáveis ​​com hash são listados. O -r opção
faz com que todos os comandos hash sejam removidos da tabela hash. Cada nome é pesquisado
como se fosse um nome de comando e adicionado à tabela de hash se fosse um executável
comando.

empregos [-lnp] [trabalho ...]
Exibir informações sobre o (s) trabalho (s) especificado (s); se nenhum trabalho for especificado, todos os trabalhos
Estão exibidas. O -n opção faz com que as informações sejam exibidas apenas para trabalhos que
mudaram de estado desde a última notificação. Se o -l opção é usada, o
o ID do processo de cada processo em um trabalho também é listado. O -p opção faz com que apenas o
grupo de processos de cada trabalho a ser impresso. Ver Trabalho ao controle abaixo para o formato de trabalho
e o trabalho exibido.

matar [-s nome de assinatura | -assinar | -nome de assinatura] { trabalho | pid | arquivo } ...
Envie o sinal especificado para as tarefas, IDs de processo ou grupos de processos especificados. Se
nenhum sinal é especificado, o sinal TERM é enviado. Se um trabalho for especificado, o sinal
é enviado ao grupo de processos do trabalho. Ver Trabalho ao controle abaixo para o formato de trabalho.

matar -l [status de saída ...]
Imprima o nome do sinal correspondente a status de saída. Se nenhum argumento for especificado, um
uma lista de todos os sinais, seus números e uma breve descrição deles são impressos.

deixar [expressão ...]
Cada expressão é avaliada (ver Aritmética expressões acima). Se todas as expressões
são avaliados com sucesso, o status de saída é 0 (1) se a última expressão avaliada
para diferente de zero (zero). Se ocorrer um erro durante a análise ou avaliação de um
expressão, o status de saída é maior do que 1. Uma vez que as expressões podem precisar ser
citado, (( expr )) é um açúcar sintático para {let 'expr'; }

deixei] Alias ​​usado internamente para deixar.

mknod [-m modo] nome b|c principal menor
mknod [-m modo] nome p
Crie um arquivo especial do dispositivo. O tipo de arquivo pode ser b (dispositivo tipo bloco), c
(dispositivo de tipo de caractere), ou p (pipe nomeado, FIFO). O arquivo criado pode ser modificado
de acordo com seu modo (através do -m opção), principal (número do dispositivo principal), e menor
(número menor do dispositivo). Isso normalmente não faz parte de Obrigado; no entanto, os distribuidores podem
adicionamos isso como um hack de velocidade embutido.

impressão [-nprsu[n] -R [-in]] [argumento ...]
impressão imprime seus argumentos na saída padrão, separados por espaços e encerrados
com uma nova linha. O -n opção suprime a nova linha. Por padrão, certos escapes C
são traduzidos. Isso inclui os mencionados em Barra invertida expansão acima também
como '\ c', que é equivalente a usar o -n opção. A expansão da barra invertida pode ser
inibido com o -r opção. O -s opção imprime no arquivo de histórico em vez de
saída padrão; a -u opção imprime no descritor de arquivo n (n o padrão é 1 se
omitido); e a -p opção imprime para o co-processo (veja Co-processos acima).

A -R opção é usada para emular, até certo ponto, o BSD eco(1) comando que faz
não processa sequências '\' a menos que o -e opção é fornecida. Como acima, o -n opção
suprime a nova linha final.

printf formato [argumentos ...]
Saída formatada. Aproximadamente o mesmo que o printf(1), utilitário, exceto que usa
o mesmo Barra invertida expansão e código de E / S e não lida com ponto flutuante como o
resto de Obrigado. Um utilitário externo é preferível ao embutido. Isso não é
normalmente parte de Obrigado; no entanto, os distribuidores podem ter adicionado isso como integrado como um
hack de velocidade. Não use em novo código.

pwd [-LP]
Imprima o diretório de trabalho atual. Se o -L opção é usada ou se o físico
opção não está definida (consulte o conjunto comando abaixo), o caminho lógico é impresso (ou seja, o
caminho usado para cd para o diretório atual). Se o -P opção (caminho físico) é usado
ou se o físico opção é definida, o caminho determinado a partir do sistema de arquivos (por
seguintes diretórios '..' para o diretório raiz) é impresso.

ler [-A | -a] [-d x] [-N z | -n z] [-p | -u[n]] [-t n] [-rs] [p ...]
Lê uma linha de entrada, separa a entrada em campos usando o parâmetro IFS (consulte
Substituição acima), e atribui cada campo aos parâmetros especificados p. Se não
parâmetros são especificados, o parâmetro REPLY é usado para armazenar o resultado. Com o
-A e -a opções, apenas nenhum ou um parâmetro é aceito. Se houver mais
parâmetros do que campos, os parâmetros extras são definidos para a string vazia ou 0; E se
existem mais campos do que parâmetros, o último parâmetro é atribuído ao restante
campos (incluindo os separadores de palavras).

As opções são as seguintes:

-A Armazene o resultado no parâmetro p (ou REPLY) como matriz de palavras.

-a Armazene o resultado sem divisão de palavra no parâmetro p (ou REPLY) como
matriz de caracteres (caracteres largos se o modo utf8 opção é decretada,
octetos caso contrário); os pontos de código são codificados como números decimais por padrão.

-d x Use o primeiro byte de x, NUL se vazio, em vez do caractere de nova linha ASCII
como delimitador de linha de entrada.

-N z Em vez de ler até o fim da linha, leia exatamente z bytes. Se EOF ou um
ocorre um tempo limite, uma leitura parcial é retornada com o status de saída 1.

-n z Em vez de ler até o fim da linha, leia até z bytes, mas retornam assim que
quaisquer bytes são lidos, por exemplo, de um dispositivo de terminal lento, ou se EOF ou um tempo limite
ocorre.

-p Leia a partir do co-processo atualmente ativo, consulte Co-processos acima para detalhes
nisto.

-u[n] Leia a partir do descritor de arquivo n (o padrão é 0, ou seja, entrada padrão). O
o argumento deve seguir imediatamente o caractere de opção.

-t n Interromper a leitura após n segundos (especificado como valor decimal positivo com um
parte fracionária opcional). O status de saída de ler é 1 se o tempo limite
ocorreu, mas as leituras parciais ainda podem ser retornadas.

-r Normalmente, o caractere de barra invertida ASCII escapa do significado especial do
caractere seguinte e é retirado da entrada; ler não para quando
encontrando uma sequência barra invertida-nova linha e não armazena essa nova linha em
o resultado. Esta opção ativa o modo bruto, no qual as barras invertidas não são
processado.

-s A linha de entrada é salva no histórico.

Se a entrada for um terminal, tanto o -N e -n as opções configuram-no no modo bruto; elas
ler um arquivo inteiro se -1 for passado como z argumento.

O primeiro parâmetro pode ter um ponto de interrogação e uma string anexada a ele, em que
caso a string seja usada como um prompt (impresso no erro padrão antes de qualquer entrada ser
ler) se a entrada for um tty(4) (por exemplo ler nfoo? 'número of foos: ').

Se nenhuma entrada for lida ou ocorrer um tempo limite, ler sai com um status diferente de zero.

Outro conjunto útil de truques: Se ler é executado em um loop, como enquanto ler foo; do ...;
feito então, os espaços em branco iniciais serão removidos (IFS) e as barras invertidas serão processadas. Você
pode querer usar enquanto IFS = ler -r foo; do ...; feito para E / S primitiva. Similarmente,
ao usar o -a opção, uso do -r opção pode ser prudente; o mesmo se aplica
para:

achar . -tipo f -print0 | & \
enquanto IFS = read -d '' -pr nome do arquivo; Faz
print -r - "encontrado <$ {filename #. /}>"
feito

O loop interno será executado em um subshell e as mudanças de variáveis ​​não podem ser
propagado se executado em um pipeline:

bar | baz | enquanto lê foo; Faz ...; feito

Em vez disso, use coprocessos:

bar | baz | &
enquanto lê -p foo; Faz ...; feito
exec 3> & p; exec 3> & -

somente leitura [-p] [parâmetro [=valor] ...]
Define o atributo somente leitura dos parâmetros nomeados. Se os valores forem fornecidos,
os parâmetros são definidos para eles antes de definir o atributo. Uma vez que um parâmetro é feito
somente leitura, ele não pode ser removido e seu valor não pode ser alterado.

Se nenhum parâmetro for especificado, os nomes de todos os parâmetros com o somente leitura
atributo são impressos um por linha, a menos que o -p opção é usada, caso em que
somente leitura comandos que definem todos os parâmetros somente leitura, incluindo seus valores, são
impresso.

caminho real [--] nome
Imprime o caminho absoluto resolvido correspondente a nome. Se nome termina com um
barra ('/'), também é verificada quanto à existência e se é um diretório;
de outra forma, caminho real retorna 0 se o nome do caminho existe ou pode ser criado
imediatamente, ou seja, todos, exceto o último componente, existem e são diretórios.

rebatizar [--] da para
Renomeia o arquivo da para para. Ambos devem ser nomes de caminho completos e no mesmo dispositivo.
Este embutido é destinado a situações de emergência onde / bin / mv torna-se inutilizável, e
liga diretamente rebatizar(2).

retorno [estado]
Retorna de uma função ou . script, com status de saída estado. Se não estado é dada,
o status de saída do último comando executado é usado. Se usado fora de uma função
or . script, tem o mesmo efeito que saída. Observe que Obrigado trata tanto o perfil quanto
Arquivos ENV como . scripts, enquanto o shell Korn original apenas trata os perfis como .
scripts.

conjunto [+ -abCefhiklmnprsUuvXx] [+ -o opção] [+ -A nome] [--] [arg ...]
A conjunto comando pode ser usado para definir (-) ou claro (+) opções de shell, defina a posição
parâmetros ou definir um parâmetro de matriz. As opções podem ser alteradas usando o + -o opção
sintaxe, onde opção é o nome longo de uma opção ou usando o +-carta sintaxe,
onde carta éo nome de uma única letra da opção (nem todas as opções têm uma única letra
nome). A tabela a seguir lista letras de opção (se houver) e nomes longos
junto com uma descrição do que a opção faz:

-A nome
Define os elementos do parâmetro de matriz nome para arg ... If -A É usado, o
a matriz é redefinida (isto é, esvaziada) primeiro; E se +A é usado, os primeiros N elementos são definidos
(onde N é o número de argumentos); o resto é deixado intocado.

Uma sintaxe alternativa para o comando conjunto -A Foo -- a b c que é compatível com
GNU bater e também suportado por AT&T UNIX ksh93 é: foo = (a b c); foo + = (d e)

-a | -o Allexport
Todos os novos parâmetros são criados com o atributo export.

-b | -o notificar
Imprimir mensagens de notificação de trabalho de forma assíncrona, em vez de antes do
mensagem. Usado apenas se o controle de trabalho estiver habilitado (-m).

-C | -o nocturno
Impedir> redirecionamento de sobrescrever arquivos existentes. Em vez disso,> | deve ser usado
para forçar uma substituição. Observe que não é seguro usar para a criação de
arquivos temporários ou arquivos de bloqueio devido a um TOCTOU em uma verificação que permite redirecionar
saída para / dev / null ou outros arquivos de dispositivo, mesmo em nocturno modo.

-e | -o errar
Saia (depois de executar a armadilha ERR) assim que ocorrer um erro ou um comando
falha (ou seja, sai com um status diferente de zero). Isso não se aplica a comandos
cujo status de saída é explicitamente testado por uma construção de shell, como if, até,
enquantoou ! afirmações. Por && ou ||, apenas o status do último comando é
testado.

-f | -o noglob
Não expanda os padrões de nome de arquivo.

-h | -o rastrear tudo
Crie apelidos rastreados para todos os comandos executados (ver Alias acima). Habilitado
por padrão para shells não interativos.

-i | -o interativo
O shell é um shell interativo. Esta opção só pode ser usada quando o shell
é invocado. Veja acima uma descrição do que isso significa.

-k | -o palavra chave
As atribuições de parâmetros são reconhecidas em qualquer lugar em um comando.

-l | -o entrar
O shell é um shell de login. Esta opção só pode ser usada quando o shell está
invocado. Veja acima uma descrição do que isso significa.

-m | -o monitor
Habilite o controle de trabalho (padrão para shells interativos).

-n | -o noexec
Não execute nenhum comando. Útil para verificar a sintaxe de scripts (ignorado
se interativo).

-p | -o privilegiado
O shell é um shell privilegiado. É definido automaticamente se, quando o shell
começa, o UID ou GID real não corresponde ao UID (EUID) ou GID efetivo
(EGID), respectivamente. Veja acima uma descrição do que isso significa.

-r | -o restringido
O shell é um shell restrito. Esta opção só pode ser usada quando o shell está
invocado. Veja acima uma descrição do que isso significa.

-s | -o stdin
Se usado quando o shell é invocado, os comandos são lidos da entrada padrão. Definir
automaticamente se o shell for invocado sem argumentos.

Quando -s é usado com o conjunto comando faz com que os argumentos especificados sejam
ordenados antes de atribuí-los aos parâmetros posicionais (ou ao array nome, Se
-A é usado).

-U | -o modo utf8
Habilite o suporte UTF-8 no Emacs edição modo e manipulação de coluna interna
funções. Este sinalizador é desabilitado por padrão, mas pode ser habilitado configurando-o
na linha de comando do shell; é habilitado automaticamente para shells interativos se
solicitado em tempo de compilação, seu sistema suporta definir local(LC_CTYPE, "") e
opcionalmente nl_langinfo(CONJUNTO DE CÓDIGOS), ou o ambiente LC_ALL, LC_CTYPE ou LANG
variáveis, e pelo menos uma delas retorna algo que corresponde a “UTF-8” ou
“Utf8” não faz distinção entre maiúsculas e minúsculas; para chamadas internas diretas, dependendo do
variáveis ​​de ambiente acima mencionadas; ou para stdin ou scripts, se a entrada
começa com uma marca de ordem de bytes UTF-8.

Em um futuro próximo, o rastreamento local será implementado, o que significa que conjunto - + U is
alterado sempre que uma das variáveis ​​de ambiente relacionadas à localidade POSIX muda.

-u | -o conjunto de substantivos
A referência a um parâmetro não definido, diferente de "$ @" ou "$ *", é tratada como um
erro, a menos que um dos modificadores '-', '+' ou '=' seja usado.

-v | -o detalhado
Grave a entrada do shell no erro padrão à medida que é lida.

-X | -o markdirs
Marque os diretórios com um '/' final durante a geração do nome do arquivo.

-x | -o xtrace
Imprime árvores de comandos quando são executados, precedidos do valor de PS4.

-o bom
Trabalhos em segundo plano são executados com prioridade mais baixa.

-o braçadeira
Habilite a expansão da braçadeira (também conhecida como alternância). Isso é ativado por padrão. Se
desativado, a expansão do til após um sinal de igual é desativada como um efeito colateral.

-o emacs
Habilitar edição de linha de comando semelhante ao BRL emacs (somente shells interativos); Vejo Emacs
edição modo.

-o gmacs
Habilite a edição de linha de comando semelhante ao gmacs (somente shells interativos). Atualmente
idêntico à edição emacs exceto que transpose-chars (^ T) age ligeiramente
diferentemente.

-o ignorar
O shell não sairá (facilmente) quando o final do arquivo for lido; saída deve ser usado.
Para evitar loops infinitos, o shell sairá se EOF for lido 13 vezes consecutivas.

-o herdar xtrace
Não reinicie -o xtrace ao entrar nas funções. Isso é ativado por padrão.

-o nohup
Não elimine jobs em execução com um sinal SIGHUP quando um shell de login é encerrado.
Atualmente definido por padrão, mas isso pode mudar no futuro para ser compatível
com AT&T UNIX ksh, que não tem essa opção, mas envia o SIGHUP
sinal.

-o nolog
Sem efeito. No shell Korn original, isso impede que as definições de função
sendo armazenado no arquivo de histórico.

-o físico
Faz com que o cd e pwd comandos para usar "físico" (isto é, do sistema de arquivos) '..'
diretórios em vez de diretórios "lógicos" (ou seja, o shell lida com '..', que
permite ao usuário ignorar links simbólicos para diretórios). Limpar por
padrão. Observe que definir esta opção não afeta o valor atual do
Parâmetro PWD; apenas o cd comando muda PWD. Veja o cd e pwd comandos
acima para mais detalhes.

-o falha na tubulação
Faça o status de saída de um pipeline (antes de complementar logicamente) o
nível de erro diferente de zero mais à direita ou zero se todos os comandos saíram com zero.

-o posix
Comporte-se mais de acordo com os padrões (veja POSIX modo para detalhes). Automaticamente
ativado se o nome de base da invocação do shell começar com "sh" e este
o recurso de autodetecção é compilado (não no MirBSD). Como efeito colateral, definir
esta bandeira apaga braçadeira modo, que pode ser ativado manualmente, e
sh modo (a menos que ambos estejam habilitados ao mesmo tempo).

-o sh
permitir / Bin / sh (kludge) modo (ver SH modo) Ativado automaticamente se o
o nome de base da invocação do shell começa com “sh” e este recurso de autodetecção
é compilado em (não em MirBSD). Como efeito colateral, definir este sinalizador desativa
braçadeira modo, que pode ser ativado manualmente, e posix modo (a menos que
ambos são ativados ao mesmo tempo).

-o vi
permitir vi(1) edição de linha de comando semelhante (somente shells interativos). Ver Vi
edição modo para documentação e limitações.

-o vi-completo
Na edição da linha de comando do vi, execute o comando e a conclusão do nome do arquivo ao escapar (^ [)
é inserido no modo de comando.

-o vi-tabcompleto
Na edição da linha de comando do vi, complete o comando e o nome do arquivo quando a guia (^ I) estiver
entrou no modo de inserção. Este é o padrão.

-o vira
Sem efeito. No shell Korn original, a menos que vira foi definido, o comando vi-
modo de linha deixaria o tty(4) o motorista faz o trabalho até que ESC (^ [) seja inserido.
Obrigado está sempre no modo viraw.

Essas opções também podem ser usadas na chamada do shell. O conjunto atual de
opções (com nomes de uma única letra) podem ser encontradas no parâmetro '$ -'. conjunto -o com
nenhum nome de opção listará todas as opções e se cada uma está ativada ou desativada; conjunto +o precisarão
imprime os nomes longos de todas as opções que estão ativadas no momento. Em uma versão futura, conjunto
+o irá se comportar em conformidade com POSIX e imprimir comandos para restaurar as opções atuais
ao invés.

Os argumentos restantes, se houver, são parâmetros posicionais e são atribuídos, em ordem, a
os parâmetros posicionais (ou seja, $ 1, $ 2, etc.). Se as opções terminarem com '-' e aí
não há argumentos restantes, todos os parâmetros posicionais são limpos. Se não houver opções ou
argumentos são fornecidos, os valores de todos os nomes são impressos. Para histórico desconhecido
razões, uma única opção '-' é tratada de maneira especial - ela limpa tanto o -v e -x
opções.

mudança [número]
Os parâmetros posicionais número+ 1, número+2, etc. são renomeados para '1', '2', etc.
número o padrão é 1.

dormir segundo
Suspende a execução por um mínimo de segundo especificado como valor decimal positivo
com uma parte fracionária opcional. A entrega do sinal pode continuar a execução mais cedo.

fonte lima [arg ...]
Como . (“Ponto”), exceto que o diretório de trabalho atual é anexado à pesquisa
caminho (GNU bater extensão).

suspender
Para o shell como se ele tivesse recebido o caractere suspenso do terminal. Isto é
não é possível suspender um shell de login, a menos que o processo pai seja membro do
mesma sessão de terminal, mas é membro de um grupo de processos diferente. Como um general
regra, se o shell foi iniciado por outro shell ou via su(1), ele pode ser suspenso.

teste expressão
[ expressão ]
teste avalia o expressão e retorna o status zero se verdadeiro, 1 se falso ou maior
de 1 se houver um erro. É normalmente usado como o comando de condição de if e
enquanto afirmações. Links simbólicos são seguidos por todos lima expressões exceto -h e
-L.

As seguintes expressões básicas estão disponíveis:

-a lima lima existe.

-b lima lima é um dispositivo especial de bloco.

-c lima lima é um dispositivo especial de caráter.

-d lima lima é um diretório.

-e lima lima existe.

-f lima lima é um arquivo normal.

-G lima limaO grupo de é o ID de grupo efetivo do shell.

-g lima limaO modo de tem o conjunto de bits setgid.

-H lima lima é um diretório dependente do contexto (útil apenas no HP-UX).

-h lima lima é um link simbólico.

-k lima limao modo de tem o pegajoso(8) conjunto de bits.

-L lima lima é um link simbólico.

-O lima limadono é o ID de usuário efetivo do shell.

-o opção concha opção está definido (veja o conjunto comando acima para uma lista de
opções). Como uma extensão não padrão, se a opção começar com
a '!', o teste é negado; o teste sempre falha se opção
não existe (então [-o foo -o -o! foo] retorna verdadeiro se e somente
se opção Foo existe). O mesmo pode ser alcançado com [-o? Foo]
como em AT&T UNIX ksh93. opção também pode ser a bandeira curta liderada por
ou '-' ou '+' (sem negação lógica), por exemplo '-x' ou '+ x'
em vez de 'xtrace'.

-p lima lima é um pipe nomeado (FIFO).

-r lima lima existe e é legível.

-S lima lima é um unix(4) soquete de domínio.

-s lima lima não está vazio.

-t fd Descritor de arquivo fd é um tty(4) dispositivo.

-u lima limaO modo de tem o conjunto de bits setuid.

-w lima lima existe e é gravável.

-x lima lima existe e é executável.

file1 -nt file2 file1 é mais novo que file2 or file1 existe e file2 não.

file1 -ot file2 file1 É mais velho que file2 or file2 existe e file1 não.

file1 -E se file2 file1 é o mesmo arquivo que file2.

corda corda tem comprimento diferente de zero.

-n corda corda não está vazio.

-z corda corda está vazia.

corda = corda As cordas são iguais.

corda == corda As cordas são iguais.

corda > corda O primeiro operando da string é maior do que o segundo operando da string.

corda < corda O primeiro operando da string é menor que o segundo operando da string.

corda != corda Strings não são iguais.

número -eq número Os números são comparados iguais.

número -um número Os números não são iguais.

número -dar número Números comparados maiores ou iguais.

número -gt número Os números comparados são maiores que.

número Eles número Os números são comparados a menos ou iguais.

número -lt número Os números são comparados a menos de.

As expressões básicas acima, nas quais os operadores unários têm precedência sobre os binários
operadores, podem ser combinados com os seguintes operadores (listados em ordem crescente
de precedência):

expr -o expr OU lógico.
expr -a expr AND lógico.
! expr NÃO lógico.
(expr) Agrupamento.

Observe que um número, na verdade, pode ser uma expressão aritmética, como uma expressão matemática
termo ou o nome de uma variável inteira:

x = 1; ["x" -eq 1] avalia como verdadeiro

Observe que algumas regras especiais são aplicadas (cortesia de POSIX) se o número de
argumentos para teste ou dentro dos colchetes [ ... ] é menor que cinco: se liderar '!'
argumentos podem ser removidos de modo que apenas um a três argumentos permaneçam, então o
a comparação rebaixada é executada; (graças ao XSI) parênteses \( ... \) quatro inferiores e
formas de três argumentos para formas de dois e um argumento, respectivamente; três argumentos
formas, em última análise, preferem operações binárias, seguidas de negação e parênteses
abaixando; as formas de dois e quatro argumentos preferem negação seguida de parênteses; a
a forma de um argumento sempre implica -n.

Note: Um erro comum é usar “if [$ foo = bar]” que falha se o parâmetro “foo”
é NULL ou não definido, se tiver espaços incorporados (ou seja, octetos IFS), ou se for um unário
operador como '!' ou '-n'. Use testes como “if [x" $ foo "= x" bar "]” em vez disso, ou o
operador de colchetes duplos “if [[$ foo = bar]]” ou, para evitar a correspondência de padrões (consulte [[
acima): “if [[$ foo =" $ bar "]]”

A [[ ... ]] construct não é apenas mais seguro de usar, mas também mais rápido.

tempo [-p] [oleoduto]
Se um oleoduto é fornecido, os tempos usados ​​para executar o pipeline são relatados. Se não
pipeline é fornecido, então o usuário e o tempo do sistema usados ​​pelo próprio shell, e todos
os comandos executados desde que foi iniciado são relatados. Os tempos relatados são
o tempo real (tempo decorrido do início ao fim), o tempo de CPU do usuário (tempo gasto
em execução no modo de usuário) e o tempo de CPU do sistema (tempo gasto em execução no modo kernel).
Os tempos são reportados ao erro padrão; o formato da saída é:

0m0.00s real 0m0.00s usuário 0m0.00s sistema

Se o -p opção é fornecida, a saída é um pouco mais longa:

0.00 real
usuário 0.00
sys 0.00

É um erro especificar o -p opção a menos oleoduto é um comando simples.

Redirecionamentos simples de erro padrão não afetam a saída do tempo comando:

$ time sleep 1 2> afile
$ {tempo de sono 1; } 2> um arquivo

Os tempos do primeiro comando não vão para “arquivo”, mas os do segundo comando vão.

vezes Imprime os tempos acumulados do usuário e do sistema usados ​​tanto pelo shell quanto pelos processos
que o shell foi iniciado que saiu. O formato da saída é:

0m0.00s 0m0.00s
0m0.00s 0m0.00s

armadilha n [sinal ...]
Se o primeiro operando for um inteiro decimal sem sinal, isso redefine todos os sinais especificados
para a ação padrão, ou seja, é o mesmo que chamar armadilha com um sinal de menos ('-') como
treinador, seguido pelos argumentos (n [sinal ...]), todos os quais são tratados como
sinais.

armadilha [treinador sinal ...]
Define um manipulador de trap que deve ser executado quando qualquer um dos sinals são
recebido. treinador é uma string vazia, indicando que os sinais devem ser
ignorado, um sinal de menos ('-'), indicando que a ação padrão deve ser realizada para
os sinais (ver sinal(3)), ou uma string contendo comandos de shell a serem executados em
a primeira oportunidade (ou seja, quando o comando atual for concluído ou antes de imprimir
próximo prompt PS1) após o recebimento de um dos sinais. sinal é o nome de um
sinal (por exemplo, PIPE ou ALRM) ou o número do sinal (consulte o matar -l comando
acima).

Existem dois sinais especiais: EXIT (também conhecido como 0), que é executado quando o
o shell está prestes a sair e ERR, que é executado após a ocorrência de um erro; um erro é
algo que faria com que o shell saísse se o conjunto -e or conjunto -o errar opção
foram definidos. Manipuladores EXIT são executados no ambiente da última execução
comando.

Observe que, para shells não interativos, o manipulador de trap não pode ser alterado para sinais
que foram ignorados quando o shell foi iniciado.

Sem argumentos, o estado atual das armadilhas que foram definidas desde o shell
iniciado é mostrado como uma série de armadilha comandos. Observe que a saída de armadilha não podes
ser canalizado de forma útil para outro processo (um artefato do fato de que as armadilhas são eliminadas
quando os subprocessos são criados).

A armadilha DEBUG do shell Korn original e o tratamento das armadilhas ERR e EXIT em
funções ainda não foram implementadas.

verdadeiro Um comando que sai com um valor zero.

global [[+ -alpnrtUux] [-L[n]] [-R[n]] [-Z[n]] [-i[n]] | -f [- smoking]] [nome [=valor] ...]
formatado [[+ -alpnrtUux] [-LRZ[n]] [-i[n]] | -f [- smoking]] [nome [=valor] ...]
Exibir ou definir atributos de parâmetro. Com nenhum nome argumentos, atributos de parâmetro
Estão exibidas; se nenhuma opção for usada, os atributos atuais de todos os parâmetros são
impresso como formatado comandos; se uma opção for fornecida (ou '-' sem letra de opção),
todos os parâmetros e seus valores com os atributos especificados são impressos; se opções
são introduzidos com '+', os valores dos parâmetros não são impressos.

If nome argumentos são fornecidos, os atributos dos parâmetros nomeados são definidos (-) ou
limpo (+) Os valores dos parâmetros podem ser especificados opcionalmente. Por nome[*], a
a mudança afeta todo o array e nenhum valor pode ser especificado.

If formatado é usado dentro de uma função, quaisquer parâmetros especificados são localizados. Isto
não é feito por outro idêntico global. Note: Isso significa que Obrigado 's global
comando é não equivalente a outras linguagens de programação ', pois não permite um
função chamada de outra função para acessar um parâmetro no escopo verdadeiramente global,
mas apenas evita colocar um acessado no escopo local.

Quando -f é usado, formatado opera nos atributos das funções. Como com
parâmetros, se não nome argumentos são fornecidos, funções são listadas com seus valores
(ou seja, definições), a menos que as opções sejam introduzidas com '+', caso em que apenas o
nomes de funções são relatados.

-a Atributo de matriz indexado.

-f Modo de função. Exibir ou definir funções e seus atributos, em vez de
parâmetros.

-i[n] Atributo inteiro. n especifica a base a ser usada ao exibir o inteiro
(se não for especificado, a base fornecida na primeira atribuição é usada).
Parâmetros com este atributo podem ser atribuídos a valores contendo aritmética
expressões.

-L[n] Atributo justificado à esquerda. n especifica a largura do campo. Se n não é especificado,
a largura atual de um parâmetro (ou a largura de seu primeiro valor atribuído)
é usado. Espaço em branco à esquerda (e zeros, se usado com o -Z opção) é
despojado. Se necessário, os valores são truncados ou preenchidos com espaço para caber
a largura do campo.

-l Atributo em minúsculas. Todos os caracteres maiúsculos em valores são convertidos para
minúsculas. (No shell Korn original, este parâmetro significava "inteiro longo"
quando usado com o -i opção.)

-n Crie uma variável vinculada (referência de nome): qualquer acesso à variável nome
irá acessar a variável valor no escopo atual (isso é diferente de
AT&T UNIX ksh93!) em vez de. Também diferente do AT&T UNIX ksh93 é a de que
valor é preguiçosamente avaliado no momento nome é acessado. Isso pode ser usado por
funções para acessar variáveis ​​cujos nomes são passados ​​como parâmetros, em vez
de usar avaliação.

-p Impressão completa formatado comandos que podem ser usados ​​para recriar os atributos
e valores de parâmetros.

-R[n] Atributo justificado à direita. n especifica a largura do campo. Se n não é
especificado, a largura atual de um parâmetro (ou a largura de seu primeiro
valor atribuído) é usado. Os espaços em branco à direita são eliminados. Se necessário,
os valores são removidos de caracteres iniciais ou preenchidos com espaço para torná-los
ajustar a largura do campo.

-r Atributo somente leitura. Parâmetros com este atributo não podem ser atribuídos a
ou não definido. Depois que esse atributo é definido, ele não pode ser desativado.

-t Atributo da tag. Não tem significado para a casca; fornecido para uso do aplicativo.

Para funções, -t é o atributo de rastreamento. Quando funciona com o traço
atributo são executados, o xtrace (-x) opção de shell está temporariamente ativada
em.

-U Atributo inteiro sem sinal. Os inteiros são impressos como valores não assinados (combinar
com o -i opção). Esta opção não está no shell Korn original.

-u Atributo em maiúsculas. Todos os caracteres minúsculos em valores são convertidos para
maiúsculas. (No shell Korn original, este parâmetro significava "sem sinal
inteiro ”quando usado com o -i opção que significava que as letras maiúsculas
nunca ser usado para bases maiores que 10. Veja o -U opção.)

Para funções, -u é o atributo indefinido. Ver Funções acima para o
implicações disso.

-x Atributo de exportação. Parâmetros (ou funções) são colocados no ambiente de
quaisquer comandos executados. As funções exportadas ainda não foram implementadas.

-Z[n] Atributo de preenchimento zero. Se não for combinado com -L, este é o mesmo que -R, exceto
o preenchimento de zero é usado em vez do preenchimento de espaço. Para inteiros, o número
em vez da base é preenchida.

Se algum dos -i, -L, -l, -R, -U, -uou -Z opções são alteradas, todas as outras deste
set são apagados, a menos que também sejam fornecidos na mesma linha de comando.

ulimit [-aBCcdefHilMmnOPpqrSsTtVvw] [valor]
Exibir ou definir limites de processo. Se nenhuma opção for usada, o limite de tamanho do arquivo (-f) é
assumido. valor, se especificado, pode ser uma expressão aritmética ou a palavra
"ilimitado". Os limites afetam o shell e quaisquer processos criados por ele
após a imposição de um limite. Observe que alguns sistemas podem não permitir que os limites sejam
aumentados depois de definidos. Observe também que os tipos de limites disponíveis são do sistema
dependente - alguns sistemas têm apenas o -f limite.

-a Exibir todos os limites; a menos que -H é usado, os limites suaves são exibidos.

-B n Defina o tamanho do buffer de soquete para n quibibytes.

-C n Defina o número de threads em cache para n.

-c n Impor um limite de tamanho de n blocos no tamanho dos despejos de memória.

-d n Impor um limite de tamanho de n kibibytes no tamanho da área de dados.

-e n Defina a gentileza máxima para n.

-f n Impor um limite de tamanho de n blocos em arquivos escritos pelo shell e seu filho
processos (arquivos de qualquer tamanho podem ser lidos).

-H Defina apenas o limite máximo (o padrão é definir limites fixos e flexíveis).

-i n Defina o número de sinais pendentes para n.

-l n Impor um limite de n kibibytes na quantidade de memória física bloqueada (com fio).

-M n Defina a memória bloqueada AIO para n quibibytes.

-m n Impor um limite de n kibibytes na quantidade de memória física usada.

-n n Impor um limite de n descritores de arquivo que podem ser abertos imediatamente.

-O n Defina o número de operações AIO para n.

-P n Limite o número de threads por processo a n.

-p n Impor um limite de n processos que podem ser executados pelo usuário a qualquer momento.

-q n Limite o tamanho das filas de mensagens POSIX a n bytes.

-r n Defina a prioridade máxima em tempo real para n.

-S Defina apenas o limite flexível (o padrão é definir limites fixos e flexíveis).

-s n Impor um limite de tamanho de n kibibytes no tamanho da área da pilha.

-T n Impor um limite de tempo de n segundos reais a serem usados ​​por cada processo.

-t n Impor um limite de tempo de n Segundos de CPU gastos no modo de usuário para serem usados ​​por cada
processo.

-V n Defina o número de monitores vnode no Haiku para n.

-v n Impor um limite de n kibibytes na quantidade de memória virtual (espaço de endereço)
usava.

-w n Impor um limite de n kibibytes na quantidade de espaço de troca usado.

Tão longe quanto ulimit está em causa, um bloco tem 512 bytes.

umask [-S] [máscara]
Exibir ou definir a máscara de criação de permissão de arquivo, ou umask (consulte umask(2)). Se o -S
opção for usada, a máscara exibida ou definida é simbólica; caso contrário, é um octal
número.

Máscaras simbólicas são como as usadas por chmod(1). Quando usados, eles descrevem o que
as permissões podem ser disponibilizadas (ao contrário das máscaras octais em que um bit definido significa
o bit correspondente deve ser apagado). Por exemplo, “ug = rwx, o =” define a máscara para
os arquivos não serão legíveis, graváveis ​​ou executáveis ​​por “outros” e é equivalente
(na maioria dos sistemas) para a máscara octal “007”.

Unalias [-adt] [nome ...]
Os apelidos para os nomes fornecidos são removidos. Se o -a opção é usada, todos os apelidos
estão removidos. Se o -t or -d opções são usadas, as operações indicadas são realizadas
em aliases rastreados ou de diretório, respectivamente.

não definido [-fv] parâmetro ...
Remova os parâmetros nomeados (-v, o padrão) ou funções (-f) Com parâmetro[*],
os atributos são mantidos, apenas os valores não são definidos.

O status de saída é diferente de zero se algum dos parâmetros tiver o atributo somente leitura
definido, zero caso contrário.

esperar [trabalho ...]
Aguarde a conclusão do (s) trabalho (s) especificado (s). O status de saída de esperar é aquele do último
trabalho especificado; se o último trabalho for eliminado por um sinal, o status de saída é 128 + o
número do sinal (ver matar -l status de saída acima); se o último trabalho especificado não pode
ser encontrado (porque nunca existiu, ou já havia sido concluído), o status de saída de esperar
é 127. Veja Trabalho ao controle abaixo para o formato de trabalho. esperar retornará se um sinal
para o qual um trap foi definido é recebido, ou se um sinal SIGHUP, SIGINT ou SIGQUIT
é recebido.

Se nenhum trabalho for especificado, esperar espera por todos os trabalhos atualmente em execução (se houver) para
termina e sai com um status zero. Se o monitoramento de trabalho estiver habilitado, a conclusão
o status dos trabalhos é impresso (não é o caso quando os trabalhos são especificados explicitamente).

donde [-pv] [nome ...]
Sem o -v opção, é o mesmo que comando -v, exceto os aliases não são impressos
como comando alias. Com o -v opção, é exatamente o mesmo que comando -V. em
em qualquer caso, o -p opção difere: o caminho de pesquisa não é afetado em donde, mas
a pesquisa é restrita ao caminho.

Trabalho ao controle
O controle de trabalho refere-se à capacidade do shell de monitorar e controlar trabalhos que são processos ou
grupos de processos criados para comandos ou pipelines. No mínimo, o shell mantém o controle
do status dos trabalhos em segundo plano (isto é, assíncronos) que existem atualmente; isto
as informações podem ser exibidas usando o empregos comandos. Se o controle de trabalho estiver totalmente habilitado
(usando conjunto -m or conjunto -o monitor), como é para shells interativos, os processos de um trabalho
são colocados em seu próprio grupo de processos. Trabalhos em primeiro plano podem ser interrompidos digitando o botão suspend
caractere do terminal (normalmente ^ Z), as tarefas podem ser reiniciadas em primeiro plano ou
fundo usando o fg e bg comandos, e o estado do terminal é salvo ou restaurado
quando um trabalho em primeiro plano é interrompido ou reiniciado, respectivamente.

Observe que apenas os comandos que criam processos (por exemplo, comandos assíncronos, subshell
comandos e comandos não integrados e não funcionais) podem ser interrompidos; comandos como ler não podes
estar.

Quando um trabalho é criado, um número de trabalho é atribuído a ele. Para shells interativos, este número é
impresso dentro de “[..]”, seguido pelos IDs de processo dos processos no trabalho quando um
o comando assíncrono é executado. Um trabalho pode ser referido no bg, fg, empregos, matar e esperar
comandos pelo ID do processo do último processo no pipeline de comando (conforme armazenado em
que o $! ) ou prefixando o número do trabalho com um sinal de porcentagem ('%'). Outros por cento
sequências também podem ser usadas para se referir a tarefas:

% + | %% | % O trabalho interrompido mais recentemente ou, se não houver trabalhos interrompidos, o mais antigo
trabalho em execução.

% - O trabalho que seria o %+ trabalho se este não existisse.

%n O trabalho com o número do trabalho n.

%?corda O trabalho com seu comando contendo a string corda (ocorre um erro se
vários trabalhos são combinados).

%corda O trabalho com seu comando começando com a string corda (ocorre um erro se
vários trabalhos são combinados).

Quando um trabalho muda de estado (por exemplo, um trabalho em segundo plano é concluído ou um trabalho em primeiro plano é interrompido), o
o shell imprime as seguintes informações de status:

[número] bandeira estado comando

Onde ...

número é o número do trabalho do trabalho;

bandeira é o caractere '+' ou '-' se o trabalho for o %+ or %- trabalho, respectivamente, ou espaço
se não for nenhum;

estado indica o estado atual do trabalho e pode ser:

Feito [número]
O trabalho foi encerrado. número é o status de saída do trabalho que é omitido
se o status for zero.

Em execução O trabalho não parou nem saiu (observe que a execução não
necessariamente significa consumir tempo de CPU - o processo pode ser bloqueado
esperando algum evento).

Parado [sinal]
O trabalho foi interrompido pelo indicado sinal (se nenhum sinal for dado, o
o trabalho foi interrompido por SIGTSTP).

descrição do sinal [“Core despejado”]
O trabalho foi interrompido por um sinal (por exemplo, falha de memória, desligamento); usar matar -l
para obter uma lista de descrições de sinais. A mensagem "core dumpped" indica
o processo criou um arquivo principal.

comando é o comando que criou o processo. Se houver vários processos no
trabalho, cada processo terá uma linha mostrando seu comando e possivelmente é estado, Se
é diferente do status do processo anterior.

Quando é feita uma tentativa de sair do shell enquanto houver trabalhos no estado interrompido, o
O shell avisa ao usuário que há trabalhos interrompidos e não sai. Se outra tentativa for
feito imediatamente para sair do shell, os trabalhos interrompidos recebem um sinal SIGHUP e o shell
saídas. Da mesma forma, se o nohup opção não está definida e há trabalhos em execução quando uma tentativa
é feito para sair de um shell de login, o shell avisa o usuário e não sai. Se outro
é feita uma tentativa imediata de sair do shell, as tarefas em execução recebem um sinal SIGHUP e
o shell sai.

POSIX modo
entrando conjunto -o posix modo irá causar Obrigado para se comportar ainda mais compatível com POSIX em alguns lugares
onde os padrões ou opiniões diferem. Observe que Obrigado ainda funcionará com não assinado
Aritmética de 32 bits; usar lksh se aritmética no host longo tipo de dados, completo com ISO C
Comportamento indefinido, são obrigatórios; consulte o lksh(1) página de manual para detalhes. A maioria dos outros
histórico, AT&T UNIX ksh- diferenças compatíveis ou opinativas podem ser desativadas usando este
modo; estes são:

· O GNU bater Redirecionamento de I / O &>lima não é mais compatível.

· Os descritores de arquivo criados por redirecionamentos de E / S são herdados por processos filho.

· Os números com um dígito inicial zero são interpretados como octais.

· A eco embutido não interpreta barras invertidas e suporta apenas a opção exata “-n".

· ... (a lista está incompleta e pode mudar para R53)

SH modo
Modo de compatibilidade; destinado ao uso com scripts legados que não podem ser corrigidos facilmente; a
as mudanças são as seguintes:

· O GNU bater Redirecionamento de I / O &>lima não é mais compatível.

· Os descritores de arquivo criados por redirecionamentos de E / S são herdados por processos filho.

· A eco embutido não interpreta barras invertidas e suporta apenas a opção exata “-n".

· ... (a lista está incompleta e pode mudar para R53)

interativo entrada linha edição
O shell suporta três modos de leitura de linhas de comando de um tty(4) em um interativo
sessão, controlada pelo emacs, gmacs e vi opções (no máximo uma delas pode ser definida em
uma vez). O padrão é emacs. Os modos de edição podem ser definidos explicitamente usando o conjunto construídas em.
Se nenhuma dessas opções estiver habilitada, o shell simplesmente lê as linhas usando o normal tty(4)
motorista. Se o emacs or gmacs opção estiver definida, o shell permite a edição semelhante ao emacs do
comando; da mesma forma, se o vi opção estiver definida, o shell permite a edição do tipo vi do
comando. Esses modos são descritos em detalhes nas seções a seguir.

Nestes modos de edição, se uma linha for maior que a largura da tela (veja as COLUNAS
parâmetro), um caractere '>', '+' ou '<' é exibido na última coluna indicando que
há mais caracteres depois, antes e depois ou antes da posição atual,
respectivamente. A linha é rolada horizontalmente conforme necessário.

As linhas concluídas são colocadas no histórico, a menos que comecem com um octeto IFS ou IFS
espaço em branco ou são iguais à linha anterior.

Emacs edição modo
Quando o emacs opção é definida, edição de linha de entrada interativa é habilitada. Aviso: este modo
é ligeiramente diferente do modo emacs no shell Korn original. Neste modo, vários
comandos de edição (normalmente vinculados a um ou mais caracteres de controle) causam ações imediatas
sem esperar por uma nova linha. Vários comandos de edição estão vinculados a um controle particular
caracteres quando o shell é invocado; essas ligações podem ser alteradas usando o vincular comando.

A seguir está uma lista de comandos de edição disponíveis. Cada descrição começa com o
nome do comando, sufixado com dois pontos; um [n] (se o comando pode ser prefixado com um
contar); e todas as teclas às quais o comando está vinculado por padrão, escritas usando a notação circunflexa, por exemplo
o caractere ASCII ESC é escrito como ^ [. Essas sequências de controle não diferenciam maiúsculas de minúsculas.
Um prefixo de contagem para um comando é inserido usando a sequência ^ [n, Onde n é uma sequência de 1
ou mais dígitos. A menos que especificado de outra forma, se uma contagem for omitida, o padrão é 1.

Observe que os nomes dos comandos de edição são usados ​​apenas com o vincular comando. Além disso, muitos
os comandos de edição são úteis apenas em terminais com um cursor visível. As ligações padrão
foram escolhidos para se parecerem com as combinações de teclas Emacs correspondentes. O usuário tty(4) caracteres
(por exemplo, ERASE) são limitados a substitutos razoáveis ​​e sobrescrevem as ligações padrão.

abortar: ^ C, ^ G
Abortar o comando atual, esvaziar o buffer de linha e definir o estado de saída para
interrompido.

inserção automática: [n]
Simplesmente faz com que o caractere apareça como uma entrada literal. Personagens mais comuns
estão vinculados a isso.

char para trás: [n] ^ B, ^ XD, ANSI-CurLeft, PC-CurLeft
Move o cursor para trás n caracteres.

palavra invertida: [n] ^ [b, ANSI-Ctrl-CurLeft, ANSI-Alt-CurLeft
Move o cursor para trás, para o início da palavra; palavras consistem em
caracteres alfanuméricos, sublinhados ('_') e cifrões ('$').

começo da história: ^ [
Vai para o início da história.

começo da linha: ^ A, ANSI-Home, PC-Home
Move o cursor para o início da linha de entrada editada.

capitalize-word: [n] ^ [C, ^ [c
Coloque o primeiro caractere em maiúscula no próximo n palavras, deixando o cursor além do final
da última palavra.

limpar a tela: ^ [^ L
Imprime uma sequência configurável em tempo de compilação para limpar a tela e posicionar o cursor,
redesenha todo o prompt e a linha de entrada editada atualmente. A sequência padrão
funciona para quase todos os terminais padrão.

comentário: ^ [#
Se a linha atual não começar com um caractere de comentário, um será adicionado no
início da linha e a linha é inserida (como se return tivesse sido pressionado);
caso contrário, os caracteres de comentário existentes são removidos e o cursor é colocado em
o início da linha.

completo: ^ [^ [
Completa automaticamente tanto quanto é exclusivo do nome do comando ou do nome do arquivo
contendo o cursor. Se todo o comando ou nome de arquivo restante for único, um
o espaço é impresso após sua conclusão, a menos que seja um nome de diretório, caso em que
'/' é anexado. Se não houver comando ou nome de arquivo com a palavra parcial atual
como seu prefixo, um caractere de sino é gerado (geralmente fazendo com que um bipe soe).

comando completo: ^ X ^ [
Completa automaticamente tanto quanto é exclusivo do nome do comando tendo o parcial
palavra até o cursor como seu prefixo, como no completar comando acima.

arquivo completo: ^ [^ X
Completa automaticamente, tanto quanto é exclusivo do nome do arquivo tendo o parcial
palavra até o cursor como seu prefixo, como no completar comando descrito acima.

lista completa: ^ I, ^ [=
Complete o máximo possível da palavra atual e liste as possíveis
conclusões para ele. Se apenas uma conclusão for possível, combine como no completar
comando acima. Observe que ^ I geralmente é gerado pela tecla TAB (tabulador).

delete-char-backward: [n] APAGAR, ^ ?, ^ H
Exclui n caracteres antes do cursor.

excluir-char-forward: [n] ANSI-Del, PC-Del
Exclui n caracteres após o cursor.

excluir palavra para trás: [n] WERASE, ^ [^ ?, ^ [^ H, ^ [h
Exclui n palavras antes do cursor.

excluir-palavra-avançar: [n] ^ [d
Exclui caracteres após o cursor até o final de n palavras.

down-história: [n] ^ N, ^ XB, ANSI-CurDown, PC-CurDown
Rola o buffer de histórico para frente n linhas (mais tarde). Cada linha de entrada originalmente
começa logo após a última entrada no buffer de histórico, então história para baixo não é
útil até qualquer um histórico de busca, histórico de pesquisa or up-história foi
realizado.

palavra em caixa baixa: [n] ^ [L, ^ [l
O próximo em minúsculas n palavras.

linha de edição: [n] ^ Xe
Linha de edição n ou a linha atual, se não for especificada, interativamente. O real
comando executado é fc -e $ {VISUAL: - $ {EDITOR: -vi}} n.

fim da história: ^ [>
Vai para o fim da história.

fim de linha: ^ E, ANSI-End, PC-End
Move o cursor para o final da linha de entrada.

eot: ^ _
Atua como um fim de arquivo; isso é útil porque a entrada do modo de edição desativa o normal
canonização da entrada do terminal.

eot-ou-excluir: [n] ^ D
Agir como et se sozinho em uma linha; caso contrário, atua como excluir-char-forward.

erro: (não vinculado)
Erro (toque a campainha).

ponto de troca e marca: ^ X ^ X
Coloca o cursor onde a marca está e define a marca onde o cursor estava.

arquivo de expansão: ^ [*
Acrescenta um '*' à palavra atual e substitui a palavra pelo resultado de
realizando globbing de arquivo na palavra. Se nenhum arquivo corresponder ao padrão, o sino é
degrau

caractere avançado: [n] ^ F, ^ XC, ANSI-CurRight, PC-CurRight
Move o cursor para frente n caracteres.

palavra para a frente: [n] ^[f, ANSI-Ctrl-CurRight, ANSI-Alt-CurRight
Move o cursor para frente até o final da nª palavra.

goto-história: [n] ^[g
Vai para o número do histórico n.

linha de morte: KILL
Exclui toda a linha de entrada.

matar-região: ^W
Exclui a entrada entre o cursor e a marca.

matar-para-eol: [n] ^ K
Exclui a entrada do cursor até o final da linha se n não é especificado;
caso contrário, exclui caracteres entre o cursor e a coluna n.

lista: ^[?
Imprime uma lista ordenada e em colunas de nomes de comandos ou nomes de arquivos (se houver) que podem
complete a palavra parcial que contém o cursor. Os nomes dos diretórios têm '/' anexado
para eles.

comando-lista: ^X?
Imprime uma lista ordenada e em colunas de nomes de comandos (se houver) que podem completar o
palavra parcial contendo o cursor.

arquivo-lista: ^X^Y
Imprime uma lista ordenada e em colunas de nomes de arquivos (se houver) que podem completar o
palavra parcial contendo o cursor. Os indicadores de tipo de arquivo são anexados conforme descrito
para Lista acima.

nova linha: ^J, ^M
Faz com que a linha de entrada atual seja processada pelo shell. O cursor atual
posição pode estar em qualquer lugar na linha.

nova linha-e-próximo: ^O
Faz com que a linha de entrada atual seja processada pelo shell e a próxima linha de
history se torna a linha atual. Isso só é útil depois de um up-história,
histórico de busca or histórico de pesquisa.

sem operação: QUIT
Isso não faz nada.

prefixo-1: ^[
Introduz uma sequência de comandos de 2 caracteres.

prefixo-2: ^X, ^[[, ^[O
Introduz uma sequência de comandos de 2 caracteres.

palavra-hist-anterior: [n] ^[., ^[_
A última palavra, ou, se dada, a nª palavra (base zero) da anterior (em repetição
execução, penúltimo, penúltimo, etc.) é inserido no cursor. Uso de
este comando de edição destrói a marca.

citação: ^^, ^V
O caractere a seguir é interpretado literalmente e não como um comando de edição.

redesenhar: ^L
Reimprime a última linha da string de prompt e a linha de entrada atual em um novo
linha.

pesquisa-caractere-retroceder: [n] ^[^]
Pesquise para trás na linha atual para o nª ocorrência do próximo caractere
digitado.

pesquisa-caractere-forward: [n] ^]
Pesquisar para a frente na linha atual para o nª ocorrência do próximo caractere
digitado.

histórico de pesquisa: ^R
Entre no modo de pesquisa incremental. A lista de histórico interno é pesquisada para trás
comandos que correspondem à entrada. Uma inicial '^' na string de pesquisa ancora o
procurar. A tecla de escape sairá do modo de pesquisa. Outros comandos, incluindo sequências
de fuga como prefixo-1 seguido por um prefixo-1 or prefixo-2 chave será executada após
sair do modo de pesquisa. O abortar (^G) irá restaurar a linha de entrada antes
pesquisa iniciada. Sucessivo histórico de busca comandos continuam procurando para trás para
a próxima ocorrência anterior do padrão. O buffer de histórico retém apenas um
número finito de linhas; os mais antigos são descartados conforme necessário.

histórico de pesquisa: ANSI-PgUp, PC-PgUp
Pesquise para trás no buffer do histórico por comandos cujo início corresponda ao
parte da linha de entrada antes do cursor. Quando usado em uma linha vazia, isso tem
o mesmo efeito que up-história.

pesquisa-histórico-baixo: ANSI-PgDn, PC-PgDn
Pesquise no buffer do histórico por comandos cujo início corresponda ao
parte da linha de entrada antes do cursor. Quando usado em uma linha vazia, isso tem
o mesmo efeito que história para baixo. Isso só é útil depois de um up-história,
histórico de busca or histórico de pesquisa.

comando set-mark: ^[
Defina a marca na posição do cursor.

caracteres de transposição: ^T
Se no final da linha, ou se o gmacs opção está definida, isso troca os dois
caracteres anteriores; caso contrário, ele troca os caracteres anteriores e atuais e
move o cursor um caractere para a direita.

up-história: [n] ^P, ^XA, ANSI-CurUp, PC-CurUp
Rola o buffer do histórico para trás n linhas (antes).

palavra maiúscula: [n] ^[você, ^[você
Maiúsculas o próximo n palavras.

versão: ^[^V
Mostra a versão de Obrigado. O buffer de edição atual é restaurado assim que uma chave
é pressionado. O pressionamento de tecla de restauração é processado, a menos que seja um espaço.

puxe: ^Y
Insere a string de texto eliminada mais recentemente na posição atual do cursor.

ianque-pop: ^[y
Imediatamente após um puxão, substitui a string de texto inserida pela próxima anteriormente
cadeia de texto morta.

Vi edição modo
Observação: O modo de edição de linha de comando vi é órfão, mas ainda funcional. É 8 bits limpo
mas especificamente não suporta UTF-8 ou MBCS.

O editor de linha de comando vi no Obrigado tem basicamente os mesmos comandos que o vi(1) editor com
as seguintes exceções:

· Você começa no modo de inserção.

· Existem comandos de preenchimento de nome de arquivo e comando: =, \, *, ^X, ^E, ^F e,
opcionalmente, e .

· A _ comando é diferente (em Obrigado, é o último comando de argumento; dentro vi(1) vai
para o início da linha atual).

· A / e G comandos se movem na direção oposta ao j comando.

· Comandos que não fazem sentido em um editor de linha única não estão disponíveis (por exemplo, tela
comandos de movimento e ex(1) estilo dois pontos (:) comandos).

Como vi(1), existem dois modos: modo “inserir” e modo “comando”. No modo de inserção, a maioria
os caracteres são simplesmente colocados no buffer na posição atual do cursor à medida que são digitados;
no entanto, alguns caracteres são tratados de forma especial. Em particular, os seguintes caracteres são
retirado da corrente tty(4) configurações (consulte chiqueiro(1)) e têm seu significado usual (valores normais
estão entre parênteses): kill (^U), erase (^?), werase (^W), eof (^D), intr (^C) e quit (^\).
Além do acima, os seguintes caracteres também são tratados especialmente na inserção
modo:

^E Comando e enumeração do nome do arquivo (veja abaixo).

^F Complemento de comando e nome de arquivo (veja abaixo). Se usado duas vezes seguidas, a lista de
possíveis conclusões são exibidas; se usado uma terceira vez, a conclusão é desfeita.

^H Apaga o caractere anterior.

^J | ^M Fim de linha. A linha atual é lida, analisada e executada pelo shell.

^V Literal a seguir. O próximo caractere digitado não é tratado de forma especial (pode ser usado para
insira os caracteres que estão sendo descritos aqui).

^X Expansão de comando e nome de arquivo (veja abaixo).

Coloca o editor no modo de comando (veja abaixo).

Nome de arquivo opcional e conclusão de comando (consulte ^F acima), habilitado com conjunto -o
vi-tabcompleto.

No modo de comando, cada caractere é interpretado como um comando. Personagens que não
correspondem a comandos, são combinações ilegais de comandos ou são comandos que não podem ser
executado, todos causam bipes. Nas descrições de comando a seguir, um [n] indica o
comando pode ser prefixado por um número (por exemplo 10l move para a direita 10 caracteres); se nenhum número
prefixo é usado, n é assumido como 1 a menos que especificado de outra forma. O termo “atual
position” refere-se à posição entre o cursor e o caractere que precede o cursor.
Uma “palavra” é uma sequência de letras, dígitos e caracteres de sublinhado ou uma sequência de caracteres não
caracteres de letras, não dígitos, não sublinhados e não espaços em branco (por exemplo, “ab2*&^” contém dois
palavras) e uma “grande palavra” é uma sequência de caracteres que não são espaços em branco.

Destaque Obrigado comandos do vi:

Os comandos a seguir não estão ou são diferentes do editor de arquivos vi normal:

[n]_ Insira um espaço seguido do nª grande palavra do último comando da história
na posição atual e entre no modo de inserção; E se n não for especificado, o último
palavra é inserida.

# Insira o caractere de comentário ('#') no início da linha atual e retorne
a linha para o shell (equivalente a Eu#^J).

[n]g Curtir G, exceto se n não for especificado, ele vai para o mais recente lembrado
linha.

[n]v Editar linha n usando o vi(1) editor; E se n não for especificado, a linha atual é
editado. O comando real executado é fc -e $ {VISUAL: - $ {EDITOR: -vi}} n.

* e ^X Comando ou expansão de nome de arquivo é aplicado à palavra grande atual (com um
acrescentado '*' se a palavra não contiver caracteres de globbing de arquivo) - a palavra grande é
substituído pelas palavras resultantes. Se a palavra grande atual for a primeira no
linha ou segue um dos caracteres ';', '|', '&', '(', ou ')', e não
conter uma barra ('/'), então a expansão do comando é feita; caso contrário, nome do arquivo
expansão é feita. A expansão do comando combinará a palavra grande com todos
aliases, funções e comandos integrados, bem como quaisquer arquivos executáveis ​​encontrados
pesquisando os diretórios no parâmetro PATH. A expansão do nome do arquivo corresponde
a palavra grande contra os arquivos no diretório atual. Após a expansão, o
cursor é colocado logo após a última palavra e o editor está no modo de inserção.

[n]\, [n]^F, [n] , e [n]
Conclusão do nome do comando/arquivo. Substitua a palavra grande atual pela mais longa
correspondência exclusiva obtida após executar o comando e a expansão do nome do arquivo.
só é reconhecido se o vi-tabcompleto opção está definida, enquanto é apenas
reconhecido se o vi-completo opção está definida (consulte conjunto -o). Se n é especificado,
que o na conclusão possível está seleccionada (conforme indicado pelo comando/nome do ficheiro
comando de enumeração).

= e ^E Enumeração do nome do comando/arquivo. Liste todos os comandos ou arquivos que correspondem ao
palavra grande atual.

^V Exibe a versão de Obrigado. O buffer de edição atual é restaurado assim que um
tecla é pressionada. O pressionamento de tecla de restauração é ignorado.

@c Expansão macro. Execute os comandos encontrados no alias c.

Comandos de movimento intra-linha:

[n]mão [n]^H
Mova à esquerda n caracteres.

[n]terra [n]
Mover para a direita n caracteres.

0 Mover para a coluna 0.

^ Move para o primeiro caractere sem espaço em branco.

[n]| Mover para coluna n.

$ Move para o último caractere.

[n]b Mover para trás n palavras.

[n]B Mover para trás n palavras grandes.

[n]e Avance para o final da palavra, n vezes.

[n]E Avance para o final da palavra grande, n vezes.

[n]w Avançar n palavras.

[n]W Avançar n palavras grandes.

% Encontrar partida. O editor aguarda o parêntese, colchete ou chave mais próximo
e, em seguida, move o cursor para o parêntese, colchete ou chave correspondente.

[n]fc Avance para o nª ocorrência do personagem c.

[n]Fc Mover para trás para o nª ocorrência do personagem c.

[n]tc Avançar para pouco antes do nª ocorrência do personagem c.

[n]Tc Mover para trás para um pouco antes do nª ocorrência do personagem c.

[n]; Repete o último f, F, tou T comando.

[n], Repete o último f, F, tou T comando, mas se move na direção oposta.

Comandos de movimento entre linhas:

[n]j, [n]+, e [n]^N
Mover para o nª linha seguinte na história.

[n]k, [n]-, e [n]^P
Mover para o nª linha anterior na história.

[n]G Mover para a linha n na historia; E se n não for especificado, o número do primeiro
linha lembrada é usada.

[n]g Curtir G, exceto se n não for especificado, ele vai para a linha lembrada mais recente.

[n]/corda
Pesquise para trás através do histórico para o nª linha contendo corda; E se corda
começa com '^', o restante da string deve aparecer no início do histórico
linha para que corresponda.

[n]?corda
Igual a /, exceto que ele pesquisa para frente no histórico.

[n]n Procure o nª ocorrência da última string de pesquisa; a direção da busca
é igual à última pesquisa.

[n]N Procure o nª ocorrência da última string de pesquisa; a direção da busca
é o oposto da última pesquisa.

CurUp ANSI, PC-PgUp
Leve os caracteres do início da linha até a posição atual do cursor como
pesquisar string e fazer uma pesquisa de histórico para trás por linhas começando com isso
corda; mantenha a posição do cursor. Isso funciona apenas no modo de inserção e o mantém
ativado.

Editar comandos

[n]a Anexar texto n vezes; entra no modo de inserção logo após a posição atual. O
append só é replicado se o modo de comando for reinserido, ou seja é usado.

[n] Igual a a, exceto que acrescenta no final da linha.

[n]i Inserir texto n vezes; entra no modo de inserção na posição atual. A inserção
só é replicado se o modo de comando for reinserido, ou seja é usado.

[n]Igual a i, exceto que a inserção é feita logo antes do primeiro caractere não em branco.

[n]s Substituir o próximo n caracteres (ou seja, apague os caracteres e vá para inserir
modo).

S Substitua a linha inteira. Todos os caracteres do primeiro caractere não em branco até o final
da linha são excluídos e o modo de inserção é inserido.

[n]cmover-cmd
Mudança da posição atual para a posição resultante da n mover-cmds (ou seja
exclua a região indicada e entre no modo de inserção); E se mover-cmd is c, A linha
a partir do primeiro caractere não em branco é alterado.

C Mude da posição atual para o final da linha (ou seja, delete para o final da
a linha e entrar no modo de inserção).

[n]x Excluir o próximo n caracteres.

[n]X Excluir o anterior n caracteres.

D Apague até o final da linha.

[n]dmover-cmd
Excluir da posição atual para a posição resultante de n mover-cmds;
mover-cmd é um comando de movimento (veja acima) ou d, caso em que a linha atual é
excluída.

[n]rc Substitua o próximo n personagens com o personagem c.

[n]R Substitua. Entre no modo de inserção, mas sobrescreva os caracteres existentes em vez de inserir
antes dos caracteres existentes. A substituição é repetida n vezes.

[n]~ Mude o caso do próximo n caracteres.

[n]ymover-cmd
Puxe da posição atual para a posição resultante da n mover-cmdestá no
puxar buffer; E se mover-cmd is y, toda a linha é puxada.

Y Puxe da posição atual até o final da linha.

[n]p Cole o conteúdo do buffer yank logo após a posição atual, n vezes.

[n]P Igual a p, exceto que o buffer é colado na posição atual.

Comandos diversos do vi

^J e ^M
A linha atual é lida, analisada e executada pelo shell.

^L e ^R
Redesenhe a linha atual.

[n]. Refazer o último comando de edição n vezes.

u Desfaz o último comando de edição.

Desfazer todas as alterações feitas na linha atual.

Teclas PC Home, End, Del e cursor
Eles se movem conforme o esperado, tanto no modo de inserção quanto no de comando.

intr e desistir
Os caracteres do terminal de interrupção e saída fazem com que a linha atual seja excluída e
um novo prompt a ser impresso.

Use mksh online usando serviços onworks.net