mksh - Online sa Cloud

PROGRAMA:

NAME

Salamat, sh — MirBSD Korn shell

SINOPSIS

Salamat [-+abCefhiklmnprUuvXx] [-T [!]tty | -] [-+o opsyon] [-c pisi | -s | file
[argumento ...]]
built-name [argumento ...]

DESCRIPTION

Salamat ay isang command interpreter na nilayon para sa parehong interactive at shell na paggamit ng script. Nito
Ang command language ay isang superset ng sh(C) shell na wika at higit na katugma sa
orihinal na shell ng Korn. Kung minsan, ang manwal na pahinang ito ay maaaring magbigay ng payo sa script; habang ito
minsan ay isinasaalang-alang ang lahat ng portable shell scripting o iba't ibang pamantayan
ang impormasyon ay una at pangunahin na ipinakita Salamat sa isip at dapat na kunin sa gayon.

Ako ay an Android gumagamit, so ano ba mksh?
Salamat ay isang UNIX shell / command interpreter, katulad ng COMMAND.COM or CMD.EXE, na mayroon
naisama sa Android Open Source Project sa loob ng ilang sandali. Talaga, ito ay isang programa
na tumatakbo sa isang terminal (console window), kumukuha ng input ng user at nagpapatakbo ng mga command o script,
na maaari rin itong hilingin na gawin ng iba pang mga programa, kahit na sa background. Anumang pribilehiyo
ang mga pop-up na maaari mong makaharap ay hindi Salamat mga isyu ngunit tanong ng iba
programang gumagamit nito.

Pagsamba
Karamihan sa mga builtin ay maaaring direktang tawagan, halimbawa kung ang isang link ay tumuturo mula sa pangalan nito hanggang sa
shell; hindi lahat ay may katuturan, nasubok o gumagana sa lahat bagaman.

Ang mga pagpipilian ay ang mga sumusunod:

-c pisi Salamat ay isasagawa ang (mga) utos na nakapaloob sa pisi.

-i Interactive na shell. Ang isang shell na nagbabasa ng mga utos mula sa karaniwang input ay
"interactive" kung gagamitin ang opsyong ito o kung parehong karaniwang input at karaniwang error
ay nakakabit sa a tty(4). Ang isang interactive na shell ay may pinaganang kontrol sa trabaho, hindi pinapansin
ang mga signal ng SIGINT, SIGQUIT, at SIGTERM, at nagpi-print ng mga prompt bago basahin ang input
(tingnan ang mga parameter ng PS1 at PS2). Pinoproseso din nito ang parameter ng ENV o ang
mkshrc file (tingnan sa ibaba). Para sa mga non-interactive na shell, ang trackall naka-on ang opsyon
bilang default (tingnan ang itakda utos sa ibaba).

-l Shell sa pag-login. Kung ang basename ang shell ay tinatawag na (ie argv[0]) ay nagsisimula sa
'-' o kung ang opsyong ito ay ginagamit, ang shell ay ipinapalagay na isang login shell; tingnan mo
Startup file sa ibaba.

-p Privileged shell. Ang isang shell ay "pribilehiyo" kung ang tunay na user ID o group ID ay ganoon
hindi tumutugma sa epektibong user ID o group ID (tingnan getuid(2) at getgid(2)).
Ang pag-clear sa privileged na opsyon ay nagdudulot sa shell na itakda ang epektibong user ID nito
(group ID) sa totoong user ID nito (group ID). Para sa karagdagang implikasyon, tingnan Startup
file. Kung ang shell ay may pribilehiyo at ang watawat na ito ay hindi tahasang itinakda, ang
Awtomatikong na-clear ang opsyong "privileged" pagkatapos iproseso ang mga startup file.

-r Restricted shell. "Pinaghihigpitan" ang isang shell kung gagamitin ang opsyong ito. Ang mga sumusunod
magkakabisa ang mga paghihigpit pagkatapos maproseso ng shell ang anumang profile at ENV
file:

· Ang cd (At chdir) na utos ay hindi pinagana.
· Ang mga parameter ng SHELL, ENV, at PATH ay hindi mababago.
· Ang mga pangalan ng command ay hindi maaaring tukuyin sa ganap o kaugnay na mga path.
· Ang -p opsyon ng built-in na command utos hindi magagamit.
· Ang mga pag-redirect na lumilikha ng mga file ay hindi maaaring gamitin (ibig sabihin '>', '>|', '>>', '<>').

-s Ang shell ay nagbabasa ng mga utos mula sa karaniwang input; lahat ng hindi opsyon na argumento ay
positional na mga parameter.

-T pangalan Mga itlog ng isda Salamat sa tty(4) ibinigay na aparato. Ang mga landas pangalan, /dev/ttyCname at
/dev/ttyname ay sinubukan sa pagkakasunud-sunod. Maliban kung pangalan nagsisimula sa tandang padamdam
('!'), ginagawa ito sa isang subshell at bumabalik kaagad. Kung pangalan ay isang gitling
('-'), humiwalay sa controlling terminal (daemonise) sa halip.

Bilang karagdagan sa itaas, ang mga opsyon na inilarawan sa itakda ang built-in na command ay maaari ding gamitin
sa command line: pareho [-+abCefhkmnuvXx] at [-+o opsyon] ay maaaring gamitin para sa isang titik
o mahabang mga pagpipilian, ayon sa pagkakabanggit.

Kung hindi man ang -c ni ang -s ang opsyon ay tinukoy, ang unang hindi-opsyon na argumento ay tumutukoy
ang pangalan ng isang file kung saan binabasa ng shell ang mga utos. Kung walang mga argumentong hindi opsyon, ang
Binabasa ng shell ang mga utos mula sa karaniwang input. Ang pangalan ng shell (ibig sabihin ang mga nilalaman ng
$0) ay tinutukoy bilang mga sumusunod: kung ang -c ginagamit ang opsyon at mayroong argumentong hindi opsyon,
ito ay ginagamit bilang pangalan; kung ang mga command ay binabasa mula sa isang file, ang file ay ginagamit bilang ang
pangalan; kung hindi, ang basename kung saan tinawag ang shell (ie argv[0]) ay ginagamit.

Ang exit status ng shell ay 127 kung ang command file na tinukoy sa command line ay maaari
hindi mabubuksan, o non-zero kung may naganap na fatal syntax error sa panahon ng pagpapatupad ng a
iskrip. Sa kawalan ng nakamamatay na mga error, ang exit status ay ang huling command
executed, o zero, kung walang command na naisakatuparan.

Startup file
Para sa aktwal na lokasyon ng mga file na ito, tingnan MGA FILE. Pinoproseso ng isang login shell ang system
profile muna. Pagkatapos ay pinoproseso ng isang privileged shell ang profile ng suid. Isang walang pribilehiyong pag-login
sunod na pinoproseso ng shell ang profile ng user. Sinusuri ng isang non-privileged interactive shell ang halaga
ng parameter ng ENV pagkatapos itong isailalim sa parameter, command, arithmetic at tilde ('~')
pagpapalit; kung unset o walang laman, ang user mkshrc profile ay pinoproseso; kung hindi, kung ang isang file
na ang pangalan ay ang resulta ng pagpapalit ay umiiral, ito ay naproseso; walang imik ay tahimik
hindi pinansin. Ang isang privileged shell pagkatapos ay bumababa ng mga pribilehiyo kung alinman ay ang -p opsyon na ibinigay sa
command line o itinakda sa panahon ng pagpapatupad ng mga startup file.

Utos palaugnayan
Nagsisimula ang shell sa pag-parse ng input nito sa pamamagitan ng pag-alis ng anumang mga kumbinasyon ng backslash-newline, pagkatapos
pagsira nito sa mga salita. Ang mga salita (na mga pagkakasunud-sunod ng mga character) ay nililimitahan ng hindi sinipi
mga whitespace na character (space, tab, at newline) o meta-character ('<', '>', '|', ';', '(',
')', at '&'). Bukod sa pagtatanggal ng mga salita, ang mga puwang at mga tab ay binabalewala, habang ang mga bagong linya
karaniwang nililimitahan ang mga utos. Ang mga meta-character ay ginagamit sa pagbuo ng mga sumusunod token:
Ginagamit ang '<', '<&', '<<', '<<<', '>', '>&', '>>', '&>', atbp. upang tukuyin ang mga pag-redirect (tingnan ang
Input / output pag-redirect sa ibaba); '|' ay ginagamit upang lumikha ng mga pipeline; '|&' ay ginagamit upang lumikha ng co-
mga proseso (tingnan Mga co-process sa ibaba); ';' ay ginagamit upang paghiwalayin ang mga utos; '&' ay ginagamit upang lumikha
asynchronous na mga pipeline; '&&' at '||' ay ginagamit upang tukuyin ang kondisyon na pagpapatupad; ';;', ';&'
at ';|' ay ginagamit sa kaso mga pahayag; '(( .. ))' ay ginagamit sa mga aritmetika na expression; at
panghuli, '( .. )' ay ginagamit upang lumikha ng mga subshell.

Maaaring banggitin ang mga whitespace at meta-character nang paisa-isa gamit ang backslash ('\'), o in
mga pangkat na gumagamit ng double ('"') o single (“'”) quotes. Tandaan na ang mga sumusunod na character ay
espesyal na ginagamot din ng shell at dapat na banggitin kung sila ay kumakatawan sa kanilang sarili:
'\', '"', ''', '#', '$', '`', '~', '{', '}', '*', '?', at '['. Ang unang tatlo sa mga ito
ay ang mga nabanggit sa itaas na nagsisipi ng mga karakter (tingnan Pag-quote sa ibaba); '#', kung ginamit sa
simula ng isang salita, nagpapakilala ng komento – lahat pagkatapos ng '#' hanggang sa pinakamalapit
hindi pinansin ang bagong linya; '$' ay ginagamit upang ipakilala ang parameter, command, at arithmetic
mga pagpapalit (tingnan Paghalili sa ibaba); Ang '''' ay nagpapakilala ng lumang istilong pagpapalit ng command
(Tingnan ang Paghalili sa ibaba); Nagsisimula ang '~' ng pagpapalawak ng direktoryo (tingnan Tilde paglawak sa ibaba); '{'
at '}' na may hangganan csh(1)-style na mga alternasyon (tingnan Brace paglawak sa ibaba); at sa wakas, '*',
'?', at '[' ay ginagamit sa pagbuo ng pangalan ng file (tingnan talaksan pangalan pattern sa ibaba).

Habang ang mga salita at mga token ay na-parse, ang shell ay bumubuo ng mga utos, kung saan mayroong dalawang pangunahing
mga uri: simpleng-utos, karaniwang mga program na pinaandar, at tambalang-utos, tulad
as para at if mga pahayag, pagpapangkat ng mga konstruksyon, at mga kahulugan ng function.

Ang isang simpleng utos ay binubuo ng ilang kumbinasyon ng mga pagtatalaga ng parameter (tingnan parameter
sa ibaba), mga pag-redirect ng input/output (tingnan Input / output mga pag-redirect sa ibaba), at mga salitang utos;
ang tanging paghihigpit ay ang mga takdang-aralin ng parameter ay mauna bago ang anumang mga salita ng utos. Ang
mga salitang utos, kung mayroon man, tukuyin ang utos na isasagawa at ang mga argumento nito. Ang
Ang command ay maaaring isang shell built-in na command, isang function, o isang panlabas na command (ibig sabihin, isang hiwalay na
executable file na matatagpuan gamit ang PATH parameter; tingnan mo Utos pagpapatupad sa ibaba).
Tandaan na ang lahat ng command construct ay may exit status: para sa mga external na command, ito ay nauugnay
sa status na ibinalik ni maghintay(2) (kung hindi mahanap ang command, ang exit status ay
127; kung hindi ito maisakatuparan, ang exit status ay 126); ang exit status ng ibang command
mga construct (built-in na command, function, compound-commands, pipelines, lists, atbp.) ay lahat
mahusay na tinukoy at inilarawan kung saan inilarawan ang konstruksyon. Ang katayuan ng paglabas ng a
Ang utos na binubuo lamang ng mga pagtatalaga ng parameter ay ang huling pagpapalit ng utos
isinagawa sa panahon ng pagtatalaga ng parameter o 0 kung walang mga pagpapalit ng command.

Maaaring i-chain ang mga command gamit ang '|' token upang bumuo ng mga pipeline, kung saan ang
karaniwang output ng bawat command ngunit ang huli ay piped (tingnan tubo(2)) sa karaniwang input ng
ang sumusunod na utos. Ang exit status ng pipeline ay ang huling command nito, maliban kung
ang pipefail ang opsyon ay nakatakda (tingnan doon). Ang lahat ng mga utos ng isang pipeline ay isinasagawa nang hiwalay
mga subshell; ito ay pinapayagan ng POSIX ngunit naiiba sa parehong mga variant ng AT&T UNIX ksh, Kung saan
lahat maliban sa huling utos ay naisakatuparan sa mga subshell; tingnan ang basahin paglalarawan ng builtin para sa
implikasyon at solusyon. Ang isang pipeline ay maaaring prefix ng '!' reserbang salita na
nagiging sanhi ng lohikal na pagpupuno ng exit status ng pipeline: kung ang orihinal na status
ay 0, ang kinumpletong katayuan ay magiging 1; kung ang orihinal na katayuan ay hindi 0, ang kinumpleto
magiging 0 ang katayuan.

Mga Listahan ng mga utos ay maaaring malikha sa pamamagitan ng paghihiwalay ng mga pipeline ng alinman sa mga sumusunod na token:
'&&', '||', '&', '|&', at ';'. Ang unang dalawa ay para sa kondisyon na pagpapatupad: "cmd1 && cmd2"
nagpapatupad cmd2 lamang kung ang exit status ng cmd1 ay zero; '||' ay ang kabaligtaran - cmd2 is
naisakatuparan lamang kung ang exit status ng cmd1 ay hindi zero. '&&' at '||' magkaroon ng pantay na pangunguna
na mas mataas kaysa sa '&', '|&', at ';', na mayroon ding pantay na pangunguna. Tandaan
na ang '&&' at '||' ang mga operator ay "kaliwa-kaugnay". Halimbawa, pareho sa mga ito
Ang mga utos ay magpi-print lamang ng "bar":

$ false && echo foo || echo bar
$ totoo || echo foo && echo bar

Ang token na '&' ay nagiging sanhi ng naunang utos na maisakatuparan nang asynchronous; iyon ay, ang shell
sinisimulan ang utos ngunit hindi hinintay itong makumpleto (sinusubaybayan ng shell ang
katayuan ng mga asynchronous na utos; tingnan mo Trabaho kontrol sa ibaba). Kapag ang isang asynchronous na utos ay
nagsimula kapag ang kontrol sa trabaho ay hindi pinagana (ibig sabihin, sa karamihan ng mga script), sinimulan ang command
ang mga signal na SIGINT at SIGQUIT ay hindi pinansin at may input na na-redirect mula sa / dev / null (gayunpaman,
ang mga pag-redirect na tinukoy sa asynchronous na utos ay nangunguna). Ang operator na '|&'
nagsisimula ng isang co-process na isang espesyal na uri ng asynchronous na proseso (tingnan Mga co-process
sa ibaba). Tandaan na dapat sundin ng isang utos ang '&&' at '||' operator, habang hindi kailangan
sundan ang '&', '|&', o ';'. Ang exit status ng isang listahan ay ang huling utos na naisakatuparan,
maliban sa mga asynchronous na listahan, kung saan ang exit status ay 0.

Ang mga compound command ay nilikha gamit ang mga sumusunod na nakalaan na salita. Ang mga salitang ito ay tanging
kinikilala kung hindi sinipi ang mga ito at kung ginagamit ang mga ito bilang unang salita ng isang utos (hal
hindi sila maaaring unahan ng mga takdang-aralin o pag-redirect ng parameter):

kaso iba ang pag-andar pagkatapos! (
gawin ang esac kung oras [[ ((
tapos fi in hanggang {
elif para sa piling habang }

Sa mga sumusunod na paglalarawan ng tambalang command, mga listahan ng command (na tinukoy bilang listahan) iyon ay
na sinusundan ng mga nakalaan na salita ay dapat magtapos sa isang semicolon, isang bagong linya, o isang (syntactically
tama) nakalaan na salita. Halimbawa, lahat ng mga sumusunod ay wasto:

$ { echo foo; echo bar; }
$ { echo foo; echo bar }
$ { { echo foo; echo bar; } }

Ito ay hindi wasto:

$ { echo foo; echo bar }

(listahan)
Isakatuparan listahan sa isang subshell. Walang implicit na paraan upang maipasa ang mga pagbabago sa kapaligiran
isang subshell pabalik sa magulang nito.

{ listahan; }
Compound construct; listahan ay naisakatuparan, ngunit hindi sa isang subshell. Tandaan na ang '{' at '}'
ay mga reserbang salita, hindi meta-character.

kaso salita sa [[(] huwaran [| huwaran] ...) listahan terminator] ... esac
Ang kaso pagtatangkang tumugma ang pahayag salita laban sa isang tinukoy huwaran; ang listahan
na nauugnay sa unang matagumpay na naitugmang pattern ay naisakatuparan. Mga pattern na ginamit sa
kaso ang mga pahayag ay pareho sa mga ginamit para sa mga pattern ng pangalan ng file maliban na ang
mga paghihigpit patungkol sa '.' at ang '/' ay ibinaba. Tandaan na anumang hindi naka-quote na espasyo dati
at pagkatapos ng isang pattern ay Nakuha; anumang espasyo sa loob ng isang pattern ay dapat na sinipi. Parehong ang
salita at ang mga pattern ay napapailalim sa parameter, command, at arithmetic substitution,
pati na rin ang pagpapalit ng tilde.

Para sa mga makasaysayang dahilan, ang mga bukas at malapit na brace ay maaaring gamitin sa halip na in at na C hal
kaso $foo { *) miss bar ;; }.

Ang listahan terminators ay:

';;' Tapusin pagkatapos ng listahan.

';&' Pumapasok sa susunod na listahan.

';|' Suriin ang natitirang mga tuple ng pattern-list.

Ang katayuan ng paglabas ng a kaso pahayag ay na ng naisakatuparan listahan; kung hindi listahan is
naisakatuparan, ang exit status ay zero.

para pangalan [sa salita ...]; gawin listahan; tapos na
Para sa bawat salita sa tinukoy na listahan ng salita, ang parameter pangalan ay nakatakda sa salita at
listahan ay pinaandar. Kung in ay hindi ginagamit upang tukuyin ang isang listahan ng salita, ang mga positional na parameter
($1, $2, atbp.) ang ginagamit sa halip. Para sa mga makasaysayang dahilan, maaaring bukas at malapit na mga brace
ginamit sa halip na do at tapos hal para i; { miss $i; }. Ang katayuan ng paglabas ng a para
ang pahayag ay ang huling katayuan sa paglabas ng listahan; kung listahan ay hindi kailanman naisakatuparan, ang katayuan sa paglabas
ay zero.

if listahan; pagkatapos listahan; [elif listahan; pagkatapos listahan;] ... [iba listahan;] fi
Kung ang exit status ng una listahan ay zero, ang pangalawa listahan ay naisakatuparan; kung hindi,
ang listahan ng pagsunod sa mga elif, kung mayroon man, ay isinasagawa na may katulad na mga kahihinatnan. Kung lahat
ang mga listahang sumusunod sa if at elifs mabibigo (ie exit na may non-zero status), ang listahan
ng pagsunod sa mga iba ay pinaandar. Ang katayuan ng paglabas ng isang if pahayag ay ang hindi-
kondisyonal listahan iyon ay naisakatuparan; kung walang non-conditional listahan ay naisakatuparan, ang paglabas
ang katayuan ay zero.

piliin pangalan [sa salita ...]; gawin listahan; tapos na
Ang piliin Ang pahayag ay nagbibigay ng awtomatikong paraan ng pagpapakita sa user ng isang menu
at pagpili mula dito. Isang enumerated list ng tinukoy salita(mga) ay nakalimbag sa
karaniwang error, na sinusundan ng isang prompt (PS3: normally '#? '). Isang numero na katumbas ng
ang isa sa mga binilang salita ay binabasa mula sa karaniwang input, pangalan ay nakatakda sa
piniling salita (o hindi nakatakda kung hindi wasto ang pagpili), nakatakda ang REPLY sa nabasa
(nahubaran ang puwang sa nangungunang/trailing), at listahan ay pinaandar. Kung ang isang blangkong linya (hal
zero o higit pang mga IFS octets) ay ipinasok, ang menu ay muling nai-print nang hindi isinasagawa listahan.

Kailan listahan makumpleto, ang enumerated list ay naka-print kung REPLY ay NULL, ang prompt ay
nakalimbag, at iba pa. Nagpapatuloy ang prosesong ito hanggang sa mabasa ang isang end-of-file, isang interrupt
ay natanggap, o a masira Ang pahayag ay isinasagawa sa loob ng loop. Kung "sa salita ..." ay
tinanggal, ang mga positional na parameter ay ginagamit (ibig sabihin $1, $2, atbp.). Para sa makasaysayang
Dahilan, maaaring gumamit ng open at close braces sa halip na do at tapos hal piliin i; {
miss $i; }. Ang katayuan ng paglabas ng a piliin ang pahayag ay zero kung a masira pahayag ay
ginamit upang lumabas sa loop, hindi zero kung hindi man.

hanggang listahan; gawin listahan; tapos na
Ito ay gumagana tulad ng habang, maliban na ang katawan ay isinasagawa lamang habang ang exit status ng
ang unang listahan ay hindi zero.

habang listahan; gawin listahan; tapos na
A habang ay isang paunang nasuri na loop. Ang katawan nito ay isinasagawa nang kasingdalas ng exit status ng
ang unang listahan ay zero. Ang katayuan ng paglabas ng a habang ang pahayag ay ang huling katayuan sa paglabas
ng listahan sa katawan ng loop; kung ang katawan ay hindi naisakatuparan, ang exit status ay
zero.

tungkulin pangalan { listahan; }
Tinutukoy ang function pangalan (Tingnan ang Pag-andar sa ibaba). Tandaan na tinukoy ang mga pag-redirect
pagkatapos maisagawa ang isang kahulugan ng function sa tuwing ipapatupad ang function, hindi kung kailan
ang kahulugan ng function ay naisakatuparan.

pangalan() utos
Karamihan sa parehong bilang tungkulin (Tingnan ang Pag-andar sa ibaba). Whitespace (space o tab) pagkatapos
pangalan ay hindi papansinin sa halos lahat ng oras.

tungkulin pangalan() { listahan; }
Katulad ng pangalan() (malakas na paloism). Ang tungkulin hindi pinapansin ang keyword.

oras [-p] [padaanin sa tubo]
Ang Utos pagpapatupad inilalarawan ng seksyon ang oras nakalaan na salita.

(( pagpapahayag ))
Ang pagpapahayag ng aritmetika pagpapahayag ay sinusuri; katumbas ng "hayaan ang pagpapahayag" (tingnan
Pang-aritmetika mga expression at ang pabayaan command, sa ibaba) sa isang compound construct.

[[ pagpapahayag ]]
Katulad sa pagsusulit at [ ... ] mga utos (inilarawan sa ibang pagkakataon), kasama ang mga sumusunod
mga pagbubukod:

· Ang paghahati ng field at pagbuo ng pangalan ng file ay hindi ginagawa sa mga argumento.

· Ang -a (At at -o (O) ang mga operator ay pinalitan ng '&&' at '||', ayon sa pagkakabanggit.

· Mga operator (hal. '-f', '=', '!') ay dapat na hindi sinipi.

· Ang mga pagpapalit ng parameter, utos, at arithmetic ay ginagawa bilang mga expression
nasuri at tamad na expression na pagsusuri ay ginagamit para sa '&&' at '||' mga operator.
Nangangahulugan ito na sa sumusunod na pahayag, $( ay sinusuri kung at kung lamang
mga file foo umiiral at nababasa:

$ [[ -r foo && $(

· Ang pangalawang operand ng '!=' at '=' na mga expression ay isang subset ng mga pattern (hal
ang pagkukumpara [[ foobar = f*r ]] nagtagumpay). Ito ay kahit na hindi direktang gumagana:

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

Marahil ay nakakagulat, ang unang paghahambing ay nagtagumpay, samantalang ang pangalawa ay hindi.
Hindi ito nalalapat sa lahat ng extglob metacharacter, sa kasalukuyan.

Pag-quote
Ang pag-quote ay ginagamit upang pigilan ang shell na tratuhin ang mga character o salita nang espesyal. meron
tatlong paraan ng pagsipi. Una, sinipi ng '\' ang sumusunod na karakter, maliban kung ito ay nasa
dulo ng isang linya, kung saan pareho ang '\' at ang bagong linya ay natanggal. Pangalawa, single
sinipi ng quote (“'”) ang lahat hanggang sa susunod na solong quote (maaaring sumasaklaw ito sa mga linya). Pangatlo, a
double quote ('"') ay sumipi sa lahat ng character, maliban sa '$', '`' at '\', hanggang sa susunod na hindi nakatakas
dobleng quote. Ang '$' at ''' sa loob ng double quotes ay may karaniwang kahulugan (ibig sabihin, parameter,
arithmetic, o command substitution) maliban kung walang field splitting na isinasagawa sa mga resulta
ng mga double-quoted substitution, at ang lumang istilong anyo ng command substitution ay mayroon
naka-enable ang backslash-quoting para sa double quotes. Kung ang isang '\' sa loob ng isang double-quoted na string ay
sinusundan ng '\', '$', '`', o '"', ito ay papalitan ng pangalawang character; kung ito ay susundan
sa pamamagitan ng isang bagong linya, pareho ang '\' at ang bagong linya ay tinanggal; kung hindi, pareho ang '\' at ang
ang mga sumusunod na karakter ay hindi nagbabago.

Kung ang isang single-quoted string ay nangunguna sa isang hindi naka-quote na '$', C style backslash expansion (tingnan ang
sa ibaba) ay inilapat (kahit na mga solong quote na character sa loob ay maaaring i-escape at huwag wakasan
ang string pagkatapos); ang pinalawak na resulta ay itinuturing bilang anumang iba pang single-quoted string. Kung ang
Ang double-quoted na string ay pinangungunahan ng isang hindi naka-quote na '$', ang '$' ay binabalewala lang.

backslash paglawak
Sa mga lugar kung saan pinalawak ang mga backslash, ilang partikular na C at AT&T UNIX ksh o GNU malakas na palo estilo
ang mga pagtakas ay isinalin. Kabilang dito ang '\a', '\b', '\f', '\n', '\r', '\t', '\U########',
'\u####', at '\v'. Para sa '\U########' at '\u####', ang ibig sabihin ng "#" ay isang hexadecimal digit, na may kapal
maaaring walang hanggang apat o walo; ang mga escape na ito ay nagsasalin ng Unicode codepoint sa UTF-8.
Higit pa rito, ang '\E' at '\e' ay lumalawak sa escape character.

Sa i-print builtin mode, '\"', '\'', at '\?' ay tahasang hindi kasama; octal sequence
dapat ay mayroong wala hanggang tatlong octal na digit na “#” na may prefix na digit na zero ('\0###');
ang mga hexadecimal sequence na '\x##' ay limitado sa wala hanggang sa dalawang hexadecimal na digit na "#"; pareho
octal at hexadecimal sequence convert sa raw octets; '\#', kung saan # ay wala sa itaas,
isinasalin sa \# (pinananatili ang mga backslashes).

Ang pagpapalawak ng backslash sa C style mode ay bahagyang naiiba: ang mga octal na pagkakasunud-sunod ay dapat na '\###'
walang digit na zero ang prefixing ng isa hanggang tatlong octal digit na “#” at magbubunga ng mga raw octet;
ang mga hexadecimal sequence na '\x#*' ay matakaw na kumakain ng maraming hexadecimal digit na “#” hangga't kaya nila at
wakasan gamit ang unang non-hexadecimal digit; ang mga ito ay nagsasalin ng isang Unicode codepoint sa
UTF-8. Ang sequence na '\c#', kung saan ang "#" ay anumang octet, ay isinasalin sa Ctrl-# (na karaniwang
ibig sabihin, '\c?' nagiging DEL, lahat ng iba ay bitwise ANDed na may 0x1F). Sa wakas, '\#', kung saan
# ay wala sa itaas, isinasalin sa # (na-trim ang backslash), kahit na ito ay isang
bagong linya.

Aliases
Mayroong dalawang uri ng mga alias: normal na command alias at sinusubaybayang alias. Mga alias ng command
ay karaniwang ginagamit bilang isang maikling kamay para sa isang mahaba o madalas na ginagamit na utos. Lumalawak ang shell
command aliases (ibig sabihin, pinapalitan ang pangalan ng alias para sa halaga nito) kapag binasa nito ang unang salita
ng isang utos. Ang isang pinalawak na alias ay muling pinoproseso upang suriin para sa higit pang mga alias. Kung isang utos
nagtatapos ang alias sa isang puwang o tab, ang sumusunod na salita ay sinusuri din para sa pagpapalawak ng alias. Ang
Ang proseso ng pagpapalawak ng alias ay hihinto kapag may nakitang salita na hindi alias, kapag may sinipi na salita
ay natagpuan, o kapag may nakitang alias na salita na kasalukuyang pinalawak. Ang mga alyas ay
partikular na isang interactive na tampok: habang nagkataon na gumagana ang mga ito sa mga script at sa
command line sa ilang mga kaso, ang mga alias ay pinalawak sa panahon ng lexing, kaya ang kanilang paggamit ay dapat na nasa a
hiwalay na command tree mula sa kanilang kahulugan; kung hindi, hindi mahahanap ang alias.
Kapansin-pansin, ang mga listahan ng command (na pinaghihiwalay ng tuldok-kuwit, sa mga pagpapalit ng command din ng newline)
maaaring isang parehong puno ng parse.

Ang mga sumusunod na command alias ay awtomatikong tinukoy ng shell:

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

Ang mga sinusubaybayang alias ay nagbibigay-daan sa shell na matandaan kung saan ito nakakita ng isang partikular na command. Ang una
oras na ang shell ay gumagawa ng isang paghahanap ng landas para sa isang utos na minarkahan bilang isang sinusubaybayang alias, ito ay nagse-save
ang buong landas ng utos. Sa susunod na isagawa ang command, susuriin ng shell ang
naka-save na landas upang makita na ito ay wasto pa rin, at kung gayon, iwasang ulitin ang paghahanap ng landas.
Ang mga sinusubaybayang alias ay maaaring ilista at likhain gamit ang bansag -t. Tandaan na ang pagbabago ng PATH
nililinis ng parameter ang mga naka-save na path para sa lahat ng sinusubaybayang alias. Kung ang trackall nakatakda ang opsyon
(ibig sabihin itakda -o trackall or itakda -h), sinusubaybayan ng shell ang lahat ng mga utos. Nakatakda ang opsyong ito
awtomatikong para sa mga non-interactive na shell. Para sa mga interactive na shell, ang mga sumusunod lamang
Ang mga utos ay awtomatikong sinusubaybayan: pusaNa (1), ccNa (1), chmodNa (1), cpNa (1), petsaNa (1), edNa (1),
emacsNa (1), grepNa (1), lsNa (1), gumawaNa (1), mvNa (1), prNa (1), rmNa (1), uhawNa (1), shNa (1), vi(1), at sinoNa (1).

Paghalili
Ang unang hakbang na ginagawa ng shell sa pagsasagawa ng isang simpleng utos ay ang magsagawa ng mga pagpapalit sa
ang mga salita ng utos. May tatlong uri ng pagpapalit: parameter, command, at
aritmetika. Mga pagpapalit ng parameter, na inilalarawan nang detalyado sa susunod na seksyon,
kunin ang form na $pangalan o ${...}; Ang mga pagpapalit ng utos ay nasa anyo na $(utos) O
(hindi na ginagamit) `utos` o (isinasagawa sa kasalukuyang kapaligiran) ${ utos;} at hubarin
sumusunod sa mga bagong linya; at ang mga pagpapalit ng aritmetika ay nasa anyong $((pagpapahayag)). Pag-parse ng
Ang pagpapalit ng command sa kasalukuyang kapaligiran ay nangangailangan ng espasyo, tab o bagong linya pagkatapos ng pagbubukas
brace at na ang closing brace ay kilalanin bilang isang keyword (ibig sabihin, pinangungunahan ng isang bagong linya
o semicolon). Ang mga ito ay tinatawag ding funsubs (function substitutions) at kumikilos tulad ng
function sa na lokal at pagbabalik trabaho, at doon lumabas tinatapos ang parent shell; kabibi
ibinabahagi ang mga opsyon.

Ang isa pang variant ng pagpapalit ay ang mga valsubs (mga pagpapalit ng halaga) ${|utos;} Alin ang mga
isinagawa din sa kasalukuyang kapaligiran, tulad ng funsubs, ngunit ibahagi ang kanilang I/O sa magulang;
sa halip, sinusuri nila kung anuman ang, sa una ay walang laman, expression-lokal na variable REPLY ay
nakatakda sa loob ng utoss.

Kung lumilitaw ang isang pagpapalit sa labas ng dobleng panipi, ang mga resulta ng pagpapalit ay
karaniwang napapailalim sa paghahati ng salita o field ayon sa kasalukuyang halaga ng IFS
parameter. Ang parameter ng IFS ay tumutukoy sa isang listahan ng mga octet na ginagamit upang maputol ang isang string
sa ilang mga salita; anumang octet mula sa hanay na espasyo, tab, at bagong linya na lalabas sa IFS
Ang mga octet ay tinatawag na "IFS whitespace". Mga pagkakasunud-sunod ng isa o higit pang IFS whitespace octets, in
kumbinasyon na may zero o isang non-IFS whitespace octets, magtakda ng isang field. Bilang isang espesyal na kaso,
Ang nangunguna at sumusunod na IFS whitespace ay tinanggal (ibig sabihin, walang nangunguna o sumusunod na walang laman na field ay
nilikha nito); Ang nangunguna o sumusunod na hindi IFS na whitespace ay lumilikha ng isang walang laman na field.

Halimbawa: Kung ang IFS ay nakatakda sa “ :”, at nakatakda ang VAR sa
“ A : B::D”, ang pagpapalit para sa $VAR ay nagreresulta sa apat na field: 'A',
'B', '' (isang walang laman na field), at 'D'. Tandaan na kung ang parameter ng IFS ay nakatakda sa walang laman
string, walang field splitting ay tapos na; kung ito ay hindi nakatakda, ang default na halaga ng espasyo, tab, at
newline ang ginagamit.

Gayundin, tandaan na ang paghahati ng field ay nalalapat lamang sa agarang resulta ng
pagpapalit. Gamit ang nakaraang halimbawa, ang pagpapalit para sa $VAR:E ay nagreresulta sa
mga field: 'A', 'B', '', at 'D:E', hindi 'A', 'B', '', 'D', at 'E'. Ang pag-uugali na ito ay POSIX
sumusunod, ngunit hindi tugma sa ilang iba pang mga pagpapatupad ng shell na gumagawa ng field splitting
sa salitang naglalaman ng pagpapalit o gumamit ng IFS bilang pangkalahatang whitespace delimiter.

Ang mga resulta ng pagpapalit ay, maliban kung tinukoy, napapailalim din sa pagpapalawak ng brace
at pagpapalawak ng pangalan ng file (tingnan ang mga nauugnay na seksyon sa ibaba).

Ang pagpapalit ng command ay pinapalitan ng output na nabuo ng tinukoy na command which is
tumakbo sa isang subshell. Para sa $(utos) at ${|utos;} at ${ utos;} mga pagpapalit, normal
Ang mga tuntunin sa pagsipi ay ginagamit kapag utos ay na-parse; gayunpaman, para sa hindi na ginagamit `utos` anyo, a
Ang '\' na sinusundan ng alinman sa '$', '`', o '\' ay hinuhubaran (tulad ng '"' kapag bahagi ang pagpapalit
ng isang double-quoted string); ang isang backslash na '\' na sinusundan ng anumang iba pang character ay hindi nagbabago.
Bilang isang espesyal na kaso sa mga pagpapalit ng command, isang utos ng formfile ay binibigyang kahulugan sa
ibig sabihin palitan ang mga nilalaman ng file. Tandaan na $( ay may parehong epekto bilang $(pusa foo).

Tandaan na ang ilang mga shell ay hindi gumagamit ng recursive parser para sa mga pagpapalit ng command, na humahantong sa
kabiguan para sa ilang mga konstruksyon; para maging portable, gamitin bilang workaround 'x=$(cat) <<"EOF"' (o ang
newline-keeping 'x=<<"EOF"' extension) sa halip na slurp lang ang string. IEEE Std 1003.1
Inirerekomenda ng (“POSIX.1”) na gumamit ng mga case statement ng form na 'x=$(case $foo in (bar) echo $bar
;; (*) echo $baz ;; esac)' sa halip, na gagana ngunit hindi magsisilbing halimbawa para dito
isyu sa portable.

x=$(case $foo sa bar) echo $bar ;; *) echo $baz ;; esac)
# sa itaas ay nabigong ma-parse sa mga lumang shell; nasa ibaba ang workaround
x=$(eval $(cat)) <<"EOF"
kaso $foo sa bar) echo $bar ;; *) echo $baz ;; esac
EOF

Ang mga pagpapalit ng aritmetika ay pinapalitan ng halaga ng tinukoy na expression. Para sa
halimbawa, ang utos i-print $((2+3*4)) nagpapakita 14. Tingnan Pang-aritmetika mga expression para sa isang
paglalarawan ng isang pagpapahayag.

parameter
Ang mga parameter ay mga variable ng shell; maaari silang italaga ng mga halaga at ang kanilang mga halaga ay maaaring ma-access
gamit ang pagpapalit ng parameter. Ang pangalan ng parameter ay alinman sa isa sa mga espesyal na single
mga parameter ng bantas o digit na character na inilarawan sa ibaba, o isang titik na sinusundan ng zero o
higit pang mga titik o digit ('_' ay binibilang bilang isang titik). Ang huling anyo ay maaaring ituring bilang mga array
sa pamamagitan ng pagdaragdag ng array index ng form [ipahayag] saan ipahayag ay isang arithmetic expression.
Ang mga indeks ng array ay nasa Salamat ay limitado sa hanay na 0 hanggang 4294967295, kasama. Yan ay,
sila ay isang 32-bit na unsigned integer.

Ang mga pagpapalit ng parameter ay nasa anyong $pangalan, ${pangalan}, o ${pangalan[ipahayag]} saan pangalan ay isang
pangalan ng parameter. Pagpapalit ng lahat ng elemento ng array na may ${pangalan[*]} at ${pangalan[@]} gumagana
katumbas ng $* at $@ para sa mga positional na parameter. Kung ang pagpapalit ay ginawa sa a
parameter (o elemento ng array parameter) na hindi nakatakda, pinapalitan ang null string
maliban kung nounset pagpipilian (itakda -o nounset or itakda -u) ay nakatakda, kung saan ang isang error ay nangyayari.

Ang mga parameter ay maaaring magtalaga ng mga halaga sa maraming paraan. Una, ang shell ay tahasang nagtatakda
ilang mga parameter tulad ng '#', 'PWD', at '$'; ito ang tanging paraan ng espesyal na solong karakter
nakatakda ang mga parameter. Pangalawa, ang mga parameter ay na-import mula sa kapaligiran ng shell sa
Magsimula. Pangatlo, ang mga parameter ay maaaring magtalaga ng mga halaga sa command line: halimbawa, FOO=bar
itinatakda ang parameter na "FOO" sa "bar"; maramihang mga pagtatalaga ng parameter ay maaaring ibigay sa isang solong
command line at maaari silang sundan ng isang simpleng-utos, kung saan ang mga takdang-aralin ay
may bisa lamang sa tagal ng utos (ang mga naturang takdang-aralin ay ini-export din; tingnan
sa ibaba para sa mga implikasyon nito). Tandaan na ang pangalan ng parameter at ang '=' ay dapat na
hindi naka-quote para makilala ng shell ang isang pagtatalaga ng parameter. Ang konstruksyon FOO+=baz ding
kinikilala; ang luma at bagong mga halaga ay agad na pinagsama. Ang ikaapat na paraan ng pagtatakda
ang isang parameter ay kasama ang i-export, global, Basahin lamang, at typeset mga utos; makita ang kanilang
mga paglalarawan sa Utos pagpapatupad seksyon. Ikalima, para at piliin mga loop set ng mga parameter
pati na rin ang mga getopts, basahin, at itakda -A mga utos. Panghuli, maaaring italaga ang mga parameter
mga halaga gamit ang mga operator ng pagtatalaga sa loob ng mga expression ng aritmetika (tingnan Pang-aritmetika mga expression
sa ibaba) o gamit ang ${pangalan=halaga} anyo ng pagpapalit ng parameter (tingnan sa ibaba).

Mga parameter na may katangian ng pag-export (itakda gamit ang i-export or typeset -x utos, o sa pamamagitan ng
ang mga takdang-aralin ng parameter na sinusundan ng mga simpleng utos) ay inilalagay sa kapaligiran (tingnan
tungkol sa(7)) ng mga utos na pinapatakbo ng shell bilang pangalan=halaga magkapares. Ang pagkakasunud-sunod kung aling mga parameter
lumalabas sa kapaligiran ng isang command ay hindi natukoy. Kapag nagsimula ang shell, ito
kinukuha ang mga parameter at ang kanilang mga halaga mula sa kapaligiran nito at awtomatikong itinatakda ang pag-export
attribute para sa mga parameter na iyon.

Maaaring ilapat ang mga modifier sa ${pangalan} anyo ng pagpapalit ng parameter:

${pangalan:-salita}
If pangalan ay nakatakda at hindi NULL, ito ay pinapalitan; kung hindi, salita ay pinalitan.

${pangalan:+salita}
If pangalan ay nakatakda at hindi NULL, salita ay pinalitan; kung hindi, walang kapalit.

${pangalan:=salita}
If pangalan ay nakatakda at hindi NULL, ito ay pinapalitan; kung hindi, ito ay itinalaga salita at
ang nagresultang halaga ng pangalan ay pinalitan.

${pangalan:?salita}
If pangalan ay nakatakda at hindi NULL, ito ay pinapalitan; kung hindi, salita ay nakalimbag sa
karaniwang error (nangunguna sa pangalan:) at may naganap na error (karaniwang nagdudulot ng pagwawakas
ng isang shell script, function, o script na nagmula gamit ang '.' built-in). Kung salita is
inalis, ang string na "parameter null or not set" ang ginamit sa halip. Sa kasalukuyan ay isang bug,
if salita ay isang variable na lumalawak sa null string, ang error na mensahe ay din
nakalimbag

Tandaan na, para sa lahat ng nasa itaas, salita ay talagang itinuturing na sinipi, at espesyal na pag-parse
nalalapat ang mga tuntunin. Naiiba din ang mga panuntunan sa pag-parse kung ang expression ay naka-double-quoted: salita
pagkatapos ay gumagamit ng double-quoting na mga panuntunan, maliban sa double quote mismo ('"') at ang pagsasara
brace, na, kung nakatakas ang backslash, ay mailalapat ang pag-alis ng quote.

Sa mga modifier sa itaas, ang ':' ay maaaring tanggalin, kung saan ang mga kundisyon ay nakasalalay lamang sa
pangalan itinatakda (kumpara sa set at hindi NULL). Kung salita kailangan, parameter, utos,
aritmetika, at pagpapalit ng tilde ay isinasagawa dito; kung salita ay hindi kailangan, ito ay hindi
sinuri

Ang mga sumusunod na anyo ng pagpapalit ng parameter ay maaari ding gamitin (kung pangalan ay isang array, ang
ang elementong may susi na "0" ay papalitan sa kontekstong scalar):

${#pangalan}
Ang bilang ng mga positional na parameter kung pangalan ay '*', '@', o hindi tinukoy; kung hindi
ang haba (sa mga character) ng string value ng parameter pangalan.

${#pangalan[*]}
${#pangalan[@]}
Ang bilang ng mga elemento sa array pangalan.

${%pangalan}
Ang lapad (sa mga column ng screen) ng string value ng parameter pangalan, o -1 kung
${pangalan} ay naglalaman ng isang control character.

${!pangalan}
Ang pangalan ng variable na tinutukoy ni pangalan. Ito ay magiging pangalan maliban kung kailan pangalan is
isang sanggunian ng pangalan (nakatali na variable), na nilikha ng nameref command (na isang alias
para typeset -n).

${!pangalan[*]}
${!pangalan[@]}
Ang mga pangalan ng mga indeks (key) sa array pangalan.

${pangalan#huwaran}
${pangalan##huwaran}
If huwaran tumutugma sa simula ng halaga ng parameter pangalan, ang katugmang teksto ay
tinanggal mula sa resulta ng pagpapalit. Ang isang solong '#' ay nagreresulta sa pinakamaikling
tugma, at dalawa sa kanila ang nagreresulta sa pinakamahabang laban. Hindi mailalapat sa isang vector
(${*} o ${@} o ${array[*]} o ${array[@]}).

${pangalan%huwaran}
${pangalan%%huwaran}
Tulad ng ${..#..} na pagpapalit, ngunit tinatanggal nito mula sa dulo ng halaga. Hindi maaaring
inilapat sa isang vector.

${pangalan/pattern/string}
${pangalan/#pattern/string}
${pangalan/%pattern/string}
${pangalan//pattern/string}
Ang pinakamahabang laban ng huwaran sa halaga ng parameter pangalan ay pinapalitan ng pisi
(tinanggal kung pisi ay walang laman; ang trailing slash ('/') ay maaaring tanggalin sa kasong iyon).
Ang isang nangungunang slash na sinusundan ng '#' o '%' ay nagiging sanhi ng pattern na ma-angkla sa
simula o katapusan ng halaga, ayon sa pagkakabanggit; walang laman na hindi nakakla huwarans sanhi no
kapalit; isang solong nangungunang slash o paggamit ng a huwaran na tumutugma sa walang laman
string ay nagiging sanhi ng kapalit na mangyari nang isang beses lamang; dalawang nangungunang slash sanhi ng lahat
paglitaw ng mga tugma sa halagang papalitan. Hindi mailalapat sa isang vector.
Hindi mahusay na ipinatupad, maaaring mabagal.

${pangalan:magpaskil:Len}
Ang unang Len mga karakter ng pangalan, simula sa posisyon magpaskil, ay pinapalitan. pareho
magpaskil at:Len ay opsyonal. Kung magpaskil ay negatibo, ang pagbibilang ay magsisimula sa dulo ng
string; kung ito ay tinanggal, ito ay magiging default sa 0. Kung Len ay tinanggal o mas malaki kaysa sa
haba ng natitirang string, lahat ng ito ay pinapalitan. pareho magpaskil at Len ay
sinusuri bilang mga ekspresyong aritmetika. Kasalukuyan, magpaskil dapat magsimula sa isang puwang,
pambungad na panaklong o digit na makikilala. Hindi mailalapat sa isang vector.

${pangalan@#}
Ang hash (gamit ang BAFH algorithm) ng pagpapalawak ng pangalan. Ito ay ginagamit din
panloob para sa mga hashtable ng shell.

${pangalan@Q}
Isang naka-quote na expression na ligtas para sa muling pagpasok, na ang halaga ay ang halaga ng pangalan
parameter, ay pinalitan.

Tandaan na ang huwaran Maaaring kailanganin ng pinahabang globbing pattern (@(...)), single ('...') o double
("...") quote escaping maliban kung -o sh ay nakatakda.

Ang mga sumusunod na espesyal na parameter ay tahasang itinakda ng shell at hindi maaaring itakda nang direkta
gamit ang mga takdang-aralin:

! Nagsimula ang Process ID ng huling proseso sa background. Kung walang mga proseso sa background
nasimulan, hindi nakatakda ang parameter.

# Ang bilang ng mga positional na parameter ($1, $2, atbp.).

$ Ang PID ng shell, o ang PID ng orihinal na shell kung ito ay isang subshell. gawin HINDI
gamitin ang mekanismong ito para sa pagbuo ng mga pansamantalang pangalan ng file; tingnan mo mktemp(1) sa halip.

- Ang pagsasama-sama ng kasalukuyang mga pagpipilian sa solong titik (tingnan ang itakda utos sa ibaba
para sa isang listahan ng mga opsyon).

? Ang exit status ng huling hindi-asynchronous na command na naisakatuparan. Kung ang huling utos
pinatay ng isang senyales, $? ay nakatakda sa 128 kasama ang signal number, ngunit hindi hihigit sa 255.

0 Ang pangalan ng shell, tinutukoy bilang mga sumusunod: ang unang argumento sa Salamat kung ito ay
hinihingi ng -c ibinigay ang opsyon at argumento; kung hindi man ang file argumento, kung
ito ay ibinigay; o kung hindi ang basename na ginamit ng shell (ibig sabihin, argv[0]). $0
ay nakatakda din sa pangalan ng kasalukuyang script o sa pangalan ng kasalukuyang function,
kung ito ay tinukoy sa tungkulin keyword (ibig sabihin, isang Korn shell style function).

1 .. 9 Ang unang siyam na positional na parameter na ibinigay sa shell, function, o
script sourced gamit ang '.' built-in. Ang mga karagdagang positional na parameter ay maaaring
na-access gamit ang ${numero}.

* Lahat ng positional na parameter (maliban sa 0), ibig sabihin, $1, $2, $3, ...
Kung ginamit sa labas ng dobleng panipi, ang mga parameter ay magkahiwalay na salita (na napapailalim
sa paghahati ng salita); kung ginamit sa loob ng double quotes, ang mga parameter ay pinaghihiwalay ng
unang karakter ng parameter ng IFS (o ang walang laman na string kung ang IFS ay NULL).

@ Katulad ng $*, maliban kung ito ay ginagamit sa loob ng dobleng panipi, kung saan ang isang hiwalay na salita ay
nabuo para sa bawat positional na parameter. Kung walang mga positional na parameter, hindi
nabuo ang salita. $@ ay maaaring gamitin upang ma-access ang mga argumento, verbatim, nang hindi nawawala
NULL argument o paghahati ng mga argumento na may mga puwang.

Ang mga sumusunod na parameter ay itinakda at/o ginagamit ng shell:

_ (underscore) Kapag ang isang panlabas na command ay pinaandar ng shell, ang parameter na ito
ay nakatakda sa kapaligiran ng bagong proseso patungo sa landas ng naisakatuparan
utos. Sa interactive na paggamit, ang parameter na ito ay nakatakda din sa parent shell sa
ang huling salita ng naunang utos.

BASHPID Ang PID ng shell o subshell.

CDPATH Tulad ng PATH, ngunit ginamit upang malutas ang argumento sa cd built-in na utos. Tandaan
na kung ang CDPATH ay nakatakda at hindi naglalaman ng '.' o isang walang laman na elemento ng string, ang
kasalukuyang direktoryo ay hindi hinahanap. Din ang cd ipapakita ang built-in na command
ang resultang direktoryo kapag may nakitang tugma sa anumang landas sa paghahanap maliban sa
walang laman na landas.

COLUMNS Itakda sa bilang ng mga column sa terminal o window. Palaging nakatakda, mga default
hanggang 80, maliban kung ang halaga tulad ng iniulat ni stty(1) ay hindi zero at sapat na katinuan
(minimum ay 12x3); katulad para sa LINES. Ang parameter na ito ay ginagamit ng
interactive line editing modes, at sa pamamagitan ng piliin, itakda -o, at pumatay -l utos
para i-format ang mga column ng impormasyon. Ang pag-import mula sa kapaligiran o pag-unsetting
ang parameter na ito ay nag-aalis ng pagbubuklod sa aktwal na laki ng terminal pabor sa
ibinigay na halaga.

ENV Kung ang parameter na ito ay nakitang nakatakda pagkatapos maisagawa ang anumang mga profile file, ang
ang pinalawak na halaga ay ginagamit bilang isang shell startup file. Ito ay karaniwang naglalaman ng function
at mga kahulugan ng alias.

ERRNO Integer na halaga ng shell's mali variable. Ipinapahiwatig nito ang huling dahilan
Nabigo ang system call. Hindi pa ipinapatupad.

EXECSHELL Kung nakatakda, ang parameter na ito ay ipinapalagay na naglalaman ng shell na gagamitin
isagawa ang mga utos na iyon execve(2) nabigong isagawa at hindi nagsisimula sa a
“#!talukap ng alimango” pagkakasunod-sunod.

FCEDIT Ang editor na ginamit ng fc utos (tingnan sa ibaba).

FPATH Tulad ng PATH, ngunit ginagamit kapag ang isang hindi natukoy na function ay naisakatuparan upang mahanap ang file
pagtukoy sa function. Hinahanap din ito kapag ang isang utos ay hindi mahanap gamit
DAAN. Tingnan mo Pag-andar sa ibaba para sa karagdagang impormasyon.

HISTFILE Ang pangalan ng file na ginamit upang mag-imbak ng kasaysayan ng command. Kapag itinalaga o hindi nakatakda,
ang file ay binuksan, ang kasaysayan ay pinutol pagkatapos ay na-load mula sa file; kasunod
ang mga bagong command (maaaring binubuo ng ilang linya) ay idinagdag kapag sila
matagumpay na naipon. Gayundin, ibabahagi ang ilang mga invocation ng shell
history kung ang kanilang mga parameter ng HISTFILE ay tumuturo sa parehong file.

nota: Kung ang HISTFILE ay hindi nakatakda o walang laman, walang history file na ginagamit. Ito ay
iba sa AT&T UNIX ksh.

HISTSIZE Ang bilang ng mga utos na karaniwang nakaimbak para sa kasaysayan. Ang default ay 2047. Gawin
hindi itinakda ang halagang ito sa mga nakakabaliw na matataas na halaga gaya ng 1000000000 dahil Salamat maaari
pagkatapos ay hindi maglaan ng sapat na memorya para sa kasaysayan at hindi magsisimula.

HOME Ang default na direktoryo para sa cd utos at ang halaga na ipinalit para sa isang
hindi kwalipikado ~ (Tingnan ang Tilde paglawak sa ibaba).

IFS Internal field separator, ginagamit sa panahon ng pagpapalit at ng basahin utos, sa
hatiin ang mga halaga sa mga natatanging argumento; karaniwang nakatakda sa espasyo, tab, at bagong linya.
Tingnan Paghalili sa itaas para sa mga detalye.

nota: Ang parameter na ito ay hindi na-import mula sa kapaligiran kapag ang shell ay
nagsimula.

KSHEGID Ang mabisang group id ng shell.

KSHGID Ang tunay na group id ng shell.

KSHUID Ang tunay na user id ng shell.

KSH_VERSION Ang pangalan at bersyon ng shell (read-only). Tingnan din ang mga utos ng bersyon
in Emacs pag-edit paraan at Vi pag-edit paraan mga seksyon, sa ibaba.

LINENO Ang numero ng linya ng function o shell script na kasalukuyang ginagawa
pinatay.

LINES Itakda sa bilang ng mga linya sa terminal o window. Palaging nakatakda, naka-default sa
24. Tingnan ang MGA HANAY.

EPOCHREALTIME
Oras mula noong panahon, bilang ibinalik ng gettimeofday(2), na-format bilang decimal
tv_sec sinusundan ng isang tuldok ('.') at tv_usec may palaman sa eksaktong anim na decimal
mga digit

OLDPWD Ang dating working directory. I-unset kung cd ay hindi matagumpay na nagbago
mga direktoryo mula noong nagsimula ang shell, o kung hindi alam ng shell kung nasaan ito.

OPTARG Kapag gumagamit mga getopts, naglalaman ito ng argument para sa isang na-parse na opsyon, kung ito
nangangailangan ng isa.

OPTIND Ang index ng susunod na argumento na ipoproseso kapag ginagamit mga getopts. Pagtatalaga 1
sa parameter na ito sanhi mga getopts upang iproseso ang mga argumento mula sa simula ang
sa susunod na i-invoke ito.

PATH Isang colon (semicolon sa OS/2) ang pinaghihiwalay na listahan ng mga direktoryo na hinahanap
kapag naghahanap ng mga utos at file na pinanggalingan gamit ang '.' utos (tingnan sa ibaba).
Isang walang laman na string na nagreresulta mula sa isang nangunguna o sumusunod na colon, o dalawang magkatabi
colons, ay itinuturing bilang isang '.' (ang kasalukuyang direktoryo).

PGRP Ang process ID ng pinuno ng grupo ng proseso ng shell.

PIPESTATUS Isang array na naglalaman ng errorlevel (exit status) code, isa-isa, ng huli
tumatakbo ang pipeline sa harapan.

PPID Ang process ID ng parent ng shell.

PS1 Ang pangunahing prompt para sa mga interactive na shell. Parameter, utos, at aritmetika
ginagawa ang mga pagpapalit, at '!' ay pinalitan ng kasalukuyang utos
numero (tingnan ang fc utos sa ibaba). Isang literal na '!' maaaring ilagay sa prompt ng
paglalagay ng '!!' sa PS1.

Ang default na prompt ay '$ ' para sa mga hindi root na user, '# ' para sa root. Kung Salamat is
na hinihingi ng ugat at ang PS1 ay hindi naglalaman ng '#' na character, ang default na halaga
ay gagamitin kahit na ang PS1 ay umiiral na sa kapaligiran.

Ang Salamat ang pamamahagi ay may kasamang sample dot.mkshrc naglalaman ng isang sopistikadong
halimbawa, ngunit maaaring gusto mo ang sumusunod (tandaan na
${HOSTNAME:=$(hostname)} at ang root-vs-user distinguishing clause ay (sa
ang halimbawang ito) ay isinagawa sa oras ng pagtatalaga ng PS1, habang ang $USER at $PWD ay
nakatakas at sa gayon ay susuriin sa tuwing may ipapakitang prompt):

PS1='${USER:=$(id -un)}'"@${HOSTNAME:=$(hostname)}:\$PWD $(
kung (( USER_ID )); pagkatapos ay i-print ang \$; iba print \#; fi)"

Tandaan na dahil sinusubukan ng mga editor ng command-line na malaman kung gaano katagal ang prompt
ay (para malaman nila kung gaano kalayo ito sa gilid ng screen), mga escape code sa
maagap ay may posibilidad na guluhin ang mga bagay-bagay. Maaari mong sabihin sa shell na huwag magbilang ng tiyak
mga pagkakasunud-sunod (gaya ng mga escape code) sa pamamagitan ng paglalagay sa iyong prompt ng isang character
(gaya ng Ctrl-A) na sinusundan ng pagbabalik ng karwahe at pagkatapos ay i-delimitahan ang pagtakas
mga code na may ganitong karakter. Anumang mga paglitaw ng character na iyon sa prompt ay
hindi nakalimbag. Siyanga pala, huwag mo akong sisihin sa hack na ito; ito ay nagmula sa
orihinal ksh88(1), na nag-print ng delimiter character kaya wala ka
swerte kung wala kang anumang mga character na hindi naka-print.

Dahil ang mga Backslashes at iba pang mga espesyal na character ay maaaring bigyang-kahulugan ng shell,
upang itakda ang PS1 alinman sa pagtakas sa backslash mismo, o gumamit ng double quotes. Ang
ang huli ay mas praktikal. Ito ay isang mas kumplikadong halimbawa, pag-iwas sa direkta
magpasok ng mga espesyal na character (halimbawa sa ^V sa emacs editing mode), na
naka-embed ang kasalukuyang gumaganang direktoryo, sa reverse video (ang kulay ay gagana,
masyadong), sa prompt string:

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

Dahil sa isang malakas na mungkahi mula kay David G. Korn, Salamat ngayon din ay sumusuporta sa
sumusunod na form:

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

PS2 Secondary prompt string, bilang default '> ', ginagamit kapag kailangan ng higit pang input
kumpletuhin ang isang utos.

PS3 Prompt na ginagamit ng piliin pahayag kapag nagbabasa ng pagpili ng menu. Ang default
ay '#? '.

PS4 Ginagamit para i-prefix ang mga command na naka-print sa panahon ng execution tracing (tingnan ang itakda
-x utos sa ibaba). Parameter, command, at arithmetic substitutions ay
isinagawa bago ito mailimbag. Ang default ay '+'. Baka gusto mong itakda ito
sa '[$EPOCHREALTIME] ' sa halip, upang isama ang mga timestamp.

PWD Ang kasalukuyang gumaganang direktoryo. Maaaring hindi nakatakda o NULL kung hindi alam ng shell
kung nasaan ito

RANDOM Sa tuwing sasangguni ang RANDOM, ito ay itinatalaga ng isang numero sa pagitan ng 0 at 32767
mula sa isang Linear Congruential PRNG muna.

REPLY Default na parameter para sa basahin utos kung walang ibinigay na pangalan. Ginagamit din sa
piliin mga loop upang iimbak ang halaga na binabasa mula sa karaniwang input.

SECONDS Ang bilang ng mga segundo mula noong nagsimula ang shell o, kung ang parameter ay naging
nagtalaga ng isang integer na halaga, ang bilang ng mga segundo mula noong pagtatalaga kasama ang
halaga na itinalaga.

TMOUT Kung nakatakda sa isang positibong integer sa isang interactive na shell, tinutukoy nito ang maximum
bilang ng mga segundo maghihintay ang shell para sa input pagkatapos i-print ang primary
prompt (PS1). Kung lumampas ang oras, lalabas ang shell.

TMPDIR Ang mga pansamantalang shell file ng direktoryo ay nilikha. Kung ang parameter na ito ay hindi
itinakda, o hindi naglalaman ng ganap na landas ng isang masusulat na direktoryo, pansamantala
ang mga file ay nilikha sa / Tmp.

USER_ID Ang epektibong user id ng shell.

Tilde paglawak
Ang pagpapalawak ng Tilde na ginagawa kasabay ng pagpapalit ng parameter, ay ginagawa sa mga salita
nagsisimula sa isang hindi naka-quote na '~'. Ang mga character na sumusunod sa tilde, hanggang sa unang '/', kung
alinman, ay ipinapalagay na isang pangalan sa pag-login. Kung walang laman ang pangalan sa pag-log in, '+', o '-', ang halaga ng
ang HOME, PWD, o OLDPWD na parameter ay pinapalitan, ayon sa pagkakabanggit. Kung hindi, ang password
Hinahanap ang file para sa login name, at ang tilde expression ay pinapalitan ng user
direktoryo ng tahanan. Kung ang login name ay hindi makita sa password file o kung anumang pagsipi o
Ang pagpapalit ng parameter ay nangyayari sa pangalan ng pag-login, walang ginagawang pagpapalit.

Sa mga takdang-aralin ng parameter (gaya ng mga nauuna sa isang simpleng-utos o mga nagaganap sa
mga argumento ng bansag, i-export, global, Basahin lamang, at typeset), ang pagpapalawak ng tilde ay ginagawa pagkatapos
anumang takdang-aralin (ibig sabihin, pagkatapos ng equals sign) o pagkatapos ng hindi sinipi na tutuldok (':'); mga pangalan sa pag-login
ay nililimitahan din ng mga tutuldok.

Ang home directory ng mga dating pinalawak na pangalan sa pag-log in ay naka-cache at muling ginagamit. Ang bansag -d
Ang command ay maaaring gamitin upang ilista, baguhin, at idagdag sa cache na ito (hal bansag -d
fac=/usr/local/facilities; cd ~fac/bin).

Brace paglawak (paghahalili)
Ang mga expression ng brace ay nasa sumusunod na anyo:

unlapi{str1,...,strN}suffix

Ang mga expression ay pinalawak sa N mga salita, na ang bawat isa ay pinagdugtong ng unlapi, STRi,
at suffix (hal. “a{c,b{X,Y},d}e” ay lumalawak sa apat na salita: “ace”, “abXe”, “abYe”, at “ade”).
Tulad ng nabanggit sa halimbawa, ang mga expression ng brace ay maaaring ma-nest at ang mga resultang salita ay hindi
pinagsunod-sunod. Ang mga expression ng brace ay dapat maglaman ng hindi naka-quote na kuwit (',') para maganap ang pagpapalawak (hal
{} at {foo} ay hindi pinalawak). Ang pagpapalawak ng brace ay isinasagawa pagkatapos ng pagpapalit ng parameter
at bago ang pagbuo ng pangalan ng file.

talaksan pangalan pattern
Ang pattern ng pangalan ng file ay isang salita na naglalaman ng isa o higit pang hindi naka-quote na '?', '*', '+', '@', o '!'
mga character o “[..]” na mga sequence. Kapag naisagawa na ang pagpapalawak ng brace, papalitan ang shell
mga pattern ng pangalan ng file na may mga pinagsunod-sunod na pangalan ng lahat ng mga file na tumutugma sa pattern (kung hindi
tumutugma ang mga file, ang salita ay hindi nababago). Ang mga elemento ng pattern ay may sumusunod na kahulugan:

? Tumutugma sa anumang solong karakter.

* Tumutugma sa anumang pagkakasunud-sunod ng mga octet.

[..] Tumutugma sa alinman sa mga octet sa loob ng mga bracket. Ang mga hanay ng mga octet ay maaaring tukuyin ng
ang paghihiwalay ng dalawang octet ng '-' (hal. “[a0-9]” ay tumutugma sa letrang 'a' o anumang digit).
Upang kumatawan sa sarili nito, ang isang '-' ay dapat na sinipi o ang una o huling octet
sa listahan ng octet. Katulad nito, ang isang ']' ay dapat na sinipi o ang unang octet sa listahan
kung ito ay kumakatawan sa sarili sa halip na sa dulo ng listahan. Isa ding '!' lumilitaw
sa simula ng listahan ay may espesyal na kahulugan (tingnan sa ibaba), kaya upang kumatawan sa sarili nito
dapat na ma-quote o lumitaw sa ibang pagkakataon sa listahan.

[!..] Tulad ng [..], maliban kung tumutugma ito sa anumang octet na wala sa loob ng mga bracket.

*(huwaran|...|huwaran)
Tumutugma sa anumang string ng mga octet na tumutugma sa zero o higit pang mga paglitaw ng tinukoy
mga pattern. Halimbawa: Ang pattern *(foo|bar) tumutugma sa mga string na "", "foo", "bar",
"foobarfoo", atbp.

+(huwaran|...|huwaran)
Tumutugma sa anumang string ng mga octet na tumutugma sa isa o higit pang mga paglitaw ng tinukoy
mga pattern. Halimbawa: Ang pattern +(foo|bar) tumutugma sa mga string na "foo", "bar",
"foobar", atbp.

?(huwaran|...|huwaran)
Tumutugma sa walang laman na string o isang string na tumutugma sa isa sa mga tinukoy na pattern.
Halimbawa: Ang pattern ?(foo|bar) tumutugma lamang sa mga string na "", "foo", at "bar".

@(huwaran|...|huwaran)
Tumutugma sa isang string na tumutugma sa isa sa mga tinukoy na pattern. Halimbawa: Ang pattern
@(foo|bar) tumutugma lamang sa mga string na "foo" at "bar".

!(huwaran|...|huwaran)
Tumutugma sa anumang string na hindi tumutugma sa isa sa mga tinukoy na pattern. Mga Halimbawa: Ang
huwaran !(foo|bar) tumutugma sa lahat ng mga string maliban sa "foo" at "bar"; ang pattern !(*)
hindi tumutugma sa mga string; ang pattern !(?)* tumutugma sa lahat ng mga string (pag-isipan ito).

Tandaan na ang kumplikadong globbing, lalo na sa mga alternatibo, ay mabagal; gamit ang hiwalay
ang mga paghahambing ay maaaring (o maaaring hindi) mas mabilis.

Tandaan na ang Salamat (At Halimbawa) hindi kailanman tumutugma sa '.' at '..', ngunit AT&T UNIX ksh, Bourne sh, at GNU
malakas na palo gawin.

Tandaan na wala sa mga elemento ng pattern sa itaas ang tumutugma sa alinman sa isang tuldok ('.') sa simula ng a
pangalan ng file o isang slash ('/'), kahit na ang mga ito ay tahasang ginagamit sa isang [..] sequence; din ang
mga pangalan '.' at '..' ay hindi kailanman tugma, kahit na sa pattern na '.*'.

Kung ang markdirs nakatakda ang opsyon, ang anumang mga direktoryo na nagreresulta mula sa pagbuo ng pangalan ng file ay
minarkahan ng trailing '/'.

Input / output pag-redirect
Kapag ang isang utos ay naisakatuparan, ang karaniwang input, karaniwang output, at karaniwang error nito (file
descriptors 0, 1, at 2, ayon sa pagkakabanggit) ay karaniwang minana mula sa shell. Tatlo
Ang mga pagbubukod dito ay mga utos sa mga pipeline, kung saan karaniwang input at/o pamantayan
ang output ay ang mga naka-set up ng pipeline, mga asynchronous na command na nilikha kapag ang kontrol ng trabaho ay
hindi pinagana, kung saan ang karaniwang input ay unang nakatakdang magmumula / dev / null, at mga utos para sa
na ang alinman sa mga sumusunod na pag-redirect ay tinukoy:

>file Ang karaniwang output ay na-redirect sa file. Kung file ay hindi umiiral, ito ay nilikha;
kung ito ay umiiral, ay isang regular na file, at ang noclobber nakatakda ang opsyon, isang error
nangyayari; kung hindi, ang file ay pinutol. Tandaan na ang ibig sabihin nito ay ang utos cmd
<foo >foo magbubukas foo para sa pagbabasa at pagkatapos ay putulin ito kapag binuksan ito para sa
pagsusulat, dati cmd nakakakuha ng pagkakataon na talagang magbasa foo.

>|file Katulad ng >, maliban kung ang file ay pinutol, kahit na ang noclobber nakatakda ang opsyon.

>>file Katulad ng >, maliban kung file umiiral ito ay idinagdag sa halip na putulin.
Gayundin, ang file ay binuksan sa append mode, kaya ang pagsusulat ay palaging napupunta sa dulo ng
file (tingnan buksan(2)).

<file Ang karaniwang input ay na-redirect mula sa file, na bukas para sa pagbabasa.

<>file Katulad ng <, maliban kung ang file ay binuksan para sa pagbabasa at pagsusulat.

<<tagamarka Matapos basahin ang command line na naglalaman ng ganitong uri ng pag-redirect (tinatawag na a
"dito dokumento"), kinokopya ng shell ang mga linya mula sa source ng command papunta sa a
pansamantalang file hanggang sa isang line matching tagamarka ay binabasa. Kapag ang utos ay
naisakatuparan, ang karaniwang input ay na-redirect mula sa pansamantalang file. Kung tagamarka
naglalaman ng walang sinipi na mga character, ang mga nilalaman ng pansamantalang file ay pinoproseso
na parang nakapaloob sa dobleng mga panipi sa bawat oras na ang command ay naisakatuparan, kaya parameter,
utos, at isinasagawa ang mga pagpapalit ng aritmetika, kasama ang backslash ('\')
escapes para sa '$', '`', '\', at '\newline', ngunit hindi para sa '"'. Kung marami dito
Ang mga dokumento ay ginagamit sa parehong command line, sila ay nai-save sa pagkakasunud-sunod.

Kung hindi tagamarka ay ibinigay, ang dokumento dito ay nagtatapos sa susunod << at pagpapalit
isasagawa. Kung tagamarka ay isang set lamang ng iisang “''” o double '""'
mga panipi na walang nasa pagitan, ang dokumentong ito ay nagtatapos sa susunod na linyang walang laman
at hindi isasagawa ang pagpapalit.

<<-tagamarka Katulad ng <<, maliban sa mga nangungunang tab ay tinanggal mula sa mga linya sa dokumentong ito.

<<salita Katulad ng <<, maliban doon salita is ang dokumento dito. Ito ay tinatawag na dito
string.

<&fd Ang karaniwang input ay nadoble mula sa file descriptor fd. fd maaaring isang numero,
na nagpapahiwatig ng bilang ng isang umiiral na descriptor ng file; ang letrang 'p', na nagpapahiwatig
ang file descriptor na nauugnay sa output ng kasalukuyang co-process; o ang
character na '-', na nagpapahiwatig na ang karaniwang input ay isasara. Tandaan na fd is
limitado sa isang digit sa karamihan ng mga pagpapatupad ng shell.

>&fd Katulad ng <&, maliban na ang operasyon ay ginagawa sa karaniwang output.

&>file Katulad ng >file 2> & 1. Ito ay isang hindi na ginagamit (legacy) GNU malakas na palo suportado ang extension
by Salamat na sumusuporta din sa naunang tahasang numero ng fd, halimbawa,
3&>file ay pareho 3>file 2> & 3 in Salamat ngunit isang syntax error sa GNU malakas na palo.

&>|file, &>>file, &>&fd
Katulad ng >|file, >>file, O >&fd, na sinusundan ng 2> & 1, tulad ng nasa itaas. Ang mga ito ay Salamat
mga extension.

Sa alinman sa mga pag-redirect sa itaas, ang deskriptor ng file na na-redirect (ie standard
input o karaniwang output) ay maaaring tahasang ibigay sa pamamagitan ng unahan ng pag-redirect na may isang numero
(portably, isang solong digit lamang). Parameter, utos, at mga pagpapalit ng aritmetika, tilde
mga pagpapalit, at (kung interactive ang shell) ang pagbuo ng pangalan ng file ay ginagawa lahat sa
ang file, tagamarka, at fd mga argumento ng mga pag-redirect. Tandaan, gayunpaman, na ang mga resulta ng anuman
Ang pagbuo ng pangalan ng file ay ginagamit lamang kung ang isang file ay tumugma; kung magkatugma ang maraming file, ang
salita na may pinalawak na file name generation character ay ginagamit. Tandaan na sa restricted
shell, ang mga pag-redirect na maaaring lumikha ng mga file ay hindi magagamit.

Para sa mga simpleng utos, maaaring lumitaw ang mga pag-redirect kahit saan sa command; para sa tambalang-utos
(if mga pahayag, atbp.), anumang mga pag-redirect ay dapat lumitaw sa dulo. Pinoproseso ang mga pag-redirect
pagkatapos malikha ang mga pipeline at sa pagkakasunud-sunod na ibinigay sa kanila, kaya ang mga sumusunod ay magpi-print ng isang
error na may naka-prepend na numero ng linya dito:

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

Ang mga deskriptor ng file na nilikha ng mga pag-redirect ng I/O ay pribado sa shell.

Pang-aritmetika mga expression
Maaaring gamitin ang mga integer na arithmetic expression sa pabayaan command, sa loob ng $((..)) na mga expression,
mga sanggunian sa loob ng array (hal pangalan[ipahayag]), bilang mga numeric na argumento sa pagsusulit utos, at bilang
ang halaga ng isang pagtatalaga sa isang integer na parameter. babala: Nakakaapekto rin ito sa implicit
conversion sa integer, halimbawa tulad ng ginawa ng pabayaan utos. Hindi kailanman gumamit ng walang check na user
input, hal mula sa kapaligiran, sa arithmetics!

Kinakalkula ang mga ekspresyon gamit ang nilagdaang arithmetic at ang mksh_ari_t uri (isang 32-bit na nilagdaan
integer), maliban kung magsisimula sila sa isang solong character na '#', kung saan ginagamit nila mksh_uari_t (a
32-bit unsigned integer).

Maaaring maglaman ang mga expression ng alpha-numeric na parameter identifier, array reference, at integer
constants at maaaring isama sa mga sumusunod na operator ng C (nakalista at naka-grupo sa
pagtaas ng pagkakasunud-sunod ng pangunguna):

Unary operator:

+ - ! ~ ++ --

Binary operator:

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

Mga operator ng ternary:

?: (mas mataas agad ang priority kaysa assignment)

Mga operator ng pagpapangkat:

()

Ang mga integer at expression ay kinakalkula gamit ang eksaktong 32-bit na lapad, nilagdaan o
unsigned, i-type na may silent wraparound sa integer overflow. Ang mga integer constant ay maaaring
tinukoy na may mga arbitrary na batayan gamit ang notasyon base#numero, Kung saan base ay isang decimal
integer na tumutukoy sa base, at numero ay isang numero sa tinukoy na base. Bukod pa rito,
base-16 integer ay maaaring tukuyin sa pamamagitan ng paglalagay ng prefix sa mga ito ng '0x' (case-insensitive) sa lahat
mga anyo ng mga aritmetika na expression, maliban bilang mga numeric na argumento sa pagsusulit built-in na utos.
Ang pag-prefix ng mga numero na may nag-iisang digit na zero ('0') ay hindi nagiging sanhi ng interpretasyon bilang octal, bilang
hindi ligtas na gawin iyon.

Bilang isang espesyal Salamat extension, ang mga numero sa base ng isa ay itinuturing bilang alinman sa (8-bit
transparent) ASCII o Unicode codepoints, depende sa shell's utf8-mode bandila (kasalukuyang
setting). Ang AT&T UNIX ksh93 syntax ng "'x'" sa halip na "1#x" ay sinusuportahan din. Tandaan
na ang NUL bytes (integral value of zero) ay hindi magagamit. Isang hindi nakatakda o walang laman na parameter
sinusuri sa 0 sa integer na konteksto. Sa Unicode mode, ang mga raw octet ay nakamapa sa hanay
EF80..EFFF tulad ng sa OPTU-8, na nasa PUA at itinalaga ng CSUR para sa paggamit na ito. Kung
higit sa isang octet sa ASCII mode, o isang sequence ng higit sa isang octet na hindi bumubuo ng valid
at minimal CESU-8 sequence ay naipasa, ang pag-uugali ay hindi natukoy (karaniwan, ang shell ay nag-abort
na may error sa pag-parse, ngunit bihira, nagtagumpay ito, hal sa sequence C2 20). Kaya ikaw
dapat palaging gumamit ng ASCII mode maliban kung alam mo na ang input ay mahusay na nabuo sa UTF-8 sa
saklaw na 0000..FFFD kung gagamitin mo ang feature na ito, kumpara sa basahin -a.

Ang mga operator ay sinusuri tulad ng sumusunod:

unary +
Ang resulta ay ang argumento (kasama para sa pagkakumpleto).

unary -
Negasyon.

! Lohikal HINDI; ang resulta ay 1 kung ang argumento ay zero, 0 kung hindi.

~ Arithmetic (bit-wise) HINDI.

++ Pagtaas; dapat ilapat sa isang parameter (hindi literal o iba pang expression).
Ang parameter ay dinaragdagan ng 1. Kapag ginamit bilang prefix operator, ang resulta
ay ang incremented value ng parameter; kapag ginamit bilang postfix operator,
ang resulta ay ang orihinal na halaga ng parameter.

-- Kapareho ng ++, maliban sa parameter ay binabawasan ng 1.

, Naghihiwalay sa dalawang aritmetika na expression; ang kaliwang bahagi ay sinusuri muna,
tapos ang kanan. Ang resulta ay ang halaga ng expression sa kanang kamay
panig.

= Takdang-aralin; ang variable sa kaliwa ay nakatakda sa halaga sa kanan.

+= -= *= /= %= <<<= >>>= <<= >>= &= ^= |=
Mga operator ng assignment.ay><op>=ipahayag> ay katulad ngay>=ay><op><ipahayag>,
na may anumang operator na nangunguna saipahayag> iniingatan. Halimbawa, "var1 *= 5 +
3" ay kapareho ng pagtukoy sa "var1 = var1 * (5 + 3)".

|| Lohikal O; ang resulta ay 1 kung alinman sa argumento ay hindi zero, 0 kung hindi. Ang
Ang tamang argumento ay sinusuri lamang kung ang kaliwang argumento ay zero.

&& Lohikal AT; ang resulta ay 1 kung ang parehong mga argumento ay hindi zero, 0 kung hindi. Ang
ang tamang argumento ay sinusuri lamang kung ang kaliwang argumento ay hindi zero.

| Arithmetic (bit-wise) O.

^ Arithmetic (bit-wise) XOR (exclusive-OR).

& Arithmetic (bit-wise) AT.

== Katumbas; ang resulta ay 1 kung ang parehong mga argumento ay pantay, 0 kung hindi.

!= Hindi katumbas; ang resulta ay 0 kung ang parehong mga argumento ay pantay, 1 kung hindi.

< Mas mababa sa; ang resulta ay 1 kung ang kaliwang argumento ay mas mababa sa kanan, 0 kung
hindi.

<= > >=
Mas mababa sa o katumbas, mas malaki kaysa, mas malaki kaysa o katumbas. Tingnan mo <.

<<< >>>
I-rotate pakaliwa (kanan); ang resulta ay katulad ng shift (tingnan <<) maliban na ang
Ang mga bit na inilipat sa isang dulo ay inilipat sa kabilang dulo, sa halip na zero
o sign bits.

<< >> Lumipat pakaliwa (pakanan); ang resulta ay ang kaliwang argumento na ang mga bit nito ay inilipat pakaliwa
(kanan) sa halagang ibinigay sa tamang argumento.

+ - * /
Pagdaragdag, pagbabawas, pagpaparami, at paghahati.

% Natitira; ang resulta ay ang simetriko na natitira sa dibisyon ng kaliwa
argumento ng karapatan. Upang makuha ang mathematical modulus ng “a mod b”, gamitin ang
formula "(a % b + b) % b".

<arg1>?arg2>:arg3>
Kungarg1> ay non-zero, ang resulta ayarg2>; kung hindi ang resulta ayarg3>.
Ang argumentong hindi resulta ay hindi sinusuri.

Mga co-process
Ang isang co-process (na isang pipeline na nilikha gamit ang '|&' operator) ay isang asynchronous na proseso
na parehong maaaring sulatan ng shell (gamit ang i-print -p) at basahin mula sa (gamit basahin -p). Ang input
at ang output ng co-process ay maaari ding manipulahin gamit >&p at <&p mga pag-redirect,
ayon sa pagkakabanggit. Kapag nasimulan na ang isang co-process, hindi na masisimulan ang isa pa hanggang sa ang co-
paglabas ng proseso, o hanggang sa nai-redirect ang input ng co-process gamit ang isang exec n>&p
pag-redirect. Kung ang input ng isang co-process ay na-redirect sa ganitong paraan, ang susunod na co-process ay magiging
Ang nagsimula ay magbabahagi ng output sa unang co-process, maliban kung ang output ng inisyal
Ang co-process ay na-redirect gamit ang isang exec n<&p pag-redirect.

Ilang mga tala tungkol sa mga co-process:

· Ang tanging paraan upang isara ang input ng co-process (kaya ang co-process ay nagbabasa ng end-of-file) ay
upang i-redirect ang input sa isang may numerong descriptor ng file at pagkatapos ay isara ang file descriptor na iyon:
exec 3>&p; exec 3>&-

· Upang ang mga co-process ay magbahagi ng isang karaniwang output, dapat panatilihin ng shell ang pagsulat
bahagi ng output pipe bukas. Nangangahulugan ito na ang end-of-file ay hindi matutukoy hanggang sa
lahat ng mga co-process na nagbabahagi ng output ng co-process ay lumabas na (kapag lumabas silang lahat, ang
isinasara ng shell ang kopya nito ng tubo). Ito ay maiiwasan sa pamamagitan ng pag-redirect ng output sa a
may numerong deskriptor ng file (dahil nagiging sanhi din ito ng shell upang isara ang kopya nito). Tandaan na
ang gawi na ito ay bahagyang naiiba sa orihinal na shell ng Korn na nagsasara ng kopya nito
ng write na bahagi ng co-process na output noong ang pinakahuling nagsimula ng co-process
(sa halip na kapag ang lahat ng pagbabahagi ng co-processes) ay lalabas.

· i-print -p ay papansinin ang mga signal ng SIGPIPE habang nagsusulat kung ang signal ay hindi nakulong o
hindi pinansin; ang parehong ay totoo kung ang co-process input ay na-duplicate sa isa pang file
deskriptor at i-print -un Ginagamit.

Pag-andar
Tinutukoy ang mga function gamit ang alinman sa Korn shell tungkulin function-name syntax o ang
Bourne/POSIX shell function-name() syntax (tingnan sa ibaba para sa pagkakaiba ng dalawa
mga form). Ang mga function ay tulad ng .‐scripts (ibig sabihin, ang mga script na pinagmulan gamit ang '.' built-in) doon
ang mga ito ay isinasagawa sa kasalukuyang kapaligiran. Gayunpaman, hindi tulad ng .‐scripts, shell arguments
(ibig sabihin, ang mga positional na parameter $1, $2, atbp.) ay hindi kailanman makikita sa loob ng mga ito. Kapag ang shell ay
pagtukoy sa lokasyon ng isang command, ang mga function ay hinanap pagkatapos ng espesyal na built-in
mga utos, bago ang mga builtin at ang PATH ay hinanap.

Ang isang umiiral na function ay maaaring tanggalin gamit ang i-unset -f function-name. Ang isang listahan ng mga function ay maaaring
makuha gamit ang typeset +f at ang mga kahulugan ng function ay maaaring ilista gamit typeset -f.
Ang autoload command (na isang alias para sa typeset -fu) ay maaaring gamitin upang lumikha ng hindi natukoy
function: kapag ang isang hindi natukoy na function ay naisakatuparan, hinahanap ng shell ang path na tinukoy sa
ang parameter ng FPATH para sa isang file na may kaparehong pangalan ng function na, kung matagpuan, ay babasahin
at pinaandar. Kung pagkatapos isagawa ang file ang pinangalanang function ay natagpuan na tinukoy, ang
ang function ay naisakatuparan; kung hindi, ang normal na paghahanap ng command ay ipagpapatuloy (ibig sabihin, ang shell
hinahanap ang regular na built-in na command table at PATH). Tandaan na kung ang isang utos ay hindi natagpuan
gamit ang PATH, isang pagtatangka ay ginawa upang i-autoload ang isang function gamit ang FPATH (ito ay isang undocumented
tampok ng orihinal na shell ng Korn).

Ang mga function ay maaaring magkaroon ng dalawang katangian, "trace" at "export", na maaaring itakda sa typeset -ft
at typeset -fx, ayon sa pagkakabanggit. Kapag ang isang traced function ay naisakatuparan, ang shell's xtrace
naka-on ang opsyon para sa tagal ng function. Ang "export" na katangian ng mga function ay
kasalukuyang hindi ginagamit. Sa orihinal na shell ng Korn, ang mga na-export na function ay makikita ng shell
mga script na naisakatuparan.

Dahil ang mga pag-andar ay isinasagawa sa kasalukuyang kapaligiran ng shell, ginawa ang mga pagtatalaga ng parameter
makikita ang mga function sa loob pagkatapos makumpleto ang function. Kung hindi ito ang ninanais
epekto, ang typeset Ang command ay maaaring gamitin sa loob ng isang function upang lumikha ng isang lokal na parameter. Tandaan
na AT&T UNIX ksh93 gumagamit ng static na saklaw (isang pandaigdigang saklaw, isang lokal na saklaw bawat function)
at pinapayagan ang mga lokal na variable lamang sa mga pag-andar ng istilo ng Korn, samantalang Salamat gumagamit ng dynamic na scoping
(mga nested na saklaw ng iba't ibang lokalidad). Tandaan na ang mga espesyal na parameter (hal $$, $!) hindi pwede
nasasakupan sa ganitong paraan.

Ang exit status ng isang function ay ang huling command na naisakatuparan sa function. A
function ay maaaring gawin upang matapos kaagad gamit ang pagbabalik utos; ito ay maaari ding gamitin
upang tahasang tukuyin ang katayuan sa paglabas.

Ang mga function na tinukoy sa tungkulin ang nakalaan na salita ay naiiba ang pagtrato sa mga sumusunod
paraan mula sa mga function na tinukoy sa () notasyon:

· Ang $0 na parameter ay nakatakda sa pangalan ng function (Bourne-style functions ay nag-iiwan ng $0
hindi nagalaw).

· Ang mga pagtatalaga ng parameter bago ang mga function na tawag ay hindi pinananatili sa kapaligiran ng shell
(Ang pagpapatupad ng mga function na istilong Bourne ay magpapanatili ng mga takdang-aralin).

· Ang OPTIND ay nai-save/i-reset at naibalik sa pagpasok at paglabas mula sa function kaya mga getopts ay maaaring maging
ginamit nang maayos sa loob at labas ng function (Ang mga function sa istilo ng Bourne ay umaalis sa OPTIND
hindi nagalaw, kaya ginagamit mga getopts sa loob ng isang function ay nakakasagabal sa paggamit mga getopts sa labas ng
pagpapaandar).

· Mga pagpipilian sa shell (itakda -o) ay may lokal na saklaw, ibig sabihin, ang mga pagbabago sa loob ng isang function ay na-reset
paglabas nito.

Sa hinaharap, ang mga sumusunod na pagkakaiba ay maaari ding idagdag:

· Isang hiwalay na trap/signal environment ang gagamitin sa panahon ng pagpapatupad ng mga function. Ito
ay nangangahulugan na ang mga traps na nakalagay sa loob ng isang function ay hindi makakaapekto sa mga traps at signal ng shell
na hindi binabalewala sa shell (ngunit maaaring nakulong) ay magkakaroon ng kanilang default na epekto sa
isang function.

· Ang EXIT trap, kung nakatakda sa isang function, ay isasagawa pagkatapos bumalik ang function.

Utos pagpapatupad
Pagkatapos ng pagsusuri ng mga argumento ng command-line, pag-redirect, at pagtatalaga ng parameter, ang
uri ng command ay tinutukoy: isang espesyal na built-in na command, isang function, isang normal na builtin, o
ang pangalan ng isang file na isasagawa ay natagpuan gamit ang PATH parameter. Ang mga tseke ay ginawa sa
ayos sa itaas. Ang mga espesyal na built-in na command ay naiiba sa iba pang mga command dahil ang PATH
parameter ay hindi ginagamit upang mahanap ang mga ito, ang isang error sa panahon ng kanilang pagpapatupad ay maaaring magdulot ng hindi
interactive na shell upang lumabas, at mga pagtatalaga ng parameter na tinukoy bago ang command
ay pinananatili pagkatapos makumpleto ang utos. Ang mga regular na built-in na command ay naiiba lamang doon
ang parameter ng PATH ay hindi ginagamit upang mahanap ang mga ito.

Ang orihinal na ksh at POSIX medyo naiiba kung saan ang mga utos ay itinuturing na espesyal o
regular

Mga espesyal na built-in na utility ng POSIX:

., :, masira, magpatuloy, eval, exec, lumabas, i-export, Basahin lamang, pagbabalik, itakda, ilipat, beses, bitag,
i-unset

karagdagan Salamat mga utos na nag-iingat ng mga takdang-aralin:

builtin, global, pinagmulan, typeset, maghintay

Mga builtin na hindi espesyal:

[, bansag, bg, magtali, pusa, cd, utos, miss, hindi totoo, fc, fg, mga getopts, trabaho, pumatay, pabayaan, i-print,
pwd, basahin, realpath, palitan ang pangalan, matulog, suspindihin, pagsusulit, totoo, limitasyon, umask, Unalias, saan

Kapag natukoy na ang uri ng command, ang anumang pagtatalaga ng parameter ng command-line ay
ginanap at na-export para sa tagal ng utos.

Ang mga sumusunod ay naglalarawan sa mga espesyal at regular na built-in na mga command at builtin-like na nakalaan
mga salita:

. file [arg ...]
Ito ay tinatawag na "tuldok" na utos. Isagawa ang mga utos sa file sa kasalukuyang
kapaligiran. Hinahanap ang file sa mga direktoryo ng PATH. Kung ang mga argumento ay
ibinigay, ang mga positional na parameter ay maaaring gamitin upang ma-access ang mga ito habang file ay ang pagiging
pinaandar. Kung walang ibinigay na mga argumento, ang mga positional na parameter ay yaong sa
kapaligiran kung saan ginagamit ang utos.

: [...]
Ang null command. Nakatakda sa zero ang status ng paglabas.

[ pagpapahayag ]
Tingnan pagsusulit.

bansag [-d | -t [-r] | +-x] [-p] [+] [pangalan [=halaga] ...]
Nang walang mga argumento, bansag naglilista ng lahat ng alyas. Para sa anumang pangalan na walang halaga, ang
nakalista ang kasalukuyang alias. Ang anumang pangalan na may halaga ay tumutukoy sa isang alias (tingnan Aliases
sa itaas).

Kapag naglilista ng mga alias, isa sa dalawang format ang ginagamit. Karaniwan, ang mga alias ay nakalista bilang
pangalan=halaga, Kung saan halaga ay sinipi. Kung ang mga opsyon ay nauna sa '+', o nag-iisang '+'
ay ibinigay sa command line, lamang pangalan ay nakalimbag.

Ang -d ang opsyon ay nagiging sanhi ng mga alias ng direktoryo na ginagamit sa pagpapalawak ng tilde upang mailista
o itakda (tingnan Tilde paglawak sa itaas).

Kung ang -p ginagamit ang opsyon, ang bawat alias ay may prefix na string na "alias".

Ang -t ang opsyon ay nagpapahiwatig na ang mga sinusubaybayang alias ay dapat ilista/itakda (mga value na tinukoy
sa command line ay binabalewala para sa mga sinusubaybayang alias). Ang -r ang opsyon ay nagpapahiwatig na
lahat ng sinusubaybayang alias ay ire-reset.

Ang -x mga hanay ng opsyon (+x nililimas) ang katangian ng pag-export ng isang alias, o, kung walang mga pangalan
ibinigay, naglilista ng mga alias na may katangian ng pag-export (ang pag-export ng isang alias ay may no
epekto).

bg [trabaho ...]
Ipagpatuloy ang tinukoy na (mga) nahintong trabaho sa background. Kung walang tinukoy na mga trabaho, %+
ay ipinapalagay. Tingnan mo Trabaho kontrol sa ibaba para sa karagdagang impormasyon.

magtali [-l]
Ang kasalukuyang mga binding ay nakalista. Kung ang -l ang bandila ay ibinigay, magtali sa halip ay naglilista ng
mga pangalan ng mga function kung saan maaaring itali ang mga key. Tingnan mo Emacs pag-edit paraan para sa karagdagang
impormasyon.

magtali [-m] pisi=[kapalit] ...
magtali pisi=[utos sa pag-edit] ...
Ang tinukoy na utos sa pag-edit ay nakatali sa ibinigay pisi, na dapat ay binubuo ng a
control character na opsyonal na pinangungunahan ng isa sa dalawang prefix na character at
opsyonal na nagtagumpay sa pamamagitan ng isang tilde character. Hinaharap na input ng pisi Magdudulot ang
utos sa pag-edit upang ma-invoke kaagad. Kung ang -m flag ay ibinigay, ang tinukoy
input pisi ay pagkatapos ay agad na papalitan ng ibinigay kapalit pisi
na maaaring naglalaman ng mga utos sa pag-edit ngunit hindi iba pang mga macro. Kung ang isang tilde postfix ay
ibinigay, isang tilde na sumusunod sa isa o dalawang prefices at ang control character ay binabalewala,
anumang iba pang trailing character ay ipoproseso pagkatapos.

Ang mga control character ay maaaring isulat gamit ang caret notation ie ^X ay kumakatawan sa Ctrl-X.
Tandaan na bagama't dalawang prefix na character lamang (karaniwang ESC at ^X) ang sinusuportahan,
maaaring suportahan ang ilang mga multi-character na sequence.

Ipinapakita ng mga sumusunod na default na binding kung paano ang mga arrow key, home, end at delete key
sa isang BSD wsvt25, xterm-xfree86 o GNU screen terminal ay nakatali (siyempre ang ilan
ang mga escape sequence ay hindi gagana nang ganito kaganda):

bind '^X'=prefix-2
itali ang '^[['=prefix-2
bind '^XA'=up-history
bind '^XB'=down-history
bind '^XC'=forward-char
bind '^XD'=backward-char
bind '^X1~'=simula-ng-linya
bind '^X7~'=simula-ng-linya
bind '^XH'=simula-ng-linya
bind '^X4~'=end-of-line
bind '^X8~'=end-of-line
bind '^XF'=end-of-line
bind '^X3~'=delete-char-forward

masira [antas]
Lumabas sa antasika-inner-most para, piliin, hanggang, O habang loop. antas default sa 1.

builtin [--] utos [arg ...]
Isagawa ang built-in na command utos.

pusa [-u] [file ...]
Basahin ang mga file nang sunud-sunod, sa pagkakasunud-sunod ng command line, at isulat ang mga ito sa karaniwang output.
Kung ang isang file ay isang solong gitling ('-') o wala, basahin mula sa karaniwang input. Para direkta
builtin na tawag, ang POSIX -u ang opsyon ay sinusuportahan bilang no-op. Para sa mga tawag mula sa shell, kung
anumang mga pagpipilian ay ibinigay, isang panlabas pusa(1) mas gusto ang utility kaysa sa builtin.

cd [-L] [dir]
cd -P [-e] [dir]
chdir [-eLP] [dir]
Itakda ang gumaganang direktoryo sa dir. Kung nakatakda ang parameter na CDPATH, inililista nito ang
path ng paghahanap para sa direktoryo na naglalaman ng dir. Ang isang NULL na landas ay nangangahulugang ang kasalukuyang
direktoryo. Kung dir ay matatagpuan sa anumang bahagi ng CDPATH na landas sa paghahanap maliban sa
NULL path, ang pangalan ng bagong working directory ay isusulat sa karaniwang output.
If dir ay nawawala, ang home directory HOME ay ginagamit. Kung dir ay '-', ang nauna
gumaganang direktoryo ang ginagamit (tingnan ang parameter ng OLDPWD).

Kung ang -L opsyon (lohikal na landas) ang ginagamit o kung ang Physical ang opsyon ay hindi nakatakda (tingnan ang
itakda utos sa ibaba), mga sanggunian sa '..' sa dir ay may kaugnayan sa landas na ginamit upang makarating
ang direktoryo. Kung ang -P opsyon (pisikal na landas) ang ginagamit o kung ang Physical Ang opsyon ay
set, ang '..' ay nauugnay sa puno ng direktoryo ng filesystem. Ang PWD at OLDPWD
na-update ang mga parameter upang ipakita ang kasalukuyan at lumang direktoryo ng trabaho,
ayon sa pagkakabanggit. Kung ang -e Ang opsyon ay nakatakda para sa pisikal na filesystem traversal, at PWD
hindi maitakda, ang exit code ay 1; mas malaki sa 1 kung may naganap na error, 0
kung hindi man.

cd [-eLP] luma bago
chdir [-eLP] luma bago
Ang tali bago ay pinalitan para sa luma sa kasalukuyang direktoryo, at ang shell
sumusubok na lumipat sa bagong direktoryo.

utos [-pVv] cmd [arg ...]
Kung hindi man ang -v ni -V ibinigay ang pagpipilian, cmd ay naisakatuparan nang eksakto na parang utos nagkaroon
hindi tinukoy, na may dalawang pagbubukod: una, cmd hindi maaaring isang function ng shell; at
pangalawa, nawawalan ng espesyalidad ang mga espesyal na built-in na command (ibig sabihin, redirection at
Ang mga error sa utility ay hindi nagiging sanhi ng pag-alis ng shell, at ang mga pagtatalaga ng command ay hindi
permanenteng).

Kung ang -p Ang opsyon ay ibinigay, ang isang default na landas sa paghahanap ay ginagamit sa halip na ang kasalukuyang halaga
ng PATH, ang aktwal na halaga nito ay nakasalalay sa system.

Kung ang -v ang opsyon ay ibinigay, sa halip na isagawa cmd, impormasyon tungkol sa kung ano ang magiging
naisakatuparan ay ibinigay (at ang parehong ay ginagawa para sa arg ...). Para sa mga builtin, function at
mga keyword, ang kanilang mga pangalan ay naka-print lamang; para sa mga alias, isang utos na tumutukoy sa kanila ay
nakalimbag; para sa mga utility na natagpuan sa pamamagitan ng paghahanap sa PATH parameter, ang buong path ng
naka-print ang command. Kung walang nahanap na command (ibig sabihin, nabigo ang paghahanap ng landas), wala
nakalimbag at utos paglabas na may hindi zero na katayuan. Ang -V Ang pagpipilian ay tulad ng -v
opsyon, maliban kung ito ay mas verbose.

magpatuloy [antas]
Tumalon sa simula ng antasika-inner-most para, piliin, hanggang, O habang loop.
antas default sa 1.

miss [-A] [arg ...]
Babala: ang utility na ito ay hindi portable; gamitin ang Korn shell builtin i-print sa halip.

Ini-print ang mga argumento nito (na pinaghihiwalay ng mga puwang) na sinusundan ng isang bagong linya, sa pamantayan
output. Ang bagong linya ay pinipigilan kung ang alinman sa mga argumento ay naglalaman ng backslash
sequence '\c'. Tingnan ang i-print command sa ibaba para sa isang listahan ng iba pang mga backslash sequence
na kinikilala.

Ang mga opsyon ay ibinigay para sa pagiging tugma sa mga script ng shell ng BSD. Ang -n opsyon
pinipigilan ang sumusunod na bagong linya, -e nagbibigay-daan sa backslash na interpretasyon (isang no-op, since
ito ay karaniwang ginagawa), at -E pinipigilan ang backslash na interpretasyon.

Kung ang posix or sh nakatakda ang opsyon o ito ay isang direktang builtin na tawag, ang una lang
Ang argumento ay itinuturing bilang isang opsyon, at kung ito ay eksaktong "-n”. Backslash
hindi pinagana ang interpretasyon.

eval utos ...
Ang mga argumento ay pinagsama-sama (na may mga puwang sa pagitan ng mga ito) upang bumuo ng isang solong string
na kung saan ang shell pagkatapos ay na-parse at execute sa kasalukuyang kapaligiran.

exec [-a argv0] [-c] [utos [arg ...]]
Ang utos ay isinasagawa nang walang tinidor, pinapalitan ang proseso ng shell. Ito ay
kasalukuyang ganap, ibig sabihin exec hindi na babalik, kahit na ang utos hindi mahanap. Ang
-a pinahihintulutan ng opsyon ang pagtatakda ng ibang halaga ng argv[0], at -c nililinis ang kapaligiran
bago isagawa ang proseso ng bata, maliban sa _ variable at direktang mga takdang-aralin.

Kung walang command na ibinigay maliban sa I/O redirection, permanente ang I/O redirection
at ang shell ay hindi pinapalitan. Anumang mga deskriptor ng file na higit sa 2 na nabuksan
or dup(2)'d sa paraang ito ay hindi ginawang magagamit sa iba pang mga executed command (hal
mga utos na hindi naka-built-in sa shell). Tandaan na ang Bourne shell ay naiiba
dito; ipinapasa nito ang mga deskriptor ng file na ito.

lumabas [katayuan]
Lalabas ang shell na may tinukoy na katayuan sa paglabas. Kung katayuan ay hindi tinukoy, ang paglabas
ang katayuan ay ang kasalukuyang halaga ng $? parameter

i-export [-p] [parametro[=halaga]]
Itinatakda ang katangian ng pag-export ng mga pinangalanang parameter. Ipinapasa ang mga na-export na parameter
ang kapaligiran upang maisagawa ang mga utos. Kung ang mga halaga ay tinukoy, ang pinangalanang mga parameter
ay nakatalaga rin.

Kung walang tinukoy na parameter, lahat ng parameter na may set ng attribute ng pag-export ay
naka-print ng isa sa bawat linya; alinman sa kanilang mga pangalan, o, kung ang isang '-' na walang opsyon na titik ay
tinukoy, pangalan=mga pares ng halaga, o, may -p, i-export mga utos na angkop para sa muling pagpasok.

hindi totoo Isang utos na lumalabas na may hindi zero na katayuan.

fc [-e editor | -l [-n]] [-r] [una [huli]]
una at huli pumili ng mga utos mula sa kasaysayan. Maaaring mapili ang mga utos ayon sa kasaysayan
numero (paatras ang mga negatibong numero mula sa kasalukuyan, pinakabago, linya) o a
string na tumutukoy sa pinakabagong command na nagsisimula sa string na iyon. Ang -l opsyon
naglilista ng command sa karaniwang output, at -n pinipigilan ang mga default na numero ng command.
Ang -r Binabaliktad ng opsyon ang pagkakasunud-sunod ng listahan. Kung wala -l, ang mga napiling command ay
na-edit ng editor na tinukoy kasama ang -e opsyon, o kung hindi -e ay tinukoy, ang
editor na tinukoy ng parameter ng FCEDIT (kung hindi nakatakda ang parameter na ito, /bin/ed is
ginamit), at pagkatapos ay pinaandar ng shell.

fc -e - | -s [-g] [luma=bago] [unlapi]
Muling isagawa ang napiling command (ang nakaraang command bilang default) pagkatapos gumanap
ang opsyonal na pagpapalit ng luma sa bago. Kung -g ay tinukoy, lahat ng paglitaw ng
luma ay pinalitan ng bago. Ang kahulugan ng -e - at -s ay magkapareho: muling isagawa ang
piniling utos nang hindi gumagamit ng editor. Karaniwang ina-access ang command na ito gamit ang
ang paunang natukoy: bansag r='fc -e -'

fg [trabaho ...]
Ipagpatuloy ang tinukoy na (mga) trabaho sa foreground. Kung walang tinukoy na mga trabaho, %+ is
ipinapalagay. Tingnan mo Trabaho kontrol sa ibaba para sa karagdagang impormasyon.

mga getopts optstring pangalan [arg ...]
Ginagamit ng mga pamamaraan ng shell upang i-parse ang mga tinukoy na argumento (o mga positional na parameter,
kung walang ibinigay na argumento) at upang suriin ang mga legal na opsyon. optstring naglalaman ng
opsyon na mga titik na mga getopts ay ang pagkilala. Kung ang isang titik ay sinusundan ng tutuldok, ang
ang opsyon ay inaasahang magkakaroon ng argumento. Ang mga opsyon na hindi kumukuha ng mga argumento ay maaaring
pinagsama-sama sa iisang argumento. Kung ang isang opsyon ay tumatagal ng argumento at ang opsyon
ang karakter ay hindi ang huling karakter ng argumento kung saan ito matatagpuan, ang natitira sa
ang argumento ay itinuturing na argumento ng opsyon; kung hindi, ang susunod na argumento ay
argumento ng opsyon.

Sa bawat oras mga getopts ay hinihingi, inilalagay nito ang susunod na opsyon sa parameter ng shell pangalan
at ang index ng argumento na ipoproseso ng susunod na tawag sa mga getopts nasa
shell parameter OPTIND. Kung ang opsyon ay ipinakilala na may '+', ang opsyon ay inilagay
in pangalan ay may prefix na '+'. Kapag ang isang opsyon ay nangangailangan ng argumento, mga getopts lugar
ito sa shell parameter na OPTARG.

Kapag nakatagpo ang isang ilegal na opsyon o isang nawawalang argumento ng opsyon, isang tandang pananong
o nilagyan ng colon pangalan (nagsasaad ng ilegal na opsyon o nawawalang argumento,
ayon sa pagkakabanggit) at ang OPTARG ay nakatakda sa opsyong karakter na naging sanhi ng problema.
Bukod dito, kung optstring ay hindi nagsisimula sa isang tutuldok, may inilalagay na tandang pananong
pangalan, ang OPTARG ay hindi nakatakda, at ang isang mensahe ng error ay naka-print sa karaniwang error.

Kapag ang dulo ng mga pagpipilian ay nakatagpo, mga getopts paglabas na may di-zero na paglabas
katayuan. Nagtatapos ang mga opsyon sa unang argumento (hindi opsyon na argumento) na hindi nagsisimula
na may '-', o kapag ang isang '--' argumento ay nakatagpo.

Maaaring i-reset ang pag-parse ng opsyon sa pamamagitan ng pagtatakda ng OPTIND sa 1 (awtomatikong ginagawa ito
sa tuwing ang shell o isang shell procedure ay invoke).

Babala: Ang pagpapalit ng value ng shell parameter na OPTIND sa isang value maliban sa 1, o
ang pag-parse ng iba't ibang hanay ng mga argumento nang hindi nire-reset ang OPTIND, ay maaaring humantong sa hindi inaasahan
resulta.

global ...
Tingnan typeset.

sumira [-r] [pangalan ...]
Kung walang mga argumento, nakalista ang anumang mga na-hash na executable na pathname ng command. Ang -r opsyon
nagiging sanhi ng lahat ng mga hash na utos na maalis mula sa hash table. Bawat isa pangalan ay hinahanap
na parang ito ay isang command name at idinagdag sa hash table kung ito ay isang executable
utos.

trabaho [-lnp] [trabaho ...]
Ipakita ang impormasyon tungkol sa tinukoy na (mga) trabaho; kung walang trabahong tinukoy, lahat ng trabaho
ay ipinapakita. Ang -n ang opsyon ay nagdudulot ng impormasyon na maipakita lamang para sa mga trabahong iyon
ay nagbago ng estado mula noong huling abiso. Kung ang -l ginagamit ang opsyon, ang
nakalista din ang process ID ng bawat proseso sa isang trabaho. Ang -p ang opsyon ay nagdudulot lamang ng
pangkat ng proseso ng bawat trabahong ipi-print. Tingnan mo Trabaho kontrol sa ibaba para sa format ng trabaho
at ang ipinakitang trabaho.

pumatay [-s signame | -tanda | -signame] { trabaho | pid | pgrp } ...
Ipadala ang tinukoy na signal sa mga tinukoy na trabaho, mga process ID, o mga grupo ng proseso. Kung
walang signal na tinukoy, ang TERM signal ay ipinadala. Kung ang isang trabaho ay tinukoy, ang signal
ay ipinadala sa pangkat ng proseso ng trabaho. Tingnan mo Trabaho kontrol sa ibaba para sa format ng trabaho.

pumatay -l [exit-status ...]
I-print ang pangalan ng signal na naaayon sa exit-status. Kung walang tinukoy na argumento, a
Ang listahan ng lahat ng mga signal, ang kanilang mga numero, at isang maikling paglalarawan ng mga ito ay naka-print.

pabayaan [pagpapahayag ...]
Ang bawat expression ay sinusuri (tingnan Pang-aritmetika mga expression sa itaas). Kung lahat ng expression
ay matagumpay na nasuri, ang exit status ay 0 (1) kung ang huling expression ay nasuri
sa di-zero (zero). Kung may naganap na error sa panahon ng pag-parse o pagsusuri ng isang
expression, ang exit status ay higit sa 1. Dahil ang mga expression ay maaaring kailanganin
sinipi, (( ipahayag )) ay syntactic sugar para sa { let 'ipahayag'; }.

hayaan] Panloob na ginagamit na alyas para sa pabayaan.

mknod [-m paraan] pangalan b|c pangunahing minor
mknod [-m paraan] pangalan p
Gumawa ng espesyal na file ng device. Ang uri ng file ay maaaring b (block type device), c
(character type device), o p (pinangalanang tubo, FIFO). Maaaring mabago ang file na nilikha
ayon nito paraan (sa pamamagitan ng -m opsyon), pangunahing (pangunahing numero ng device), at minor
(minor device number). Ito ay hindi karaniwang bahagi ng Salamat; gayunpaman, ang mga distributor ay maaaring
idinagdag ito bilang builtin bilang isang speed hack.

i-print [-nprsu[n] | -R [-en]] [argumento ...]
i-print nagpi-print ng mga argumento nito sa karaniwang output, na pinaghihiwalay ng mga puwang at tinapos
na may bagong linya. Ang -n pinipigilan ng opsyon ang bagong linya. Bilang default, lumalabas ang ilang partikular na C
ay isinalin. Kabilang dito ang mga nabanggit sa backslash paglawak sa itaas, pati na rin
bilang '\c', na katumbas ng paggamit ng -n opsyon. Ang pagpapalawak ng backslash ay maaaring
inhibited sa -r pagpipilian Ang -s ang opsyon ay nagpi-print sa history file sa halip na
karaniwang output; ang -u opsyon na naka-print sa file descriptor n (n default sa 1 kung
tinanggal); at ang -p ang opsyon ay naka-print sa co-process (tingnan Mga co-process sa itaas).

Ang -R ang opsyon ay ginagamit upang tularan, sa ilang antas, ang BSD miss(1) utos na ginagawa
hindi nagpoproseso ng mga '\' sequence maliban kung ang -e ang pagpipilian ay ibinigay. Gaya ng nasa itaas, ang -n opsyon
pinipigilan ang sumusunod na bagong linya.

printf format [argumento ...]
Naka-format na output. Tinatayang pareho sa printf(1), utility, maliban kung ginagamit nito
pareho backslash paglawak at I/O code at hindi humahawak ng floating point bilang ang
pahinga ng Salamat. Ang isang panlabas na utility ay ginustong kaysa sa builtin. Hindi ito
karaniwang bahagi ng Salamat; gayunpaman, maaaring idinagdag ito ng mga distributor bilang builtin bilang a
bilis hack. Huwag gumamit sa bagong code.

pwd [-LP]
I-print ang kasalukuyang gumaganang direktoryo. Kung ang -L opsyon ang ginagamit o kung ang Physical
ang opsyon ay hindi nakatakda (tingnan ang itakda command sa ibaba), ang lohikal na landas ay naka-print (ibig sabihin ang
daan noon cd sa kasalukuyang direktoryo). Kung ang -P opsyon (pisikal na landas) ang ginagamit
o kung ang Physical ang opsyon ay nakatakda, ang landas na tinutukoy mula sa filesystem (sa pamamagitan ng
sumusunod na '..' na mga direktoryo sa root directory) ay naka-print.

basahin [-A | -a] [-d x] [-N z | -n z] [-p | -u[n]] [-t n] [-rs] [p ...]
Nagbabasa ng isang linya ng input, naghihiwalay sa input sa mga field gamit ang IFS parameter (tingnan
Paghalili sa itaas), at itinalaga ang bawat field sa tinukoy na mga parameter p. Kung hindi
ang mga parameter ay tinukoy, ang REPLY parameter ay ginagamit upang iimbak ang resulta. Kasama ang
-A at -a mga opsyon, wala o isang parameter lang ang tinatanggap. Kung meron pa
mga parameter kaysa sa mga patlang, ang mga karagdagang parameter ay nakatakda sa walang laman na string o 0; kung
mayroong higit pang mga patlang kaysa sa mga parameter, ang huling parameter ay itinalaga ang natitira
mga patlang (kabilang ang mga salitang separator).

Ang mga pagpipilian ay ang mga sumusunod:

-A Itabi ang resulta sa parameter p (o REPLY) bilang hanay ng mga salita.

-a I-imbak ang resulta nang walang paghahati ng salita sa parameter p (o REPLY) bilang
hanay ng mga character (malawak na mga character kung ang utf8-mode ang pagpipilian ay pinagtibay,
octets kung hindi man); ang mga codepoint ay naka-encode bilang mga decimal na numero bilang default.

-d x Gamitin ang unang byte ng x, NUL kung walang laman, sa halip na ASCII newline na character
bilang input line delimiter.

-N z Sa halip na magbasa hanggang sa dulo ng linya, basahin nang eksakto z byte. Kung EOF o a
Ang pag-timeout ay nangyayari, ang isang bahagyang nabasa ay ibinalik na may exit status 1.

-n z Sa halip na magbasa hanggang sa dulo ng linya, basahin hanggang sa z bytes ngunit bumalik sa lalong madaling panahon
anumang byte ang binabasa, hal. mula sa isang mabagal na terminal device, o kung EOF o isang timeout
nangyayari.

-p Basahin mula sa kasalukuyang aktibong co-process, tingnan Mga co-process sa itaas para sa mga detalye
sa ito.

-u[n] Basahin mula sa file descriptor n (default sa 0, ibig sabihin, karaniwang input). Ang
dapat sundin kaagad ng argumento ang opsyon na karakter.

-t n Ihinto ang pagbabasa pagkatapos n segundo (tinukoy bilang positibong decimal na halaga na may isang
opsyonal na fractional na bahagi). Ang katayuan ng paglabas ng basahin ay 1 kung ang timeout
nangyari, ngunit ang mga bahagyang nabasa ay maaari pa ring ibalik.

-r Karaniwan, ang ASCII backslash na character ay tumatakas sa espesyal na kahulugan ng
sumusunod na character at tinanggal mula sa input; basahin hindi tumitigil kapag
nakakaranas ng backslash-newline sequence at hindi nag-iimbak sa newline na iyon
ang resulta. Ang opsyong ito ay nagbibigay-daan sa raw mode, kung saan ang mga backslashes ay hindi
naproseso

-s Ang input line ay naka-save sa history.

Kung ang input ay isang terminal, pareho ang -N at -n mga pagpipilian itakda ito sa raw mode; sila
basahin ang isang buong file kung ang -1 ay naipasa bilang z argumento.

Ang unang parameter ay maaaring may tandang pananong at may nakadugtong na string dito, kung saan
kaso ang string ay ginamit bilang isang prompt (naka-print sa karaniwang error bago ang anumang input ay
basahin) kung ang input ay a tty(4) (hal basahin nfoo?'number of foos: ').

Kung walang nabasang input o nagkaroon ng timeout, basahin paglabas na may hindi zero na katayuan.

Isa pang madaling gamiting hanay ng mga trick: Kung basahin ay tumatakbo sa isang loop tulad ng habang basahin foo; do ...;
tapos pagkatapos ay aalisin ang nangungunang whitespace (IFS) at mapoproseso ang mga backslashes. Ikaw
baka gustong gamitin habang IFS= basahin -r foo; do ...; tapos para sa malinis na I/O. Katulad nito,
kapag ginagamit ang -a opsyon, paggamit ng -r ang pagpipilian ay maaaring maging maingat; ang parehong naaangkop
para sa:

hanapin ang . -type f -print0 |& \
habang ang IFS= read -d '' -pr filename; gawin
print -r -- "nahanap <${filename#./}>"
tapos

Ang panloob na loop ay isasagawa sa isang subshell at ang mga variable na pagbabago ay hindi maaaring
pinapalaganap kung naisakatuparan sa isang pipeline:

bar | baz | habang nagbabasa ng foo; gawin ...; tapos na

Gumamit na lang ng mga co-process:

bar | baz |&
habang binabasa -p foo; gawin ...; tapos na
exec 3>&p; exec 3>&-

Basahin lamang [-p] [parametro [=halaga] ...]
Itinatakda ang read-only na katangian ng mga pinangalanang parameter. Kung ang mga halaga ay ibinigay,
ang mga parameter ay itinakda sa kanila bago itakda ang katangian. Kapag ang isang parameter ay ginawa
read-only, hindi ito maaaring i-unset at hindi mababago ang value nito.

Kung walang mga parameter na tinukoy, ang mga pangalan ng lahat ng mga parameter na may read-only
ang attribute ay naka-print ng isa sa bawat linya, maliban kung ang -p ginagamit ang opsyon, kung saan
Basahin lamang ang mga command na tumutukoy sa lahat ng read-only na parameter, kasama ang kanilang mga value, ay
nakalimbag

realpath [--] pangalan
Ini-print ang nalutas na absolute pathname na naaayon sa pangalan. Kung pangalan nagtatapos sa a
slash ('/'), sinusuri din ito para sa pagkakaroon at kung ito ay isang direktoryo;
kung hindi man, realpath nagbabalik ng 0 kung ang pathname ay umiiral o maaaring malikha
kaagad, ibig sabihin, lahat maliban sa huling bahagi ay umiiral at mga direktoryo.

palitan ang pangalan [--] mula sa
Pinapalitan ang pangalan ng file mula sa sa. Pareho dapat ay kumpletong mga pathname at sa parehong device.
Ang builtin na ito ay inilaan para sa mga emergency na sitwasyon kung saan /bin/mv nagiging hindi magamit, at
direktang tumatawag palitan ang pangalanNa (2).

pagbabalik [katayuan]
Nagbabalik mula sa isang function o . script, na may exit status katayuan. Kung hindi katayuan ay ibinigay,
ang exit status ng huling executed command ay ginagamit. Kung ginagamit sa labas ng isang function
or . script, ito ay may parehong epekto bilang lumabas. Tandaan na Salamat tinatrato ang parehong profile at
ENV file bilang . script, habang tinatrato lang ng orihinal na shell ng Korn ang mga profile bilang .
script.

itakda [+-abCefhiklmnprsUuvXx] [+-o opsyon] [+-A pangalan] [--] [arg ...]
Ang itakda maaaring gamitin ang utos upang itakda ang (-) o malinaw (+) mga pagpipilian sa shell, itakda ang positional
mga parameter, o magtakda ng array parameter. Maaaring baguhin ang mga opsyon gamit ang +-o opsyon
syntax, kung saan opsyon ay ang mahabang pangalan ng isang opsyon, o gamit ang +-sulat syntax,
saan sulat ay ang pangalan ng solong titik ng opsyon (hindi lahat ng opsyon ay may iisang titik
pangalan). Ang sumusunod na talahanayan ay naglilista ng parehong opsyon na mga titik (kung mayroon sila) at mahabang pangalan
kasama ng isang paglalarawan kung ano ang ginagawa ng opsyon:

-A pangalan
Itinatakda ang mga elemento ng array parameter pangalan sa arg ... If -A ginagamit, ang
array ay i-reset (ibig sabihin, walang laman) muna; kung +A ay ginagamit, ang unang N elemento ay nakatakda
(kung saan ang N ay ang bilang ng mga argumento); ang natitira ay hindi nagalaw.

Isang alternatibong syntax para sa utos itakda -A foo -- a b c na katugma sa
GNU malakas na palo at sinusuportahan din ng AT&T UNIX ksh93 ay: foo=(a b c); foo+=(d e)

-a | -o allexport
Lahat ng bagong parameter ay ginawa gamit ang export attribute.

-b | -o ipagbigay-alam
Mag-print ng mga mensahe ng abiso sa trabaho nang asynchronous, sa halip na bago ang
prompt. Ginagamit lamang kung ang kontrol sa trabaho ay pinagana (-m).

-C | -o noclobber
Pigilan ang > pag-redirect mula sa pag-overwrite ng mga kasalukuyang file. Sa halip, >| dapat gamitin
upang pilitin ang isang overwrite. Tandaan na hindi ito ligtas na gamitin para sa paggawa ng
pansamantalang mga file o lockfile dahil sa isang TOCTOU sa isang tseke na nagpapahintulot sa isa na mag-redirect
output sa / dev / null o iba pang mga file ng device kahit na sa noclobber mode.

-e | -o errexit
Lumabas (pagkatapos isagawa ang ERR trap) sa sandaling magkaroon ng error o isang command
nabigo (ibig sabihin, paglabas na may hindi zero na katayuan). Hindi ito nalalapat sa mga utos
na ang exit status ay tahasang sinusuri ng isang shell construct gaya ng if, hanggang,
habang, O ! mga pahayag. Para sa && o ||, ang status lang ng huling command ay
nasubukan

-f | -o noglob
Huwag palawakin ang mga pattern ng pangalan ng file.

-h | -o trackall
Lumikha ng mga sinusubaybayang alias para sa lahat ng naisakatuparan na mga utos (tingnan Aliases sa itaas). Pinagana
bilang default para sa mga non-interactive na shell.

-i | -o interactive
Ang shell ay isang interactive na shell. Ang pagpipiliang ito ay magagamit lamang kapag ang shell
ay hinihingi. Tingnan sa itaas para sa isang paglalarawan kung ano ang ibig sabihin nito.

-k | -o keyword
Ang mga pagtatalaga ng parameter ay kinikilala kahit saan sa isang command.

-l | -o login
Ang shell ay isang login shell. Magagamit lang ang opsyong ito kapag ang shell ay
hinihingi. Tingnan sa itaas para sa isang paglalarawan kung ano ang ibig sabihin nito.

-m | -o monitor
Paganahin ang kontrol sa trabaho (default para sa mga interactive na shell).

-n | -o noexec
Huwag magsagawa ng anumang mga utos. Kapaki-pakinabang para sa pagsuri sa syntax ng mga script (hindi pinansin
kung interactive).

-p | -o may pribilehiyo
Ang shell ay isang privileged shell. Ito ay awtomatikong itinakda kung, kapag ang shell
magsisimula, ang totoong UID o GID ay hindi tumutugma sa epektibong UID (EUID) o GID
(EGID), ayon sa pagkakabanggit. Tingnan sa itaas para sa isang paglalarawan kung ano ang ibig sabihin nito.

-r | -o pinaghihigpitan
Ang shell ay isang restricted shell. Magagamit lang ang opsyong ito kapag ang shell ay
hinihingi. Tingnan sa itaas para sa isang paglalarawan kung ano ang ibig sabihin nito.

-s | -o si stdin
Kung ginamit kapag na-invoke ang shell, binabasa ang mga command mula sa karaniwang input. Itakda
awtomatikong kung ang shell ay hinihingi nang walang mga argumento.

Kailan -s ay ginagamit sa itakda utos na nagiging sanhi ito ng mga tinukoy na argumento
pinagsunod-sunod bago italaga ang mga ito sa mga positional na parameter (o sa array pangalan, Kung
-A Ginagamit).

-U | -o utf8-mode
Paganahin ang suporta ng UTF-8 sa Emacs pag-edit paraan at panloob na paghawak ng string
mga function. Ang flag na ito ay hindi pinagana bilang default, ngunit maaaring paganahin sa pamamagitan ng pagtatakda nito
sa shell command line; ay awtomatikong pinagana para sa mga interactive na shell kung
hiniling sa oras ng pag-compile, sinusuportahan ng iyong system setlocale(LC_CTYPE, "") At
opsyonal nl_langinfo(CODESET), o ang LC_ALL, LC_CTYPE, o LANG na kapaligiran
mga variable, at kahit isa sa mga ito ay nagbabalik ng isang bagay na tumutugma sa "UTF-8" o
"utf8" na case-insensitively; para sa mga direktang builtin na tawag depende sa
nabanggit na mga variable ng kapaligiran; o para sa stdin o mga script, kung ang input
nagsisimula sa isang UTF-8 Byte Order Mark.

Sa malapit na hinaharap, ang pagsubaybay sa lokal ay ipapatupad, na nangangahulugang iyon itakda -+U is
nagbabago sa tuwing nagbabago ang isa sa mga variable ng kapaligiran na nauugnay sa lokal na POSIX.

-u | -o nounset
Ang pagtukoy sa isang hindi nakatakdang parameter, maliban sa "$@" o "$*", ay itinuturing bilang isang
error, maliban kung ang isa sa mga modifier na '-', '+', o '=' ay ginamit.

-v | -o pandiwang
Isulat ang input ng shell sa karaniwang error habang binabasa ito.

-X | -o markdirs
Markahan ang mga direktoryo na may sumusunod na '/' sa panahon ng pagbuo ng pangalan ng file.

-x | -o xtrace
Mag-print ng mga command tree kapag naisakatuparan ang mga ito, na nauunahan ng halaga ng PS4.

-o bgnice
Ang mga trabaho sa background ay pinapatakbo nang may mas mababang priyoridad.

-o braceexpand
I-enable ang pagpapalawak ng brace (aka alternation). Ito ay pinagana bilang default. Kung
hindi pinagana, ang pagpapalawak ng tilde pagkatapos ng equals sign ay hindi pinagana bilang side effect.

-o emacs
I-enable ang BRL emacs-like command-line editing (interactive shells lang); tingnan mo Emacs
pag-edit paraan.

-o gmacs
I-enable ang pag-edit ng command-line na tulad ng gmacs (mga interactive na shell lang). Kasalukuyan
kapareho sa pag-edit ng emacs maliban na ang transpose-chars (^T) ay bahagyang kumikilos
naiiba.

-o hindi pinansin
Ang shell ay hindi (madaling) lalabas kapag nabasa ang end-of-file; lumabas dapat gamitin.
Upang maiwasan ang walang katapusang mga loop, lalabas ang shell kung babasahin ang EOF nang 13 beses nang sunud-sunod.

-o magmana-xtrace
Huwag i-reset -o xtrace sa pagpasok ng mga function. Ito ay pinagana bilang default.

-o nohup
Huwag patayin ang mga tumatakbong trabaho gamit ang isang SIGHUP signal kapag lumabas ang isang login shell.
Kasalukuyang itinakda bilang default, ngunit maaari itong magbago sa hinaharap upang maging tugma
kasama ang AT&T UNIX ksh, na walang ganitong opsyon, ngunit nagpapadala ng SIGHUP
signal.

-o nolog
Walang epekto. Sa orihinal na shell ng Korn, pinipigilan nito ang mga kahulugan ng function mula sa
iniimbak sa history file.

-o Physical
Nagdudulot ng cd at pwd mga utos na gumamit ng "pisikal" (ibig sabihin, ang filesystem's) '..'
mga direktoryo sa halip na "lohikal" na mga direktoryo (ibig sabihin, pinangangasiwaan ng shell ang '..', na
nagbibigay-daan sa gumagamit na hindi makakalimutan ang mga simbolikong link sa mga direktoryo). I-clear ng
default. Tandaan na ang pagtatakda ng opsyong ito ay hindi makakaapekto sa kasalukuyang halaga ng
Parameter ng PWD; tanging ang cd utos ay nagbabago ng PWD. Tingnan ang cd at pwd utos
sa itaas para sa higit pang mga detalye.

-o pipefail
Gawin ang exit status ng isang pipeline (bago lohikal na umakma) ang
pinakakanan na hindi zero na antas ng error, o zero kung ang lahat ng mga utos ay lumabas na may zero.

-o posix
Kumilos nang mas malapit sa mga pamantayan (tingnan POSIX paraan para sa mga detalye). Awtomatikong
pinagana kung ang basename ng shell invocation ay nagsisimula sa "sh" at ito
Ang tampok na autodetection ay pinagsama-sama sa (hindi sa MirBSD). Bilang isang side effect, setting
naka-off ang watawat na ito braceexpand mode, na maaaring i-on muli nang manu-mano, at
sh mode (maliban kung parehong pinagana nang sabay).

-o sh
Paganahin / Bin / SH (kludge) mode (tingnan SH paraan). Awtomatikong pinagana kung ang
Ang basename ng shell invocation ay nagsisimula sa "sh" at ang autodetection na feature na ito
ay pinagsama-sama sa (hindi sa MirBSD). Bilang side effect, naka-off ang pagtatakda ng flag na ito
braceexpand mode, na maaaring i-on muli nang manu-mano, at posix mode (maliban kung
parehong pinagana sa parehong oras).

-o vi
Paganahin vi(1)-tulad ng pag-edit ng command-line (mga interactive na shell lamang). Tingnan mo Vi
pag-edit paraan para sa dokumentasyon at limitasyon.

-o vi-escomplete
Sa vi command-line editing, gawin ang command at file name completion kapag tumakas (^[)
ay ipinasok sa command mode.

-o vi-tabcomplete
Sa vi command-line editing, gawin ang command at file name completion kapag ang tab (^I) ay
ipinasok sa insert mode. Ito ang default.

-o viraw
Walang epekto. Sa orihinal na shell ng Korn, maliban kung viraw ay itinakda, ang vi command-
line mode ay hayaan ang tty(4) gawin ng driver ang trabaho hanggang sa maipasok ang ESC (^[).
Salamat ay palaging nasa viraw mode.

Ang mga opsyon na ito ay maaari ding gamitin sa invocation ng shell. Ang kasalukuyang hanay ng
Ang mga pagpipilian (na may mga pangalan ng isang titik) ay matatagpuan sa parameter na '$-'. itakda -o sa
walang pangalan ng opsyon ang maglilista ng lahat ng opsyon at kung naka-on o naka-off ang bawat isa; itakda +o habilin
i-print ang mahabang pangalan ng lahat ng opsyon na kasalukuyang naka-on. Sa hinaharap na bersyon, itakda
+o ay kikilos na sumusunod sa POSIX at mag-print ng mga command upang maibalik ang kasalukuyang mga opsyon
sa halip.

Ang mga natitirang argumento, kung mayroon man, ay mga positional na parameter at itinalaga, sa pagkakasunud-sunod, sa
ang mga positional na parameter (ibig sabihin $1, $2, atbp.). Kung ang mga opsyon ay nagtatapos sa '--' at doon
ay walang natitirang mga argumento, ang lahat ng mga positional na parameter ay na-clear. Kung walang mga pagpipilian o
ang mga argumento ay ibinigay, ang mga halaga ng lahat ng mga pangalan ay naka-print. Para sa hindi kilalang makasaysayang
mga dahilan, ang nag-iisang '-' na opsyon ay espesyal na tinatrato – nililinis nito pareho ang -v at -x
mga pagpipilian.

ilipat [numero]
Ang mga positional na parameter numero+ 1, numeroAng +2, atbp. ay pinalitan ng pangalan sa '1', '2', atbp.
numero default sa 1.

matulog segundo
Sinususpinde ang pagpapatupad para sa isang minimum ng segundo tinukoy bilang positibong halaga ng decimal
na may opsyonal na bahaging praksyonal. Ang paghahatid ng signal ay maaaring magpatuloy sa pagpapatupad nang mas maaga.

pinagmulan file [arg ...]
katulad . (“tuldok”), maliban na ang kasalukuyang gumaganang direktoryo ay nakadugtong sa paghahanap
landas (GNU malakas na palo extension).

suspindihin
Pinipigilan ang shell na parang natanggap nito ang suspendido na karakter mula sa terminal. Ito ay
hindi posibleng suspindihin ang isang login shell maliban kung ang proseso ng magulang ay miyembro ng
parehong terminal session ngunit miyembro ito ng ibang grupo ng proseso. Bilang isang heneral
panuntunan, kung ang shell ay sinimulan ng isa pang shell o sa pamamagitan ng su(1), maaari itong masuspinde.

pagsusulit pagpapahayag
[ pagpapahayag ]
pagsusulit sinusuri ang pagpapahayag at nagbabalik ng zero status kung true, 1 kung false, o mas mataas
kaysa sa 1 kung may error. Ito ay karaniwang ginagamit bilang utos ng kondisyon ng if at
habang mga pahayag. Ang mga simbolikong link ay sinusunod para sa lahat file mga ekspresyon maliban sa -h at
-L.

Ang mga sumusunod na pangunahing expression ay magagamit:

-a file file umiiral.

-b file file ay isang block na espesyal na aparato.

-c file file ay isang espesyal na aparato ng character.

-d file file ay isang direktoryo.

-e file file umiiral.

-f file file ay isang regular na file.

-G file fileAng pangkat ni ay ang epektibong ID ng grupo ng shell.

-g file fileAng mode ni ay may setgid bit set.

-H file file ay isang direktoryo na nakasalalay sa konteksto (kapaki-pakinabang lamang sa HP-UX).

-h file file ay isang simbolikong link.

-k file fileAng mode ni ay may malagkit(8) bit set.

-L file file ay isang simbolikong link.

-O file fileAng may-ari ay ang epektibong user ID ng shell.

-o opsyon Talukap ng alimango opsyon ay nakatakda (tingnan ang itakda utos sa itaas para sa isang listahan ng
mga pagpipilian). Bilang isang hindi karaniwang extension, kung magsisimula ang opsyon sa
a '!', ang pagsubok ay tinanggihan; laging bagsak ang pagsubok kung opsyon
ay hindi umiiral (kaya ang [ -o foo -o -o !foo ] ay nagbabalik ng totoo kung at lamang
kung opsyon foo umiiral). Ang parehong ay maaaring makamit sa [ -o ?foo]
tulad ng sa AT&T UNIX ksh93. opsyon maaari ding ang maikling bandila na pinamumunuan ni
alinman sa '-' o '+' (walang lohikal na negation), halimbawa '-x' o '+x'
sa halip na 'xtrace'.

-p file file ay isang pinangalanang tubo (FIFO).

-r file file umiiral at nababasa.

-S file file ay isang Unix(4)-domain socket.

-s file file ay walang laman.

-t fd Deskriptor ng file fd ay isang tty(4) aparato.

-u file fileAng 's mode ay may set ng setuid bit.

-w file file umiiral at nasusulat.

-x file file umiiral at maipapatupad.

file1 -nt file2 file1 ay mas bago kaysa sa file2 or file1 umiiral at file2 ay hindi.

file1 -hindi na file2 file1 ay mas matanda kaysa sa file2 or file2 umiiral at file1 ay hindi.

file1 -kung file2 file1 ay ang parehong file bilang file2.

pisi pisi ay may di-zero na haba.

-n pisi pisi ay walang laman.

-z pisi pisi walang laman.

pisi = pisi Ang mga string ay pantay-pantay.

pisi == pisi Ang mga string ay pantay-pantay.

pisi > pisi Ang unang string operand ay mas malaki kaysa sa pangalawang string operand.

pisi < pisi Ang unang string operand ay mas mababa kaysa sa pangalawang string operand.

pisi != pisi Ang mga string ay hindi pantay.

numero -eq numero Ang mga numero ay naghahambing ng pantay.

numero - ay numero Hindi pantay ang paghahambing ng mga numero.

numero -ge numero Ang mga numero ay naghahambing ng higit sa o katumbas.

numero -gt numero Ang mga numero ay naghahambing ng mas malaki kaysa sa.

numero -ang numero Ang mga numero ay naghahambing ng mas mababa sa o katumbas.

numero -lt numero Ang mga numero ay naghahambing ng mas mababa sa.

Ang mga pangunahing expression sa itaas, kung saan ang mga unary operator ay nangunguna sa binary
operator, ay maaaring isama sa mga sumusunod na operator (nakalista sa tumataas na pagkakasunud-sunod
nangunguna):

expr -o expr Lohikal O.
expr -a expr Lohikal AT.
! expr Logical HINDI.
( expr ) Pagpapangkat.

Tandaan na ang isang numero ay maaaring isang arithmetic expression, tulad ng isang mathematical
termino o ang pangalan ng isang integer variable:

x=1; Ang [ "x" -eq 1 ] ay nagsusuri sa totoo

Tandaan na ang ilang espesyal na panuntunan ay inilapat (kagandahang-loob ng POSIX) kung ang bilang ng
mga argumento sa pagsusulit o sa loob ng mga bracket [ ... ] ay mas mababa sa lima: kung nangunguna '!'
maaaring tanggalin ang mga argumento na isa hanggang tatlong argumento na lang ang natitira, pagkatapos ay ang
ang pinababang paghahambing ay naisakatuparan; (salamat sa XSI) panaklong \( ... \) ibabang apat- at
tatlong-argumentong anyo sa dalawa- at isang-argumentong anyo, ayon sa pagkakabanggit; tatlong-argumento
Sa huli, mas gusto ng mga form ang mga binary operation, na sinusundan ng negation at parenthesis
pagpapababa; ang dalawa- at apat na-argumentong anyo ay mas gusto ang negasyon na sinusundan ng panaklong; ang
palaging ipinahihiwatig ng one-argument form -n.

nota: Ang isang karaniwang pagkakamali ay ang paggamit ng “if [ $foo = bar ]” na nabigo kung ang parameter na “foo”
ay NULL o hindi nakatakda, kung ito ay may mga naka-embed na espasyo (ibig sabihin, IFS octets), o kung ito ay unary
operator tulad ng '!' o '-n'. Gumamit ng mga pagsubok tulad ng “if [ x"$foo" = x"bar" ]” sa halip, o ang
operator ng double-bracket “kung [[ $foo = bar ]]” o, upang maiwasan ang pagtutugma ng pattern (tingnan [[
sa itaas): “kung [[ $foo = "$bar" ]]”

Ang [[ ... ]] construct ay hindi lamang mas ligtas na gamitin ngunit madalas din na mas mabilis.

oras [-p] [padaanin sa tubo]
Kung ang isang padaanin sa tubo ay ibinigay, ang mga oras na ginamit upang isagawa ang pipeline ay iniulat. Kung hindi
ibinibigay ang pipeline, pagkatapos ay ang oras ng user at system na ginagamit ng shell mismo, at lahat
ang mga utos na pinatakbo nito mula noong ito ay sinimulan, ay iniulat. Ang mga oras na iniulat ay
ang totoong oras (lumipas na oras mula simula hanggang matapos), ang oras ng CPU ng gumagamit (oras na ginugol
tumatakbo sa user mode), at ang oras ng CPU ng system (oras na ginugol sa pagtakbo sa kernel mode).
Ang mga oras ay iniuulat sa karaniwang error; ang format ng output ay:

0m0.00s totoong 0m0.00s user 0m0.00s system

Kung ang -p ang pagpipilian ay binibigyan ang output ay bahagyang mas mahaba:

totoong 0.00
gumagamit 0.00
sys 0.00

Ito ay isang error upang tukuyin ang -p opsyon maliban kung padaanin sa tubo ay isang simpleng utos.

Ang mga simpleng pag-redirect ng karaniwang error ay hindi nakakaapekto sa output ng oras utos:

$time sleep 1 2>afile
$ { oras ng pagtulog 1; } 2>afile

Ang mga oras para sa unang utos ay hindi pumupunta sa "afile", ngunit ang mga nasa pangalawang utos ay napupunta.

beses I-print ang naipon na user at mga oras ng system na ginamit ng shell at ng mga proseso
na nagsimula ang shell na lumabas na. Ang format ng output ay:

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

bitag n [senyas ...]
Kung ang unang operand ay isang decimal na unsigned integer, nire-reset nito ang lahat ng tinukoy na signal
sa default na aksyon, ibig sabihin ay kapareho ng pagtawag bitag na may minus sign ('-') bilang
Handler, na sinusundan ng mga argumento (n [senyas ...]), lahat ng ito ay itinuturing bilang
signal.

bitag [Handler senyas ...]
Nagtatakda ng trap handler na isasagawa kapag alinman sa tinukoy senyass ay
natanggap. Handler ay alinman sa isang walang laman na string, na nagpapahiwatig na ang mga signal ay dapat na
hindi pinansin, isang minus sign ('-'), na nagpapahiwatig na ang default na aksyon ay dapat gawin
ang mga senyales (tingnan senyas(3)), o isang string na naglalaman ng mga shell command na ipapatupad sa
ang unang pagkakataon (ibig sabihin kapag nakumpleto ang kasalukuyang command, o bago ang pag-print
ang susunod na PS1 prompt) pagkatapos matanggap ang isa sa mga signal. senyas ay ang pangalan ng a
signal (hal. PIPE o ALRM) o ang numero ng signal (tingnan ang pumatay -l utos
sa itaas).

Mayroong dalawang espesyal na signal: EXIT (kilala rin bilang 0), na isinasagawa kapag ang
malapit nang lumabas ang shell, at ang ERR, na isasagawa pagkatapos magkaroon ng error; isang error ay
isang bagay na magiging sanhi ng paglabas ng shell kung ang itakda -e or itakda -o errexit opsyon
ay itinakda. Ang mga EXIT handler ay isinasagawa sa kapaligiran ng huling naisakatuparan
utos.

Tandaan na, para sa mga non-interactive na shell, hindi mababago ang trap handler para sa mga signal
na hindi pinansin nang magsimula ang shell.

Nang walang mga argumento, ang kasalukuyang estado ng mga bitag na itinakda mula noong shell
ang nagsimula ay ipinapakita bilang isang serye ng bitag mga utos. Tandaan na ang output ng bitag hindi maaari
ay kapaki-pakinabang na maihatid sa isa pang proseso (isang artifact ng katotohanan na ang mga bitag ay na-clear
kapag ginawa ang mga subprocess).

Ang DEBUG trap ng orihinal na shell ng Korn at ang paghawak ng ERR at EXIT traps in
mga function ay hindi pa ipinatupad.

totoo Isang utos na lumalabas na may zero na halaga.

global [[+-alpnrtUux] [-L[n]] [-R[n]] [-Z[n]] [-i[n]] | -f [-tux]] [pangalan [=halaga] ...]
typeset [[+-alpnrtUux] [-LRZ[n]] [-i[n]] | -f [-tux]] [pangalan [=halaga] ...]
Ipakita o itakda ang mga katangian ng parameter. Sa no pangalan mga argumento, mga katangian ng parameter
ay ipinapakita; kung walang mga opsyon na ginagamit, ang kasalukuyang mga katangian ng lahat ng mga parameter ay
nakalimbag bilang typeset mga utos; kung ang isang opsyon ay ibinigay (o '-' na walang opsyon na titik),
ang lahat ng mga parameter at ang kanilang mga halaga na may tinukoy na mga katangian ay naka-print; kung mga pagpipilian
ay ipinakilala sa '+', ang mga halaga ng parameter ay hindi naka-print.

If pangalan ang mga argumento ay ibinigay, ang mga katangian ng pinangalanang mga parameter ay nakatakda (-) O
nalinis (+). Maaaring opsyonal na tukuyin ang mga halaga para sa mga parameter. Para sa pangalan[*], ang
Ang pagbabago ay nakakaapekto sa buong array, at walang halaga ang maaaring tukuyin.

If typeset ay ginagamit sa loob ng isang function, ang anumang mga parameter na tinukoy ay naisalokal. Ito
ay hindi ginagawa ng kung hindi man magkapareho global. nota: Ibig sabihin nito Salamat 's global
utos ay hindi katumbas ng iba pang mga programming language' dahil hindi nito pinapayagan ang a
function na tinatawag mula sa isa pang function upang ma-access ang isang parameter sa tunay na pandaigdigang saklaw,
ngunit pinipigilan lamang ang paglalagay ng isang na-access sa lokal na saklaw.

Kailan -f Ginagamit, typeset gumagana sa mga katangian ng mga function. Tulad ng sa
mga parameter, kung hindi pangalan ang mga argumento ay ibinigay, ang mga function ay nakalista kasama ang kanilang mga halaga
(ibig sabihin, mga kahulugan) maliban kung ang mga opsyon ay ipinakilala sa '+', kung saan tanging ang
iniulat ang mga pangalan ng function.

-a Na-index na katangian ng array.

-f Function mode. Ipakita o itakda ang mga function at ang kanilang mga katangian, sa halip na
parameter.

-i[n] Integer na katangian. n tumutukoy sa base na gagamitin kapag ipinapakita ang integer
(kung hindi tinukoy, ang base na ibinigay sa unang takdang-aralin ay ginagamit).
Ang mga parameter na may ganitong katangian ay maaaring magtalaga ng mga halaga na naglalaman ng arithmetic
mga ekspresyon.

-L[n] Kaliwa justify attribute. n tumutukoy sa lapad ng field. Kung n ay hindi tinukoy,
ang kasalukuyang lapad ng isang parameter (o ang lapad ng unang itinalagang halaga nito)
Ginagamit. Nangungunang whitespace (at mga zero, kung ginamit kasama ng -Z opsyon) ay
hinubaran. Kung kinakailangan, ang mga halaga ay pinutol o pinutol ang espasyo upang magkasya
ang lapad ng field.

-l Lower case na katangian. Ang lahat ng upper case na character sa mga value ay kino-convert sa
maliit na titik. (Sa orihinal na shell ng Korn, ang parameter na ito ay nangangahulugang "mahabang integer"
kapag ginamit kasama ng -i opsyon.)

-n Gumawa ng nakatali na variable (reference ng pangalan): anumang access sa variable pangalan
ay maa-access ang variable halaga sa kasalukuyang saklaw (ito ay iba sa
AT&T UNIX ksh93!) sa halip. Iba rin sa AT&T UNIX ksh93 ay na
halaga ay tamad na sinusuri sa panahong iyon pangalan ay naa-access. Ito ay maaaring gamitin ng
function upang ma-access ang mga variable na ang mga pangalan ay ipinasa bilang mga parameter, sa halip
ng paggamit eval.

-p Kumpleto na ang pag-print typeset mga utos na maaaring magamit upang muling likhain ang mga katangian
at mga halaga ng mga parameter.

-R[n] Right justify attribute. n tumutukoy sa lapad ng field. Kung n Hindi
tinukoy, ang kasalukuyang lapad ng isang parameter (o ang lapad ng una nito
assigned value) ay ginagamit. Ang mga sumusunod na whitespace ay tinanggal. Kung kinakailangan,
ang mga value ay maaaring tinanggalan ng mga nangungunang character o space padded para gawin ang mga ito
magkasya sa lapad ng field.

-r Read-only attribute. Maaaring hindi italaga ang mga parameter na may ganitong katangian
o hindi nakatakda. Kapag naitakda na ang attribute na ito, hindi na ito maaaring i-off.

-t Katangian ng tag. Walang kahulugan sa shell; ibinigay para sa paggamit ng aplikasyon.

Para sa mga function, -t ay ang trace attribute. Kapag gumagana sa bakas
attribute ay naisakatuparan, ang xtrace (-x) ang opsyon sa shell ay pansamantalang nakabukas
sa.

-U Unsigned integer attribute. Ang mga integer ay naka-print bilang mga unsigned value (pagsamahin
sa -i opsyon). Ang opsyon na ito ay wala sa orihinal na shell ng Korn.

-u Katangian ng upper case. Ang lahat ng lower case na character sa mga value ay kino-convert sa
upper case. (Sa orihinal na shell ng Korn, ang parameter na ito ay nangangahulugang "unsigned
integer” kapag ginamit kasama ng -i opsyon na nangangahulugang gagawin ng mga malalaking titik
hindi kailanman gagamitin para sa mga base na higit sa 10. Tingnan ang -U opsyon.)

Para sa mga function, -u ay ang hindi natukoy na katangian. Tingnan mo Pag-andar sa itaas para sa
implikasyon nito.

-x I-export ang attribute. Ang mga parameter (o function) ay inilalagay sa kapaligiran ng
anumang naisagawang utos. Ang mga na-export na function ay hindi pa ipinapatupad.

-Z[n] Zero fill na katangian. Kung hindi pinagsama sa -L, ito ay kapareho ng -R, maliban
zero padding ang ginagamit sa halip na space padding. Para sa mga integer, ang numero
sa halip na ang base ay may palaman.

Kung mayroon man sa -i, -L, -l, -R, -U, -u, O -Z binago ang mga opsyon, lahat ng iba pa mula rito
na-clear ang set, maliban kung ibinigay din ang mga ito sa parehong command line.

limitasyon [-aBCcdefHilMmnOPpqrSsTtVvw] [halaga]
Ipakita o itakda ang mga limitasyon sa proseso. Kung walang mga opsyon na ginagamit, ang limitasyon sa laki ng file (-f) ay
ipinapalagay. halaga, kung tinukoy, ay maaaring alinman sa isang aritmetika na expression o ang salita
"walang limitasyon". Ang mga limitasyon ay nakakaapekto sa shell at anumang mga proseso na nilikha ng shell
pagkatapos ng limitasyon ay ipataw. Tandaan na maaaring hindi pinapayagan ng ilang system na magkaroon ng mga limitasyon
nadagdagan kapag naitakda na sila. Tandaan din na ang mga uri ng mga limitasyon na magagamit ay system
umaasa – ang ilang mga sistema ay mayroon lamang -f hangganan

-a Ipakita ang lahat ng mga limitasyon; maliban kung -H ay ginagamit, ang mga soft limit ay ipinapakita.

-B n Itakda ang laki ng socket buffer sa n kibibibytes.

-C n Itakda ang bilang ng mga naka-cache na thread sa n.

-c n Maglagay ng limitasyon sa laki ng n mga bloke sa laki ng mga core dump.

-d n Maglagay ng limitasyon sa laki ng n kibibytes sa laki ng lugar ng data.

-e n Itakda ang maximum na kagandahan sa n.

-f n Maglagay ng limitasyon sa laki ng n mga bloke sa mga file na isinulat ng shell at ng anak nito
mga proseso (maaaring basahin ang mga file ng anumang laki).

-H Itakda lamang ang hard limit (ang default ay ang magtakda ng parehong hard at soft limit).

-i n Itakda ang bilang ng mga nakabinbing signal sa n.

-l n Maglagay ng limitasyon ng n kibibytes sa dami ng naka-lock (wired) na pisikal na memorya.

-M n Itakda ang naka-lock na memorya ng AIO sa n kibibibytes.

-m n Maglagay ng limitasyon ng n kibibytes sa dami ng pisikal na memorya na ginamit.

-n n Maglagay ng limitasyon ng n mga deskriptor ng file na maaaring buksan nang sabay-sabay.

-O n Itakda ang bilang ng mga pagpapatakbo ng AIO sa n.

-P n Limitahan ang bilang ng mga thread sa bawat proseso sa n.

-p n Maglagay ng limitasyon ng n mga proseso na maaaring patakbuhin ng user sa anumang oras.

-q n Limitahan ang laki ng POSIX message queue sa n byte.

-r n Itakda ang maximum na real-time na priyoridad sa n.

-S Itakda lamang ang soft limit (ang default ay ang magtakda ng parehong hard at soft limit).

-s n Maglagay ng limitasyon sa laki ng n kibibytes sa laki ng stack area.

-T n Maglagay ng limitasyon sa oras ng n totoong segundo na gagamitin ng bawat proseso.

-t n Maglagay ng limitasyon sa oras ng n Mga segundo ng CPU na ginugol sa user mode na gagamitin ng bawat isa
proseso.

-V n Itakda ang bilang ng mga vnode monitor sa Haiku sa n.

-v n Maglagay ng limitasyon ng n kibibytes sa dami ng virtual memory (address space)
ginagamit.

-w n Maglagay ng limitasyon ng n kibibytes sa dami ng swap space na ginamit.

Hangga't limitasyon ay nababahala, ang isang bloke ay 512 bytes.

umask [-S] [mask]
Ipakita o itakda ang mask sa paggawa ng pahintulot ng file, o umask (tingnan ang umask(2)). Kung ang -S
ang opsyon ay ginagamit, ang mask na ipinapakita o itinakda ay simboliko; kung hindi, ito ay isang octal
numero.

Ang mga simbolikong maskara ay katulad ng mga ginamit ni chmod(1). Kapag ginamit, inilalarawan nila kung ano
maaaring magamit ang mga pahintulot (kumpara sa mga octal mask kung saan nangangahulugan ang isang set bit
ang kaukulang bit ay dapat i-clear). Halimbawa, itinatakda ng “ug=rwx,o=” ang mask
ang mga file ay hindi mababasa, maisusulat, o maipapatupad ng "iba", at katumbas ito
(sa karamihan ng mga system) sa octal mask na "007".

Unalias [-adt] [pangalan ...]
Ang mga alias para sa mga ibinigay na pangalan ay tinanggal. Kung ang -a ginagamit ang opsyon, lahat ng alias
ay tinanggal. Kung ang -t or -d ang mga opsyon ay ginagamit, ang ipinahiwatig na mga operasyon ay isinasagawa
out sa mga sinusubaybayan o mga alias sa direktoryo, ayon sa pagkakabanggit.

i-unset [-fv] parametro ...
I-unset ang pinangalanang mga parameter (-v, ang default) o mga function (-f). Sa parametro[*],
pinapanatili ang mga katangian, ang mga halaga lamang ang hindi nakatakda.

Ang exit status ay non-zero kung alinman sa mga parameter ang may read-only na attribute
set, zero kung hindi man.

maghintay [trabaho ...]
Hintaying matapos ang tinukoy na (mga) trabaho. Ang katayuan ng paglabas ng maghintay ay iyon sa huli
tinukoy na trabaho; kung ang huling trabaho ay pinatay ng isang signal, ang exit status ay 128 + ang
bilang ng signal (tingnan pumatay -l exit-status sa itaas); kung ang huling tinukoy na trabaho ay hindi magagawa
matagpuan (dahil hindi ito umiral, o natapos na), ang katayuan sa paglabas ng maghintay
ay 127. Tingnan Trabaho kontrol sa ibaba para sa format ng trabaho. maghintay babalik kung may signal
kung saan ang isang bitag ay naitakda ay natanggap, o kung ang isang SIGHUP, SIGINT, o SIGQUIT signal
ay natanggap.

Kung walang tinukoy na mga trabaho, maghintay naghihintay para sa lahat ng kasalukuyang tumatakbong trabaho (kung mayroon man).
tapusin at lalabas na may zero status. Kung pinagana ang pagsubaybay sa trabaho, ang pagkumpleto
ang katayuan ng mga trabaho ay naka-print (hindi ito ang kaso kapag ang mga trabaho ay tahasang tinukoy).

saan [-pv] [pangalan ...]
Wala ang -v opsyon, ito ay kapareho ng utos -v, maliban sa mga alias ay hindi naka-print
bilang utos ng alias. Kasama ang -v opsyon, ito ay eksaktong kapareho ng utos -V. Sa
alinman sa kaso, ang -p iba ang opsyon: hindi apektado ang path ng paghahanap sa saan, Ngunit
ang paghahanap ay limitado sa landas.

Trabaho kontrol
Ang kontrol sa trabaho ay tumutukoy sa kakayahan ng shell na subaybayan at kontrolin ang mga trabaho na mga proseso o
mga pangkat ng mga prosesong nilikha para sa mga utos o pipeline. Sa pinakamababa, sinusubaybayan ng shell
ng katayuan ng background (ibig sabihin, asynchronous) na mga trabaho na kasalukuyang umiiral; ito
maaaring ipakita ang impormasyon gamit ang trabaho mga utos. Kung ang kontrol sa trabaho ay ganap na pinagana
(gamit itakda -m or itakda -o monitor), tulad ng para sa mga interactive na shell, ang mga proseso ng isang trabaho
ay inilalagay sa kanilang sariling pangkat ng proseso. Maaaring ihinto ang mga trabaho sa harapan sa pamamagitan ng pag-type ng suspendido
character mula sa terminal (karaniwang ^Z), ang mga trabaho ay maaaring i-restart sa alinman sa foreground o
background gamit ang fg at bg command, at ang estado ng terminal ay nai-save o naibalik
kapag ang isang foreground na trabaho ay itinigil o na-restart, ayon sa pagkakabanggit.

Tandaan na ang mga command lang na lumilikha ng mga proseso (hal. asynchronous commands, subshell
mga command, at non-built-in, non-function na command) ay maaaring ihinto; mga utos tulad ng basahin hindi maaari
maging.

Kapag ang isang trabaho ay nilikha, ito ay itinalaga ng isang numero ng trabaho. Para sa mga interactive na shell, ang numerong ito ay
naka-print sa loob ng “[..]”, na sinusundan ng mga process ID ng mga proseso sa trabaho kapag ang isang
Ang asynchronous na utos ay pinapatakbo. Maaaring tukuyin ang isang trabaho sa bg, fg, trabaho, pumatay, at maghintay
mga command alinman sa pamamagitan ng process ID ng huling proseso sa command pipeline (tulad ng nakaimbak sa
ang $! parameter) o sa pamamagitan ng paglalagay ng prefix sa numero ng trabaho na may tandang porsyento ('%'). Iba pang porsyento
Ang mga pagkakasunud-sunod ay maaari ding gamitin upang sumangguni sa mga trabaho:

%+ | %% | % Ang pinakahuling nahintong trabaho, o, kung walang mga nahintong trabaho, ang pinakamatanda
tumatakbong trabaho.

%- Ang trabaho na magiging %+ trabaho kung wala ang huli.

%n Ang trabaho na may numero ng trabaho n.

%?pisi Ang trabaho kasama ang utos nito na naglalaman ng string pisi (may error na nagaganap kung
maraming trabaho ang tumugma).

%pisi Ang trabaho kasama ang utos nito na nagsisimula sa string pisi (may error na nagaganap kung
maraming trabaho ang tumugma).

Kapag ang isang trabaho ay nagbago ng estado (hal. isang background na trabaho ay natapos o ang foreground na trabaho ay itinigil), ang
Ini-print ng shell ang sumusunod na impormasyon sa katayuan:

[numero] bandila katayuan utos

saan...

numero ay ang numero ng trabaho ng trabaho;

bandila ay ang karakter na '+' o '-' kung ang trabaho ay ang %+ or %- trabaho, ayon sa pagkakabanggit, o espasyo
kung hindi man;

katayuan ay nagpapahiwatig ng kasalukuyang estado ng trabaho at maaaring:

Tapos na [numero]
Ang trabaho ay umalis. numero ay ang exit status ng trabaho na tinanggal
kung ang katayuan ay zero.

Pagtakbo Ang trabaho ay hindi huminto o lumabas (tandaan na ang pagtakbo ay hindi
Nangangahulugan ito ng pag-ubos ng oras ng CPU – maaaring ma-block ang proseso
naghihintay ng ilang kaganapan).

Tumigil [senyas]
Ang trabaho ay itinigil ng ipinahiwatig senyas (kung walang signal na ibinigay, ang
ang trabaho ay pinahinto ng SIGTSTP).

signal-deskripsyon ["tinapon ang core"]
Ang trabaho ay pinatay ng isang senyas (hal memory fault, hangup); gamitin pumatay -l
para sa isang listahan ng mga paglalarawan ng signal. Ang "core dumped" na mensahe ay nagpapahiwatig
ang proseso ay lumikha ng isang pangunahing file.

utos ay ang utos na lumikha ng proseso. Kung mayroong maraming mga proseso sa
trabaho, ang bawat proseso ay magkakaroon ng linyang nagpapakita nito utos at posibleng nito katayuan, Kung
iba ito sa katayuan ng nakaraang proseso.

Kapag sinubukang lumabas sa shell habang may mga trabaho sa huminto na estado, ang
Binabalaan ng shell ang gumagamit na may mga tumigil na trabaho at hindi lalabas. Kung ang isa pang pagtatangka ay
agad na ginawa upang lumabas sa shell, ang mga natigil na trabaho ay pinadalhan ng SIGHUP signal at ang shell
labasan. Katulad nito, kung ang nohup ang opsyon ay hindi nakatakda at may mga tumatakbong trabaho kapag sinubukan
ay ginawa upang lumabas sa isang login shell, binabalaan ng shell ang user at hindi lalabas. Kung iba
Ang pagtatangka ay agad na ginawa upang lumabas sa shell, ang mga tumatakbong trabaho ay pinadalhan ng SIGHUP signal at
lumabas ang shell.

POSIX paraan
Pagpasok itakda -o posix mode ang magiging sanhi Salamat upang kumilos nang mas sumusunod sa POSIX sa mga lugar
kung saan naiiba ang mga default o opinyon. Tandaan na Salamat magpapatakbo pa rin ng hindi pinirmahan
32-bit na aritmetika; gamitin lksh kung arithmetics sa host mahaba uri ng data, kumpleto sa ISO C
Hindi Natukoy na Pag-uugali, ay kinakailangan; sumangguni sa lksh(1) manual page para sa mga detalye. Karamihan sa iba
makasaysayan, AT&T UNIX ksh-maaaring hindi paganahin ang mga katugma, o opinyon na pagkakaiba sa pamamagitan ng paggamit nito
mode; ito ay:

· Ang GNU malakas na palo Ako / O pag-redirect &>file ay hindi na suportado.

· Ang mga deskriptor ng file na ginawa ng mga pag-redirect ng I/O ay minana ng mga proseso ng bata.

· Ang mga numerong may nangungunang digit na zero ay binibigyang kahulugan bilang octal.

· Ang miss hindi binibigyang-kahulugan ng builtin ang mga backslashes at sinusuportahan lamang ang eksaktong opsyon "-n".

· ... (hindi kumpleto ang listahan at maaaring magbago para sa R53)

SH paraan
Mode ng pagiging tugma; nilayon para gamitin sa mga legacy na script na hindi madaling maayos; ang
ang mga pagbabago ay ang mga sumusunod:

· Ang GNU malakas na palo Ako / O pag-redirect &>file ay hindi na suportado.

· Ang mga deskriptor ng file na ginawa ng mga pag-redirect ng I/O ay minana ng mga proseso ng bata.

· Ang miss hindi binibigyang-kahulugan ng builtin ang mga backslashes at sinusuportahan lamang ang eksaktong opsyon "-n".

· ... (hindi kumpleto ang listahan at maaaring magbago para sa R53)

Interactive input linya pag-edit
Sinusuportahan ng shell ang tatlong mga mode ng pagbabasa ng mga command line mula sa a tty(4) sa isang interactive
session, na kinokontrol ng emacs, gmacs, at vi mga opsyon (sa karamihan sa mga ito ay maaaring itakda sa
isang beses). Ang default ay emacs. Ang mga mode ng pag-edit ay maaaring tahasang itakda gamit ang itakda built-in
Kung wala sa mga opsyong ito ang pinagana, binabasa lang ng shell ang mga linya gamit ang normal tty(4)
driver. Kung ang emacs or gmacs nakatakda ang opsyon, pinapayagan ng shell ang pag-edit na tulad ng emacs ng
utos; katulad, kung ang vi nakatakda ang opsyon, pinapayagan ng shell ang vi-like na pag-edit ng
utos. Ang mga mode na ito ay inilarawan nang detalyado sa mga sumusunod na seksyon.

Sa mga mode ng pag-edit na ito, kung ang isang linya ay mas mahaba kaysa sa lapad ng screen (tingnan ang COLUMNS
parameter), isang '>', '+', o '<' na character ay ipinapakita sa huling column na nagsasaad na
mayroong higit pang mga character pagkatapos, bago at pagkatapos, o bago ang kasalukuyang posisyon,
ayon sa pagkakabanggit. Ang linya ay ini-scroll nang pahalang kung kinakailangan.

Ang mga nakumpletong linya ay itinutulak sa kasaysayan, maliban kung magsisimula sila sa isang IFS octet o IFS
puting espasyo, o pareho sa nakaraang linya.

Emacs pag-edit paraan
Kapag ang emacs nakatakda ang opsyon, pinagana ang interactive na pag-edit ng linya ng input. Babala: Ang mode na ito
ay bahagyang naiiba sa emacs mode sa orihinal na shell ng Korn. Sa mode na ito, iba't-ibang
ang mga utos sa pag-edit (karaniwang nakatali sa isa o higit pang mga control character) ay nagdudulot ng mga agarang aksyon
nang hindi naghihintay ng bagong linya. Ang ilang mga utos sa pag-edit ay nakasalalay sa partikular na kontrol
mga character kapag ang shell ay tinatawag; maaaring baguhin ang mga binding na ito gamit ang magtali utos.

Ang sumusunod ay isang listahan ng magagamit na mga utos sa pag-edit. Ang bawat paglalarawan ay nagsisimula sa
pangalan ng utos, na may suffix na may tutuldok; isang [n] (kung ang utos ay maaaring lagyan ng prefix ng a
bilangin); at anumang mga key kung saan nakatali ang command bilang default, na isinulat gamit ang caret notation hal
ang ASCII ESC character ay nakasulat bilang ^[. Ang mga control sequence na ito ay hindi case sensitive.
Ang isang count prefix para sa isang command ay ipinasok gamit ang sequence ^[n, Kung saan n ay isang sequence ng 1
o higit pang mga digit. Maliban kung tinukoy, kung ang isang bilang ay tinanggal, ito ay magiging default sa 1.

Tandaan na ang pag-edit ng mga pangalan ng command ay ginagamit lamang sa magtali utos. Higit pa rito, marami
Ang mga utos sa pag-edit ay kapaki-pakinabang lamang sa mga terminal na may nakikitang cursor. Ang mga default na binding
ay pinili upang maging katulad ng kaukulang Emacs key bindings. Ang gumagamit tty(4) mga karakter
(hal. ERASE) ay nakasalalay sa mga makatwirang kapalit at i-override ang mga default na binding.

abort: ^C, ^G
I-abort ang kasalukuyang command, alisan ng laman ang line buffer at itakda ang exit state sa
nagambala.

auto-insert: [n]
Nagdudulot lang ng character na lumabas bilang literal na input. Karamihan sa mga ordinaryong character
ay nakatali dito.

backward-char: [n] ^B, ^XD, ANSI-CurLeft, PC-CurLeft
Inilipat ang cursor pabalik n character.

pabalik na salita: [n] ^[b, ANSI-Ctrl-CurLeft, ANSI-Alt-CurLeft
Inilipat ang cursor pabalik sa simula ng salita; mga salita ay binubuo ng
alphanumerics, underscore ('_'), at dollar sign ('$') na mga character.

simula-ng-kasaysayan: ^[
Lumipat sa simula ng kasaysayan.

simula-ng-linya: ^A, ANSI-Home, PC-Home
Inilipat ang cursor sa simula ng na-edit na linya ng input.

capitalize-word: [n] ^[C, ^[c
Uppercase ang unang character sa susunod n mga salita, na iniiwan ang cursor sa dulo
ng huling salita.

malinaw na screen: ^[^L
Nagpi-print ng compile-time configurable sequence para i-clear ang screen at i-home ang cursor,
muling iginuguhit ang buong prompt at ang kasalukuyang na-edit na linya ng input. Ang default na pagkakasunud-sunod
gumagana para sa halos lahat ng karaniwang mga terminal.

komento: ^[#
Kung ang kasalukuyang linya ay hindi nagsisimula sa isang karakter ng komento, idaragdag ang isa sa
simula ng linya at ang linya ay ipinasok (parang ang pagbabalik ay pinindot);
kung hindi, ang mga umiiral na character ng komento ay aalisin at ang cursor ay inilalagay sa
simula ng linya.

kumpleto: ^[^[
Awtomatikong nakumpleto hangga't natatangi ang pangalan ng command o ang pangalan ng file
naglalaman ng cursor. Kung ang buong natitirang command o pangalan ng file ay natatangi, a
ang espasyo ay naka-print pagkatapos nitong makumpleto, maliban kung ito ay isang pangalan ng direktoryo kung saan
'/' ay idinagdag. Kung walang command o file name na may kasalukuyang partial na salita
bilang prefix nito, ang isang bell character ay output (karaniwang nagiging sanhi ng isang beep na tumunog).

kumpletong-utos: ^X^[
Awtomatikong nakumpleto hangga't natatangi ang pangalan ng command na mayroong partial
salita hanggang sa cursor bilang prefix nito, tulad ng sa matapos utos sa itaas.

kumpletong-file: ^[^X
Awtomatikong nakumpleto hangga't natatangi ang pangalan ng file na mayroong bahagyang
salita hanggang sa cursor bilang prefix nito, tulad ng sa matapos utos na inilarawan sa itaas.

kumpletong-listahan: ^I, ^[=
Kumpletuhin hangga't maaari ang kasalukuyang salita, at ilista ang posible
mga pagkumpleto para dito. Kung isang pagkumpleto lamang ang posible, itugma tulad ng sa matapos
utos sa itaas. Tandaan na ang ^I ay karaniwang binubuo ng TAB (tabulator) key.

delete-char-backward: [n] BURAHIN, ^?, ^H
Tinatanggal n mga character bago ang cursor.

delete-char-forward: [n] ANSI-Del, PC-Del
Tinatanggal n mga character pagkatapos ng cursor.

tanggalin-salita-pabalik: [n] WERASE, ^[^?, ^[^H, ^[h
Tinatanggal n mga salita bago ang cursor.

tanggalin-salita-pasulong: [n] ^[d
Tinatanggal ang mga character pagkatapos ng cursor hanggang sa dulo ng n mga salita.

down na kasaysayan: [n] ^N, ^XB, ANSI-CurDown, PC-CurDown
Ini-scroll pasulong ang history buffer n mga linya (mamaya). Bawat linya ng pag-input sa orihinal
magsisimula pagkatapos lamang ng huling entry sa history buffer, kaya down-kasaysayan Hindi
kapaki-pakinabang hanggang sa alinman kasaysayan ng paghahanap, paghahanap-kasaysayan-up or up-kasaysayan ay naging
gumanap.

downcase na salita: [n] ^[L, ^[l
Ibinababa ang mga titik sa susunod n mga salita.

edit-line: [n] ^Xe
I-edit ang linya n o ang kasalukuyang linya, kung hindi tinukoy, interactive. Ang totoo
utos na naisakatuparan ay fc -e ${VISUAL:-${EDITOR:-vi}} n.

katapusan-ng-kasaysayan: ^[>
Lumipat sa dulo ng kasaysayan.

end-of-line: ^E, ANSI-End, PC-End
Inilipat ang cursor sa dulo ng linya ng pag-input.

eot: ^_
Gumaganap bilang isang end-of-file; ito ay kapaki-pakinabang dahil ang edit-mode input ay hindi pinapagana ang normal
canonicalization ng terminal input.

eot-or-delete: [n] ^D
Gumaganap bilang eot kung nag-iisa sa isang linya; kung hindi ay gumaganap bilang tanggalin-char-forward.

error: (hindi nakatali)
Error (tunog ang kampana).

exchange-point-and-mark: ^X^X
Inilalagay ang cursor kung nasaan ang marka at itinatakda ang marka kung nasaan ang cursor.

palawakin ang file: ^[*
Nagdaragdag ng '*' sa kasalukuyang salita at pinapalitan ang salita ng resulta ng
gumaganap ng file globbing sa salita. Kung walang mga file na tumutugma sa pattern, ang kampana ay
tumunog.

forward-char: [n] ^F, ^XC, ANSI-CurRight, PC-CurRight
Inilipat ang cursor pasulong n character.

pasulong na salita: [n] ^[f, ANSI-Ctrl-CurRight, ANSI-Alt-CurRight
Inilipat ang cursor pasulong sa dulo ng nika salita.

goto-history: [n] ^[g
Pupunta sa numero ng kasaysayan n.

kill-line: PATAYIN
Tinatanggal ang buong linya ng input.

pumatay-rehiyon: ^W
Tinatanggal ang input sa pagitan ng cursor at ng marka.

kill-to-eol: [n] ^K
Tinatanggal ang input mula sa cursor hanggang sa dulo ng linya kung n ay hindi tinukoy;
kung hindi man ay tinatanggal ang mga character sa pagitan ng cursor at column n.

listahan: ^[?
Nagpi-print ng pinagsunod-sunod, columnated na listahan ng mga pangalan ng command o mga pangalan ng file (kung mayroon) na magagawa
kumpletuhin ang bahagyang salita na naglalaman ng cursor. Ang mga pangalan ng direktoryo ay may '/' na nakadugtong
sa kanila.

list-command: ^X?
Nagpi-print ng pinagsunod-sunod, columnated na listahan ng mga pangalan ng command (kung mayroon) na maaaring kumpletuhin ang
bahagyang salita na naglalaman ng cursor.

list-file: ^X^Y
Nagpi-print ng pinagsunod-sunod, columnated na listahan ng mga pangalan ng file (kung mayroon man) na maaaring kumpletuhin ang
bahagyang salita na naglalaman ng cursor. Ang mga tagapagpahiwatig ng uri ng file ay idinagdag gaya ng inilarawan
sa ilalim listahan sa itaas.

bagong linya: ^J, ^M
Nagiging sanhi ng kasalukuyang linya ng input upang maproseso ng shell. Ang kasalukuyang cursor
ang posisyon ay maaaring nasaan man sa linya.

bagong linya-at-susunod: ^O
Nagiging sanhi ng kasalukuyang linya ng input upang maproseso ng shell, at mula sa susunod na linya
kasaysayan ang nagiging kasalukuyang linya. Ito ay kapaki-pakinabang lamang pagkatapos ng isang up-kasaysayan,
kasaysayan ng paghahanap or paghahanap-kasaysayan-up.

no-op: QUIT
Wala itong ginagawa.

prefix-1: ^[
Nagpapakilala ng 2-character na pagkakasunud-sunod ng command.

prefix-2: ^X, ^[[, ^[O
Nagpapakilala ng 2-character na pagkakasunud-sunod ng command.

prev-hist-word: [n] ^[., ^[_
Ang huling salita, o, kung ibinigay, ang nika salita (zero-based) ng nauna (sa paulit-ulit
execution, second-last, third-last, etc.) na utos ay ipinapasok sa cursor. Paggamit ng
ang utos sa pag-edit na ito ay nagtatapon ng marka.

quote: ^^, ^V
Ang sumusunod na karakter ay literal na kinuha sa halip na bilang isang utos sa pag-edit.

muling iguhit: ^L
Muling nire-print ang huling linya ng prompt string at ang kasalukuyang input line sa isang bago
linya.

search-character-backward: [n] ^[^]
Maghanap pabalik sa kasalukuyang linya para sa nang paglitaw ng susunod na karakter
nag-type.

search-character-forward: [n] ^]
Maghanap pasulong sa kasalukuyang linya para sa nang paglitaw ng susunod na karakter
nag-type.

kasaysayan ng paghahanap: ^R
Ipasok ang incremental na mode ng paghahanap. Hinahanap pabalik ang listahan ng panloob na kasaysayan
mga utos na tumutugma sa input. Ang isang inisyal na '^' sa string ng paghahanap ay nag-angkla sa
paghahanap. Aalis ang escape key sa mode ng paghahanap. Iba pang mga utos, kabilang ang mga pagkakasunud-sunod
ng pagtakas bilang unlapi-1 sinusundan ng isang unlapi-1 or unlapi-2 susi ay isasagawa pagkatapos
umaalis sa search mode. Ang magpalaglag (^G) command ay ibabalik ang input line dati
nagsimula ang paghahanap. Sunod-sunod kasaysayan ng paghahanap ang mga utos ay patuloy na naghahanap pabalik sa
ang susunod na nakaraang paglitaw ng pattern. Ang history buffer ay nagpapanatili lamang ng a
may hangganan na bilang ng mga linya; ang pinakamatanda ay itinatapon kung kinakailangan.

search-history-up: ANSI-PgUp, PC-PgUp
Maghanap pabalik sa history buffer para sa mga command na ang simula ay tumutugma sa
bahagi ng linya ng input bago ang cursor. Kapag ginamit sa isang walang laman na linya, mayroon itong
ang parehong epekto bilang up-kasaysayan.

search-history-down: ANSI-PgDn, PC-PgDn
Pasulong sa paghahanap sa history buffer para sa mga command na ang simula ay tumutugma sa
bahagi ng linya ng input bago ang cursor. Kapag ginamit sa isang walang laman na linya, mayroon itong
ang parehong epekto bilang down-kasaysayan. Ito ay kapaki-pakinabang lamang pagkatapos ng isang up-kasaysayan,
kasaysayan ng paghahanap or paghahanap-kasaysayan-up.

set-mark-command: ^[
Itakda ang marka sa posisyon ng cursor.

transpose-chars: ^T
Kung nasa dulo ng linya, o kung ang gmacs ang opsyon ay nakatakda, ito ang nagpapalitan ng dalawa
nakaraang mga character; kung hindi, ipinagpapalit nito ang dati at kasalukuyang mga character at
inililipat ang cursor ng isang character sa kanan.

up-kasaysayan: [n] ^P, ^XA, ANSI-CurUp, PC-CurUp
Ini-scroll pabalik ang history buffer n mga linya (mas maaga).

upcase na salita: [n] ^[U, ^[u
Malaking titik ang susunod n mga salita.

bersyon: ^[^V
Ipakita ang bersyon ng Salamat. Ang kasalukuyang buffer sa pag-edit ay naibalik kaagad bilang isang susi
ay pinindot. Ang nagpapanumbalik na keypress ay pinoproseso, maliban kung ito ay isang espasyo.

yank: ^Y
Inilalagay ang pinakakamakailang pinatay na string ng teksto sa kasalukuyang posisyon ng cursor.

yank-pop: ^[y
Kaagad pagkatapos ng a yank, pinapalitan ang ipinasok na text string ng susunod na nauna
pinatay ang text string.

Vi pag-edit paraan
tandaan: Ang vi command-line editing mode ay naulila, ngunit gumagana pa rin. Ito ay 8-bit na malinis
ngunit partikular na hindi sumusuporta sa UTF-8 o MBCS.

Ang vi command-line editor sa Salamat ay karaniwang may parehong mga utos bilang ang vi(1) editor na may
ang mga sumusunod na pagbubukod:

· Magsisimula ka sa insert mode.

· Mayroong pangalan ng file at mga command sa pagkumpleto ng command: =, \, *, ^X, ^E, ^F, at,
opsyonal, at .

· Ang _ iba ang utos (sa Salamat, ito ang huling utos ng argumento; sa vi(1) napupunta ito
sa simula ng kasalukuyang linya).

· Ang / at G ang mga utos ay gumagalaw sa kabaligtaran ng direksyon sa j utos.

· Ang mga utos na walang kahulugan sa isang editor ng linya ay hindi magagamit (hal. screen
utos ng paggalaw at ex(1)-style colon (:) mga utos).

katulad vi(1), mayroong dalawang mode: "insert" mode at "command" mode. Sa insert mode, karamihan
ang mga character ay inilalagay lamang sa buffer sa kasalukuyang posisyon ng cursor habang sila ay nai-type;
gayunpaman, ang ilang mga karakter ay espesyal na tinatrato. Sa partikular, ang mga sumusunod na karakter ay
kinuha mula sa kasalukuyang tty(4) mga setting (tingnan stty(1)) at may kanilang karaniwang kahulugan (normal na mga halaga
ay nasa panaklong): patayin (^U), burahin (^?), werase (^W), eof (^D), intr (^C), at quit (^\).
Bilang karagdagan sa nasa itaas, ang mga sumusunod na character ay partikular na itinuturing din sa insert
mode:

^E Command at file name enumeration (tingnan sa ibaba).

^F Command at pagkumpleto ng pangalan ng file (tingnan sa ibaba). Kung ginamit nang dalawang beses sa isang hilera, ang listahan ng
ang mga posibleng pagkumpleto ay ipinapakita; kung ginamit sa pangatlong beses, mababawi ang pagkumpleto.

^H Binubura ang dating karakter.

^J | ^M Katapusan ng linya. Ang kasalukuyang linya ay binabasa, na-parse, at pinaandar ng shell.

^V Literal na susunod. Ang susunod na character na na-type ay hindi ginagamot nang espesyal (maaaring magamit sa
ipasok ang mga character na inilalarawan dito).

^X Command at pagpapalawak ng pangalan ng file (tingnan sa ibaba).

Inilalagay ang editor sa command mode (tingnan sa ibaba).

Opsyonal na pangalan ng file at pagkumpleto ng command (tingnan ^F sa itaas), pinagana sa itakda -o
vi-tabcomplete.

Sa command mode, ang bawat karakter ay binibigyang kahulugan bilang isang command. Mga character na hindi
tumutugma sa mga utos, mga ilegal na kumbinasyon ng mga utos, o mga utos na hindi maaaring
natupad, lahat ay nagdudulot ng mga beep. Sa mga sumusunod na paglalarawan ng command, isang [n] ay nagpapahiwatig ng
Ang command ay maaaring prefix ng isang numero (hal 10l gumagalaw sa kanan ng 10 character); kung walang numero
ginagamit ang prefix, n ay ipinapalagay na 1 maliban kung tinukoy. Ang katagang “kasalukuyan
position” ay tumutukoy sa posisyon sa pagitan ng cursor at ng character na nauuna sa cursor.
Ang "salita" ay isang pagkakasunud-sunod ng mga titik, digit, at underscore na mga character o isang pagkakasunod-sunod ng hindi-
letter, non-digit, non-underscore, at non-whitespace na character (hal. “ab2*&^” ay naglalaman ng dalawang
salita) at ang isang "malaking salita" ay isang pagkakasunud-sunod ng mga hindi whitespace na character.

espesyal Salamat vi command:

Ang mga sumusunod na command ay wala sa, o iba sa, normal na vi file editor:

[n] Maglagay ng puwang na sinusundan ng nika malaking salita mula sa huling utos sa kasaysayan
sa kasalukuyang posisyon at ipasok ang insert mode; kung n ay hindi tinukoy, ang huli
salita ay nasingit.

# Ipasok ang character ng komento ('#') sa simula ng kasalukuyang linya at bumalik
ang linya sa shell (katumbas ng Ako#^J).

[n]g Tulad G, maliban kung n ay hindi tinukoy, napupunta ito sa pinakahuling naalala
linya.

[n]v I-edit ang linya n gamit ang vi(1) editor; kung n ay hindi tinukoy, ang kasalukuyang linya ay
na-edit. Ang aktwal na utos na naisakatuparan ay fc -e ${VISUAL:-${EDITOR:-vi}} n.

* at ^X Command o pagpapalawak ng pangalan ng file ay inilalapat sa kasalukuyang malaking salita (na may isang
idinagdag ang '*' kung ang salita ay walang mga file globbing character) – ang malaking salita ay
pinalitan ng mga nabuong salita. Kung ang kasalukuyang big-word ay ang una sa
linya o sumusunod sa isa sa mga character na ';', '|', '&', '(', o ')', at hindi
naglalaman ng slash ('/'), pagkatapos ay tapos na ang pagpapalawak ng command; kung hindi man pangalan ng file
tapos na ang pagpapalawak. Ang pagpapalawak ng command ay tutugma sa malaking salita laban sa lahat
mga alias, function, at built-in na command pati na rin ang anumang executable na file na nakita
sa pamamagitan ng paghahanap sa mga direktoryo sa parameter ng PATH. Mga tugma sa pagpapalawak ng pangalan ng file
ang malaking salita laban sa mga file sa kasalukuyang direktoryo. Pagkatapos ng pagpapalawak, ang
Ang cursor ay inilalagay lamang sa huling salita at ang editor ay nasa insert mode.

[n]\, [n]^F, [n] , at [n]
Pagkumpleto ng command/file name. Palitan ang kasalukuyang big-word ng pinakamahaba
natatanging tugma na nakuha pagkatapos magsagawa ng command at pagpapalawak ng pangalan ng file.
ay makikilala lamang kung ang vi-tabcomplete nakatakda ang opsyon, habang ay lamang
kinikilala kung ang vi-escomplete ang opsyon ay nakatakda (tingnan itakda -o). Kung n ay tinukoy,
ang nAng posibleng pagkumpleto ay napili (tulad ng iniulat ng command/file name
utos ng enumeration).

= at ^E Command/file name enumeration. Ilista ang lahat ng mga command o file na tumutugma sa
kasalukuyang malaking salita.

^V Ipakita ang bersyon ng Salamat. Ang kasalukuyang buffer sa pag-edit ay naibalik sa sandaling a
pinindot ang key. Ang pagpapanumbalik ng keypress ay hindi pinapansin.

@c Pagpapalawak ng macro. Isagawa ang mga utos na makikita sa alias c.

Intra-line na mga utos ng paggalaw:

[n]h at [n]^H
Ilipat ang kaliwa n character.

[n]l at [n]
Ilipat ang kanan n character.

0 Ilipat sa column 0.

^ Ilipat sa unang character na hindi whitespace.

[n]| Ilipat sa column n.

$ Ilipat sa huling karakter.

[n]b Bumalik n mga salita.

[n]B Bumalik ka n malalaking salita.

[n]e Sumulong sa dulo ng salita, n beses.

[n]E Sumulong sa dulo ng malaking salita, n beses.

[n]w Sumulong n mga salita.

[n]W Sumulong n malalaking salita.

% Maghanap ng katugma. Inaasahan ng editor ang pinakamalapit na parenthesis, bracket, o brace
at pagkatapos ay ililipat ang cursor sa katugmang panaklong, bracket, o brace.

[n]fc Sumulong sa nang paglitaw ng karakter c.

[n]Fc Lumipat pabalik sa nang paglitaw ng karakter c.

[n]tc Sumulong sa bago ang nang paglitaw ng karakter c.

[n]Tc Ilipat pabalik sa bago ang nang paglitaw ng karakter c.

[n]; Inuulit ang huli f, F, t, O T utos.

[n], Inuulit ang huli f, F, t, O T utos, ngunit gumagalaw sa kabilang direksyon.

Mga utos ng paggalaw sa pagitan ng linya:

[n]j, [n]+, at [n]^N
Ilipat sa nika-sunod na linya sa kasaysayan.

[n]k, [n]-, at [n]^P
Ilipat sa nika-naunang linya sa kasaysayan.

[n]G Lumipat sa linya n sa kasaysayan; kung n ay hindi tinukoy, ang numero ng una
naaalalang linya ang ginagamit.

[n]g Tulad G, maliban kung n ay hindi tinukoy, napupunta ito sa pinakakamakailang natatandaang linya.

[n]/pisi
Maghanap pabalik sa kasaysayan para sa nika linyang naglalaman ng pisi; kung pisi
nagsisimula sa '^', ang natitira sa string ay dapat na lumitaw sa simula ng kasaysayan
linya para magkatugma ito.

[n]?pisi
Katulad ng /, maliban kung naghahanap ito ng pasulong sa kasaysayan.

[n]n Hanapin ang nika- paglitaw ng huling string ng paghahanap; direksyon ng paghahanap
ay pareho sa huling paghahanap.

[n]N Maghanap para sa nika- paglitaw ng huling string ng paghahanap; direksyon ng paghahanap
ay ang kabaligtaran ng huling paghahanap.

ANSI-CurUp, PC-PgUp
Dalhin ang mga character mula sa simula ng linya hanggang sa kasalukuyang posisyon ng cursor bilang
hanapin ang string at gumawa ng pabalik na kasaysayan ng paghahanap para sa mga linya na nagsisimula dito
string; panatilihin ang posisyon ng cursor. Gumagana lamang ito sa insert mode at pinapanatili ito
pinagana.

I-edit ang mga utos

[n]a Magdugtong ng teksto n beses; napupunta sa insert mode pagkatapos lamang ng kasalukuyang posisyon. Ang
Ang append ay ginagaya lamang kung ang command mode ay muling ipinasok ie Ginagamit.

[n]A Kapareho ng a, maliban kung ito ay nakadugtong sa dulo ng linya.

[n]i Ipasok ang teksto n beses; papunta sa insert mode sa kasalukuyang posisyon. Ang pagsingit
ay ginagaya lamang kung ang command mode ay muling ipinasok ie Ginagamit.

[n]Katulad ko i, maliban sa pagpasok ay tapos na bago ang unang hindi blangkong character.

[n]s Palitan ang susunod n mga character (ibig sabihin, tanggalin ang mga character at pumunta sa insert
mode).

S Palitan ang buong linya. Lahat ng character mula sa unang hindi blangko na character hanggang sa dulo
ng linya ay tinanggal at ang insert mode ay ipinasok.

[n]cilipat-cmd
Baguhin mula sa kasalukuyang posisyon sa posisyon na nagreresulta mula sa n ilipat-cmds (ibig sabihin
tanggalin ang ipinahiwatig na rehiyon at pumunta sa insert mode); kung ilipat-cmd is c, Ang linya
simula sa unang hindi blangko na karakter ay binago.

C Baguhin mula sa kasalukuyang posisyon hanggang sa dulo ng linya (ibig sabihin, tanggalin hanggang sa dulo ng
ang linya at pumunta sa insert mode).

[n]x Tanggalin ang susunod n character.

[n]X Tanggalin ang nakaraan n character.

D Tanggalin hanggang sa dulo ng linya.

[n]dilipat-cmd
Tanggalin mula sa kasalukuyang posisyon sa posisyon na nagreresulta mula sa n ilipat-cmds;
ilipat-cmd ay isang utos ng paggalaw (tingnan sa itaas) o d, kung saan ang kasalukuyang linya ay
tinanggal.

[n]rc Palitan ang susunod n mga karakter na may karakter c.

[n]R Palitan. Ipasok ang insert mode ngunit i-overwrite ang mga umiiral nang character sa halip na ipasok
bago ang mga umiiral na character. Ang kapalit ay paulit-ulit n beses.

[n]~ Baguhin ang kaso ng susunod n character.

[n]yilipat-cmd
Yank mula sa kasalukuyang posisyon sa posisyon na nagreresulta mula sa n ilipat-cmds sa
yank buffer; kung ilipat-cmd is y, hinihimas ang buong linya.

Y Yank mula sa kasalukuyang posisyon hanggang sa dulo ng linya.

[n]p Idikit ang mga nilalaman ng yank buffer pagkatapos lamang ng kasalukuyang posisyon, n beses.

[n]P Kapareho ng p, maliban na ang buffer ay na-paste sa kasalukuyang posisyon.

Sari-saring utos ng vi

^J at ^M
Ang kasalukuyang linya ay binabasa, na-parse, at pinaandar ng shell.

^L at ^R
Muling iguhit ang kasalukuyang linya.

[n]. Gawin muli ang huling utos sa pag-edit n beses.

u I-undo ang huling utos sa pag-edit.

I-undo ang lahat ng mga pagbabagong ginawa sa kasalukuyang linya.

Mga key ng PC Home, End, Del, at cursor
Gumagalaw sila gaya ng inaasahan, parehong nasa insert at command mode.

intr at umalis
Ang interrupt at quit terminal character ay nagiging sanhi ng pagtanggal ng kasalukuyang linya at
isang bagong prompt na ipi-print.

Gumamit ng mksh online gamit ang mga serbisyo ng onworks.net