mksh - Online nel cloud

PROGRAMMA:

NOME

Grazie, sh — Conchiglia Korn MirBSD

SINOSSI

Grazie [-+abCefhiklmnprUuvXx] [-T [!]tty | -] [-+o opzione] [-c stringa | -s | filetto
[argomento ...]]
nome-incorporato [argomento ...]

DESCRIZIONE

Grazie è un interprete di comandi destinato all'uso sia interattivo che di script di shell. Suo
il linguaggio di comando è un superset del linguaggio della shell sh(C) ed è ampiamente compatibile con il
guscio originale Korn. A volte, questa pagina di manuale può fornire consigli sullo scripting; mentre è
a volte tiene conto di script di shell portabili o di vari standard
le informazioni sono prima di tutto presentate con Grazie in mente e come tale va preso.

sono an Android utente, so ciò che è mksh?
Grazie è una shell UNIX / interprete di comandi, simile a COMMAND.COM or CMD.EXE, Che ha
è stato incluso con Android Open Source Project per un po' di tempo. Fondamentalmente, è un programma
che viene eseguito in un terminale (finestra della console), accetta l'input dell'utente ed esegue comandi o script,
cosa che può essere richiesta anche da altri programmi, anche in background. Qualsiasi privilegio
i pop-up che potresti incontrare non lo sono quindi Grazie problemi ma domande di qualcun altro
programma che lo utilizza.

Invocazione
La maggior parte dei comandi incorporati può essere chiamata direttamente, ad esempio se un collegamento punta dal suo nome a
guscio; non tutti hanno senso, sono stati testati o funzionano affatto.

Le opzioni sono le seguenti:

-c stringa Grazie eseguirà i comandi contenuti in stringa.

-i Guscio interattivo. Una shell che legge i comandi dall'input standard è
“interattivo” se viene utilizzata questa opzione o se sia lo standard input che l'errore standard
sono attaccati ad un tty(4). Una shell interattiva ha il controllo del lavoro abilitato, ignora
i segnali SIGINT, SIGQUIT e SIGTERM e stampa i prompt prima di leggere l'input
(vedi i parametri PS1 e PS2). Elabora anche il parametro ENV o il
mkshrc file (vedi sotto). Per le shell non interattive, il trackall l'opzione è attiva
per impostazione predefinita (vedi set comando sotto).

-l Shell di accesso. Se il nome base con cui viene chiamata la shell (ad esempio argv[0]) inizia con
'-' o se viene utilizzata questa opzione, si presume che la shell sia una shell di login; vedere
Startup file qua sotto.

-p Conchiglia privilegiata. Una shell è "privilegiata" se lo fa l'ID utente reale o l'ID gruppo
non corrisponde all'ID utente effettivo o all'ID gruppo (vedi getuid(2) e impazzisci(2)).
La cancellazione dell'opzione privilegiata fa sì che la shell imposti il ​​suo ID utente effettivo
(ID gruppo) al suo ID utente reale (ID gruppo). Per ulteriori implicazioni, cfr Startup
file. Se la shell è privilegiata e questo flag non è esplicitamente impostato, il
L'opzione "privilegiata" viene cancellata automaticamente dopo l'elaborazione dei file di avvio.

-r Guscio ristretto. Una shell è "limitata" se viene utilizzata questa opzione. Il seguente
le restrizioni entrano in vigore dopo che la shell elabora qualsiasi profilo e ENV
File:

· I cd (E chdir) il comando è disabilitato.
· I parametri SHELL, ENV e PATH non possono essere modificati.
· I nomi dei comandi non possono essere specificati con percorsi assoluti o relativi.
· I -p opzione del comando integrato command non può essere utilizzato.
· I reindirizzamenti che creano file non possono essere utilizzati (es. '>', '>|', '>>', '<>').

-s La shell legge i comandi dallo standard input; tutti gli argomenti non di opzione sono
parametri posizionali.

-T Nome Deporre le uova Grazie sul tty(4) dispositivo dato. i percorsi Nome, /dev/ttyCnome ed
/dev/ttynome vengono tentati in ordine. Salvo che Nome inizia con un punto esclamativo
('!'), questo viene fatto in una subshell e ritorna immediatamente. Se Nome è un trattino
('-'), invece, staccarsi dal terminale di controllo (demonizzare).

Oltre a quanto sopra, le opzioni descritte nel set è possibile utilizzare anche il comando integrato
sulla riga di comando: entrambi [-+abCefhkmnuvXx] E [-+o opzione] può essere utilizzato per una singola lettera
o opzioni lunghe, rispettivamente.

Se né il -c né l' -s opzione è specificata, il primo argomento non opzione specifica
il nome di un file da cui la shell legge i comandi. Se non ci sono argomenti non di opzione, il
shell legge i comandi dallo standard input. Il nome della shell (cioè il contenuto di
$0) è determinato come segue: se il -c viene utilizzata l'opzione e c'è un argomento non opzione,
è usato come nome; se i comandi vengono letti da un file, il file viene utilizzato come
nome; in caso contrario, viene utilizzato il nome base con cui è stata chiamata la shell (ad esempio argv[0]).

Lo stato di uscita della shell è 127 se il file di comando specificato sulla riga di comando potrebbe
non essere aperto, o diverso da zero se si è verificato un errore di sintassi fatale durante l'esecuzione di a
sceneggiatura. In assenza di errori fatali, lo stato di uscita è quello dell'ultimo comando
eseguito, o zero, se non viene eseguito alcun comando.

Startup file
Per la posizione effettiva di questi file, vedere FILE. Una shell di login elabora il sistema
prima il profilo. Una shell privilegiata elabora quindi il profilo suid. Un accesso non privilegiato
shell elabora successivamente il profilo utente. Una shell interattiva non privilegiata controlla il valore
del parametro ENV dopo averlo sottoposto a parametro, comando, aritmetica e tilde ('~')
sostituzione; se non impostato o vuoto, viene elaborato il profilo mkshrc dell'utente; altrimenti, se un file
il cui nome è il risultato della sostituzione esiste, viene elaborato; la non esistenza è silenziosa
ignorato. Una shell privilegiata quindi rilascia i privilegi se nessuno dei due lo era -p opzione data sul
riga di comando né impostato durante l'esecuzione dei file di avvio.

Comando sintassi
La shell inizia ad analizzare il suo input rimuovendo qualsiasi combinazione di backslash-newline, quindi
romperlo in parole. Le parole (che sono sequenze di caratteri) sono delimitate da senza virgolette
caratteri spazi bianchi (spazio, tab e nuova riga) o metacaratteri ('<', '>', '|', ';', '(',
')', e '&'). Oltre a delimitare le parole, gli spazi e le tabulazioni vengono ignorati, mentre le nuove righe
di solito delimitano i comandi. I meta-caratteri vengono utilizzati nella costruzione di quanto segue token:
'<', '<&', '<<', '<<<', '>', '>&', '>>', '&>', ecc. vengono utilizzati per specificare i reindirizzamenti (vedi
Input / output reindirizzamento sotto); '|' viene utilizzato per creare pipeline; '|&' viene utilizzato per creare co-
processi (vedi Co-processi sotto); ';' è usato per separare i comandi; '&' è usato per creare
pipeline asincrone; '&&' e '||' sono usati per specificare l'esecuzione condizionale; ';;', ';&'
e ';|' sono usati in Custodie dichiarazioni; '(( .. ))' è usato nelle espressioni aritmetiche; e
infine, '( .. )' viene utilizzato per creare subshell.

Gli spazi bianchi e i metacaratteri possono essere citati singolarmente utilizzando una barra rovesciata ('\') o in
gruppi utilizzando virgolette doppie ('"') o singole ("'"). Nota che i seguenti caratteri sono
trattate anche in modo speciale dalla conchiglia e devono essere citate se devono rappresentare se stesse:
'\', '"', ''', '#', '$', '`', '~', '{', '}', '*', '?' e '['. i primi tre di questi
sono i caratteri di citazione sopra menzionati (vedi Quoting sotto); '#', se usato al
all'inizio di una parola, introduce un commento – tutto dopo il '#' fino al più vicino
la nuova riga viene ignorata; '$' viene utilizzato per introdurre parametri, comandi e aritmetica
sostituzioni (vedi Sostituzione sotto); '`' introduce una sostituzione di comando vecchio stile
(Vedi Sostituzione sotto); '~' inizia un'espansione di directory (vedi tilde espansione sotto); '{'
e '}' delimitano csh(1) alternanze di stile (vedi Bretelle espansione sotto); e infine, '*',
'?' e '[' sono usati nella generazione del nome file (vedi Compila il Nome modelli sotto).

Man mano che le parole e i token vengono analizzati, la shell costruisce i comandi, di cui ci sono due fondamentali
tipi: semplici-comandi, tipicamente programmi che vengono eseguiti, e comandi-composti, come
as per ed if istruzioni, costrutti di raggruppamento e definizioni di funzioni.

Un comando semplice consiste in una combinazione di assegnazioni di parametri (vedi parametri
sotto), reindirizzamenti input/output (vedi Input / output redirect sotto) e parole di comando;
l'unica limitazione è che le assegnazioni dei parametri vengono prima di qualsiasi parola di comando. Il
le parole di comando, se presenti, definiscono il comando che deve essere eseguito e i suoi argomenti. Il
comando può essere un comando integrato nella shell, una funzione o un comando esterno (cioè un comando separato
file eseguibile che si trova utilizzando il parametro PATH; vedere Comando esecuzione sotto).
Nota che tutti i costrutti di comando hanno uno stato di uscita: per i comandi esterni, questo è correlato
allo stato restituito da aspettare(2) (se non è stato possibile trovare il comando, lo stato di uscita è
127; se non può essere eseguito, lo stato di uscita è 126); lo stato di uscita di un altro comando
i costrutti (comandi incorporati, funzioni, comandi composti, pipeline, elenchi, ecc.) sono tutti
ben definiti e sono descritti dove è descritto il costrutto. Lo stato di uscita di a
comando costituito dalla sola parametrizzazione è quello dell'ultima sostituzione di comando
eseguita durante la parametrizzazione o 0 se non sono state effettuate sostituzioni di comandi.

I comandi possono essere concatenati usando '|' token per formare pipeline, in cui il
l'output standard di ogni comando ma l'ultimo viene reindirizzato (vedi tubo(2)) allo standard input di
il seguente comando. Lo stato di uscita di una pipeline è quello del suo ultimo comando, a meno che
, il tubo fallito l'opzione è impostata (vedi lì). Tutti i comandi di una pipeline vengono eseguiti separatamente
sottoconchiglie; questo è consentito da POSIX ma differisce da entrambe le varianti di AT&T UNIX ksh, Dove
tutti i comandi tranne l'ultimo sono stati eseguiti nelle subshell; vedere il read descrizione di built-in per
implicazioni e soluzioni alternative. Una pipeline può essere preceduta da '!' parola riservata che
fa sì che lo stato di uscita del gasdotto sia logicamente complementare: se lo stato originario
era 0, lo stato complementare sarà 1; se lo stato originale non era 0, il complemento
lo stato sarà 0.

elenchi di comandi possono essere creati separando le pipeline con uno dei seguenti token:
'&&', '||', '&', '|&' e ';'. I primi due sono per l'esecuzione condizionale: “cmd1 && cmd2"
esegue cmd2 solo se lo stato di uscita di cmd1 è zero; '||' è il contrario - cmd2 is
eseguito solo se lo stato di uscita di cmd1 è diverso da zero. '&&' e '||' hanno uguale precedenza
che è superiore a quello di '&', '|&' e ';', che hanno anch'essi uguale precedenza. Nota
che '&&' e '||' gli operatori sono "associativi di sinistra". Ad esempio, entrambi
i comandi stamperanno solo "bar":

$ false && echo foo || barra dell'eco
$ vero || echo foo && echo bar

Il token '&' fa in modo che il comando precedente venga eseguito in modo asincrono; cioè il guscio
avvia il comando ma non aspetta che venga completato (la shell tiene traccia del
stato dei comandi asincroni; vedere Lavoro di controllo sotto). Quando un comando asincrono è
avviato quando il controllo del lavoro è disabilitato (cioè nella maggior parte degli script), il comando viene avviato con
segnali SIGINT e SIGQUIT ignorati e con ingresso reindirizzato da / Dev / null (però,
i reindirizzamenti specificati nel comando asincrono hanno la precedenza). L'operatore '|&'
avvia un co-processo che è un tipo speciale di processo asincrono (vedi Co-processi
sotto). Nota che un comando deve seguire '&&' e '||' operatori, mentre non è necessario
segui '&', '|&' o ';'. Lo stato di uscita di una lista è quello dell'ultimo comando eseguito,
ad eccezione delle liste asincrone, per le quali lo stato di uscita è 0.

I comandi composti vengono creati utilizzando le seguenti parole riservate. Queste parole sono solo
riconosciuti se non sono quotati e se sono usati come prima parola di un comando (es
non possono essere preceduti da assegnazioni di parametri o reindirizzamenti):

caso altrimenti funzione allora! (
fai esac se ora [[ ((
fatto fino a {
elif per selezionare mentre }

Nelle seguenti descrizioni dei comandi composti, gli elenchi dei comandi (indicati come stratagemma) che sono
seguito da parole riservate deve terminare con un punto e virgola, una nuova riga o un (sintatticamente
corretta) parola riservata. Ad esempio, sono tutti validi:

$ { eco pippo; barra dell'eco; }
$ { eco pippo; barra dell'eco }
$ { { eco pippo; barra dell'eco; } }

Questo non è valido:

$ { eco pippo; barra dell'eco }

(stratagemma)
Eseguire stratagemma in un sottoscala. Non esiste un modo implicito per passare i cambiamenti dell'ambiente da
una subshell al suo genitore.

{ stratagemma; }
Costrutto composto; stratagemma viene eseguito, ma non in una subshell. Nota che '{' e '}'
sono parole riservate, non metacaratteri.

Custodie parola In [[(] modello [| modello]...) stratagemma Terminator] ... es
I Custodie l'istruzione tenta di corrispondere parola contro un determinato modello; il stratagemma
associato al primo modello abbinato correttamente viene eseguito. Modelli utilizzati in
Custodie le istruzioni sono le stesse usate per i modelli di nomi di file tranne per il fatto che
restrizioni riguardanti '.' e '/' vengono eliminati. Nota che qualsiasi spazio non quotato prima
e dopo che un modello è stato spogliato; qualsiasi spazio all'interno di un modello deve essere citato. entrambi
la parola e gli schemi sono soggetti a parametri, comandi e sostituzioni aritmetiche,
così come la sostituzione della tilde.

Per ragioni storiche, è possibile utilizzare le parentesi graffe aperte e chiuse al posto di in ed che C per esempio
Custodie $ foo { *) eco bar ;; }.

La lista Terminatorsono:

';;' Termina dopo l'elenco.

';&' Passa alla lista successiva.

';|' Valutare le restanti tuple dell'elenco di modelli.

Lo stato di uscita di a Custodie l'istruzione è quella dell'eseguito stratagemma; se no stratagemma is
eseguito, lo stato di uscita è zero.

per Nome [nel parola ...]; fare stratagemma; fatto
Per ciascun parola nell'elenco di parole specificato, il parametro Nome è impostato sulla parola e
stratagemma viene eseguito. Se in non viene utilizzato per specificare un elenco di parole, i parametri posizionali
($ 1, $ 2, ecc.) Vengono invece utilizzati. Per ragioni storiche, le parentesi graffe aperte e chiuse possono essere
usato invece di do ed fatto per esempio per i; { eco $ io; }. Lo stato di uscita di a per
l'istruzione è l'ultimo stato di uscita di stratagemma; Se stratagemma non viene mai eseguito, lo stato di uscita
è zero.

if stratagemma; poi stratagemma; [elifi stratagemma; poi stratagemma;] ... [altro stratagemma;] fi
Se lo stato di uscita del primo stratagemma è zero, il secondo stratagemma viene eseguito; altrimenti,
, il stratagemma seguendo la Elif, se del caso, è eseguito con conseguenze simili. Cado
gli elenchi che seguono if ed Elifs fail (cioè uscita con stato diverso da zero), il stratagemma
seguendo la altro viene eseguito. Lo stato di uscita di an if l'affermazione è quella di non
condizionale stratagemma che viene eseguito; se non incondizionato stratagemma viene eseguito, l'uscita
lo stato è zero.

select Nome [nel parola ...]; fare stratagemma; fatto
I select l'istruzione fornisce un metodo automatico per presentare all'utente un menu
e selezionando da esso. Un elenco enumerato degli specificati parola(s) è stampato su
errore standard, seguito da un prompt (PS3: normalmente '#? '). Un numero corrispondente a
una delle parole enumerate viene poi letta dallo standard input, Nome è impostato al
parola selezionata (o disattivata se la selezione non è valida), REPLY è impostato su quanto letto
(lo spazio iniziale/finale è spogliato), e stratagemma viene eseguito. Se una riga vuota (es
zero o più ottetti IFS), il menu viene ristampato senza eseguire stratagemma.

Quando stratagemma completa, l'elenco enumerato viene stampato se REPLY è NULL, il prompt è
stampato, e così via. Questo processo continua fino a quando non viene letta una fine del file, un'interruzione
è ricevuto, o a rompere l'istruzione viene eseguita all'interno del ciclo. Se "in parole..." è
omessi, vengono utilizzati i parametri posizionali (es. $1, $2, ecc.). Per storico
motivi, si possono usare parentesi graffe aperte e chiuse al posto di do ed fatto per esempio select i; {
eco $ io; }. Lo stato di uscita di a select l'istruzione è zero se a rompere l'affermazione è
usato per uscire dal ciclo, diverso da zero altrimenti.

fino a quando stratagemma; fare stratagemma; fatto
Funziona come while, tranne che il corpo viene eseguito solo mentre lo stato di uscita di
il primo stratagemma è diverso da zero.

while stratagemma; fare stratagemma; fatto
A while è un ciclo pre-controllato. Il suo corpo viene eseguito tutte le volte che lo stato di uscita di
il primo stratagemma è zero. Lo stato di uscita di a while l'istruzione è l'ultimo stato di uscita
della stratagemma nel corpo del ciclo; se il corpo non viene eseguito, lo stato di uscita è
zero.

function Nome { stratagemma; }
Definisce la funzione Nome (Vedi funzioni sotto). Nota che i reindirizzamenti sono stati specificati
dopo che una definizione di funzione viene eseguita ogni volta che viene eseguita la funzione, non quando
viene eseguita la definizione della funzione.

Nome() command
Per lo più lo stesso di function (Vedi funzioni sotto). Spazi bianchi (spazio o tab) dopo
Nome verrà ignorato per la maggior parte del tempo.

function Nome() { stratagemma; }
Lo stesso di Nome() (bashismo). Il function la parola chiave viene ignorata.

tempo [-p] [conduttura]
I Comando esecuzione sezione descrive il tempo parola riservata.

(( espressione ))
L'espressione aritmetica espressione viene valutato; equivalente a "let expression" (vedi
Aritmetica espressioni e la lasciare comando, sotto) in un costrutto composto.

[[ espressione ]]
Simile al test ed [ ... ] comandi (descritti in seguito), con il seguente
eccezioni:

· La suddivisione dei campi e la generazione del nome file non vengono eseguite sugli argomenti.

· I -a (E e -o Gli operatori (OR) vengono sostituiti rispettivamente con '&&' e '||'.

· Operatori (es. '-f', '=', '!') deve essere senza virgolette.

· Le sostituzioni di parametri, comandi e aritmetiche vengono eseguite come le espressioni
la valutazione dell'espressione valutata e pigra viene utilizzata per '&&' e '||' operatori.
Ciò significa che nella seguente affermazione, $( si valuta se e solo se
il file foo esiste ed è leggibile:

$ [[ -r pippo && $(

· Il secondo operando delle espressioni '!=' e '=' è un sottoinsieme di pattern (es
il confronto [[ foobar = FR ]] riesce). Funziona anche indirettamente:

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

Forse sorprendentemente, il primo confronto riesce, mentre il secondo no.
Questo non si applica a tutti i metacaratteri extglob, attualmente.

Quoting
La citazione viene utilizzata per impedire alla shell di trattare caratteri o parole in modo speciale. Ci sono
tre metodi di citazione. Primo, '\' cita il seguente carattere, a meno che non sia al
fine di una riga, nel qual caso sia la '\' che la nuova riga vengono eliminati. Secondo, un singolo
quote ("'") cita tutto fino alla virgoletta singola successiva (questo può estendersi su righe). Terzo, a
virgolette doppie ('"') cita tutti i caratteri, eccetto '$', '`' e '\', fino al successivo senza caratteri di escape
doppia citazione. '$' e '`' all'interno delle virgolette hanno il loro significato abituale (cioè parametro,
aritmetica o sostituzione di comando) eccetto che sui risultati non viene eseguita alcuna suddivisione dei campi
di sostituzioni tra virgolette e la forma vecchio stile di sostituzione di comando ha
virgolette backslash per virgolette abilitate. Se una '\' all'interno di una stringa tra virgolette è
seguito da '\', '$', '`' o '"', viene sostituito dal secondo carattere; se è seguito
da una nuova riga, sia la '\' che la nuova riga vengono eliminate; altrimenti, sia '\' che
carattere che segue sono invariati.

Se una stringa con apici singoli è preceduta da un '$' senza virgolette, espansione barra rovesciata in stile C (vedi
sotto) viene applicato (anche le virgolette all'interno possono essere sfuggite e non terminare
la stringa quindi); il risultato espanso viene trattato come qualsiasi altra stringa tra virgolette singole. Se un
la stringa tra virgolette è preceduta da un '$' senza virgolette, il '$' viene semplicemente ignorato.

Barra rovesciata espansione
Nei luoghi in cui le barre rovesciate sono espanse, alcuni UNIX C e AT&T ksh o GNU bash style
le fughe sono tradotte. Questi includono '\a', '\b', '\f', '\n', '\r', '\t', '\U########',
'\u####' e '\v'. Per '\U########' e '\u####', “#” indica una cifra esadecimale, di cui
non ce ne possono essere fino a quattro o otto; questi escape traducono un codepoint Unicode in UTF-8.
Inoltre, '\E' e '\e' si espandono al carattere di escape.

Nel stampare modalità incorporata, '\"', '\'' e '\?' sono esplicitamente escluse; sequenze ottali
deve avere il none fino a tre cifre ottali “#” preceduto dalla cifra zero ('\0###');
le sequenze esadecimali '\x##' sono limitate a nessuna fino a due cifre esadecimali “#”; entrambi
le sequenze ottali ed esadecimali vengono convertite in ottetti grezzi; '\#', dove # non è nessuno dei precedenti,
si traduce in \# (le barre rovesciate vengono mantenute).

L'espansione della barra rovesciata nella modalità stile C è leggermente diversa: le sequenze ottali '\###' devono avere
nessuna cifra zero che preceda l'uno fino a tre cifre ottali "#" e produce ottetti grezzi;
sequenze esadecimali '\x#*' mangiano avidamente quante più cifre esadecimali "#" possibile e
terminare con la prima cifra non esadecimale; questi traducono un codepoint Unicode in
UTF-8. La sequenza '\c#', dove "#" è un qualsiasi ottetto, si traduce in Ctrl-# (che fondamentalmente
significa, '\c?' diventa DEL, tutto il resto è AND bit per bit con 0x1F). Infine, '\#', dove
# non è nessuno dei precedenti, si traduce in # (ha la barra rovesciata tagliata), anche se è a
nuova linea.

Alias
Esistono due tipi di alias: alias di comando normali e alias tracciati. Alias ​​di comando
sono normalmente usati come mano corta per un comando lungo o usato spesso. Il guscio si espande
alias di comando (cioè sostituisce il nome dell'alias per il suo valore) quando legge la prima parola
di un comando. Un alias espanso viene rielaborato per verificare la presenza di altri alias. Se un comando
alias termina con uno spazio o una tabulazione, anche la parola seguente viene controllata per l'espansione dell'alias. Il
il processo di espansione degli alias si interrompe quando viene trovata una parola che non è un alias, quando una parola tra virgolette
viene trovata o quando viene trovata una parola alias che è attualmente in fase di espansione. Gli alias sono
specificamente una funzione interattiva: mentre capita di lavorare negli script e sul
riga di comando in alcuni casi, gli alias vengono espansi durante il lexing, quindi il loro uso deve essere in a
albero dei comandi separato dalla loro definizione; in caso contrario, l'alias non verrà trovato.
Notevolmente, elenchi di comandi (separati da punto e virgola, nelle sostituzioni di comandi anche da newline)
potrebbe essere uno stesso albero di analisi.

I seguenti alias di comando sono definiti automaticamente dalla shell:

autoload='\typeset -fu'
functions='\typeset -f'
hash='\alias integrato -t'
history='\builtin fc -l'
intero='\typeset -i'
local='\typeset'
login='\exec login'
nameref='\typeset -n'
nohup='nohup '
r='\builtin fc -e -'
type='\builtin donde -v'

Gli alias tracciati consentono alla shell di ricordare dove ha trovato un particolare comando. Il primo
ogni volta che la shell esegue una ricerca del percorso per un comando contrassegnato come alias tracciato, salva
il percorso completo del comando. La prossima volta che il comando viene eseguito, la shell controlla il
percorso salvato per vedere che è ancora valido e, in tal caso, evita di ripetere la ricerca del percorso.
Gli alias tracciati possono essere elencati e creati utilizzando alias -t. Nota che cambiando il PERCORSO
Il parametro cancella i percorsi salvati per tutti gli alias tracciati. Se la trackall l'opzione è impostata
(vale a dire set -o trackall or set -h), la shell tiene traccia di tutti i comandi. Questa opzione è impostata
automaticamente per shell non interattive. Per le shell interattive, solo quanto segue
i comandi vengono tracciati automaticamente: gatto(1) cc(1) chmod(1) cp(1) quando(1) ed(1)
emacs(1) grep(1) ls(1) make(1) mv(1) pr(1) rm(1) sete(1) sh(1) vi(1), e che(1).

Sostituzione
Il primo passo che la shell esegue nell'esecuzione di un comando semplice è eseguire le sostituzioni su
le parole del comando. Esistono tre tipi di sostituzione: parametro, comando e
aritmetica. Le sostituzioni dei parametri, descritte in dettaglio nella sezione successiva,
prendere la forma $Nome o ${...}; le sostituzioni di comando assumono la forma $(command) o puoi
(deprecato) `command` o (eseguito nell'ambiente corrente) ${ command;} e striscia
nuove righe finali; e le sostituzioni aritmetiche assumono la forma $((espressione)). Analizzando il
la sostituzione del comando dell'ambiente corrente richiede uno spazio, un tab o una nuova riga dopo l'apertura
parentesi graffa e che la parentesi graffa di chiusura sia riconosciuta come una parola chiave (cioèèpreceduta da una nuova riga
o punto e virgola). Sono anche chiamati funsub (sostituzioni di funzioni) e si comportano come
funzioni in questo locale ed ritorno lavoro, e in questo exit termina la shell genitore; guscio
le opzioni sono condivise

Un'altra variante della sostituzione sono i valsub (sostituzioni di valori) ${|command;} quali sono
eseguito anche nell'ambiente corrente, come funsubs, ma condivide il proprio I/O con il genitore;
invece, valutano qualunque sia la variabile locale dell'espressione, inizialmente vuota, REPLY
impostato su entro il commands.

Se una sostituzione appare fuori dalle virgolette, i risultati della sostituzione sono
generalmente soggetto a suddivisione in parole o campi in base al valore corrente dell'IFS
parametro. Il parametro IFS specifica un elenco di ottetti che vengono utilizzati per spezzare una stringa
in più parole; qualsiasi ottetto dallo spazio impostato, dalla tabulazione e dalla nuova riga che appare nell'IFS
gli ottetti sono chiamati "spazi bianchi IFS". Sequenze di uno o più ottetti di spazi bianchi IFS, in
combinazione con zero o uno ottetti di spazi bianchi non IFS, delimita un campo. Come caso speciale,
gli spazi bianchi IFS iniziali e finali vengono eliminati (cioè nessun campo vuoto iniziale o finale è
da esso creato); Gli spazi bianchi non IFS iniziali o finali creano un campo vuoto.

Esempio: se IFS è impostato su " :”, e VAR è impostato su
“ UN : B::D”, la sostituzione di $VAR risulta in quattro campi: 'A',
'B', '' (un campo vuoto) e 'D'. Nota che se il parametro IFS è impostato su vuoto
stringa, non viene eseguita alcuna suddivisione del campo; se non è impostato, il valore predefinito di spazio, tabulazione e
viene utilizzata la nuova riga.

Inoltre, tieni presente che la suddivisione del campo si applica solo al risultato immediato del
sostituzione. Utilizzando l'esempio precedente, la sostituzione di $VAR:E risulta nel
campi: 'A', 'B', '' e 'D:E', non 'A', 'B', '', 'D' e 'E'. Questo comportamento è POSIX
compatibile, ma incompatibile con alcune altre implementazioni di shell che eseguono la suddivisione dei campi
sulla parola che conteneva la sostituzione o usa IFS come delimitatore di spazi bianchi generale.

I risultati della sostituzione sono, se non diversamente specificato, soggetti anche ad espansione del tutore
e l'espansione del nome del file (vedere le sezioni pertinenti di seguito).

Una sostituzione di comando è sostituita dall'output generato dal comando specificato che è
eseguire in una sottoshell. Per $(command) e ${|command;} e ${ command;} sostituzioni, normale
le regole di citazione vengono utilizzate quando command viene analizzato; tuttavia, per il deprecato `command` forma, a
'\' seguito da '$', '`' o '\' viene rimosso (come '"' quando la sostituzione fa parte
di una stringa tra virgolette); una barra rovesciata '\' seguita da qualsiasi altro carattere rimane invariata.
Come caso speciale nelle sostituzioni di comando, un comando della formafiletto è interpretato come
significa sostituire il contenuto di filetto. Nota che $( ha lo stesso effetto di $(cat pippo).

Nota che alcune shell non usano un parser ricorsivo per le sostituzioni di comandi, portando a
fallimento per alcuni costrutti; per essere portabile, usa come soluzione alternativa 'x=$(cat) <<"EOF"' (o il
newline-keeping 'x=<<"EOF"' extension) invece di sgranocchiare semplicemente la stringa. Norma IEEE 1003.1
("POSIX.1") consiglia di utilizzare istruzioni case della forma 'x=$(case $foo in (bar) echo $bar
;; (*) echo $baz ;; esac)' invece, che funzionerebbe ma non servirebbe da esempio per questo
problema di portabilità.

x=$(caso $pippo nella barra) echo $bar ;; *) echo $baz ;; esac)
# sopra non riesce ad analizzare su vecchie shell; di seguito è la soluzione alternativa
x=$(eval $(cat)) <<"EOF"
case $pippo in bar) echo $bar ;; *) echo $baz ;; esac
EOF

Le sostituzioni aritmetiche vengono sostituite dal valore dell'espressione specificata. Per
esempio, il comando stampare $((2+3*4)) visualizza 14. Vedi Aritmetica espressioni per
descrizione di un'espressione

parametri
I parametri sono variabili di shell; possono essere assegnati valori e si può accedere ai loro valori
utilizzando una sostituzione di parametro. Il nome di un parametro è uno dei singoli speciali
parametri di caratteri di punteggiatura o cifra descritti di seguito, o una lettera seguita da zero o
più lettere o cifre ('_' conta come una lettera). Quest'ultima forma può essere trattata come array
aggiungendo un indice di array della forma [espr] dove espr è un'espressione aritmetica.
Indici di array in Grazie sono limitati all'intervallo da 0 a 4294967295 incluso. Questo è,
sono un intero senza segno a 32 bit.

Le sostituzioni dei parametri assumono la forma $Nome, ${Nome} o ${Nome[espr]} dove Nome è un
nome del parametro. Sostituzione di tutti gli elementi dell'array con ${Nome[*]} e ${Nome[@]} lavori
equivalente a $* e $@ per i parametri posizionali. Se la sostituzione viene eseguita su a
parametro (o un elemento parametro array) che non è impostato, viene sostituita una stringa nulla
a meno che il sostantivo opzione (set -o sostantivo or set -u) è impostato, nel qual caso si verifica un errore.

I parametri possono essere assegnati valori in diversi modi. Primo, la shell imposta implicitamente
alcuni parametri come '#', 'PWD' e '$'; questo è l'unico modo per il singolo carattere speciale
parametri sono impostati. In secondo luogo, i parametri vengono importati dall'ambiente della shell in
avviare. Terzo, i parametri possono essere assegnati valori sulla riga di comando: ad esempio, PIÙ = barra
imposta il parametro “FOO” su “bar”; più assegnazioni di parametri possono essere date su un singolo
riga di comando e possono essere seguiti da un semplice comando, nel qual caso le assegnazioni sono
in vigore solo per la durata del comando (anche tali assegnazioni vengono esportate; cfr
di seguito per le implicazioni di ciò). Nota che sia il nome del parametro che il '=' devono essere
senza virgolette affinché la shell riconosca un'assegnazione di parametri. il costrutto PIEDI+=baz è altresì
riconosciuto; i valori vecchi e nuovi vengono immediatamente concatenati. Il quarto modo di impostare
un parametro è con il export, globale, in sola letturae comporre comandi; vedere il loro
descrizioni nel Comando esecuzione sezione. Quinto, per ed select i loop impostano i parametri
nonché getopts, reade set -A comandi. Infine, è possibile assegnare i parametri
valori utilizzando operatori di assegnazione all'interno di espressioni aritmetiche (vedi Aritmetica espressioni
sotto) o utilizzando ${Nome=APPREZZIAMO} forma della sostituzione del parametro (vedi sotto).

Parametri con l'attributo di esportazione (impostato utilizzando il export or comporre -x comandi, o da
assegnazioni di parametri seguite da semplici comandi) sono messe nell'ambiente (vedi
ambiente(7)) di comandi eseguiti dalla shell come Nome=APPREZZIAMO coppie. L'ordine in cui i parametri
apparire nell'ambiente di un comando non è specificato. Quando il guscio si avvia, è
estrae i parametri e i loro valori dal suo ambiente e imposta automaticamente l'esportazione
attributo per quei parametri.

I modificatori possono essere applicati a ${Nome} forma di sostituzione dei parametri:

${Nome:-parola}
If Nome è impostato e non NULL, viene sostituito; altrimenti, parola è sostituito.

${Nome:+parola}
If Nome è impostato e non NULL, parola è sostituito; in caso contrario, nulla viene sostituito.

${Nome:=parola}
If Nome è impostato e non NULL, viene sostituito; in caso contrario, è assegnato parola ed
il valore risultante di Nome è sostituito.

${Nome:?parola}
If Nome è impostato e non NULL, viene sostituito; altrimenti, parola è stampato su
errore standard (preceduto da Nome:) e si verifica un errore (che normalmente causa la terminazione
di uno script di shell, funzione o script originato utilizzando il '.' integrato). Se parola is
omesso, viene utilizzata la stringa "parametro nullo o non impostato". Attualmente un bug,
if parola è una variabile che si espande alla stringa nulla, anche il messaggio di errore è
stampato.

Si noti che, per tutto quanto sopra, parola è effettivamente considerato citato, e l'analisi speciale
si applicano le regole. Le regole di analisi differiscono anche se l'espressione è tra virgolette: parola
quindi usa le regole delle doppie virgolette, eccetto per le virgolette stesse ('"') e la chiusura
brace, che, se la barra rovesciata è sfuggita, viene applicata la rimozione della citazione.

Nei modificatori di cui sopra, il ':' può essere omesso, nel qual caso le condizioni dipendono solo da
Nome essere impostato (al contrario di set e non NULL). Se parola è necessario, parametro, comando,
su di esso vengono eseguite l'aritmetica e la sostituzione della tilde; Se parola non è necessario, non è
valutato.

Possono essere utilizzate anche le seguenti forme di sostituzione dei parametri (se Nome è un array, il
elemento con la chiave “0” sarà sostituito in contesto scalare):

${#Nome}
Il numero di parametri posizionali se Nome è '*', '@' o non è specificato; altrimenti
la lunghezza (in caratteri) del valore della stringa del parametro Nome.

${#Nome[*]}
${#Nome[@]}
Il numero di elementi nell'array Nome.

${%Nome}
La larghezza (nelle colonne dello schermo) del valore della stringa del parametro Nome, o -1 se
${Nome} contiene un carattere di controllo.

${!Nome}
Il nome della variabile a cui fa riferimento Nome. Questo sarà Nome tranne quando Nome is
un riferimento al nome (variabile legata), creato dal nomeref comando (che è un alias
per comporre -n).

${!Nome[*]}
${!Nome[@]}
I nomi degli indici (chiavi) nell'array Nome.

${Nome#modello}
${Nome##modello}
If modello corrisponde all'inizio del valore del parametro Nome, il testo corrispondente è
cancellato dal risultato della sostituzione. Un singolo '#' risulta nel più breve
partita, e due di loro risultano nella partita più lunga. Non può essere applicato a un vettore
(${*} o ${@} o ${array[*]} o ${array[@]}).

${Nome%modello}
${Nome%%modello}
Come la sostituzione ${..#..}, ma cancella dalla fine del valore. Non può essere
applicato a un vettore.

${Nome/motivo/corda}
${Nome/#motivo/corda}
${Nome/%motivo/corda}
${Nome//motivo/corda}
La partita più lunga di modello nel valore del parametro Nome viene sostituito con stringa
(cancellato se stringa è vuoto; la barra finale ('/') può essere omessa in tal caso).
Una barra iniziale seguita da '#' o '%' fa sì che il pattern sia ancorato al
rispettivamente all'inizio o alla fine del valore; vuoto disancorato modellos causa no
sostituzione; una singola barra iniziale o l'uso di a modello che corrisponde al vuoto
string fa sì che la sostituzione avvenga una sola volta; due barre iniziali causano tutto
occorrenze di corrispondenze nel valore da sostituire. Non può essere applicato a un vettore.
Implementato in modo inefficiente, potrebbe essere lento.

${Nome:inviare:len}
Il primo len personaggi di Nome, a partire dalla posizione inviare, sono sostituiti. Entrambi
inviare e:len sono opzionali. Se inviare è negativo, il conteggio inizia alla fine del
corda; se viene omesso, il valore predefinito è 0. Se len è omesso o maggiore di
lunghezza della stringa rimanente, viene sostituita tutta. Entrambi inviare ed len sono
valutati come espressioni aritmetiche. Attualmente, inviare deve iniziare con uno spazio,
parentesi aperta o cifra da riconoscere. Non può essere applicato a un vettore.

${Nome@#}
L'hash (usando l'algoritmo BAFH) dell'espansione di Nome. Anche questo è usato
internamente per le tabelle hash della shell.

${Nome@Q}
Un'espressione citata sicura per il rientro, il cui valore è il valore di Nome
parametro, viene sostituito.

Si noti che modello potrebbe essere necessario un modello di globbing esteso (@(...)), singolo ('...') o doppio
("...") citazione che scappa a meno che -o sh è impostato.

I seguenti parametri speciali sono impostati implicitamente dalla shell e non possono essere impostati direttamente
utilizzando i compiti:

! ID processo dell'ultimo processo in background avviato. Se nessun processo in background ha
stato avviato, il parametro non è impostato.

# Il numero di parametri posizionali ($1, $2, ecc.).

$ Il PID della shell o il PID della shell originale se è una subshell. Fare NON
utilizzare questo meccanismo per generare nomi di file temporanei; vedere mktemp(1) invece.

- La concatenazione delle attuali opzioni a singola lettera (vedi il set comando qui sotto
per un elenco di opzioni).

? Lo stato di uscita dell'ultimo comando non asincrono eseguito. Se l'ultimo comando
fu ucciso da un segnale, $? è impostato su 128 più il numero del segnale, ma al massimo 255.

0 Il nome della shell, determinato come segue: il primo argomento a Grazie se fosse
invocato con il -c sono state fornite opzioni e argomenti; altrimenti il filetto argomento, se
è stato fornito; oppure il nome base con cui è stata invocata la shell (es. argv[0]). $ 0
è anche impostato sul nome dello script corrente o sul nome della funzione corrente,
se fosse definito con il function parola chiave (cioè una funzione in stile Korn shell).

1 .. 9 I primi nove parametri posizionali forniti a shell, funzione o
script originato utilizzando il '.' incorporato. Ulteriori parametri posizionali possono essere
a cui si accede utilizzando ${numero}.

* Tutti i parametri posizionali (tranne 0), ovvero $1, $2, $3, ...
Se usati al di fuori delle virgolette, i parametri sono parole separate (che sono soggette
alla suddivisione in parole); se usato tra virgolette, i parametri sono separati dal
primo carattere del parametro IFS (o la stringa vuota se IFS è NULL).

@ Uguale a $*, a meno che non sia usato tra virgolette, nel qual caso una parola separata è
generato per ogni parametro posizionale. Se non ci sono parametri posizionali, no
parola è generata. $@ può essere utilizzato per accedere agli argomenti, parola per parola, senza perdere
Argomenti NULL o suddivisione degli argomenti con spazi.

I seguenti parametri sono impostati e/o utilizzati dalla shell:

_ (trattino basso) Quando un comando esterno viene eseguito dalla shell, questo parametro
è impostato nell'ambiente del nuovo processo al percorso dell'eseguito
comando. Nell'uso interattivo, questo parametro è impostato anche nella shell genitore su
l'ultima parola del comando precedente.

BASHPID Il PID della shell o subshell.

CDPATH Come PATH, ma utilizzato per risolvere l'argomento in cd comando integrato. Nota
che se CDPATH è impostato e non contiene '.' o un elemento stringa vuoto, il
la directory corrente non viene cercata. Anche il cd verrà visualizzato il comando integrato
la directory risultante quando viene trovata una corrispondenza in qualsiasi percorso di ricerca diverso da
percorso vuoto.

COLONNE Imposta il numero di colonne sul terminale o sulla finestra. Sempre impostato, default
a 80, a meno che il valore riportato da sty(1) è diverso da zero e abbastanza sano di mente
(il minimo è 12x3); simile per LINEE. Questo parametro è utilizzato dal
modalità di modifica della linea interattiva e dal select, set -oe kill -l comandi
per formattare le colonne di informazioni. Importazione dall'ambiente o disinserimento
questo parametro rimuove il legame alla dimensione effettiva del terminale a favore del
valore fornito.

ENV Se viene rilevato che questo parametro è impostato dopo l'esecuzione di qualsiasi file di profilo,
il valore espanso viene utilizzato come file di avvio della shell. Di solito contiene una funzione
e definizioni di alias.

ERRNO Valore intero della shell err variabile. Indica il motivo l'ultimo
chiamata di sistema non riuscita. Non ancora implementato.

EXECSHELL Se impostato, si presume che questo parametro contenga la shell che deve essere utilizzata per
eseguire comandi che esecutivo(2) non viene eseguito e che non iniziano con a
“#!conchiglia” sequenza.

FCEDIT L'editor utilizzato dal fc comando (vedi sotto).

FPATH Come PATH, ma utilizzato quando viene eseguita una funzione non definita per individuare il file
definire la funzione. Viene anche cercato quando non è possibile trovare un comando utilizzando
IL PERCORSO. Vedere funzioni sotto per maggiori informazioni.

HISTFILE Il nome del file utilizzato per memorizzare la cronologia dei comandi. Quando assegnato o disinserito,
il file viene aperto, la cronologia viene troncata e poi caricata dal file; successivo
nuovi comandi (possibilmente costituiti da più righe) vengono aggiunti una volta che
compilato con successo. Inoltre, condivideranno diverse invocazioni della shell
history se i loro parametri HISTFILE puntano tutti allo stesso file.

Note:Nota: se HISTFILE non è impostato o è vuoto, non viene utilizzato alcun file di cronologia. Questo è
diverso da AT&T UNIX ksh.

HISTSIZE Il numero di comandi normalmente memorizzati per la cronologia. Il valore predefinito è 2047. Fare
non impostare questo valore su valori follemente alti come 1000000000 perché Grazie può
quindi non allocare memoria sufficiente per la cronologia e non si avvia.

HOME La directory predefinita per il cd comando e il valore sostituito da an
non qualificato ~ (Vedi tilde espansione sotto).

IFS Separatore di campo interno, utilizzato durante la sostituzione e dal read comando, a
dividere i valori in argomenti distinti; normalmente impostato su spazio, tabulazione e nuova riga.
See Sostituzione sopra per i dettagli.

Note:: Questo parametro non viene importato dall'ambiente quando la shell è
iniziato.

KSHEGID L'ID di gruppo effettivo della shell.

KSHGID Il vero ID di gruppo della shell.

KSHUID L'ID utente reale della shell.

KSH_VERSION Il nome e la versione della shell (sola lettura). Vedi anche i comandi della versione
in Emacs montaggio modo ed Vi montaggio modo sezioni, di seguito.

LINENO Il numero di riga della funzione o dello script di shell attualmente in corso
eseguito.

LINEE Imposta il numero di linee sul terminale o sulla finestra. Sempre impostato, il valore predefinito è
24. Vedi COLONNE.

TEMPO EPOCRALE
Tempo dall'epoca, come restituito da gettimeofday(2), formattato come decimale
tv_sec seguito da un punto ('.') e tv_usec riempito con esattamente sei decimali
cifre.

OLDPWD La directory di lavoro precedente. Disattiva se cd non è cambiato con successo
directory dall'avvio della shell o se la shell non sa dove si trova.

OPTARG Quando si utilizza getopts, contiene l'argomento per un'opzione analizzata, se è
ne richiede uno.

OPTIND L'indice del prossimo argomento da elaborare quando si usa getopts. Assegnare 1
a questo parametro provoca getopts per elaborare gli argomenti dall'inizio il
la prossima volta che viene invocato.

PERCORSO Un elenco separato da due punti (punto e virgola su OS/2) di directory che vengono cercate
quando si cercano comandi e file originati usando il '.' comando (vedi sotto).
Una stringa vuota risultante da due punti iniziali o finali o due adiacenti
due punti, viene trattato come un '.' (la directory corrente).

PGRP L'ID processo del leader del gruppo di processi della shell.

PIPESTATUS Un array contenente i codici errorlevel (exit status), uno per uno, dell'ultimo
la pipeline viene eseguita in primo piano.

PPID L'ID di processo del genitore della shell.

PS1 Il prompt principale per le shell interattive. Parametro, comando e aritmetica
vengono eseguite le sostituzioni e '!' viene sostituito con il comando corrente
numero (vedi fc comando sotto). Un letterale '!' può essere inserito nel prompt da
mettendo '!!' su PS1.

Il prompt predefinito è '$ ' per utenti non root, '# ' per root. Se Grazie is
invocato da root e PS1 non contiene un carattere '#', il valore predefinito
verrà utilizzato anche se la PS1 esiste già nell'ambiente.

I Grazie la distribuzione viene fornita con un campione punto.mkshrc contenente un sofisticato
esempio, ma potrebbe piacerti il ​​seguente (nota che
${HOSTNAME:=$(hostname)} e la clausola di distinzione root-vs-user sono (in
questo esempio) eseguito al momento dell'assegnazione PS1, mentre $USER e $PWD sono
escape e quindi verrà valutato ogni volta che viene visualizzato un prompt):

PS1='${USER:=$(id -un)}'"@${HOSTNAME:=$(hostname)}:\$PWD $(
if (( ID_UTENTE )); quindi stampa \$; altrimenti stampa \#; f)"

Nota che poiché gli editor della riga di comando cercano di capire per quanto tempo il prompt
è (in modo che sappiano quanto è lontano dal bordo dello schermo), codici di escape nel
prompt tendono a rovinare le cose. Puoi dire alla shell di non contare certo
sequenze (come i codici di escape) anteponendo al prompt un carattere
(come Ctrl-A) seguito da un ritorno a capo e quindi delimitando l'escape
codici con questo carattere. Qualsiasi occorrenza di quel carattere nel prompt è
non stampato. A proposito, non incolpare me per questo hack; è derivato da
i ksh88(1), che ha stampato il carattere delimitatore quindi eri fuori
fortuna se non avevi caratteri non stampabili.

Poiché le barre rovesciate e altri caratteri speciali possono essere interpretati dalla shell,
per impostare PS1 o esegui l'escape della barra rovesciata stessa o usa le virgolette doppie. Il
quest'ultimo è più pratico. Questo è un esempio più complesso, evitando di direttamente
inserire caratteri speciali (ad esempio con ^V nella modalità di modifica di emacs), che
incorpora la directory di lavoro corrente, a video inverso (il colore funzionerebbe,
anche), nella stringa di prompt:

x=$(stampa \\001)
PS1="$x$(print \\r)$x$(tput così)$x\$PWD$x$(tput se)$x> "

Grazie a un forte suggerimento di David G. Korn, Grazie ora supporta anche il
seguente modulo:

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

PS2 Stringa di prompt secondaria, per impostazione predefinita '> ', utilizzata quando è necessario più input per
completare un comando.

Prompt PS3 utilizzato dal select dichiarazione durante la lettura di una selezione di menu. Il predefinito
è '#? '.

PS4 Usato per anteporre i comandi che vengono stampati durante il tracciamento dell'esecuzione (vedi set
-x comando sotto). Le sostituzioni di parametri, comandi e aritmetiche sono
eseguita prima di essere stampata. L'impostazione predefinita è "+". Potresti volerlo impostare
a '[$EPOCHREALTIME] ' invece, per includere i timestamp.

PWD La directory di lavoro corrente. Può essere non impostato o NULL se la shell non lo sa
dove è.

RANDOM Ogni volta che si fa riferimento a RANDOM, viene assegnato un numero compreso tra 0 e 32767
da un PRNG Lineare Congruente prima.

REPLY Parametro di default per il read comando se non vengono dati nomi. Utilizzato anche in
select loop per memorizzare il valore letto dall'input standard.

SECONDI Il numero di secondi dall'avvio della shell o, se il parametro è stato
assegnato un valore intero, il numero di secondi trascorsi dall'assegnazione più il
valore che è stato assegnato.

TMOUT Se impostato su un numero intero positivo in una shell interattiva, specifica il massimo
numero di secondi in cui la shell attende l'input dopo aver stampato il primario
prompt (PS1). Se il tempo viene superato, la shell esce.

TMPDIR La directory in cui vengono creati i file shell temporanei. Se questo parametro non lo è
impostato, o non contiene il percorso assoluto di una directory scrivibile, temporaneo
i file sono creati in / Tmp.

USER_ID L'ID utente effettivo della shell.

tilde espansione
L'espansione della tilde che viene eseguita in parallelo con la sostituzione dei parametri, viene eseguita sulle parole
iniziando con un "~" senza virgolette. I caratteri che seguono la tilde, fino al primo '/', se
any, si presume che sia un nome di accesso. Se il nome di accesso è vuoto, '+' o '-', il valore di
viene sostituito rispettivamente il parametro HOME, PWD o OLDPWD. In caso contrario, la password
file viene cercato per il nome di accesso e l'espressione tilde viene sostituita con quella dell'utente
directory principale. Se il nome di accesso non viene trovato nel file della password o se cita o
la sostituzione del parametro avviene nel nome di accesso, non viene eseguita alcuna sostituzione.

Nelle assegnazioni di parametri (come quelle che precedono un comando semplice o quelle che si verificano nel
argomenti di alias, export, globale, in sola letturae comporre), l'espansione della tilde viene eseguita dopo
qualsiasi assegnazione (cioè dopo il segno di uguale) o dopo i due punti senza virgolette (':'); nomi di accesso
sono inoltre delimitati da due punti.

La home directory dei nomi di accesso precedentemente espansi viene memorizzata nella cache e riutilizzata. Il alias -d
il comando può essere usato per elencare, modificare e aggiungere a questa cache (ad es alias -d
fac=/usr/local/strutture; cd ~faccia/cestino).

Bretelle espansione (alternanza)
Le espressioni di parentesi graffe assumono la forma seguente:

prefisso{str1,...,strN}suffisso

Le espressioni sono espanse in N parole, ognuna delle quali è la concatenazione di prefisso, stri,
ed suffisso (es. "a{c,b{X,Y},d}e" si espande in quattro parole: "ace", "abXe", "abYe" e "ade").
Come notato nell'esempio, le espressioni tra parentesi graffe possono essere nidificate e le parole risultanti non lo sono
smistato. Le espressioni tra parentesi graffe devono contenere una virgola senza virgolette (',') affinché si verifichi l'espansione (ad es
{} ed {pippo} non sono espanse). L'espansione della parentesi viene eseguita dopo la sostituzione del parametro
e prima della generazione del nome del file.

Compila il Nome modelli
Un modello di nome file è una parola contenente uno o più "?", "*", "+", "@" o "!"
caratteri o sequenze “[..]”. Una volta eseguita l'espansione del tutore, il guscio si sostituisce
modelli di nome file con i nomi ordinati di tutti i file che corrispondono al modello (se no
i file corrispondono, la parola viene lasciata invariata). Gli elementi del modello hanno il seguente significato:

? Corrisponde a qualsiasi singolo carattere.

* Corrisponde a qualsiasi sequenza di ottetti.

[..] Corrisponde a uno qualsiasi degli ottetti all'interno delle parentesi. Gli intervalli di ottetti possono essere specificati da
separando due ottetti da un '-' (es. “[a0-9]” corrisponde alla lettera 'a' oa qualsiasi cifra).
Per rappresentare se stesso, un '-' deve essere citato o il primo o l'ultimo ottetto
nell'elenco degli ottetti. Allo stesso modo, un ']' deve essere citato o il primo ottetto nell'elenco
se deve rappresentare se stesso invece della fine dell'elenco. Anche un '!' che appare
all'inizio dell'elenco ha un significato speciale (vedi sotto), quindi rappresentarlo
deve essere citato o apparire più avanti nell'elenco.

[!..] Come [..], tranne che corrisponde a qualsiasi ottetto non compreso tra parentesi.

*(modello|...|modello)
Corrisponde a qualsiasi stringa di ottetti che corrisponda a zero o più occorrenze dell'oggetto specificato
modelli. Esempio: il modello *(pippo|sbarra) corrisponde alle stringhe “”, “pippo”, “bar”,
"foobarfoo", ecc.

+(modello|...|modello)
Corrisponde a qualsiasi stringa di ottetti che corrisponda a una o più occorrenze dell'oggetto specificato
modelli. Esempio: il modello +(pippo|sbarra) corrisponde alle stringhe “foo”, “bar”,
"foobar", ecc.

?(modello|...|modello)
Corrisponde alla stringa vuota oa una stringa che corrisponde a uno dei modelli specificati.
Esempio: il modello ?(pippo|sbarra) corrisponde solo alle stringhe "", "foo" e "bar".

@(modello|...|modello)
Corrisponde a una stringa che corrisponde a uno dei modelli specificati. Esempio: il modello
@(pippo|sbarra) corrisponde solo alle stringhe "foo" e "bar".

!(modello|...|modello)
Corrisponde a qualsiasi stringa che non corrisponde a uno dei modelli specificati. Esempi: il
modello !(pippo|sbarra) corrisponde a tutte le stringhe tranne "foo" e "bar"; Il modello !(*)
non corrisponde a nessuna stringa; Il modello !(?)* corrisponde a tutte le stringhe (pensaci).

Nota che il globbing complicato, specialmente con le alternative, è lento; usando separato
i confronti possono (o non possono) essere più veloci.

Si noti che Grazie (E pdsh) non corrisponde mai a '.' e '..', ma AT&T UNIX ksh, Bourne she GNU
bash fare.

Nota che nessuno degli elementi del modello di cui sopra corrisponde a un punto ('.') all'inizio di a
nome del file o una barra ('/'), anche se sono utilizzati esplicitamente in una sequenza [..]; anche il
nomi '.' e '..' non vengono mai abbinati, nemmeno dal modello '.*'.

Se l' markdir l'opzione è impostata, tutte le directory risultanti dalla generazione del nome file sono
contrassegnato con un '/' finale.

Input / output reindirizzamento
Quando viene eseguito un comando, il suo input standard, output standard ed errore standard (file
i descrittori 0, 1 e 2, rispettivamente) sono normalmente ereditati dalla shell. Tre
eccezioni a questo sono i comandi nelle pipeline, per i quali input standard e/o standard
output sono quelli impostati dalla pipeline, comandi asincroni creati quando il controllo del lavoro è
disabilitato, per il quale lo standard input è inizialmente impostato su from / Dev / nulle comandi per
quale è stato specificato uno dei seguenti reindirizzamenti:

>filetto L'output standard viene reindirizzato a filetto. Se filetto non esiste, si crea;
se esiste, è un file normale e il noclobber l'opzione è impostata, un errore
si verifica; in caso contrario, il file viene troncato. Nota che questo significa il comando cmd
<pippo > pippo aprirà foo per la lettura e poi troncare quando lo apre per
scrivere, prima cmd ha la possibilità di leggere davvero foo.

>|filetto Uguale a >, tranne che il file viene troncato, anche se il noclobber l'opzione è impostata.

>>filetto Uguale a >, tranne che filetto esiste a cui viene aggiunto invece di essere troncato.
Inoltre, il file viene aperto in modalità append, quindi le scritture vanno sempre alla fine del
file (vedi aprire(2)).

<filetto L'input standard viene reindirizzato da filetto, che è aperto per la lettura.

<>filetto Uguale a <, tranne che il file viene aperto per la lettura e la scrittura.

<<marcatore Dopo aver letto la riga di comando contenente questo tipo di reindirizzamento (chiamato a
"here document"), la shell copia le righe dal sorgente del comando in a
file temporaneo fino alla corrispondenza di una riga marcatore viene letto. Quando il comando è
eseguito, l'input standard viene reindirizzato dal file temporaneo. Se marcatore
non contiene caratteri tra virgolette, il contenuto del file temporaneo viene elaborato
come se fosse racchiuso tra virgolette ogni volta che viene eseguito il comando, quindi parametro,
comando e vengono eseguite le sostituzioni aritmetiche, insieme alla barra rovesciata ('\')
escape per '$', '`', '\' e '\newline', ma non per '"'. Se più qui
i documenti vengono utilizzati sulla stessa riga di comando, vengono salvati in ordine.

Se no marcatore è dato, il documento qui finisce al prossimo << e sostituzione
sarà eseguita. Se marcatore è solo un insieme di "''" singolo o doppio '""'
virgolette senza nulla in mezzo, il documento qui termina alla riga vuota successiva
e la sostituzione non verrà eseguita.

<< -marcatore Uguale a <<, eccetto che le tabulazioni iniziali vengono eliminate dalle righe nel documento qui.

<<parola Uguale a <<, salvo che parola is il documento qui Questo si chiama qui
stringa.

<&fd L'input standard è duplicato dal descrittore di file fd. fd può essere un numero,
indicando il numero di un descrittore di file esistente; la lettera 'p', che indica
il descrittore di file associato all'output del coprocesso corrente; o il
carattere '-', che indica che l'input standard deve essere chiuso. Notare che fd is
limitato a una singola cifra nella maggior parte delle implementazioni della shell.

>&fd Uguale a <&, tranne che l'operazione viene eseguita sullo standard output.

&>filetto Uguale a >filetto 2> e 1. Questo è un GNU deprecato (legacy) bash estensione supportata
by Grazie che supporta anche il precedente numero fd esplicito, ad esempio,
3&>filetto equivale a 3>filetto 2> e 3 in Grazie ma un errore di sintassi in GNU bash.

&>|filetto, &>>filetto, &>&fd
Uguale a >|filetto, >>filetto, o >&fd, Seguita da 2> e 1, come sopra. Questi sono Grazie
estensioni.

In uno qualsiasi dei reindirizzamenti precedenti, il descrittore di file che viene reindirizzato (cioè standard
input o standard output) può essere dato esplicitamente facendo precedere il reindirizzamento da un numero
(portatile, solo una singola cifra). Sostituzioni di parametri, comandi e aritmetiche, tilde
le sostituzioni e (se la shell è interattiva) la generazione dei nomi dei file sono tutte eseguite su
, il filetto, marcatoree fd argomenti di reindirizzamento. Si noti, tuttavia, che i risultati di any
la generazione del nome del file viene utilizzata solo se corrisponde un singolo file; se più file corrispondono, il
viene utilizzata la parola con i caratteri di generazione del nome file espanso. Nota che in limitato
shell, i reindirizzamenti che possono creare file non possono essere utilizzati.

Per i comandi semplici, i reindirizzamenti possono apparire ovunque nel comando; per comandi composti
(if istruzioni, ecc.), eventuali reindirizzamenti devono comparire alla fine. I reindirizzamenti vengono elaborati
dopo che le pipeline sono state create e nell'ordine in cui sono state fornite, quindi quanto segue stamperà un
errore con un numero di riga anteposto:

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

I descrittori di file creati dai reindirizzamenti di I/O sono privati ​​per la shell.

Aritmetica espressioni
Le espressioni aritmetiche intere possono essere utilizzate con il lasciare comando, all'interno di espressioni $((..)),
all'interno dei riferimenti di array (ad es Nome[espr]), come argomenti numerici per test comando, e come
il valore di un'assegnazione a un parametro intero. avvertimento: Questo influisce anche sull'implicito
conversione in intero, ad esempio come fatto da lasciare comando. Mai usa utente non selezionato
input, ad esempio dall'ambiente, in aritmetica!

Le espressioni sono calcolate utilizzando l'aritmetica con segno e il mksh_ari_t type (un 32 bit firmato
intero), a meno che non inizino con un solo carattere '#', nel qual caso usano mksh_uari_t (a
intero senza segno a 32 bit).

Le espressioni possono contenere identificatori di parametri alfanumerici, riferimenti a array e numeri interi
costanti e può essere combinato con i seguenti operatori C (elencati e raggruppati in
ordine crescente di precedenza):

Operatori unari:

+ - ! ~++ --

Operatori binari:

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

Operatori ternari:

?: (la precedenza è immediatamente superiore all'assegnazione)

Operatori di raggruppamento:

()

Le costanti e le espressioni intere vengono calcolate utilizzando esattamente 32 bit di larghezza, con segno o
unsigned, digitare con avvolgimento silenzioso in caso di overflow di numeri interi. Le costanti intere possono essere
specificato con basi arbitrarie usando la notazione base#numero, Dove base è un decimale
intero che specifica la base, e numero è un numero nella base specificata. Inoltre,
gli interi in base-16 possono essere specificati anteponendoli con '0x' (senza distinzione tra maiuscole e minuscole) in tutti
forme di espressioni aritmetiche, eccetto come argomenti numerici per il test comando integrato.
Il prefisso dei numeri con una sola cifra zero ("0") non causa l'interpretazione come ottale, come
non è sicuro farlo.

Come speciale Grazie estensione, i numeri alla base di uno sono trattati come (8 bit
trasparente) punti di codice ASCII o Unicode, a seconda della shell modalità utf8 bandiera (corrente
collocamento). L'UNIX AT&T ksh93 è supportata anche la sintassi di “'x'” invece di “1#x”. Nota
che i byte NUL (valore integrale di zero) non possono essere utilizzati. Un parametro non impostato o vuoto
restituisce 0 in un contesto intero. In modalità Unicode, gli ottetti grezzi sono mappati nell'intervallo
EF80..EFFF come in OPTU-8, che è nella PUA ed è stato assegnato da CSUR per questo uso. Se
più di un ottetto in modalità ASCII, o una sequenza di più di un ottetto che non costituisce un valido
e viene passata una sequenza CESU-8 minima, il comportamento non è definito (di solito, la shell si interrompe
con un errore di analisi, ma raramente riesce, ad esempio sulla sequenza C2 20). Ecco perché tu
dovrebbe sempre usare la modalità ASCII a meno che tu non sappia che l'input è UTF-8 ben formato nel
intervallo di 0000..FFFD se si utilizza questa funzione, al contrario di read -a.

Gli operatori vengono valutati come segue:

unario +
Il risultato è l'argomento (incluso per completezza).

unario -
Negazione.

! NON logico; il risultato è 1 se l'argomento è zero, 0 in caso contrario.

~ Aritmetica (bit-saggio) NOT.

++ Incremento; deve essere applicato a un parametro (non un letterale o un'altra espressione).
Il parametro viene incrementato di 1. Se utilizzato come operatore di prefisso, il risultato
è il valore incrementato del parametro; quando usato come operatore suffisso,
il risultato è il valore originale del parametro.

-- Simile a ++, tranne che il parametro viene decrementato di 1.

, Separa due espressioni aritmetiche; il lato sinistro viene valutato per primo,
poi la destra. Il risultato è il valore dell'espressione a destra
lato.

= Assegnazione; la variabile a sinistra è impostata sul valore a destra.

+= -= *= /= %= <<<= >>>= <<= >>= &= ^= |=
Operatori di assegnazione.var><op>=espr> è uguale avar>=var><op><espr>,
con qualsiasi operatore in precedenza inespr> conservato. Ad esempio, “var1 *= 5 +
3” equivale a specificare “var1 = var1 * (5 + 3)”.

|| OR logico; il risultato è 1 se uno degli argomenti è diverso da zero, 0 in caso contrario. Il
l'argomento di destra viene valutato solo se l'argomento di sinistra è zero.

&& AND logico; il risultato è 1 se entrambi gli argomenti sono diversi da zero, 0 in caso contrario. Il
l'argomento di destra viene valutato solo se l'argomento di sinistra è diverso da zero.

| OR aritmetico (bit-wise).

^ XOR aritmetico (a bit) (OR esclusivo).

& Aritmetico (per bit) AND.

== Uguale; il risultato è 1 se entrambi gli argomenti sono uguali, 0 in caso contrario.

!= Non uguale; il risultato è 0 se entrambi gli argomenti sono uguali, 1 in caso contrario.

< Minore di; il risultato è 1 se l'argomento di sinistra è minore di quello di destra, 0 se
non.

<= > >=
Minore o uguale, maggiore di, maggiore o uguale. Vedere <.

<<< >>>
Ruota a sinistra (destra); il risultato è simile allo spostamento (vedi <<) tranne che
i bit spostati all'esterno ad un'estremità vengono spostati all'interno all'altra estremità, invece di zero
o bit di segno.

<< >> Maiusc a sinistra (a destra); il risultato è l'argomento sinistro con i suoi bit spostati a sinistra
(a destra) per l'importo indicato nell'argomentazione giusta.

+-*/
Addizione, sottrazione, moltiplicazione e divisione.

% Resto; il risultato è il resto simmetrico della divisione della sinistra
argomento di destra. Per ottenere il modulo matematico di “a mod b”, utilizzare il
formula “(a % b + b) % b”.

<arg1>?arg2>:arg3>
Searg1> è diverso da zero, il risultato èarg2>; altrimenti il ​​risultato èarg3>.
L'argomento non risultato non viene valutato.

Co-processi
Un coprocesso (che è una pipeline creata con l'operatore '|&') è un processo asincrono
su cui la shell può scrivere (usando stampare -p) e leggi da (usando read -p). L'ingresso
e l'output del coprocesso può anche essere manipolato usando >&p ed <&p reindirizzamenti,
rispettivamente. Una volta avviato un co-processo, non se ne può avviare un altro fino a quando il co-processo non è stato avviato.
il processo esce, o fino a quando l'input del co-processo non è stato reindirizzato utilizzando un exec n>&p
reindirizzamento. Se l'input di un co-processo viene reindirizzato in questo modo, il prossimo co-processo sarà
avviato condividerà l'output con il primo co-processo, a meno che l'output dell'iniziale
il coprocesso è stato reindirizzato utilizzando an exec n<&p reindirizzamento.

Alcune note relative ai coprocessi:

· L'unico modo per chiudere l'input del coprocesso (in modo che il coprocesso legga una fine del file) è
per reindirizzare l'input a un descrittore di file numerato e quindi chiudere quel descrittore di file:
exec 3>&p; exec 3>&-

· Affinché i coprocessi condividano un output comune, la shell deve mantenere la scrittura
parte del tubo di uscita aperta. Ciò significa che la fine del file non verrà rilevata fino a quando
tutti i coprocessi che condividono l'output del coprocesso sono usciti (quando escono tutti, il
shell chiude la sua copia della pipe). Questo può essere evitato reindirizzando l'output a a
descrittore di file numerato (in quanto anche questo fa sì che la shell chiuda la sua copia). Notare che
questo comportamento è leggermente diverso dalla shell Korn originale che chiude la sua copia
della porzione di scrittura dell'output del co-processo quando il co-processo è stato avviato più di recente
(invece di quando tutti i coprocessi di condivisione) terminano.

· stampare -p ignorerà i segnali SIGPIPE durante le scritture se il segnale non viene intrappolato o
ignorato; lo stesso vale se l'input del coprocesso è stato duplicato in un altro file
descrittore e stampare -un viene utilizzato.

funzioni
Le funzioni sono definite utilizzando Korn shell function nome-funzione sintassi o il
Guscio Bourne/POSIX nome-funzione() sintassi (vedi sotto per la differenza tra i due
forme). Le funzioni sono come .-script (cioè script originati usando il built-in '.') in questo
vengono eseguiti nell'ambiente corrente. Tuttavia, a differenza di .‐script, argomenti della shell
(cioè i parametri posizionali $1, $2, ecc.) non sono mai visibili al loro interno. Quando il guscio è
determinando la posizione di un comando, le funzioni vengono ricercate dopo speciali built-in
comandi, prima dei comandi incorporati e della ricerca del PERCORSO.

Una funzione esistente può essere cancellata usando non settato -f nome-funzione. Un elenco di funzioni può
essere ottenuto utilizzando comporre +f e le definizioni delle funzioni possono essere elencate usando comporre -f.
I autoload comando (che è un alias per comporre -fu) può essere usato per creare undefined
funzioni: quando viene eseguita una funzione non definita, la shell cerca il percorso specificato in
il parametro FPATH per un file con lo stesso nome della funzione che, se trovata, viene letta
ed eseguito. Se dopo aver eseguito il file la funzione denominata risulta essere definita, il
la funzione viene eseguita; in caso contrario, la normale ricerca dei comandi continua (cioè la shell
cerca la normale tabella dei comandi incorporati e PATH). Nota che se un comando non viene trovato
utilizzando PATH, viene effettuato un tentativo di caricare automaticamente una funzione utilizzando FPATH (questo non è documentato
caratteristica del guscio Korn originale).

Le funzioni possono avere due attributi, “trace” ed “export”, che possono essere impostati con comporre -ft
ed comporre -fx, rispettivamente. Quando viene eseguita una funzione tracciata, la shell xtraccia
l'opzione è attivata per la durata della funzione. L'attributo "esportazione" delle funzioni è
attualmente non utilizzato. Nella shell Korn originale, le funzioni esportate sono visibili alla shell
script che vengono eseguiti.

Poiché le funzioni vengono eseguite nell'ambiente della shell corrente, vengono eseguite le assegnazioni dei parametri
le funzioni interne sono visibili dopo che la funzione è stata completata. Se questo non è il desiderato
effetto, il comporre comando può essere utilizzato all'interno di una funzione per creare un parametro locale. Nota
che AT&T UNIX ksh93 utilizza l'ambito statico (un ambito globale, un ambito locale per funzione)
e consente variabili locali solo su funzioni in stile Korn, mentre Grazie utilizza l'ambito dinamico
(ambiti nidificati di località variabile). Nota che parametri speciali (es $$, $!) non può essere
portata in questo modo.

Lo stato di uscita di una funzione è quello dell'ultimo comando eseguito nella funzione. UN
la funzione può essere fatta terminare immediatamente usando il ritorno comando; questo può anche essere usato
per specificare esplicitamente lo stato di uscita.

Funzioni definite con il function le parole riservate sono trattate in modo diverso di seguito
modi da funzioni definite con il () notazione:

· Il parametro $0èimpostato sul nome della funzione (le funzioni in stile Bourne lasciano $0
intatto).

· Le assegnazioni dei parametri che precedono le chiamate di funzione non vengono mantenute nell'ambiente della shell
(l'esecuzione di funzioni in stile Bourne manterrà le assegnazioni).

· OPTIND viene salvato/reimpostato e ripristinato all'ingresso e all'uscita dalla funzione quindi getopts può essere
usato correttamente sia all'interno che all'esterno della funzione (le funzioni in stile Bourne lasciano OPTIND
intatto, quindi usando getopts all'interno di una funzione interferisce con l'utilizzo getopts Outside The
funzione).

· Opzioni di shell (set -o) hanno ambito locale, ovvero le modifiche all'interno di una funzione vengono ripristinate al momento
la sua uscita.

In futuro, potrebbero essere aggiunte anche le seguenti differenze:

· Durante l'esecuzione delle funzioni verrà utilizzato un ambiente separato di trap/segnale. Questo
significherà che le trap impostate all'interno di una funzione non influenzeranno le trappole e i segnali della shell
che non vengono ignorati nella shell (ma possono essere intrappolati) avranno il loro effetto predefinito in
una funzione.

· Il trap EXIT, se impostato in una funzione, verrà eseguito dopo il ritorno della funzione.

Comando esecuzione
Dopo la valutazione degli argomenti della riga di comando, dei reindirizzamenti e delle assegnazioni dei parametri,
viene determinato il tipo di comando: uno speciale comando integrato, una funzione, un normale comando integrato o
il nome di un file da eseguire trovato utilizzando il parametro PATH. I controlli vengono effettuati in
sopra l'ordine. I comandi incorporati speciali differiscono dagli altri comandi in quanto PATH
parametro non viene utilizzato per trovarli, un errore durante la loro esecuzione può causare un mancato
shell interattiva per uscire e assegnazioni di parametri specificate prima del comando
vengono mantenuti dopo il completamento del comando. I normali comandi integrati sono diversi solo in questo
il parametro PATH non viene utilizzato per trovarli.

L'originale ksh e POSIX differiscono in qualche modo in quali comandi sono considerati speciali o
regolare.

Utilità speciali integrate POSIX:

., :, rompere, continua, eval, exec, exit, export, in sola lettura, ritorno, set, spostamento, volte, trappola,
non settato

aggiuntivo Grazie comandi mantenendo le assegnazioni:

incorporato, globale, source, comporre, aspettare

Builtin che non sono speciali:

[, alias, bg, legare, gatto, cd, command, eco, falso, fc, fg, getopts, posti di lavoro, kill, lasciare, stampare,
pwd, read, percorso reale, rinominare, sonno, sospendere, test, vero, ulimit, umask, Unalias, da dove

Una volta determinato il tipo di comando, tutte le assegnazioni dei parametri della riga di comando sono
eseguita ed esportata per la durata del comando.

Quanto segue descrive i comandi incorporati speciali e regolari e riservati come incorporati
parole:

. filetto [arg ...]
Questo è chiamato il comando "punto". Esegui i comandi in filetto nella corrente
ambiente. Il file viene cercato nelle directory di PATH. Se gli argomenti sono
dati, i parametri posizionali possono essere utilizzati per accedervi mentre filetto è essere
eseguito. Se non vengono forniti argomenti, i parametri posizionali sono quelli del
ambiente in cui viene utilizzato il comando.

: [...]
Il comando nullo. Lo stato di uscita è impostato su zero.

[ espressione ]
See test.

alias [-d | -t [-r] | +-x] [-p] [+] [Nome [=APPREZZIAMO] ...]
Senza argomenti, alias elenca tutti gli alias. Per qualsiasi nome senza valore, il
alias esistente è elencato. Qualsiasi nome con un valore definisce un alias (vedi Alias
sopra).

Quando si elencano gli alias, viene utilizzato uno dei due formati. Normalmente, gli alias sono elencati come
Nome=APPREZZIAMO, Dove APPREZZIAMO è citato. Se le opzioni erano precedute da '+' o da un solo '+'
è dato sulla riga di comando, solo Nome viene stampato.

I -d l'opzione fa sì che vengano elencati gli alias di directory utilizzati nell'espansione delle tilde
o impostare (vedi tilde espansione sopra).

Se l' -p viene utilizzata l'opzione, ogni alias è preceduto dalla stringa "alias".

I -t l'opzione indica che gli alias tracciati devono essere elencati/impostati (valori specificati
sulla riga di comando vengono ignorati per gli alias tracciati). Il -r opzione indica che
tutti gli alias tracciati devono essere reimpostati.

I -x set di opzioni (+x cancella) l'attributo di esportazione di un alias, o, se nessun nome è
dato, elenca gli alias con l'attributo export (l'esportazione di un alias non ha
effetto).

bg [lavoro ...]
Riprendere in background i lavori interrotti specificati. Se non vengono specificati lavori, %+
è assunto. Vedere Lavoro di controllo sotto per maggiori informazioni.

legare [-l]
Sono elencati i collegamenti correnti. Se la -l bandiera è data, legare elenca invece i
nomi delle funzioni a cui le chiavi possono essere associate. Vedere Emacs montaggio modo per maggiori
informazioni.

legare [-m] stringa=[sostituirlo] ...
legare stringa=[comando-modifica] ...
Il comando di modifica specificato è vincolato al dato stringa, che dovrebbe consistere in a
carattere di controllo preceduto facoltativamente da uno dei due caratteri di prefisso e
facoltativamente sostituito da un carattere tilde. Ingresso futuro del stringa causerà l'
comando di modifica da richiamare immediatamente. Se la -m flag è dato, il specificato
ingresso stringa sarà poi immediatamente sostituito dal dato sostituirlo stringa
che può contenere comandi di modifica ma non altre macro. Se un suffisso tilde è
dato, una tilde che segue uno o due prefissi e il carattere di controllo viene ignorato,
qualsiasi altro carattere finale verrà elaborato in seguito.

I caratteri di controllo possono essere scritti utilizzando la notazione caret, ad esempio ^X rappresenta Ctrl-X.
Si noti che sebbene siano supportati solo due caratteri di prefisso (di solito ESC e ^X),
alcune sequenze multi-carattere possono essere supportate.

Le seguenti associazioni predefinite mostrano come i tasti freccia, il tasto home, fine e cancella
su un terminale BSD wsvt25, xterm-xfree86 o GNU screen sono associati (ovviamente alcuni
le sequenze di escape non funzioneranno così bene):

associare '^X'=prefisso-2
associare '^[['=prefisso-2
bind '^XA'=up-history
bind '^XB'=down-history
bind '^XC'=forward-char
bind '^XD'=backward-char
bind '^X1~'=inizio-riga
bind '^X7~'=inizio-riga
bind '^XH'=inizio-riga
bind '^X4~'=fine riga
bind '^X8~'=fine riga
bind '^XF'=fine riga
bind '^X3~'=delete-char-forward

rompere [livello]
Esci dal livelloil più interno per, select, fino a quando, o while ciclo continuo. livello il valore predefinito è 1.

incorporato [--] command [arg ...]
Esegui il comando integrato command.

gatto [-u] [filetto ...]
Legge i file in sequenza, nell'ordine della riga di comando, e li scrive nell'output standard.
Se un filetto è un trattino singolo ('-') o assente, letto dallo standard input. Per diretto
chiamate integrate, il POSIX -u l'opzione è supportata come no-op. Per le chiamate dalla shell, se
tutte le opzioni sono date, un esterno gatto(1) l'utilità è preferita a quella incorporata.

cd [-L] [dir]
cd -P [-e] [dir]
chdir [-eLP] [dir]
Imposta la directory di lavoro su dir. Se il parametro CDPATH è impostato, elenca i
percorso di ricerca per la directory contenente dir. Un percorso NULL indica la corrente
directory. Se dir si trova in qualsiasi componente del percorso di ricerca CDPATH diverso da
Percorso NULL, il nome della nuova directory di lavoro verrà scritto nell'output standard.
If dir manca, viene utilizzata la directory home HOME. Se dir è '-', il precedente
viene utilizzata la directory di lavoro (vedere il parametro OLDPWD).

Se l' -L viene utilizzata l'opzione (percorso logico) o se il Fisico l'opzione non è impostata (vedi
set comando sotto), riferimenti a '..' in dir sono relativi al percorso utilizzato per arrivare a
la directory. Se la -P viene utilizzata l'opzione (percorso fisico) o se il Fisico opzione è
set, '..' è relativo all'albero delle directory del filesystem. Il PWD e OLDPWD
i parametri vengono aggiornati per riflettere la directory di lavoro corrente e precedente,
rispettivamente. Se la -e l'opzione è impostata per l'attraversamento del filesystem fisico e PWD
non può essere impostato, il codice di uscita è 1; maggiore di 1 se si è verificato un errore, 0
altrimenti.

cd [-eLP] vecchio nuovi
chdir [-eLP] vecchio nuovi
La stringa nuovi è sostituito vecchio nella directory corrente e la shell
tenta di passare alla nuova directory.

command [-pvv] cmd [arg ...]
Se né il -v né -V l'opzione è data, cmd viene eseguito esattamente come se command ha avuto
non è stato specificato, con due eccezioni: in primo luogo, cmd non può essere una funzione di shell; e
in secondo luogo, i comandi incorporati speciali perdono la loro particolarità (cioè reindirizzamento e
gli errori di utilità non causano l'uscita dalla shell e le assegnazioni dei comandi non lo sono
permanente).

Se l' -p viene data l'opzione, viene utilizzato un percorso di ricerca predefinito al posto del valore corrente
di PATH, il cui valore effettivo dipende dal sistema.

Se l' -v viene data l'opzione, invece di eseguire cmd, informazioni su cosa sarebbe
eseguito è dato (e lo stesso è fatto per arg ...). Per built-in, funzioni e
parole chiave, i loro nomi vengono semplicemente stampati; per gli alias, un comando che li definisce è
stampato; per le utilità trovate cercando il parametro PATH, il percorso completo del
comando viene stampato. Se non viene trovato alcun comando (cioè la ricerca del percorso fallisce), non viene trovato nulla
stampato e command esce con uno stato diverso da zero. Il -V l'opzione è come -v
opzione, tranne che è più prolisso.

continua [livello]
Salta all'inizio del livelloil più interno per, select, fino a quando, o while ciclo continuo.
livello il valore predefinito è 1.

eco [-UN] [arg ...]
Attenzione: questa utility non è portatile; usa la shell Korn integrata stampare anziché.

Stampa i suoi argomenti (separati da spazi) seguiti da una nuova riga, secondo lo standard
produzione. La nuova riga viene soppressa se uno degli argomenti contiene la barra rovesciata
sequenza '\c'. Vedi il stampare comando di seguito per un elenco di altre sequenze di barre rovesciate
che sono riconosciuti.

Le opzioni sono fornite per la compatibilità con gli script della shell BSD. Il -n opzione
sopprime la nuova riga finale, -e consente l'interpretazione del backslash (un no-op, poiché
questo è normalmente fatto), e -E sopprime l'interpretazione della barra rovesciata.

Se l' posix or sh l'opzione è impostata o questa è una chiamata integrata diretta, solo la prima
l'argomento viene trattato come un'opzione, e solo se è esattamente "-n”. Barra rovesciata
l'interpretazione è disabilitata.

eval command ...
Gli argomenti sono concatenati (con spazi tra di loro) per formare una singola stringa
che la shell quindi analizza ed esegue nell'ambiente corrente.

exec [-a argv0] [-c] [command [arg ...]]
Il comando viene eseguito senza fork, sostituendo il processo shell. Questo è
attualmente assoluto, cioè exec non ritorna mai, anche se il command non si trova. Il
-a l'opzione consente di impostare un valore argv[0] diverso e -c pulisce l'ambiente
prima di eseguire il processo figlio, ad eccezione della variabile _ e delle assegnazioni dirette.

Se non viene dato alcun comando ad eccezione del reindirizzamento I/O, il reindirizzamento I/O è permanente
e il guscio non viene sostituito. Qualsiasi descrittore di file maggiore di 2 che viene aperto
or dup(2) in questo modo non sono resi disponibili ad altri comandi eseguiti (es
comandi che non sono incorporati nella shell). Nota che la shell Bourne è diversa
qui; passa questi descrittori di file.

exit [status]
La shell esce con lo stato di uscita specificato. Se status non è specificato, l'uscita
lo stato è il valore corrente di $? parametro.

export [-p] [parametro[=APPREZZIAMO]]
Imposta l'attributo di esportazione dei parametri denominati. I parametri esportati vengono passati in
l'ambiente ai comandi eseguiti. Se vengono specificati dei valori, i parametri nominati
sono anche assegnati.

Se non vengono specificati parametri, tutti i parametri con l'attributo di esportazione impostato sono
stampato uno per riga; o i loro nomi, o, se una lettera '-' senza opzione è
specificato, coppie nome=valore, oppure, con -p, export comandi idonei al rientro.

falso Un comando che esce con uno stato diverso da zero.

fc [-e editore | -l [-n,-r] [prima di tutto [ultimo]]
prima di tutto ed ultimo selezionare i comandi dalla cronologia. I comandi possono essere selezionati dalla cronologia
numero (i numeri negativi vanno indietro dalla riga corrente, più recente) o a
stringa che specifica il comando più recente che inizia con quella stringa. Il -l opzione
elenca il comando sullo standard output e -n inibisce i numeri di comando predefiniti.
I -r opzione inverte l'ordine dell'elenco. Privo di -l, i comandi selezionati sono
modificato dall'editor specificato con il -e opzione, o se no -e è specificato, il
editor specificato dal parametro FCEDIT (se questo parametro non è impostato, /bin/ed is
utilizzato), e quindi eseguito dalla shell.

fc -e - | -s [-g] [vecchio=nuovi] [prefisso]
Esegui nuovamente il comando selezionato (il comando precedente per impostazione predefinita) dopo l'esecuzione
la sostituzione facoltativa di vecchio con nuovi. Se -g è specificato, tutte le occorrenze di
vecchio sono sostituiti con nuovi. Il significato di -e - ed -s è identico: eseguire nuovamente il
comando selezionato senza invocare un editor. Di solito si accede a questo comando con
il predefinito: alias r='fc -e -'

fg [lavoro ...]
Riprende i lavori specificati in primo piano. Se non vengono specificati lavori, %+ is
presunto. Vedere Lavoro di controllo sotto per maggiori informazioni.

getopts opstring Nome [arg ...]
Utilizzato dalle procedure della shell per analizzare gli argomenti specificati (o parametri posizionali,
se non vengono forniti argomenti) e per verificare le opzioni legali. opstring contiene l'
lettere di opzione che getopts è riconoscere. Se una lettera è seguita da due punti, il
ci si aspetta che l'opzione abbia un argomento. Le opzioni che non accettano argomenti possono essere
raggruppati in un unico argomento. Se un'opzione accetta un argomento e l'opzione
carattere non è l'ultimo carattere dell'argomento in cui si trova, il resto di
l'argomento è considerato l'argomento dell'opzione; altrimenti, l'argomento successivo è
l'argomento dell'opzione.

Ogni volta getopts viene invocato, inserisce l'opzione successiva nel parametro della shell Nome
e l'indice dell'argomento da elaborare dalla prossima chiamata a getopts nel
parametro della shell OPTIND. Se l'opzione è stata introdotta con un '+', l'opzione è stata piazzata
in Nome è preceduto da un '+'. Quando un'opzione richiede un argomento, getopts localita
nel parametro della shell OPTARG.

Quando si incontra un'opzione illegale o un argomento di opzione mancante, viene visualizzato un punto interrogativo
o vengono inseriti due punti in Nome (indicando un'opzione illegale o un argomento mancante,
rispettivamente) e OPTARG è impostato sul carattere dell'opzione che ha causato il problema.
Inoltre, se opstring non inizia con i due punti, viene inserito un punto interrogativo
Nome, OPTARG non è impostato e viene stampato un messaggio di errore come errore standard.

Quando si incontra la fine delle opzioni, getopts esce con un'uscita diversa da zero
stato. Le opzioni terminano al primo argomento (non opzione) che non inizia
con un '-', o quando si incontra un argomento '--'.

L'analisi delle opzioni può essere ripristinata impostando OPTIND su 1 (questo viene fatto automaticamente
ogni volta che viene invocata la shell o una procedura di shell).

Avvertenza: modifica del valore del parametro shell OPTIND su un valore diverso da 1, oppure
l'analisi di diversi set di argomenti senza reimpostare OPTIND, può portare a imprevisti
risultati.

globale ...
See comporre.

hash [-r] [Nome ...]
Senza argomenti, vengono elencati tutti i percorsi dei comandi eseguibili con hash. Il -r opzione
fa sì che tutti i comandi con hash vengano rimossi dalla tabella hash. Ogni Nome viene cercato
come se fosse un nome di comando e aggiunto alla tabella hash se è un eseguibile
comando.

posti di lavoro [-lnp] [lavoro ...]
Visualizza le informazioni sui lavori specificati; se non vengono specificati lavori, tutti i lavori
vengono visualizzati. Il -n opzione fa sì che le informazioni vengano visualizzate solo per i lavori che
hanno cambiato stato dall'ultima notifica. Se la -l viene utilizzata l'opzione, il
Viene elencato anche l'ID processo di ogni processo in un lavoro. Il -p opzione causa solo il
gruppo di processi di ogni lavoro da stampare. Vedere Lavoro di controllo di seguito per il formato di lavoro
e il lavoro visualizzato.

kill [-s sigla | -Signum | -sigla] { lavoro | pid | pgr } ...
Invia il segnale specificato ai lavori, agli ID di processo o ai gruppi di processi specificati. Se
non viene specificato alcun segnale, viene inviato il segnale TERM. Se viene specificato un lavoro, il segnale
viene inviato al gruppo di processi del lavoro. Vedere Lavoro di controllo di seguito per il formato di lavoro.

kill -l [stato di uscita ...]
Stampa il nome del segnale corrispondente a stato di uscita. Se non vengono specificati argomenti, a
viene stampato l'elenco di tutti i segnali, i loro numeri e una loro breve descrizione.

lasciare [espressione ...]
Ogni espressione viene valutata (vedi Aritmetica espressioni sopra). Se tutte le espressioni
sono valutati con successo, lo stato di uscita è 0 (1) se l'ultima espressione valutata
a diverso da zero (zero). Se si verifica un errore durante l'analisi o la valutazione di an
espressione, lo stato di uscita è maggiore di 1. Poiché potrebbe essere necessario che le espressioni siano
citato, (( espr )) è zucchero sintattico per { let 'espr'; }.

permettere] Alias ​​utilizzato internamente per lasciare.

mknod [-m modo] Nome b|c maggiore minore
mknod [-m modo] Nome p
Crea un file speciale del dispositivo. Il tipo di file potrebbe essere b (dispositivo a blocco), c
(dispositivo di tipo carattere), o p (denominato tubo, FIFO). Il file creato può essere modificato
secondo la sua modo (Attraverso il -m opzione), maggiore (numero principale del dispositivo), e minore
(numero dispositivo minore). Questo normalmente non fa parte di Grazie; tuttavia, i distributori possono
ho aggiunto questo come builtin come hack di velocità.

stampare [-nprsu[n] | -R [-in,argomento ...]
stampare stampa i suoi argomenti sullo standard output, separati da spazi e terminati
con una nuova riga. Il -n opzione sopprime la nuova riga. Per impostazione predefinita, alcuni caratteri di escape C
sono tradotti. Questi includono quelli menzionati in Barra rovesciata espansione anche sopra
come '\c', che equivale a usare il -n opzione. L'espansione della barra rovesciata potrebbe essere
inibito con il -r opzione. Il -s l'opzione stampa sul file della cronologia invece di
uscita standard; il -u l'opzione stampa sul descrittore di file n (n il valore predefinito è 1 se
omesso); e il -p l'opzione stampa sul co-processo (vedi Co-processi sopra).

I -R l'opzione viene utilizzata per emulare, in una certa misura, il BSD eco(1) comando che fa
non elaborare le sequenze '\' a meno che il -e l'opzione è data. Come sopra, il -n opzione
sopprime la nuova riga finale.

printf formato [argomenti ...]
Uscita formattata. All'incirca uguale a printf(1), utilità, tranne che usa
lo stesso Barra rovesciata espansione e codice I/O e non gestisce la virgola mobile come il
resto di Grazie. Un'utilità esterna è preferita rispetto a quella incorporata. Questo non è
normalmente parte di Grazie; tuttavia, i distributori potrebbero averlo aggiunto come integrato come a
hack di velocità. Non utilizzare nel nuovo codice.

pwd [-LP]
Stampa la directory di lavoro attuale. Se la -L viene utilizzata l'opzione o se Fisico
l'opzione non è impostata (vedi set comando sotto), viene stampato il percorso logico (cioè il
percorso usato per cd alla directory corrente). Se la -P viene utilizzata l'opzione (percorso fisico)
o se il Fisico è impostata l'opzione, il percorso determinato dal filesystem (da
seguenti directory '..' alla directory radice) viene stampato.

read [-A | -a] [-d x] [-N z | -n z] [-p | -u[n,-t n] [-r] [p ...]
Legge una riga di input, separa l'input in campi utilizzando il parametro IFS (vedi
Sostituzione sopra) e assegna ogni campo ai parametri specificati p. Se no
vengono specificati i parametri, il parametro REPLY viene utilizzato per memorizzare il risultato. Con il
-A ed -a opzioni, viene accettato solo nessun parametro o un solo parametro. Se ce ne sono di più
parametri rispetto ai campi, i parametri aggiuntivi sono impostati sulla stringa vuota o su 0; Se
ci sono più campi che parametri, all'ultimo parametro viene assegnato il rimanente
campi (compresi i separatori di parole).

Le opzioni sono le seguenti:

-A Memorizza il risultato nel parametro p (o REPLY) come matrice di parole.

-a Memorizza il risultato senza suddivisione in parole nel parametro p (o RISPONDI) come
array di caratteri (caratteri larghi se il modalità utf8 l'opzione è attivata,
ottetti altrimenti); i codepoint sono codificati come numeri decimali per impostazione predefinita.

-d x Usa il primo byte di x, NUL se vuoto, invece del carattere di nuova riga ASCII
come delimitatore di riga di input.

-N z Invece di leggere fino alla fine della riga, leggi esattamente z byte. Se EOF o a
si verifica un timeout, viene restituita una lettura parziale con stato di uscita 1.

-n z Invece di leggere fino alla fine della riga, leggi fino a z byte ma ritorna non appena
eventuali byte vengono letti, ad esempio da un dispositivo terminale lento, o se EOF o un timeout
si verifica.

-p Leggi dal co-processo attualmente attivo, vedi Co-processi sopra per i dettagli
su questo.

-u[n] Leggi dal descrittore di file n (il valore predefinito è 0, ovvero l'input standard). Il
l'argomento deve seguire immediatamente il carattere dell'opzione.

-t n Interrompi la lettura dopo n secondi (specificato come valore decimale positivo con an
parte frazionaria facoltativa). Lo stato di uscita di read è 1 se il timeout
si è verificato, ma le letture parziali possono ancora essere restituite.

-r Normalmente, il carattere barra rovesciata ASCII sfugge al significato speciale di
carattere successivo e viene rimosso dall'input; read non si ferma quando
incontra una sequenza di backslash-newline e non memorizza quella newline in
il risultato. Questa opzione abilita la modalità raw, in cui le barre rovesciate non lo sono
trasformati.

-s La riga di input viene salvata nella cronologia.

Se l'ingresso è un terminale, entrambi i -N ed -n le opzioni lo impostano in modalità raw; essi
legge un intero file se -1 viene passato come z discussione.

Il primo parametro può avere un punto interrogativo e una stringa aggiunta, in cui
caso la stringa viene utilizzata come prompt (stampata con l'errore standard prima di qualsiasi input
read) se l'input è a tty(4) (es read nfoo?'numero of fos: ').

Se non viene letto alcun input o si è verificato un timeout, read esce con uno stato diverso da zero.

Un altro utile set di trucchi: If read viene eseguito in un ciclo come while read pippo; do ...;
fatto quindi gli spazi bianchi iniziali verranno rimossi (IFS) e le barre rovesciate verranno elaborate. Voi
potrebbe voler usare while SE= read -r pippo; do ...; fatto per I/O incontaminato. Allo stesso modo,
quando si utilizza il -a opzione, uso del -r l'opzione potrebbe essere prudente; lo stesso vale
per:

trova . -type f -print0 |& \
mentre IFS= read -d '' -pr nomefile; fare
print -r -- "trovato <${nomefile#./}>"
fatto

Il ciclo interno verrà eseguito in una subshell e le modifiche alle variabili non possono essere
propagato se eseguito in una pipeline:

bar | baz | mentre leggi pippo; fare ...; fatto

Utilizzare invece i co-processi:

bar | baz |&
mentre leggi -p pippo; fare ...; fatto
esec 3>&p; esec 3>&-

in sola lettura [-p] [parametro [=APPREZZIAMO] ...]
Imposta l'attributo di sola lettura dei parametri denominati. Se vengono dati dei valori,
i parametri sono impostati su di essi prima di impostare l'attributo. Una volta creato un parametro
di sola lettura, non può essere annullato e il suo valore non può essere modificato.

Se non vengono specificati parametri, i nomi di tutti i parametri con la sola lettura
gli attributi vengono stampati uno per riga, a meno che il -p viene utilizzata l'opzione, nel qual caso
in sola lettura i comandi che definiscono tutti i parametri di sola lettura, inclusi i loro valori, sono
stampato.

percorso reale [--] Nome
Stampa il percorso assoluto risolto corrispondente a Nome. Se Nome finisce con a
barra ('/'), viene anche verificata l'esistenza e se si tratta di una directory;
altrimenti, percorso reale restituisce 0 se il percorso esiste o può essere creato
immediatamente, cioè tutti tranne l'ultimo componente esistono e sono directory.

rinominare [--] da a
Rinomina il file da a a. Entrambi devono essere percorsi completi e sullo stesso dispositivo.
Questo builtin è destinato a situazioni di emergenza in cui /bin/mv diventa inutilizzabile, e
chiama direttamente rinominare(2).

ritorno [status]
Restituisce da una funzione o . script, con stato di uscita status. Se no status viene data,
viene utilizzato lo stato di uscita dell'ultimo comando eseguito. Se utilizzato al di fuori di una funzione
or . script, ha lo stesso effetto di exit. Nota che Grazie tratta sia il profilo che
File ENV come . script, mentre la shell Korn originale tratta solo i profili come .
script.

set [+-abCefhiklmnprsUuvXx] [+-o opzione] [+-A Nome] [--] [arg ...]
I set comando può essere utilizzato per impostare (-) o chiaro (+) opzioni della shell, imposta il posizionale
parametri o impostare un parametro di matrice. Le opzioni possono essere modificate utilizzando il +-o opzione
sintassi, dove opzione è il nome lungo di un'opzione, o usando il +-lettera sintassi,
where lettera èil nome di una singola lettera dell'opzione (non tutte le opzioni hanno una sola lettera
nome). La tabella seguente elenca sia le lettere di opzione (se esistono) che i nomi lunghi
insieme a una descrizione di cosa fa l'opzione:

-A Nome
Imposta gli elementi del parametro array Nome a arg ... If -A È utilizzato, il
l'array viene ripristinato (ovvero svuotato) per primo; Se +A viene utilizzato, vengono impostati i primi N elementi
(dove N è il numero di argomenti); il resto viene lasciato intatto.

Una sintassi alternativa per il comando set -A foo -- a b c che è compatibile con
GNU bash e supportato anche da AT&T UNIX ksh93 è: pippo=(a b C); pippo+=(d e)

-a | -o allexport
Tutti i nuovi parametri vengono creati con l'attributo di esportazione.

-b | -o notificare
Stampa i messaggi di notifica del lavoro in modo asincrono, anziché appena prima del
richiesta. Utilizzato solo se è abilitato il controllo lavori (-m).

-C | -o noclobber
Impedisci al reindirizzamento > di sovrascrivere i file esistenti. Invece, >| deve essere usato
per forzare una sovrascrittura. Nota che questo non è sicuro da usare per la creazione di
file temporanei o file di blocco a causa di un TOCTOU in un controllo che consente il reindirizzamento
uscita a / Dev / null o altri file del dispositivo anche in noclobber modalità.

-e | -o errore
Esci (dopo aver eseguito il trap ERR) non appena si verifica un errore o un comando
fallisce (cioè esce con uno stato diverso da zero). Questo non si applica ai comandi
il cui stato di uscita è esplicitamente testato da un costrutto di shell come if, fino a quando,
while, o ! dichiarazioni. Per && o ||, solo lo stato dell'ultimo comando è
testato.

-f | -o noglob
Non espandere i modelli di nomi di file.

-h | -o trackall
Crea alias tracciati per tutti i comandi eseguiti (vedi Alias sopra). Abilitato
per impostazione predefinita per le shell non interattive.

-i | -o interattivo
La shell è una shell interattiva. Questa opzione può essere utilizzata solo quando la shell
viene invocato. Vedi sopra per una descrizione di cosa significa.

-k | -o parola chiave
Le assegnazioni dei parametri vengono riconosciute ovunque in un comando.

-l | -o accesso
La shell è una shell di accesso. Questa opzione può essere utilizzata solo quando la shell è
invocato. Vedi sopra per una descrizione di cosa significa.

-m | -o monitore
Abilita il controllo del lavoro (impostazione predefinita per le shell interattive).

-n | -o noexec
Non eseguire alcun comando. Utile per controllare la sintassi degli script (ignorati
se interattivo).

-p | -o privilegiato
La shell è una shell privilegiata. Viene impostato automaticamente se, quando la shell
inizia, l'UID o GID reale non corrisponde all'UID effettivo (EUID) o GID
(EGID), rispettivamente. Vedi sopra per una descrizione di cosa significa.

-r | -o limitato
La shell è una shell ristretta. Questa opzione può essere utilizzata solo quando la shell è
invocato. Vedi sopra per una descrizione di cosa significa.

-s | -o stdin
Se utilizzato quando viene invocata la shell, i comandi vengono letti dall'input standard. Set
automaticamente se la shell viene invocata senza argomenti.

Quando -s viene utilizzato con il set comando fa sì che gli argomenti specificati siano
ordinati prima di assegnarli ai parametri posizionali (o all'array Nome, Se
-A viene usato).

-U | -o modalità utf8
Abilita il supporto UTF-8 nel Emacs montaggio modo e gestione interna delle stringhe
funzioni. Questo flag è disabilitato per impostazione predefinita, ma può essere abilitato impostandolo
sulla riga di comando della shell; è abilitato automaticamente per le shell interattive se
richiesto in fase di compilazione, il tuo sistema supporta setlocale(LC_CTYPE, "") e
facoltativamente nl_langinfo(CODICE), o l'ambiente LC_ALL, LC_CTYPE o LANG
variabili e almeno una di queste restituisce qualcosa che corrisponde a "UTF-8" o
"utf8" senza distinzione tra maiuscole e minuscole; per le chiamate dirette integrate a seconda del
le suddette variabili d'ambiente; o per stdin o script, se l'input
inizia con un Byte Order Mark UTF-8.

Nel prossimo futuro verrà implementato il monitoraggio delle impostazioni locali, il che significa che set -+U is
modificato ogni volta che cambia una delle variabili di ambiente relative alla locale POSIX.

-u | -o sostantivo
Il riferimento a un parametro non impostato, diverso da "$@" o "$*", viene trattato come un
errore, a meno che non venga utilizzato uno dei modificatori '-', '+' o '='.

-v | -o verboso
Scrivi l'input della shell nell'errore standard mentre viene letto.

-X | -o markdir
Contrassegna le directory con un '/' finale durante la generazione del nome file.

-x | -o xtraccia
Stampa gli alberi dei comandi quando vengono eseguiti, preceduti dal valore di PS4.

-o bella
I lavori in background vengono eseguiti con priorità più bassa.

-o parentesi espandi
Abilita l'espansione della parentesi graffa (nota anche come alternanza). Questo è abilitato per impostazione predefinita. Se
disabilitato, l'espansione della tilde dopo un segno di uguale è disabilitata come effetto collaterale.

-o emacs
Abilita la modifica della riga di comando simile a BRL emacs (solo shell interattive); vedere Emacs
montaggio modo.

-o gmac
Abilita la modifica della riga di comando simile a gmacs (solo shell interattive). Attualmente
identico all'editing di emacs tranne che transpose-chars (^T) agisce leggermente
diversamente.

-o ignorare
La shell non uscirà (facilmente) quando viene letta la fine del file; exit deve essere usato.
Per evitare loop infiniti, la shell uscirà se EOF viene letto 13 volte di seguito.

-o ereditare-xtrace
Non resettare -o xtraccia all'ingresso delle funzioni. Questo è abilitato per impostazione predefinita.

-o no
Non terminare i lavori in esecuzione con un segnale SIGHUP quando esce una shell di login.
Attualmente impostato per impostazione predefinita, ma questo potrebbe cambiare in futuro per essere compatibile
con AT&T UNIX ksh, che non ha questa opzione, ma invia il SIGHUP
segnale.

-o nolog
Nessun effetto. Nella shell Korn originale, questo impedisce che le definizioni delle funzioni
essere memorizzato nel file di cronologia.

-o Fisico
Provoca il cd ed pwd comandi per usare "fisico" (cioè il filesystem) '..'
directory invece delle directory "logiche" (cioè la shell gestisce '..', che
consente all'utente di ignorare i collegamenti simbolici alle directory). Cancella entro
predefinito. Nota che l'impostazione di questa opzione non influisce sul valore corrente di
parametro PWD; solo il cd comando cambia PWD. Vedi il cd ed pwd comandi
sopra per maggiori dettagli.

-o tubo fallito
Rendere lo stato di uscita di un gasdotto (prima di completare logicamente) il
livello di errore diverso da zero all'estrema destra o zero se tutti i comandi sono usciti con zero.

-o posix
Comportarsi più vicino agli standard (vedi POSIX modo per dettagli). Automaticamente
abilitato se il nome base dell'invocazione della shell inizia con "sh" e questo
la funzione di rilevamento automatico è compilata in (non in MirBSD). Come effetto collaterale, impostazione
questo flag si spegne parentesi espandi modalità, che può essere riattivata manualmente, e
sh modalità (a meno che entrambi non siano abilitati contemporaneamente).

-o sh
permettere /bin/sh modalità (kludge) (vedi SH modo). Abilitato automaticamente se il
il nome base dell'invocazione della shell inizia con "sh" e questa funzione di rilevamento automatico
è compilato in (non in MirBSD). Come effetto collaterale, l'impostazione di questo flag si disattiva
parentesi espandi modalità, che può essere riattivata manualmente, e posix modalità (a meno che
entrambi sono abilitati contemporaneamente).

-o vi
permettere vi(1) come modifica della riga di comando (solo shell interattive). Vedere Vi
montaggio modo per documentazione e limitazioni.

-o vi-esccompleto
Nella modifica della riga di comando di vi, completa il comando e il nome del file quando escape (^[)
si entra in modalità comando.

-o vi-tabcomplete
Nella modifica della riga di comando di vi, completa il comando e il nome del file quando la scheda (^I) è
inserito in modalità di inserimento. Questa è l'impostazione predefinita.

-o viraw
Nessun effetto. Nella shell Korn originale, a meno che viraw è stato impostato, il comando vi-
la modalità linea lascerebbe tty(4) il driver esegue il lavoro fino a quando non è stato inserito ESC (^[).
Grazie è sempre in modalità viraw.

Queste opzioni possono essere utilizzate anche dopo l'invocazione della shell. L'attuale serie di
le opzioni (con nomi di lettere singole) possono essere trovate nel parametro '$-'. set -o con
nessun nome di opzione elencherà tutte le opzioni e se ognuna è attiva o disattivata; set +o volere
stampa i nomi lunghi di tutte le opzioni attualmente attive. In una versione futura, set
+o si comporterà in conformità con POSIX e stamperà i comandi per ripristinare le opzioni correnti
anziché.

Gli argomenti rimanenti, se presenti, sono parametri posizionali e sono assegnati, nell'ordine, a
i parametri posizionali (cioè $1, $2, ecc.). Se le opzioni finiscono con '--' e lì
non ci sono argomenti rimanenti, tutti i parametri posizionali vengono cancellati. Se nessuna opzione o
vengono forniti gli argomenti, vengono stampati i valori di tutti i nomi. Per sconosciuto storico
motivi, una sola opzione '-' viene trattata in modo speciale - cancella entrambi i -v ed -x
opzioni.

spostamento [numero]
I parametri posizionali numero+ 1, numero+2, ecc. vengono rinominati in '1', '2', ecc.
numero il valore predefinito è 1.

sonno secondo
Sospende l'esecuzione per un minimo del secondo specificato come valore decimale positivo
con una parte frazionaria facoltativa. La consegna del segnale può continuare l'esecuzione prima.

source filetto [arg ...]
Come . ("punto"), tranne per il fatto che la directory di lavoro corrente viene aggiunta alla ricerca
percorso (GNU bash estensione).

sospendere
Arresta la shell come se avesse ricevuto il carattere di sospensione dal terminale. è
non è possibile sospendere una shell di login a meno che il processo padre non sia membro del
stessa sessione di terminale ma è membro di un gruppo di processi diverso. Come un generale
regola, se la shell è stata avviata da un'altra shell o tramite su(1), può essere sospeso.

test espressione
[ espressione ]
test valuta il espressione e restituisce lo stato zero se vero, 1 se falso o maggiore
di 1 se si è verificato un errore. Viene normalmente utilizzato come comando di condizione di if ed
while dichiarazioni. I collegamenti simbolici sono seguiti per tutti filetto espressioni tranne -h ed
-L.

Sono disponibili le seguenti espressioni di base:

-a filetto filetto esiste.

-b filetto filetto è un dispositivo speciale a blocchi.

-c filetto filetto è un dispositivo speciale di carattere.

-d filetto filetto è una directory.

-e filetto filetto esiste.

-f filetto filetto è un file normale.

-G filetto filetto's group è l'ID di gruppo effettivo della shell.

-g filetto filetto's mode ha il bit setgid impostato.

-H filetto filetto è una directory dipendente dal contesto (utile solo su HP-UX).

-h filetto filetto è un collegamento simbolico.

-k filetto filettola modalità di 's ha il appiccicoso(8) bit impostato.

-L filetto filetto è un collegamento simbolico.

-O filetto filettoil proprietario è l'ID utente effettivo della shell.

-o opzione Conchiglia opzione è impostato (vedi set comando sopra per un elenco di
opzioni). Come estensione non standard, se l'opzione inizia con
un '!', il test viene negato; il test fallisce sempre se opzione
non esiste (quindi [ -o foo -o -o !foo ] restituisce true se e solo
se opzione foo esiste). Lo stesso può essere ottenuto con [ -o ?foo ]
come in AT&T UNIX ksh93. opzione può anche essere la bandiera corta guidata da
'-' o '+' (nessuna negazione logica), ad esempio '-x' o '+x'
invece di 'xtrace'.

-p filetto filetto è una named pipe (FIFO).

-r filetto filetto esiste ed è leggibile.

-S filetto filetto è un unix(4) socket di dominio.

-s filetto filetto non è vuoto.

-t fd Descrittore di file fd è un tty(4) dispositivo.

-u filetto filetto's mode ha il bit setuid impostato.

-w filetto filetto esiste ed è scrivibile.

-x filetto filetto esiste ed è eseguibile.

file1 -nt file2 file1 è più recente di file2 or file1 esiste e file2 non.

file1 -o file2 file1 è più vecchio di file2 or file2 esiste e file1 non.

file1 -ef file2 file1 è lo stesso file di file2.

stringa stringa ha lunghezza diversa da zero.

-n stringa stringa non è vuoto.

-z stringa stringa è vuoto.

stringa = stringa Le stringhe sono uguali.

stringa == stringa Le stringhe sono uguali.

stringa > stringa Il primo operando di stringa è maggiore del secondo operando di stringa.

stringa < stringa Il primo operando di stringa è minore del secondo operando di stringa.

stringa != stringa Le stringhe non sono uguali.

numero -eq numero I numeri sono uguali.

numero -Ne numero I numeri non sono uguali.

numero -dare numero I numeri confrontano maggiori o uguali.

numero -gt numero I numeri confrontano maggiori di.

numero -Le numero I numeri confrontano minore o uguale.

numero -lt numero I numeri confrontano meno di.

Le espressioni di base di cui sopra, in cui gli operatori unari hanno la precedenza su binari
operatori, possono essere combinati con i seguenti operatori (elencati in ordine crescente
di precedenza):

expr -o expr OR logico.
expr -a expr AND logico.
! expr NOT logico.
( espr ) Raggruppamento.

Nota che un numero in realtà può essere un'espressione aritmetica, come una matematica
term o il nome di una variabile intera:

x=1; [ "x" -eq 1 ] restituisce vero

Si noti che vengono applicate alcune regole speciali (per gentile concessione di POSIX) se il numero di
argomenti a test o tra parentesi [ ... ] è minore di cinque: se all'inizio '!'
gli argomenti possono essere rimossi in modo tale che rimangano solo da uno a tre argomenti, quindi il
viene eseguito il confronto ridotto; (grazie a XSI) parentesi \( ... \) inferiore quattro e
forme a tre argomenti a forme a due e un argomento, rispettivamente; tre argomenti
le forme in definitiva preferiscono le operazioni binarie, seguite da negazione e parentesi
abbassamento; le forme a due e quattro argomenti preferiscono la negazione seguita da parentesi; il
la forma a un argomento implica sempre -n.

Note:: Un errore comune è usare "if [ $pippo = bar ]" che fallisce se il parametro "pippo"
è NULL o non impostato, se ha spazi incorporati (es. ottetti IFS), o se è unario
operatore come '!' o '-n'. Usa invece test come "if [ x"$pippo" = x"bar" ]” o il
operatore tra parentesi quadre "if [[ $foo = bar ]]" o, per evitare il pattern matching (vedi [[
sopra): “if [[ $pippo = "$barra" ]]”

I [[ ... ]] build non è solo più sicuro da usare, ma spesso è anche più veloce.

tempo [-p] [conduttura]
Se un conduttura è dato, vengono riportati i tempi utilizzati per eseguire la pipeline. se no
viene data la pipeline, quindi l'ora dell'utente e del sistema utilizzata dalla shell stessa e tutto
vengono riportati i comandi che ha eseguito da quando è stato avviato. I tempi riportati sono
il tempo reale (tempo trascorso dall'inizio alla fine), il tempo della CPU dell'utente (tempo impiegato
in esecuzione in modalità utente) e il tempo della CPU di sistema (tempo trascorso in esecuzione in modalità kernel).
I tempi sono riportati all'errore standard; il formato dell'output è:

0m0.00s reale 0m0.00s utente 0m0.00s sistema

Se l' -p opzione è data l'output è leggermente più lungo:

vero 0.00
utente 0.00
sistema 0.00

È un errore specificare il -p opzione a meno che conduttura è un semplice comando.

I reindirizzamenti semplici dell'errore standard non influiscono sull'output del tempo comando:

$ time sleep 1 2>afile
$ { ora di sonno 1; } 2>afile

I tempi per il primo comando non vanno a "afile", ma quelli del secondo comando sì.

volte Stampa i tempi accumulati dell'utente e del sistema utilizzati sia dalla shell che dai processi
che la shell è iniziata che è uscita. Il formato dell'output è:

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

trappola n [segnale ...]
Se il primo operando è un intero decimale senza segno, questo ripristina tutti i segnali specificati
all'azione predefinita, cioè è lo stesso che chiamare trappola con un segno meno ('-') as
Handler, seguito dagli argomenti (n [segnale ...]), che sono tutti trattati come
segnali.

trappola [Handler segnale ...]
Imposta un gestore di trap che deve essere eseguito quando una delle condizioni specificate segnales sono
ricevuto. Handler è una stringa vuota, che indica che i segnali devono essere
ignorato, un segno meno ('-'), che indica che l'azione predefinita deve essere intrapresa per
i segnali (vedi segnale(3)), o una stringa contenente comandi di shell da eseguire su
la prima opportunità (cioè quando il comando corrente viene completato, o prima di stampare
successivo prompt PS1) dopo la ricezione di uno dei segnali. segnale è il nome di a
segnale (es. PIPE o ALRM) o il numero del segnale (vedi kill -l command
sopra).

Ci sono due segnali speciali: EXIT (noto anche come 0), che viene eseguito quando il
shell sta per uscire e ERR, che viene eseguito dopo che si è verificato un errore; un errore è
qualcosa che farebbe uscire la shell se il set -e or set -o errore opzione
sono stati impostati. I gestori EXIT vengono eseguiti nell'ambiente dell'ultimo eseguito
comando.

Nota che, per le shell non interattive, il gestore trap non può essere modificato per i segnali
che sono stati ignorati all'avvio della shell.

Senza argomenti, lo stato attuale delle trap che sono state impostate dalla shell
avviato viene mostrato come una serie di trappola comandi. Notare che l'output di trappola non può
essere utilmente convogliato a un altro processo (un artefatto del fatto che le trappole vengono rimosse
quando vengono creati sottoprocessi).

La trappola DEBUG della shell originale Korn e la gestione delle trappole ERR e EXIT in
le funzioni non sono ancora state implementate.

vero Un comando che termina con un valore zero.

globale [[+-alpnrtUux] [-L[n,-R[n,-Z[n,-i[n]] | -f [-tux,Nome [=APPREZZIAMO] ...]
comporre [[+-alpnrtUux] [-LRZ[n,-i[n]] | -f [-tux,Nome [=APPREZZIAMO] ...]
Visualizza o imposta gli attributi dei parametri. Senza Nome argomenti, attributi dei parametri
sono visualizzati; se non vengono utilizzate opzioni, gli attributi correnti di tutti i parametri sono
stampato come comporre comandi; se viene data un'opzione (o '-' senza lettera di opzione),
vengono stampati tutti i parametri ei loro valori con gli attributi specificati; se opzioni
vengono introdotti con '+', i valori dei parametri non vengono stampati.

If Nome vengono forniti gli argomenti, vengono impostati gli attributi dei parametri nominati (-) o puoi
cancellato (+). I valori per i parametri possono essere specificati facoltativamente. Per Nome[*], il
la modifica ha effetto sull'intero array e non è possibile specificare alcun valore.

If comporre viene utilizzato all'interno di una funzione, tutti i parametri specificati vengono localizzati. Questo
non è fatto dall'altro identico globale. Note:: Ciò significa che Grazie 's globale
il comando è non equivalente ad altri linguaggi di programmazione' in quanto non consente a
funzione chiamata da un'altra funzione per accedere a un parametro in ambito veramente globale,
ma impedisce solo di inserire uno a cui si accede nell'ambito locale.

Quando -f si usa, comporre opera sugli attributi delle funzioni. come con
parametri, se no Nome gli argomenti sono dati, le funzioni sono elencate con i loro valori
(vale a dire definizioni) a meno che non vengano introdotte opzioni con '+', nel qual caso solo il
vengono riportati i nomi delle funzioni.

-a Attributo dell'array indicizzato.

-f Modalità funzione. Visualizza o imposta le funzioni e i loro attributi, invece di
parametri.

-i[n] Attributo intero. n specifica la base da usare quando si visualizza l'intero
(se non specificato si utilizza la base data nella prima assegnazione).
Ai parametri con questo attributo possono essere assegnati valori contenenti aritmetica
espressioni.

-L[n] Attributo giustificato a sinistra. n specifica la larghezza del campo. Se n non è specificato,
la larghezza corrente di un parametro (o la larghezza del suo primo valore assegnato)
viene utilizzato. Spazi iniziali (e zeri, se usati con il -Z opzione) è
spogliato. Se necessario, i valori vengono troncati o riempiti di spazio per adattarsi
la larghezza del campo.

-l Attributo minuscolo. Tutti i caratteri maiuscoli nei valori vengono convertiti in
minuscolo. (Nella shell Korn originale, questo parametro significava "lungo intero"
se usato con il -i opzione.)

-n Crea una variabile associata (riferimento al nome): qualsiasi accesso alla variabile Nome
accederà alla variabile APPREZZIAMO nell'ambito corrente (questo è diverso da
AT&T UNIX ksh93!) Invece. Anche diverso da AT&T UNIX ksh93 è che
APPREZZIAMO è pigramente valutato al momento Nome si accede. Questo può essere usato da
funzioni per accedere a variabili i cui nomi sono passati come parametri, invece
di utilizzo eval.

-p Stampa completata comporre comandi che possono essere utilizzati per ricreare gli attributi
e valori dei parametri.

-R[n] Attributo giustificato a destra. n specifica la larghezza del campo. Se n non è
specificato, la larghezza corrente di un parametro (o la larghezza del suo primo
valore assegnato) viene utilizzato. Gli spazi bianchi finali vengono eliminati. Se necessario,
i valori sono o spogliati dei caratteri iniziali o riempiti di spazio per renderli
adattarsi alla larghezza del campo.

-r Attributo di sola lettura. I parametri con questo attributo potrebbero non essere assegnati a
o disinserito. Una volta impostato, questo attributo non può essere disattivato.

-t Attributo tag. Non ha significato per il guscio; fornito per l'uso dell'applicazione.

Per le funzioni, -t è l'attributo di traccia. Quando funziona con la traccia
attributo vengono eseguiti, il xtraccia (-x) l'opzione shell è temporaneamente attivata
on.

-U Attributo intero senza segno. Gli interi vengono stampati come valori senza segno (combina
con la -i opzione). Questa opzione non è nella shell Korn originale.

-u Attributo maiuscolo. Tutti i caratteri minuscoli nei valori vengono convertiti in
maiuscolo. (Nella shell Korn originale, questo parametro significava "unsigned
intero” quando utilizzato con il -i opzione che significava lettere maiuscole sarebbero
non essere mai utilizzato per basi maggiori di 10. Vedere il -U opzione.)

Per le funzioni, -u è l'attributo indefinito. Vedere funzioni sopra per il
implicazioni di questo.

-x Attributo di esportazione. I parametri (o funzioni) sono collocati nell'ambiente di
eventuali comandi eseguiti. Le funzioni esportate non sono ancora implementate.

-Z[n] Attributo di riempimento zero. Se non combinato con -L, questo è lo stesso di -R, ad eccezione
zero padding viene utilizzato al posto dello spazio padding. Per i numeri interi, il numero
invece la base è imbottita.

Se qualcuno dei -i, -L, -l, -R, -U, -u, o -Z le opzioni sono cambiate, tutte le altre da questo
set vengono cancellati, a meno che non vengano forniti anche sulla stessa riga di comando.

ulimit [-aBCcdefHilMmnOPpqrSsTtVvw] [APPREZZIAMO]
Visualizza o imposta i limiti del processo. Se non vengono utilizzate opzioni, il limite di dimensione del file (-f) è
presunto. APPREZZIAMO, se specificato, può essere un'espressione aritmetica o la parola
"illimitato". I limiti influenzano la shell e tutti i processi creati dalla shell
dopo che è stato imposto un limite. Si noti che alcuni sistemi potrebbero non consentire che i limiti siano
aumentati una volta impostati. Si noti inoltre che i tipi di limiti disponibili sono di sistema
dipendente – alcuni sistemi hanno solo il -f limite.

-a Visualizza tutti i limiti; salvo che -H viene utilizzato, vengono visualizzati i limiti soft.

-B n Imposta la dimensione del buffer del socket su n kibibyte.

-C n Imposta il numero di thread memorizzati nella cache su n.

-c n Imporre un limite di dimensione di n blocchi sulla dimensione dei core dump.

-d n Imporre un limite di dimensione di n kibibyte sulla dimensione dell'area dati.

-e n Imposta la massima gentilezza su n.

-f n Imporre un limite di dimensione di n blocchi sui file scritti dalla shell e dal suo figlio
processi (file di qualsiasi dimensione possono essere letti).

-H Imposta solo il limite rigido (l'impostazione predefinita prevede l'impostazione di entrambi i limiti rigido e flessibile).

-i n Imposta il numero di segnali in sospeso su n.

-l n Imporre un limite di n kibibyte sulla quantità di memoria fisica bloccata (cablata).

-M n Imposta la memoria bloccata AIO su n kibibyte.

-m n Imporre un limite di n kibibyte sulla quantità di memoria fisica utilizzata.

-n n Imporre un limite di n descrittori di file che possono essere aperti contemporaneamente.

-O n Imposta il numero di operazioni AIO su n.

-P n Limita il numero di thread per processo a n.

-p n Imporre un limite di n processi che possono essere eseguiti dall'utente in qualsiasi momento.

-q n Limita la dimensione delle code di messaggi POSIX a n byte.

-r n Imposta la massima priorità in tempo reale su n.

-S Imposta solo il limite soft (l'impostazione predefinita prevede l'impostazione di entrambi i limiti hard e soft).

-s n Imporre un limite di dimensione di n kibibyte sulla dimensione dell'area dello stack.

-T n Imporre un limite di tempo di n secondi reali da utilizzare per ogni processo.

-t n Imporre un limite di tempo di n Secondi CPU trascorsi in modalità utente per essere utilizzati da ciascuno
processo.

-V n Imposta il numero di monitor vnode su Haiku su n.

-v n Imporre un limite di n kibibytes sulla quantità di memoria virtuale (spazio di indirizzi)
Usato.

-w n Imporre un limite di n kibibyte sulla quantità di spazio di swap utilizzato.

Fino a ulimit è interessato, un blocco è di 512 byte.

umask [-S] [mask]
Visualizza o imposta la maschera di creazione dei permessi del file, o umask (vedi umask(2)). Se la -S
viene utilizzata l'opzione, la maschera visualizzata o impostata è simbolica; altrimenti è un ottale
numero.

Le maschere simboliche sono come quelle usate da chmod(1). Quando vengono utilizzati, descrivono cosa
i permessi possono essere resi disponibili (al contrario delle maschere ottali in cui un bit impostato significa
il bit corrispondente deve essere azzerato). Ad esempio, "ug=rwx,o=" imposta la maschera così
i file non saranno leggibili, scrivibili o eseguibili da "altri" ed è equivalente
(sulla maggior parte dei sistemi) alla maschera ottale “007”.

Unalias [-avv] [Nome ...]
Gli alias per i nomi dati vengono rimossi. Se la -a viene utilizzata l'opzione, tutti gli alias
vengono rimossi. Se la -t or -d si utilizzano le opzioni, si eseguono le operazioni indicate
out su alias tracciati o directory, rispettivamente.

non settato [-fv] parametro ...
Annulla l'impostazione dei parametri denominati (-v, l'impostazione predefinita) o funzioni (-f). Con parametro[*],
gli attributi vengono mantenuti, solo i valori non vengono impostati.

Lo stato di uscita è diverso da zero se uno qualsiasi dei parametri ha l'attributo di sola lettura
impostato, zero altrimenti.

aspettare [lavoro ...]
Attendi il completamento dei lavori specificati. Lo stato di uscita di aspettare è quello dell'ultimo
lavoro specificato; se l'ultimo lavoro viene interrotto da un segnale, lo stato di uscita è 128 + il
numero del segnale (vedi kill -l stato di uscita sopra); se l'ultimo lavoro specificato non può
essere trovato (perché non è mai esistito, o era già terminato), lo stato di uscita di aspettare
è 127. Vedi Lavoro di controllo di seguito per il formato di lavoro. aspettare tornerà se un segnale
per il quale è stato impostato un trap o se viene ricevuto un segnale SIGHUP, SIGINT o SIGQUIT
è ricevuto.

Se non vengono specificati lavori, aspettare attende tutti i lavori attualmente in esecuzione (se presenti) per
termina ed esce con stato zero. Se il monitoraggio del lavoro è abilitato, il completamento
viene stampato lo stato dei lavori (questo non è il caso quando i lavori sono specificati in modo esplicito).

da dove [-pv] [Nome ...]
Senza il -v opzione, è lo stesso di command -v, tranne che gli alias non vengono stampati
come comando alias. Con il -v opzione, è esattamente la stessa di command -V. in
in entrambi i casi, il -p l'opzione è diversa: il percorso di ricerca non è influenzato in da dove, ma
la ricerca è ristretta al percorso.

Lavoro di controllo
Il controllo del lavoro si riferisce alla capacità della shell di monitorare e controllare i lavori che sono processi o
gruppi di processi creati per comandi o pipeline. Come minimo, il guscio tiene traccia
dello stato dei lavori in background (cioè asincroni) attualmente esistenti; questo
le informazioni possono essere visualizzate utilizzando il posti di lavoro comandi. Se il controllo del lavoro è completamente abilitato
(usando set -m or set -o monitore), come per le shell interattive, i processi di un lavoro
vengono inseriti nel proprio gruppo di processi. I lavori in primo piano possono essere interrotti digitando sospendi
carattere dal terminale (normalmente ^Z), i lavori possono essere riavviati in primo piano o
sfondo usando il fg ed bg comandi e lo stato del terminale viene salvato o ripristinato
quando un lavoro in primo piano viene interrotto o riavviato, rispettivamente.

Nota che solo i comandi che creano processi (es. comandi asincroni, subshell
comandi e comandi non incorporati e non funzionali) possono essere interrotti; comandi come read non può
essere.

Quando viene creato un lavoro, gli viene assegnato un numero di lavoro. Per le shell interattive, questo numero è
stampato all'interno di “[..]”, seguito dagli ID di processo dei processi nel lavoro quando un
viene eseguito il comando asincrono. Un lavoro può essere indicato nel bg, fg, posti di lavoro, kille aspettare
comandi dall'ID del processo dell'ultimo processo nella pipeline dei comandi (come archiviato in
, il $! parametro) o anteponendo al numero del lavoro un segno di percentuale ('%'). Altra percentuale
le sequenze possono essere utilizzate anche per fare riferimento a lavori:

%+ | %% | % Il lavoro interrotto più di recente o, se non ci sono lavori interrotti, il più vecchio
lavoro in esecuzione.

%- Il lavoro che sarebbe il %+ lavoro se quest'ultimo non esisteva.

%n Il lavoro con il numero di lavoro n.

%?stringa Il lavoro con il suo comando contenente la stringa stringa (si verifica un errore se
più lavori sono abbinati).

%stringa Il lavoro con il suo comando che inizia con la stringa stringa (si verifica un errore se
più lavori sono abbinati).

Quando un lavoro cambia stato (es. un lavoro in background finisce o un lavoro in primo piano viene interrotto), il
shell stampa le seguenti informazioni di stato:

[numero] bandiera status command

dove ...

numero è il numero di lavoro del lavoro;

bandiera è il carattere '+' o '-' se il lavoro è il %+ or %- lavoro, rispettivamente, o spazio
se non è né l'uno né l'altro;

status indica lo stato attuale del lavoro e può essere:

Fatto [numero]
Il lavoro è terminato. numero è lo stato di uscita del lavoro che viene omesso
se lo stato è zero.

In esecuzione Il lavoro non è stato né interrotto né terminato (nota che l'esecuzione non lo fa
significa necessariamente consumare tempo della CPU: il processo potrebbe essere bloccato
aspettando qualche evento).

Fermato [segnale]
Il lavoro è stato interrotto dall'indicato segnale (se non viene dato alcun segnale, il
il lavoro è stato interrotto da SIGTSTP).

segnale-descrizione ["core scaricato"]
Il lavoro è stato interrotto da un segnale (ad es. errore di memoria, riaggancio); utilizzo kill -l
per un elenco di descrizioni dei segnali. Il messaggio "core dumped" indica
il processo ha creato un file core.

command è il comando che ha creato il processo. Se ci sono più processi nel
lavoro, ogni processo avrà una linea che mostra il suo command e forse è status, Se
è diverso dallo stato del processo precedente.

Quando si tenta di uscire dalla shell mentre ci sono lavori in stato di arresto, il
shell avverte l'utente che ci sono lavori interrotti e non esce. Se un altro tentativo è
immediatamente fatto uscire dalla shell, ai lavori interrotti viene inviato un segnale SIGHUP e la shell
esce. Allo stesso modo, se no l'opzione non è impostata e ci sono lavori in esecuzione quando un tentativo
viene fatto uscire da una shell di login, la shell avvisa l'utente e non esce. Se un altro
viene fatto immediatamente un tentativo di uscire dalla shell, ai lavori in esecuzione viene inviato un segnale SIGHUP e
il guscio esce.

POSIX modo
Entrando set -o posix la modalità causerà Grazie comportarsi in modo ancora più conforme a POSIX in luoghi
dove le impostazioni predefinite o le opinioni differiscono. Notare che Grazie continuerà a funzionare con unsigned
aritmetica a 32 bit; utilizzo lksh se aritmetica sull'host lungo tipo di dati, completo di ISO C
Comportamento indefinito, sono obbligatori; fare riferimento al lksh(1) pagina di manuale per i dettagli. La maggior parte degli altri
storico, AT&T UNIX ksh-differenze compatibili o supposte possono essere disabilitate usando questo
modalità; questi sono:

· Il GNU bash Reindirizzamento I / O &>filetto non è più supportato.

· I descrittori di file creati dai reindirizzamenti I/O vengono ereditati dai processi figlio.

· I numeri con una cifra iniziale zero vengono interpretati come ottali.

· I eco builtin non interpreta le barre rovesciate e supporta solo l'opzione esatta "-n".

· ... (l'elenco è incompleto e può cambiare per R53)

SH modo
Modalità di compatibilità; destinato all'uso con script legacy che non possono essere facilmente risolti; il
le modifiche sono le seguenti:

· Il GNU bash Reindirizzamento I / O &>filetto non è più supportato.

· I descrittori di file creati dai reindirizzamenti I/O vengono ereditati dai processi figlio.

· I eco builtin non interpreta le barre rovesciate e supporta solo l'opzione esatta "-n".

· ... (l'elenco è incompleto e può cambiare per R53)

Interactive ingresso linea montaggio
La shell supporta tre modalità di lettura delle righe di comando da a tty(4) in un interattivo
sessione, controllata dal emacs, gmace vi opzioni (al massimo una di queste può essere impostata su
una volta). L'impostazione predefinita è emacs. Le modalità di modifica possono essere impostate esplicitamente utilizzando il set incorporato.
Se nessuna di queste opzioni è abilitata, la shell legge semplicemente le righe usando il normale tty(4)
autista. Se la emacs or gmac l'opzione è impostata, la shell consente la modifica simile a emacs del
comando; allo stesso modo, se vi l'opzione è impostata, la shell consente la modifica in stile vi del
comando. Queste modalità sono descritte in dettaglio nelle sezioni seguenti.

In queste modalità di modifica, se una riga è più lunga della larghezza dello schermo (vedi COLONNE
parametro), un carattere '>', '+' o '<' viene visualizzato nell'ultima colonna a indicare che
ci sono più caratteri dopo, prima e dopo, o prima della posizione corrente,
rispettivamente. La riga viene fatta scorrere orizzontalmente secondo necessità.

Le righe completate vengono inserite nella cronologia, a meno che non inizino con un ottetto IFS o IFS
spazi bianchi, o sono gli stessi della riga precedente.

Emacs montaggio modo
Quando il emacs l'opzione è impostata, la modifica della riga di input interattiva è abilitata. Avvertenza: questa modalità
è leggermente diverso dalla modalità emacs nella shell Korn originale. In questa modalità, vari
i comandi di modifica (tipicamente legati a uno o più caratteri di controllo) provocano azioni immediate
senza aspettare una nuova riga. Diversi comandi di modifica sono legati a un controllo particolare
caratteri quando viene invocata la shell; questi collegamenti possono essere modificati utilizzando il pulsante legare comando.

Di seguito è riportato un elenco dei comandi di modifica disponibili. Ogni descrizione inizia con
nome del comando, suffisso con i due punti; un [n] (se il comando può essere preceduto da a
contare); e tutti i tasti a cui è associato il comando per impostazione predefinita, scritti usando la notazione accento circonflesso, ad es
il carattere ASCII ESC è scritto come ^[. Queste sequenze di controllo non fanno distinzione tra maiuscole e minuscole.
Viene immesso un prefisso di conteggio per un comando utilizzando la sequenza ^[n, Dove n è una successione di 1
o più cifre. Se non diversamente specificato, se un conteggio viene omesso, il valore predefinito è 1.

Nota che la modifica dei nomi dei comandi viene utilizzata solo con il legare comando. Inoltre, molti
i comandi di modifica sono utili solo su terminali con cursore visibile. Le associazioni predefinite
sono stati scelti per assomigliare ai corrispondenti tasti di Emacs. L'utente tty(4) caratteri
(ad es. ERASE) sono vincolati a sostituti ragionevoli e sovrascrivono le associazioni predefinite.

abortire: ^C, ^G
Interrompere il comando corrente, svuotare il buffer di riga e impostare lo stato di uscita su
interrotto.

inserimento automatico: [n]
Fa semplicemente apparire il carattere come input letterale. I personaggi più comuni
sono vincolati a questo.

carattere all'indietro: [n] ^B, ^XD, ANSI-CurLeft, PC-CurLeft
Sposta il cursore indietro n caratteri.

parola all'indietro: [n] ^[b, ANSI-Ctrl-CurLeft, ANSI-Alt-CurLeft
Sposta il cursore indietro all'inizio della parola; le parole consistono in
caratteri alfanumerici, trattino basso ('_') e segno di dollaro ('$').

inizio-storia: ^[
Si sposta all'inizio della storia.

inizio riga: ^A, ANSI-Home, PC-Home
Sposta il cursore all'inizio della riga di input modificata.

maiuscolo-parola: [n] ^[C, ^[c
Maiuscolo il primo carattere nel successivo n parole, lasciando il cursore oltre la fine
dell'ultima parola.

schermo chiaro: ^[^L
Stampa una sequenza configurabile in fase di compilazione per cancellare lo schermo e posizionare il cursore,
ridisegna l'intero prompt e la riga di input attualmente modificata. La sequenza predefinita
funziona per quasi tutti i terminali standard.

commento: ^[#
Se la riga corrente non inizia con un carattere di commento, ne viene aggiunto uno in corrispondenza di
inizio della riga e la riga viene inserita (come se fosse stato premuto invio);
in caso contrario, i caratteri di commento esistenti vengono rimossi e il cursore viene posizionato su
l'inizio della riga.

completo: ^[^[
Completa automaticamente quanto è unico il nome del comando o il nome del file
contenente il cursore. Se l'intero comando rimanente o il nome del file è univoco, a
lo spazio viene stampato dopo il suo completamento, a meno che non sia un nome di directory, nel qual caso
'/' viene aggiunto. Se non ci sono comandi o nomi di file con la parola parziale corrente
come prefisso, viene emesso un carattere di campanello (generalmente emettendo un segnale acustico).

comando-completo: ^X^[
Completa automaticamente tanto quanto è unico del nome del comando che ha il parziale
parola fino al cursore come prefisso, come nel completamento di una comando sopra.

file completo: ^[^X
Completa automaticamente quanto è univoco del nome del file con il parziale
parola fino al cursore come prefisso, come nel completamento di una comando sopra descritto.

elenco completo: ^I, ^[=
Completa il più possibile della parola corrente ed elenca le possibili
completamenti per esso. Se è possibile un solo completamento, abbina come in completamento di una
comando sopra. Nota che ^I è generalmente generato dal tasto TAB (tabulatore).

cancella-carattere-indietro: [n] CANCELLA, ^?, ^H
Elimina n caratteri prima del cursore.

cancella-char-forward: [n] ANSI-Canc, PC-Canc
Elimina n caratteri dopo il cursore.

cancella-parola-indietro: [n] MANCARE, ^[^?, ^[^H, ^[h
Elimina n parole prima del cursore.

elimina-parola-inoltra: [n] ^[d
Elimina i caratteri dopo il cursore fino alla fine di n parole.

down-storia: [n] ^N, ^XB, ANSI-CurDown, PC-CurDown
Scorre in avanti il ​​buffer della cronologia n linee (più tardi). Ogni linea di input originariamente
inizia subito dopo l'ultima voce nel buffer della cronologia, quindi down-storia non è
utile fino a quando cronologia delle ricerche, ricerca-storia-up or up-storia è stata
eseguita.

parola minuscola: [n] ^[L, ^[L
Minuscolo il prossimo n parole.

riga di modifica: [n] ^Xe
Modifica riga n o la riga corrente, se non specificata, in modo interattivo. L'attuale
il comando eseguito è fc -e ${VISUAL:-${EDITORE:-vi}} n.

fine della storia: ^[>
Si sposta alla fine della cronologia.

fine riga: ^E, ANSI-End, PC-End
Sposta il cursore alla fine della riga di input.

eo: ^_
Agisce come fine file; questo è utile perché l'ingresso in modalità di modifica disabilita il normale
canonicalizzazione dell'ingresso del terminale.

eot-o-delete: [n] ^ D
Funge da EOT se da solo su una linea; altrimenti agisce come cancella-char-forward.

errore: (non vincolato)
Errore (suonare il campanello).

scambio-punto e segno: ^X^X
Posiziona il cursore dove si trova il segno e imposta il segno dove si trovava il cursore.

file di espansione: ^[*
Aggiunge un '*' alla parola corrente e sostituisce la parola con il risultato di
eseguire il globbing dei file sulla parola. Se nessun file corrisponde al modello, la campana è
piolo.

carattere in avanti: [n] ^F, ^XC, ANSI-CurRight, PC-CurRight
Sposta il cursore in avanti n caratteri.

parola in avanti: [n] ^[f, ANSI-Ctrl-CurRight, ANSI-Alt-CurRight
Sposta il cursore in avanti alla fine del nesima parola.

goto-storia: [n] ^[g
Va al numero di storia n.

linea di morte: KILL
Elimina l'intera riga di input.

kill-regione: ^W
Elimina l'input tra il cursore e il segno.

kill-to-eol: [n] ^ K
Elimina l'input dal cursore alla fine della riga se n non è specificato;
altrimenti elimina i caratteri tra il cursore e la colonna n.

lista: ^[?
Stampa un elenco ordinato in colonne di nomi di comandi o nomi di file (se presenti) che possono
completa la parola parziale contenente il cursore. Ai nomi delle directory è stato aggiunto "/"
a loro.

comando-lista: ^X?
Stampa un elenco ordinato in colonne di nomi di comandi (se presenti) che possono completare il
parola parziale contenente il cursore.

file-elenco: ^X^Y
Stampa un elenco ordinato in colonne di nomi di file (se presenti) che possono completare il
parola parziale contenente il cursore. Gli indicatori del tipo di file vengono aggiunti come descritto
per stratagemma sopra.

nuova riga: ^J, ^M
Fa in modo che la riga di input corrente venga elaborata dalla shell. Il cursore corrente
la posizione può essere ovunque sulla linea.

nuova riga e successiva: ^O
Fa in modo che la riga di input corrente venga elaborata dalla shell e la riga successiva da
la storia diventa la linea corrente. Questo è utile solo dopo un up-storia,
cronologia delle ricerche or ricerca-storia-up.

no-op: ESCI
Questo non fa nulla.

prefisso-1: ^[
Introduce una sequenza di comandi di 2 caratteri.

prefisso-2: ^X, ^[[, ^[O
Introduce una sequenza di comandi di 2 caratteri.

prev-hist-parola: [n] ^[., ^[_
L'ultima parola, o, se data, il nesima parola (in base zero) della precedente (su ripetuta
esecuzione, penultimo, terzultimo, ecc.) viene inserito in corrispondenza del cursore. Uso di
questo comando di modifica elimina il segno.

citazione: ^^, ^V
Il seguente carattere è preso letteralmente piuttosto che come comando di modifica.

ridisegna: ^L
Ristampa l'ultima riga della stringa di prompt e la riga di input corrente su un nuovo
linea.

carattere-di-ricerca-indietro: [n] ^[^]
Cerca indietro nella riga corrente per il nesima occorrenza del carattere successivo
digitato.

carattere-di-ricerca-avanti: [n] ^]
Cerca in avanti nella riga corrente per il nesima occorrenza del carattere successivo
digitato.

cronologia delle ricerche: ^R
Entra in modalità di ricerca incrementale. L'elenco della cronologia interna viene ricercato a ritroso
comandi corrispondenti all'input. Un'iniziale '^' nella stringa di ricerca àncora il
ricerca. Il tasto Esc uscirà dalla modalità di ricerca. Altri comandi, comprese le sequenze
di fuga come prefisso-1 seguita da una prefisso-1 or prefisso-2 il tasto verrà eseguito dopo
uscire dalla modalità di ricerca. Il abortire Il comando (^G) ripristinerà la riga di input prima
ricerca iniziata. Successivo cronologia delle ricerche i comandi continuano la ricerca all'indietro fino a
la successiva occorrenza precedente del modello. Il buffer storico conserva solo a
numero finito di righe; i più vecchi vengono scartati se necessario.

ricerca-storia-up: ANSI-PgUp, PC-PgUp
Cerca a ritroso nel buffer della cronologia i comandi il cui inizio corrisponde a
porzione della riga di input prima del cursore. Se utilizzato su una riga vuota, questo ha
lo stesso effetto di up-storia.

cronologia-ricerca-down: ANSI-PgDn, PC-PgDn
Cerca in avanti nel buffer della cronologia i comandi il cui inizio corrisponde a
porzione della riga di input prima del cursore. Se utilizzato su una riga vuota, questo ha
lo stesso effetto di down-storia. Questo è utile solo dopo un up-storia,
cronologia delle ricerche or ricerca-storia-up.

comando-set-mark: ^[
Imposta il segno nella posizione del cursore.

caratteri di trasposizione: ^T
Se alla fine della riga, o se il gmac opzione è impostata, questo scambia i due
caratteri precedenti; in caso contrario, scambia i caratteri precedenti e attuali e
sposta il cursore di un carattere a destra.

up-storia: [n] ^P, ^XA, ANSI-CurUp, PC-CurUp
Scorre il buffer della cronologia all'indietro n righe (prima).

parola maiuscola: [n] ^[U, ^[u
Maiuscolo il prossimo n parole.

versione: ^[^V
Visualizza la versione di Grazie. Il buffer di modifica corrente viene ripristinato non appena viene premuto un tasto
viene premuto. La pressione del tasto di ripristino viene elaborata, a meno che non sia uno spazio.

strattone: ^Y
Inserisce la stringa di testo interrotta più di recente nella posizione corrente del cursore.

yank-pop: ^[y
Subito dopo a strattone, sostituisce la stringa di testo inserita con la successiva precedentemente
stringa di testo eliminata.

Vi montaggio modo
Nota: La modalità di modifica della riga di comando di vi è orfana, ma è ancora funzionante. È pulito a 8 bit
ma in particolare non supporta UTF-8 o MBCS.

L'editor della riga di comando vi in Grazie ha fondamentalmente gli stessi comandi del vi(1) editore con
le seguenti eccezioni:

· Si inizia in modalità di inserimento.

· Ci sono nomi di file e comandi di completamento dei comandi: =, \, *, ^X, ^E, ^F e,
facoltativamente, e .

· I _ il comando è diverso (in Grazie, è l'ultimo comando di argomento; in vi(1) va
all'inizio della riga corrente).

· I / ed G i comandi si muovono nella direzione opposta a j comando.

· I comandi che non hanno senso in un editor a riga singola non sono disponibili (ad esempio screen
comandi di movimento e ex(1) in stile due punti (:) comandi).

Come vi(1), ci sono due modalità: modalità "inserimento" e modalità "comando". In modalità di inserimento, la maggior parte
i caratteri vengono semplicemente inseriti nel buffer nella posizione corrente del cursore mentre vengono digitati;
tuttavia, alcuni caratteri vengono trattati in modo speciale. In particolare, i seguenti caratteri sono
preso dalla corrente tty(4) impostazioni (vedi sty(1)) e hanno il loro significato abituale (valori normali
sono tra parentesi): kill (^U), cancella (^?), werase (^W), eof (^D), intr (^C) e quit (^\).
Oltre a quanto sopra, anche i seguenti caratteri sono trattati in modo speciale in insert
modalità:

^E Enumerazione di comandi e nomi di file (vedi sotto).

^F Completamento del comando e del nome del file (vedi sotto). Se utilizzato due volte di seguito, l'elenco di
vengono visualizzati i possibili completamenti; se usato una terza volta, il completamento viene annullato.

^H Cancella il carattere precedente.

^J | ^M Fine della riga. La riga corrente viene letta, analizzata ed eseguita dalla shell.

^V letterale successivo. Il successivo carattere digitato non viene trattato in modo speciale (può essere usato per
inserire i caratteri qui descritti).

^X Espansione del comando e del nome del file (vedi sotto).

Mette l'editor in modalità comando (vedi sotto).

Nome file opzionale e completamento del comando (vedi ^F sopra), abilitato con set -o
vi-tabcomplete.

In modalità comando, ogni carattere viene interpretato come un comando. Personaggi che non lo fanno
corrispondono a comandi, sono combinazioni illegali di comandi o sono comandi che non possono essere
eseguite, tutte provocano segnali acustici. Nelle seguenti descrizioni dei comandi, un [n] indica il
il comando può essere preceduto da un numero (es 10l si sposta a destra di 10 caratteri); se nessun numero
viene utilizzato il prefisso, n si presume che sia 1 se non diversamente specificato. Il termine “corrente
posizione” si riferisce alla posizione tra il cursore e il carattere che precede il cursore.
Una "parola" è una sequenza di lettere, cifre e caratteri di sottolineatura o una sequenza di
lettere, caratteri senza cifre, senza trattino basso e senza spazi (es. "ab2*&^" contiene due
parole) e una "parola grossa" è una sequenza di caratteri senza spazi.

Special Grazie vi comandi:

I seguenti comandi non sono presenti o sono diversi dal normale editor di file vi:

[n]_ Inserisci uno spazio seguito dal nla parola grossa dall'ultimo comando nella storia
nella posizione corrente ed entrare in modalità di inserimento; Se n non è specificato, l'ultimo
la parola è inserita.

# Inserisce il carattere di commento ('#') all'inizio della riga corrente e ritorna
la linea al guscio (equivalente a io#^J).

[n]g Mi piace G, tranne che n non è specificato, va al più recente ricordato
linea.

[n]v Modifica riga n usando il vi(1) redattore; Se n non è specificato, la riga corrente è
modificato. Il comando effettivamente eseguito è fc -e ${VISUAL:-${EDITORE:-vi}} n.

* e ^X Il comando o l'espansione del nome del file viene applicato alla parola grossa corrente (con an
aggiunto '*' se la parola non contiene caratteri di globbing del file) – la parola grossa è
sostituito con le parole risultanti. Se la parola grossa attuale è la prima sul
riga o segue uno dei caratteri ';', '|', '&', '(' o ')' e non
contenere una barra ('/'), quindi l'espansione del comando è terminata; altrimenti nome file
l'espansione è fatta. L'espansione del comando corrisponderà alla parola grossa contro tutti
alias, funzioni e comandi integrati, nonché qualsiasi file eseguibile trovato
cercando le directory nel parametro PATH. Corrispondenze di espansione del nome del file
la parola grossa contro i file nella directory corrente. Dopo l'espansione, il
il cursore è posizionato appena dopo l'ultima parola e l'editor è in modalità di inserimento.

[n]\, [n]^F, [n] , e [n]
Completamento nome file/comando. Sostituisci la parola grossa corrente con la più lunga
corrispondenza univoca ottenuta dopo aver eseguito il comando e l'espansione del nome del file.
viene riconosciuto solo se il vi-tabcomplete l'opzione è impostata, mentre è solo
riconosciuto se il vi-esccompleto l'opzione è impostata (vedi set -o). Se n è specificato,
, il nè selezionato il possibile completamento (come riportato dal comando/nome file
comando di enumerazione).

= e ^E Enumerazione nome file/comando. Elenca tutti i comandi o i file che corrispondono a
parolone attuale.

^V Visualizza la versione di Grazie. Il buffer di modifica corrente viene ripristinato non appena a
viene premuto il tasto. La pressione del tasto di ripristino viene ignorata.

@c Macro espansione. Esegui i comandi trovati nell'alias c.

Comandi di movimento intra-linea:

[n]mano [n]^H
Muovere a sinistra n caratteri.

[n]terra [n]
Vai a destra n caratteri.

0 Passa alla colonna 0.

^ Passa al primo carattere senza spazi.

[n]| Sposta in colonna n.

$ Passa all'ultimo carattere.

[n]b Torna indietro n parole.

[n]B Torna indietro n parole grosse.

[n]e Vai alla fine della parola, n volte.

[n]E Vai alla fine della parola grossa, n volte.

[n]w Vai avanti n parole.

[n]W Vai avanti n parole grosse.

% Trova corrispondenza. L'editor attende la parentesi, la parentesi o la parentesi graffa più vicina
e quindi sposta il cursore sulla parentesi, parentesi o parentesi graffa corrispondente.

[n]fc Vai avanti al nesima occorrenza del personaggio c.

[n]Fc Torna indietro al nesima occorrenza del personaggio c.

[n]tc Vai avanti a poco prima del nesima occorrenza del personaggio c.

[n]Tc Torna indietro a poco prima di nesima occorrenza del personaggio c.

[n]; Ripete l'ultimo f, F, t, o T comando.

[n], Ripete l'ultimo f, F, t, o T comando, ma si muove nella direzione opposta.

Comandi di movimento interlinea:

[n]J, [n]+ e [n]^N
Sposta in nla riga successiva nella cronologia.

[n]K, [n]-, e [n]^P
Sposta in nth riga precedente nella cronologia.

[n]G Sposta in riga n nella storia; Se n non è specificato, il numero del primo
viene utilizzata la riga ricordata.

[n]g Mi piace G, tranne che n non è specificato, va alla riga più recente ricordata.

[n]/stringa
Cerca all'indietro nella cronologia per il nla linea che contiene stringa; Se stringa
inizia con '^', il resto della stringa deve apparire all'inizio della cronologia
linea affinché corrisponda.

[n]?stringa
Uguale a /, tranne per la ricerca in avanti nella cronologia.

[n]n Cerca il nesima occorrenza dell'ultima stringa di ricerca; la direzione della ricerca
è uguale all'ultima ricerca.

[n]N Cerca il nesima occorrenza dell'ultima stringa di ricerca; la direzione della ricerca
è l'opposto dell'ultima ricerca.

ANSI-CurUp, PC-PagSu
Porta i caratteri dall'inizio della riga alla posizione corrente del cursore come
stringa di ricerca ed eseguire una ricerca nella cronologia all'indietro per le righe che iniziano con questo
corda; mantenere la posizione del cursore. Funziona solo in modalità di inserimento e lo mantiene
abilitato.

Modifica comandi

[n]a Aggiungi testo n volte; entra in modalità di inserimento subito dopo la posizione corrente. Il
append viene replicato solo se viene reinserita la modalità di comando, ad es viene utilizzato.

[n]A Stesso di a, tranne che si aggiunge alla fine della riga.

[n]i Inserisci testo n volte; entra in modalità di inserimento nella posizione corrente. l'inserimento
viene replicato solo se viene reinserita la modalità di comando, ad es viene utilizzato.

[n]I Stesso di i, tranne che l'inserimento viene eseguito appena prima del primo carattere non vuoto.

[n]s Sostituisci il prossimo n caratteri (cioè cancella i caratteri e vai in inserisci
modalità).

S Sostituisci l'intera riga. Tutti i caratteri dal primo carattere non vuoto fino alla fine
della riga vengono cancellati e viene inserita la modalità di inserimento.

[n]csposta-cmd
Passa dalla posizione corrente alla posizione risultante da n sposta-cmds (cioè
cancellare la regione indicata ed entrare in modalità inserimento); Se sposta-cmd is c, La linea
a partire dal primo carattere non vuoto viene modificato.

C Passa dalla posizione corrente alla fine della riga (cioè cancella alla fine di
la riga ed entrare in modalità inserimento).

[n]x Elimina il prossimo n caratteri.

[n]X Elimina il precedente n caratteri.

D Cancella fino alla fine della riga.

[n]dsposta-cmd
Elimina dalla posizione corrente alla posizione risultante da n sposta-cmds;
sposta-cmd è un comando di movimento (vedi sopra) o d, nel qual caso la linea corrente è
cancellato.

[n]rc Sostituisci il prossimo n personaggi con il carattere c.

[n]R Sostituire. Entra nella modalità di inserimento ma sovrascrivi i caratteri esistenti invece di inserirli
prima dei caratteri esistenti. La sostituzione si ripete n volte.

[n]~ Cambia il caso del prossimo n caratteri.

[n]ysposta-cmd
Yank dalla posizione corrente alla posizione risultante da n sposta-cmds nel
tampone di strappo; Se sposta-cmd is y, l'intera linea viene strappata.

Y Yank dalla posizione corrente alla fine della linea.

[n]p Incolla il contenuto del buffer yank subito dopo la posizione corrente, n volte.

[n]P Come p, tranne che il buffer viene incollato nella posizione corrente.

Vari comandi vi

^J e ^M
La riga corrente viene letta, analizzata ed eseguita dalla shell.

^L e ^R
Ridisegna la riga corrente.

[n]. Ripeti l'ultimo comando di modifica n volte.

u Annulla l'ultimo comando di modifica.

U Annulla tutte le modifiche apportate alla riga corrente.

PC Home, Fine, Canc e tasti cursore
Si muovono come previsto, sia in modalità di inserimento che di comando.

intr ed smettere
I caratteri di interruzione e di chiusura del terminale fanno sì che la riga corrente venga cancellata e
un nuovo prompt da stampare.

Usa mksh online utilizzando i servizi onworks.net