ນີ້ແມ່ນຄໍາສັ່ງ mksh-static ທີ່ສາມາດດໍາເນີນການໄດ້ໃນ OnWorks ຜູ້ໃຫ້ບໍລິການໂຮດຕິ້ງຟຣີໂດຍໃຊ້ຫນຶ່ງໃນຫຼາຍໆບ່ອນເຮັດວຽກອອນໄລນ໌ຂອງພວກເຮົາເຊັ່ນ Ubuntu Online, Fedora Online, Windows online emulator ຫຼື MAC OS online emulator
ໂຄງການ:
NAME
mksh, sh — MirBSD Korn shell
ສະຫຼຸບສັງລວມ
mksh [-+abCefhiklmnprUuvXx] [-T [!]tty | -] [-+o ທາງເລືອກ] [-c string | -s | ເອກະສານ
[ການໂຕ້ຖຽງ ...]]
ຊື່ໃນຕົວ [ການໂຕ້ຖຽງ ...]
ລາຍລະອຽດ
mksh ເປັນນາຍພາສາຄໍາສັ່ງທີ່ມີຈຸດປະສົງສໍາລັບທັງສອງການໂຕ້ຕອບແລະການນໍາໃຊ້ Shell script. ຂອງມັນ
ພາສາຄໍາສັ່ງແມ່ນ superset ຂອງພາສາ sh(C) shell ແລະສ່ວນໃຫຍ່ເຂົ້າກັນໄດ້ກັບ
ແກະ Korn ຕົ້ນສະບັບ. ບາງຄັ້ງ, ຫນ້າຄູ່ມືນີ້ອາດຈະໃຫ້ຄໍາແນະນໍາການຂຽນອັກສອນ; ໃນຂະນະທີ່ມັນ
ບາງຄັ້ງກໍ່ເອົາ script shell ແບບພະກະພາຫຼືມາດຕະຖານຕ່າງໆເຂົ້າໄປໃນບັນຊີທັງຫມົດ
ຂໍ້ມູນແມ່ນນໍາສະເຫນີທໍາອິດແລະ foremost ກັບ mksh ຢູ່ໃນໃຈແລະຄວນຈະໄດ້ຮັບການປະຕິບັດເຊັ່ນນັ້ນ.
ຂ້ອຍ an Android ຜູ້ໃຊ້ so ແມ່ນຫຍັງ mksh?
mksh ແມ່ນ UNIX shell / ນາຍແປພາສາຄໍາສັ່ງ, ຄ້າຍຄືກັນກັບ COMMAND.COM or CMD.EXE, ເຊິ່ງມີ
ໄດ້ຖືກລວມເຂົ້າກັບໂຄງການ Android Open Source ສໍາລັບໃນຂະນະທີ່ໃນປັດຈຸບັນ. ໂດຍພື້ນຖານແລ້ວ, ມັນເປັນໂຄງການ
ທີ່ເຮັດວຽກຢູ່ໃນ terminal (ປ່ອງຢ້ຽມ console), ເອົາການປ້ອນຂໍ້ມູນຂອງຜູ້ໃຊ້ແລະດໍາເນີນການຄໍາສັ່ງຫຼື scripts,
ເຊິ່ງມັນຍັງສາມາດຖືກຮ້ອງຂໍໃຫ້ເຮັດໂດຍໂຄງການອື່ນໆ, ເຖິງແມ່ນວ່າຢູ່ໃນພື້ນຫລັງ. ສິດທິພິເສດໃດໆ
ປ໊ອບອັບທີ່ເຈົ້າອາດຈະພົບຢູ່ນັ້ນບໍ່ແມ່ນ mksh ບັນຫາແຕ່ມີຄໍາຖາມອື່ນໆ
ໂຄງການນໍາໃຊ້ມັນ.
Invocation
buildins ສ່ວນໃຫຍ່ສາມາດຖືກເອີ້ນໂດຍກົງ, ຕົວຢ່າງເຊັ່ນຖ້າຈຸດເຊື່ອມຕໍ່ຈາກຊື່ຂອງມັນໄປຫາ
ແກະ; ບໍ່ມີຄວາມຫມາຍທັງຫມົດ, ໄດ້ຮັບການທົດສອບຫຼືເຮັດວຽກຢູ່ໃນທັງຫມົດ.
ຕົວເລືອກມີດັ່ງນີ້:
-c string mksh ຈະປະຕິບັດຄໍາສັ່ງທີ່ມີຢູ່ໃນ string.
-i ແກະແບບໂຕ້ຕອບ. Shell ທີ່ອ່ານຄໍາສັ່ງຈາກການປ້ອນມາດຕະຖານແມ່ນ
"ໂຕ້ຕອບ" ຖ້າຕົວເລືອກນີ້ຖືກໃຊ້ຫຼືຖ້າທັງສອງວັດສະດຸປ້ອນມາດຕະຖານແລະຄວາມຜິດພາດມາດຕະຖານ
ແມ່ນຕິດກັບ a tty(4). ແກະແບບໂຕ້ຕອບມີການຄວບຄຸມວຽກທີ່ເປີດໃຊ້ງານ, ບໍ່ສົນໃຈ
ສັນຍານ SIGINT, SIGQUIT, ແລະ SIGTERM, ແລະພິມການເຕືອນກ່ອນທີ່ຈະອ່ານການປ້ອນຂໍ້ມູນ
(ເບິ່ງຕົວກໍານົດການ PS1 ແລະ PS2). ມັນຍັງປະມວນຜົນພາລາມິເຕີ ENV ຫຼື
mkshrc ໄຟລ໌ (ເບິ່ງຂ້າງລຸ່ມນີ້). ສໍາລັບແກະທີ່ບໍ່ມີການໂຕ້ຕອບ, the ຕິດຕາມ ຕົວເລືອກເປີດຢູ່
ໂດຍຄ່າເລີ່ມຕົ້ນ (ເບິ່ງ ທີ່ກໍານົດໄວ້ ຄໍາສັ່ງຂ້າງລຸ່ມນີ້).
-l ເຂົ້າສູ່ລະບົບ shell. ຖ້າຊື່ພື້ນຖານ, ແກະຖືກເອີ້ນດ້ວຍ (ie argv[0]) ເລີ່ມຕົ້ນດ້ວຍ
'-' ຫຼືຖ້າທາງເລືອກນີ້ຖືກນໍາໃຊ້, ແກະແມ່ນສົມມຸດວ່າເປັນແກະເຂົ້າສູ່ລະບົບ; ເບິ່ງ
Startup ໄຟ ຂ້າງລຸ່ມນີ້.
-p ແກະທີ່ມີສິດທິພິເສດ. Shell ແມ່ນ "ສິດທິພິເສດ" ຖ້າ ID ຜູ້ໃຊ້ທີ່ແທ້ຈິງຫຼື ID ກຸ່ມເຮັດ
ບໍ່ກົງກັບ ID ຜູ້ໃຊ້ ຫຼື ID ກຸ່ມທີ່ມີປະສິດທິພາບ (ເບິ່ງ ຂີ້ຄ້ານ(2) ແລະ getgid(2)).
ການລຶບລ້າງທາງເລືອກທີ່ມີສິດທິພິເສດເຮັດໃຫ້ shell ກໍານົດ ID ຜູ້ໃຊ້ທີ່ມີປະສິດທິພາບຂອງມັນ
(ID ກຸ່ມ) ກັບ ID ຜູ້ໃຊ້ທີ່ແທ້ຈິງຂອງມັນ (ID ກຸ່ມ). ສໍາລັບຜົນສະທ້ອນເພີ່ມເຕີມ, ເບິ່ງ Startup
ໄຟ. ຖ້າ shell ໄດ້ຮັບສິດທິພິເສດແລະທຸງນີ້ບໍ່ໄດ້ຖືກກໍານົດຢ່າງຊັດເຈນ, ໄດ້
ທາງເລືອກ "ສິດທິພິເສດ" ຈະຖືກລຶບລ້າງອັດຕະໂນມັດຫຼັງຈາກການປະມວນຜົນໄຟລ໌ເລີ່ມຕົ້ນ.
-r ເປືອກຫຸ້ມນອກຈໍາກັດ. Shell ແມ່ນ "ຖືກຈໍາກັດ" ຖ້າທາງເລືອກນີ້ຖືກນໍາໃຊ້. ຕໍ່ໄປນີ້
ຂໍ້ຈໍາກັດມີຜົນບັງຄັບໃຊ້ຫຼັງຈາກແກະປະມວນຜົນໃດໆແລະ ENV
ແຟ້ມ:
· ໄດ້ cd (ແລະ chdir) ຄໍາສັ່ງຖືກປິດໃຊ້ງານ.
· ຕົວກໍານົດການ SHELL, ENV, ແລະ PATH ບໍ່ສາມາດປ່ຽນແປງໄດ້.
· ຊື່ຄໍາສັ່ງບໍ່ສາມາດຖືກລະບຸດ້ວຍເສັ້ນທາງຢ່າງແທ້ຈິງຫຼືພີ່ນ້ອງ.
· ໄດ້ -p ທາງເລືອກຂອງຄໍາສັ່ງໃນຕົວ ຄໍາສັ່ງ ບໍ່ສາມາດໃຊ້ໄດ້.
· ການປ່ຽນເສັ້ນທາງທີ່ສ້າງໄຟລ໌ບໍ່ສາມາດຖືກນໍາໃຊ້ (ie '>', '>|', '>>', '<>').
-s ແກະອ່ານຄໍາສັ່ງຈາກວັດສະດຸປ້ອນມາດຕະຖານ; ການໂຕ້ຖຽງທີ່ບໍ່ແມ່ນທາງເລືອກທັງຫມົດແມ່ນ
ຕົວກໍານົດການຕໍາແຫນ່ງ.
-T ຊື່ Spawn mksh ກ່ຽວກັບ tty(4) ອຸປະກອນໃຫ້. ເສັ້ນທາງ ຊື່, /dev/ttyCname ແລະ
/dev/ttyname ພະຍາຍາມຢູ່ໃນຄໍາສັ່ງ. ເວັ້ນເສຍແຕ່ ຊື່ ເລີ່ມຕົ້ນດ້ວຍ exclamation mark
('!'), ນີ້ແມ່ນເຮັດໃນ subshell ແລະກັບຄືນມາທັນທີ. ຖ້າ ຊື່ ເປັນ dash ເປັນ
('-'), ແຍກອອກຈາກຕົວຄວບຄຸມ (daemonise) ແທນ.
ນອກເຫນືອໄປຈາກຂ້າງເທິງນີ້, ທາງເລືອກທີ່ອະທິບາຍໃນ ທີ່ກໍານົດໄວ້ ຄໍາສັ່ງໃນຕົວຍັງສາມາດຖືກນໍາໃຊ້
ໃນເສັ້ນຄໍາສັ່ງ: ທັງສອງ [-+abCefhkmnuvXx] ແລະ [-+o ທາງເລືອກ] ສາມາດໃຊ້ສໍາລັບຕົວອັກສອນດຽວ
ຫຼືທາງເລືອກຍາວ, ຕາມລໍາດັບ.
ຖ້າບໍ່ແມ່ນ -c ຫລື -s ທາງເລືອກແມ່ນລະບຸໄວ້, ການໂຕ້ຖຽງທີ່ບໍ່ແມ່ນທາງເລືອກທໍາອິດກໍານົດ
ຊື່ຂອງໄຟລ໌ທີ່ແກະອ່ານຄໍາສັ່ງຈາກ. ຖ້າບໍ່ມີການໂຕ້ຖຽງທີ່ບໍ່ແມ່ນທາງເລືອກ, the
shell ອ່ານຄໍາສັ່ງຈາກວັດສະດຸປ້ອນມາດຕະຖານ. ຊື່ຂອງຫອຍ (ie ເນື້ອໃນຂອງ
$0) ຖືກກໍານົດດັ່ງຕໍ່ໄປນີ້: ຖ້າ -c ທາງເລືອກໄດ້ຖືກນໍາໃຊ້ແລະມີການໂຕ້ຖຽງທີ່ບໍ່ແມ່ນທາງເລືອກ,
ມັນຖືກນໍາໃຊ້ເປັນຊື່; ຖ້າຄໍາສັ່ງຖືກອ່ານຈາກໄຟລ໌, ໄຟລ໌ຖືກນໍາໃຊ້ເປັນ
ຊື່; ຖ້າບໍ່ດັ່ງນັ້ນ, ຊື່ພື້ນຖານທີ່ແກະຖືກເອີ້ນດ້ວຍ (ie argv[0]) ຖືກໃຊ້.
ສະຖານະການອອກຂອງແກະແມ່ນ 127 ຖ້າໄຟລ໌ຄໍາສັ່ງທີ່ລະບຸໄວ້ໃນເສັ້ນຄໍາສັ່ງສາມາດເຮັດໄດ້
ບໍ່ໄດ້ຖືກເປີດ, ຫຼືບໍ່ແມ່ນສູນຖ້າຫາກວ່າຄວາມຜິດພາດ syntax ຮ້າຍແຮງເກີດຂຶ້ນໃນລະຫວ່າງການປະຕິບັດການ
ສະຄຣິບ. ໃນກໍລະນີທີ່ບໍ່ມີຄວາມຜິດພາດທີ່ຮ້າຍແຮງ, ສະຖານະການອອກແມ່ນຄໍາສັ່ງສຸດທ້າຍ
ຖືກປະຕິບັດ, ຫຼືສູນ, ຖ້າບໍ່ມີຄໍາສັ່ງຖືກປະຕິບັດ.
Startup ໄຟ
ສໍາລັບສະຖານທີ່ທີ່ແທ້ຈິງຂອງໄຟລ໌ເຫຼົ່ານີ້, ເບິ່ງ ເອກະສານ. ແກະເຂົ້າສູ່ລະບົບປະມວນຜົນລະບົບ
profile ກ່ອນ. ແກະທີ່ມີສິດທິພິເສດຫຼັງຈາກນັ້ນປະມວນຜົນໂປຣໄຟລ໌ suid. ການເຂົ້າສູ່ລະບົບທີ່ບໍ່ມີສິດທິພິເສດ
shell ປະມວນຜົນໂປຣໄຟລ໌ຜູ້ໃຊ້ຕໍ່ໄປ. ແກະແບບໂຕ້ຕອບທີ່ບໍ່ມີສິດທິພິເສດກວດເບິ່ງຄ່າ
ຂອງພາລາມິເຕີ ENV ຫຼັງຈາກມັນຂຶ້ນກັບພາລາມິເຕີ, ຄໍາສັ່ງ, ເລກເລກ ແລະ tilde ('~')
ການທົດແທນ; ຖ້າບໍ່ໄດ້ຕັ້ງ ຫຼືຫວ່າງເປົ່າ, ໂປຣໄຟລ໌ mkshrc ຜູ້ໃຊ້ຈະຖືກປະມວນຜົນ; ຖ້າບໍ່ດັ່ງນັ້ນ, ຖ້າໄຟລ໌
ຊື່ຂອງຜົນໄດ້ຮັບການທົດແທນທີ່ມີຢູ່, ມັນຖືກປຸງແຕ່ງ; ບໍ່ມີຢູ່ຢ່າງງຽບໆ
ບໍ່ສົນໃຈ. ແກະທີ່ມີສິດທິພິເສດຫຼັງຈາກນັ້ນຫຼຸດລົງສິດທິພິເສດຖ້າຫາກວ່າທັງສອງບໍ່ແມ່ນ -p ທາງເລືອກທີ່ໄດ້ຮັບໃນການ
ເສັ້ນຄໍາສັ່ງຫຼືກໍານົດໃນລະຫວ່າງການປະຕິບັດໄຟລ໌ເລີ່ມຕົ້ນ.
ຄໍາສັ່ງ syntax
ແກະຈະເລີ່ມການແຍກການປ້ອນຂໍ້ມູນຂອງມັນໂດຍການຖອນການປະສົມ backslash-newline, ຈາກນັ້ນ
ທໍາລາຍມັນເຂົ້າໄປໃນ ຄໍາເວົ້າ. ຄໍາສັບຕ່າງໆ (ເຊິ່ງເປັນລໍາດັບຂອງຕົວອັກສອນ) ແມ່ນ delimited ໂດຍ unquoted
ຕົວອັກສອນຍະຫວ່າງ (ຍະຫວ່າງ, ແຖບ, ແລະແຖວໃໝ່) ຫຼືຕົວອັກສອນເມຕາ ('<', '>', '|', ';', '(',
')', ແລະ '&'). ນອກເໜືອໄປຈາກການຈຳກັດຄຳສັບແລ້ວ, ຍະຫວ່າງ ແລະແຖບແມ່ນຖືກລະເລີຍ, ໃນຂະນະທີ່ແຖວໃໝ່
ປົກກະຕິແລ້ວ delimit ຄໍາສັ່ງ. ຕົວອັກສອນ meta ຖືກນໍາໃຊ້ໃນການກໍ່ສ້າງດັ່ງຕໍ່ໄປນີ້ tokens:
'<', '<&', '<<', '<<<', '>', '>&', '>>', '&>', ແລະອື່ນໆ ແມ່ນໃຊ້ເພື່ອກໍານົດການປ່ຽນເສັ້ນທາງ (ເບິ່ງ.
ການປ້ອນຂໍ້ມູນ / ຜົນຜະລິດ ຕົວຊີ້ທິດທາງ ຂ້າງລຸ່ມນີ້); '|' ຖືກນໍາໃຊ້ເພື່ອສ້າງທໍ່; '|&' ຖືກໃຊ້ເພື່ອສ້າງການຮ່ວມມື.
ຂະບວນການ (ເບິ່ງ ຂະບວນການຮ່ວມກັນ ຂ້າງລຸ່ມນີ້); ';' ຖືກນໍາໃຊ້ເພື່ອແຍກຄໍາສັ່ງ; '&' ຖືກນໍາໃຊ້ເພື່ອສ້າງ
ທໍ່ asynchronous; '&&' ແລະ '||' ຖືກນໍາໃຊ້ເພື່ອກໍານົດການປະຕິບັດເງື່ອນໄຂ; ';;', ';&'
ແລະ ';|' ຖືກນໍາໃຊ້ໃນ ກໍລະນີ ຖະແຫຼງການ; '((.. ))' ແມ່ນໃຊ້ໃນການສະແດງອອກທາງເລກເລກ; ແລະ
ສຸດທ້າຍ, '( .. )' ຖືກນໍາໃຊ້ເພື່ອສ້າງ subshells.
ຊ່ອງຫວ່າງ ແລະຕົວອັກສອນເມຕາສາມາດຖືກອ້າງອີງເປັນສ່ວນບຸກຄົນໂດຍໃຊ້ backslash ('\'), ຫຼື in
ກຸ່ມທີ່ໃຊ້ວົງຢືມຄູ່ ('"') ຫຼືດ່ຽວ ("'").
ຍັງໄດ້ຮັບການປິ່ນປົວພິເສດໂດຍແກະແລະຕ້ອງໄດ້ຮັບການອ້າງອີງຖ້າພວກເຂົາເປັນຕົວແທນຂອງຕົນເອງ:
'\', '"', ''', '#', '$', '`', '~', '{', '}', '*', '?', ແລະ '['. ສາມອັນທໍາອິດນີ້
ແມ່ນຕົວອັກສອນອ້າງອີງທີ່ໄດ້ກ່າວມາຂ້າງເທິງ (ເບິ່ງ Quoting ຂ້າງລຸ່ມນີ້); '#', ຖ້າໃຊ້ຢູ່ທີ່
ການເລີ່ມຕົ້ນຂອງຄໍາສັບໃດຫນຶ່ງ, ແນະນໍາຄໍາຄິດຄໍາເຫັນ - ທຸກສິ່ງທຸກຢ່າງຫຼັງຈາກ '#' ເຖິງໃກ້ທີ່ສຸດ
ແຖວໃໝ່ຖືກລະເລີຍ; '$' ຖືກນໍາໃຊ້ເພື່ອແນະນໍາພາລາມິເຕີ, ຄໍາສັ່ງ, ແລະເລກເລກ
ການທົດແທນ (ເບິ່ງ ປ່ຽນແທນ ຂ້າງລຸ່ມນີ້); '`' ແນະນຳການປ່ຽນຄໍາສັ່ງແບບເກົ່າ
(ເບິ່ງ ປ່ຽນແທນ ຂ້າງລຸ່ມນີ້); '~' ເລີ່ມຕົ້ນການຂະຫຍາຍໄດເລກະທໍລີ (ເບິ່ງ ເຄື່ອງ ໝາຍ ສຳ ນຽງ ການຂະຫຍາຍຕົວ ຂ້າງລຸ່ມນີ້); '{'
ແລະ '}' ຂີດຈຳກັດ csh(1) ສະຫຼັບແບບ (ເບິ່ງ Brace ການຂະຫຍາຍຕົວ ຂ້າງລຸ່ມນີ້); ແລະສຸດທ້າຍ, '*',
'?', ແລະ '[' ຖືກໃຊ້ໃນການສ້າງຊື່ໄຟລ໌ (ເບິ່ງ ເອກະສານ ຊື່ ຮູບແບບການ ດ້ານລຸ່ມ).
ເມື່ອຄໍາແລະ tokens ຖືກແຍກ, ແກະສ້າງຄໍາສັ່ງ, ຊຶ່ງໃນນັ້ນມີສອງພື້ນຖານ
ປະເພດ: ຄໍາສັ່ງງ່າຍດາຍ, ປົກກະຕິແລ້ວໂຄງການທີ່ຖືກປະຕິບັດ, ແລະ ຄໍາສັ່ງປະສົມ, ດັ່ງກ່າວ
as ສໍາລັບການ ແລະ if ຖະແຫຼງການ, ການສ້າງກຸ່ມ, ແລະຄໍານິຍາມຫນ້າທີ່.
ຄໍາສັ່ງທີ່ງ່າຍດາຍປະກອບດ້ວຍການປະສົມປະສານຂອງການມອບຫມາຍພາລາມິເຕີ (ເບິ່ງ ຕົວກໍານົດການ
ຂ້າງລຸ່ມນີ້), input/output redirections (ເບິ່ງ ການປ້ອນຂໍ້ມູນ / ຜົນຜະລິດ ການປ່ຽນເສັ້ນທາງ ຂ້າງລຸ່ມນີ້), ແລະຄໍາສັ່ງຄໍາສັບ;
ຂໍ້ ຈຳ ກັດພຽງແຕ່ວ່າການມອບ ໝາຍ ພາລາມິເຕີມາກ່ອນ ຄຳ ສັ່ງໃດໆ. ໄດ້
ຄໍາສັ່ງຄໍາສັບ, ຖ້າມີ, ກໍານົດຄໍາສັ່ງທີ່ຈະປະຕິບັດແລະການໂຕ້ຖຽງຂອງມັນ. ໄດ້
ຄໍາສັ່ງອາດຈະເປັນຄໍາສັ່ງທີ່ສ້າງໃນແກະ, ເປັນຫນ້າທີ່, ຫຼືຄໍາສັ່ງພາຍນອກ (ເຊັ່ນ: ແຍກຕ່າງຫາກ
ໄຟລ໌ທີ່ສາມາດປະຕິບັດໄດ້ທີ່ຕັ້ງຢູ່ໂດຍໃຊ້ພາລາມິເຕີ PATH; ເບິ່ງ ຄໍາສັ່ງ ການປະຕິບັດ ດ້ານລຸ່ມ).
ໃຫ້ສັງເກດວ່າໂຄງສ້າງຄໍາສັ່ງທັງຫມົດມີສະຖານະການອອກ: ສໍາລັບຄໍາສັ່ງພາຍນອກ, ນີ້ແມ່ນກ່ຽວຂ້ອງ
ກັບສະຖານະພາບທີ່ສົ່ງຄືນໂດຍ ລໍຖ້າ(2) (ຖ້າບໍ່ພົບຄໍາສັ່ງ, ສະຖານະການອອກແມ່ນ
127; ຖ້າມັນບໍ່ສາມາດປະຕິບັດໄດ້, ສະຖານະການອອກແມ່ນ 126); ສະຖານະການອອກຂອງຄໍາສັ່ງອື່ນ
ການກໍ່ສ້າງ (ຄໍາສັ່ງໃນຕົວ, ຫນ້າທີ່, ຄໍາສັ່ງປະສົມ, ທໍ່, ລາຍຊື່, ແລະອື່ນໆ) ແມ່ນທັງຫມົດ.
ຖືກກໍານົດດີແລະຖືກອະທິບາຍບ່ອນທີ່ການກໍ່ສ້າງຖືກອະທິບາຍ. ສະຖານະພາບທາງອອກຂອງ ກ
ຄໍາສັ່ງປະກອບດ້ວຍພຽງແຕ່ການມອບຫມາຍພາລາມິເຕີແມ່ນການທົດແທນຄໍາສັ່ງສຸດທ້າຍ
ປະຕິບັດໃນລະຫວ່າງການກໍານົດພາລາມິເຕີຫຼື 0 ຖ້າບໍ່ມີການທົດແທນຄໍາສັ່ງ.
ຄໍາສັ່ງສາມາດຖືກຕ່ອງໂສ້ເຂົ້າກັນໂດຍໃຊ້ '|' token ເພື່ອປະກອບເປັນທໍ່, ໃນທີ່
ຜົນຜະລິດມາດຕະຖານຂອງແຕ່ລະຄໍາສັ່ງແຕ່ສຸດທ້າຍແມ່ນທໍ່ (ເບິ່ງ ທໍ່(2)) ການປ້ອນຂໍ້ມູນມາດຕະຖານຂອງ
ຄໍາສັ່ງຕໍ່ໄປນີ້. ສະຖານະການອອກຂອງທໍ່ແມ່ນຄໍາສັ່ງສຸດທ້າຍຂອງມັນ, ເວັ້ນເສຍແຕ່
ໄດ້ pipefail ທາງເລືອກແມ່ນໄດ້ຖືກກໍານົດ (ເບິ່ງມີ). ຄໍາສັ່ງທັງຫມົດຂອງທໍ່ແມ່ນປະຕິບັດແຍກຕ່າງຫາກ
subshells; ນີ້ແມ່ນອະນຸຍາດໂດຍ POSIX ແຕ່ແຕກຕ່າງຈາກທັງສອງຕົວແປຂອງ AT&T UNIX ksh, ບ່ອນທີ່
ທັງຫມົດແຕ່ຄໍາສັ່ງສຸດທ້າຍໄດ້ຖືກປະຕິບັດໃນ subshells; ເບິ່ງ ອ່ານ ຄໍາອະທິບາຍຂອງ buildin ສໍາລັບ
ຜົນສະທ້ອນແລະການແກ້ໄຂ. ທໍ່ສົ່ງອາດຈະຖືກນຳໜ້າດ້ວຍ '!' ສະຫງວນຄໍາທີ່
ເຮັດໃຫ້ສະຖານະທາງອອກຂອງທໍ່ນັ້ນຖືກປະກອບຢ່າງມີເຫດຜົນ: ຖ້າສະຖານະເດີມ
ແມ່ນ 0, ສະຖານະທີ່ສົມບູນຈະເປັນ 1; ຖ້າສະຖານະເດີມບໍ່ແມ່ນ 0, ຕື່ມ
ສະຖານະຈະເປັນ 0.
ລາຍການ ຂອງຄໍາສັ່ງສາມາດຖືກສ້າງຂື້ນໂດຍການແຍກທໍ່ໂດຍ tokens ຕໍ່ໄປນີ້:
'&&', '||', '&', '|&', ແລະ ';'. ສອງອັນທໍາອິດແມ່ນສໍາລັບການປະຕິບັດທີ່ມີເງື່ອນໄຂ: "cmd1 && cmd2"
ການປະຕິບັດ cmd2 ພຽງແຕ່ຖ້າຫາກວ່າສະຖານະການອອກຂອງ cmd1 ແມ່ນສູນ; '||' ແມ່ນກົງກັນຂ້າມ - cmd2 is
ປະຕິບັດພຽງແຕ່ຖ້າຫາກວ່າສະຖານະການອອກຂອງ cmd1 ບໍ່ແມ່ນສູນ. '&&' ແລະ '||' ມີການນໍາຫນ້າເທົ່າທຽມກັນ
ເຊິ່ງສູງກວ່າຂອງ '&', '|&', ແລະ ';', ເຊິ່ງມີສ່ວນນຳໜ້າເທົ່າກັນ. ຫມາຍເຫດ
ວ່າ '&&' ແລະ '||' ຜູ້ປະກອບການແມ່ນ "ສະມາຄົມຊ້າຍ". ຕົວຢ່າງ, ທັງສອງອັນນີ້
ຄໍາສັ່ງຈະພິມພຽງແຕ່ "bar":
$ false && echo foo || ແຖບສຽງ
$ ຈິງ || echo foo && echo bar
ໂທເຄັນ '&' ເຮັດໃຫ້ຄຳສັ່ງກ່ອນໜ້ານີ້ຖືກດຳເນີນການແບບບໍ່ກົງກັນ; ນັ້ນແມ່ນ, ເປືອກ
ເລີ່ມຕົ້ນຄໍາສັ່ງແຕ່ບໍ່ໄດ້ລໍຖ້າໃຫ້ມັນສໍາເລັດ (shell ຕິດຕາມ
ສະຖານະພາບຂອງຄໍາສັ່ງ asynchronous; ເບິ່ງ ວຽກເຮັດງານທໍາ ການຄວບຄຸມ ຂ້າງລຸ່ມນີ້). ໃນເວລາທີ່ຄໍາສັ່ງ asynchronous ແມ່ນ
ເລີ່ມຕົ້ນເມື່ອການຄວບຄຸມວຽກຖືກປິດໃຊ້ງານ (ເຊັ່ນໃນສະຄຣິບສ່ວນໃຫຍ່), ຄໍາສັ່ງແມ່ນເລີ່ມຕົ້ນດ້ວຍ
ສັນຍານ SIGINT ແລະ SIGQUIT ຖືກລະເລີຍ ແລະດ້ວຍການປ້ອນຂໍ້ມູນຖືກປ່ຽນເສັ້ນທາງຈາກ / dev / null (ຢ່າງໃດກໍຕາມ,
ການປ່ຽນເສັ້ນທາງທີ່ລະບຸໄວ້ໃນຄໍາສັ່ງ asynchronous ມີອັນດັບກ່ອນ). ຕົວປະຕິບັດການ '|&'
ເລີ່ມຕົ້ນຂະບວນການຮ່ວມມືທີ່ເປັນປະເພດພິເສດຂອງຂະບວນການ asynchronous (ເບິ່ງ ຂະບວນການຮ່ວມກັນ
ຂ້າງລຸ່ມນີ້). ໃຫ້ສັງເກດວ່າຄໍາສັ່ງຕ້ອງປະຕິບັດຕາມ '&&' ແລະ '||' ຜູ້ປະກອບການ, ໃນຂະນະທີ່ມັນບໍ່ຈໍາເປັນ
ຕິດຕາມ '&', '|&', ຫຼື ';'. ສະຖານະການອອກຂອງບັນຊີລາຍຊື່ແມ່ນຄໍາສັ່ງສຸດທ້າຍທີ່ຖືກປະຕິບັດ,
ມີຂໍ້ຍົກເວັ້ນຂອງລາຍການບໍ່ຊິ້ງ, ເຊິ່ງສະຖານະອອກແມ່ນ 0.
ຄໍາສັ່ງປະສົມແມ່ນຖືກສ້າງຂຶ້ນໂດຍໃຊ້ຄໍາທີ່ສະຫງວນໄວ້ຕໍ່ໄປນີ້. ຄໍາເຫຼົ່ານີ້ແມ່ນພຽງແຕ່
ຮັບຮູ້ວ່າພວກເຂົາຖືກກ່າວເຖິງແລະຖ້າພວກມັນຖືກໃຊ້ເປັນຄໍາທໍາອິດຂອງຄໍາສັ່ງ (ie
ພວກມັນບໍ່ສາມາດນຳໜ້າໂດຍການກຳນົດພາລາມິເຕີ ຫຼືການປ່ຽນເສັ້ນທາງ):
ກໍລະນີອື່ນເຮັດວຽກຫຼັງຈາກນັ້ນ! (
ເຮັດ esac ຖ້າເວລາ [[ ((
ສຳເລັດໄປຈົນຮອດ {
elif ສໍາລັບການເລືອກໃນຂະນະທີ່ }
ໃນຄໍາອະທິບາຍຄໍາສັ່ງປະສົມຕໍ່ໄປນີ້, ລາຍການຄໍາສັ່ງ (ຫມາຍເຖິງ ບັນຊີລາຍຊື່) ນັ້ນແມ່ນ
ຕິດຕາມດ້ວຍຄຳສັບທີ່ສະຫງວນໄວ້ຕ້ອງລົງທ້າຍດ້ວຍເຄື່ອງໝາຍຈຸດ, ແຖວໃໝ່ ຫຼື a (syntactically
ຖືກຕ້ອງ) ຄໍາສະຫງວນ. ຕົວຢ່າງ, ຕໍ່ໄປນີ້ແມ່ນຖືກຕ້ອງທັງຫມົດ:
$ { echo foo; echo bar; }
$ { echo foo; ແຖບສຽງ }
$ { { echo foo; echo bar; } }
ອັນນີ້ບໍ່ຖືກຕ້ອງ:
$ { echo foo; ແຖບສຽງດັງ }
(ບັນຊີລາຍຊື່)
ປະຕິບັດ ບັນຊີລາຍຊື່ ໃນ subshell ເປັນ. ບໍ່ມີວິທີການ implicit ຜ່ານການປ່ຽນແປງສະພາບແວດລ້ອມຈາກ
subshell ກັບຄືນໄປບ່ອນພໍ່ແມ່ຂອງມັນ.
{ ບັນຊີລາຍຊື່; }
ການກໍ່ສ້າງປະສົມ; ບັນຊີລາຍຊື່ ຖືກປະຕິບັດ, ແຕ່ບໍ່ແມ່ນຢູ່ໃນ subshell. ໃຫ້ສັງເກດວ່າ '{' ແລະ '}'
ແມ່ນຄໍາສະຫງວນ, ບໍ່ແມ່ນຕົວອັກສອນ meta.
ກໍລະນີ ຄໍາ ໃນ [[(] ຮູບແບບ [| ຮູບແບບ] ... ) ບັນຊີລາຍຊື່ terminator] ... esac
ໄດ້ ກໍລະນີ ຄໍາຖະແຫຼງທີ່ພະຍາຍາມຈັບຄູ່ ຄໍາ ຕໍ່ກັບການກໍານົດ ຮູບແບບ1 the ບັນຊີລາຍຊື່
ທີ່ກ່ຽວຂ້ອງກັບຮູບແບບການຈັບຄູ່ຢ່າງສໍາເລັດຜົນທໍາອິດຖືກປະຕິບັດ. ຮູບແບບທີ່ໃຊ້ໃນ
ກໍລະນີ ຖະແຫຼງການແມ່ນຄືກັນກັບທີ່ໃຊ້ສໍາລັບຮູບແບບຊື່ໄຟລ໌ຍົກເວັ້ນວ່າ
ຂໍ້ຈໍາກັດກ່ຽວກັບ '.' ແລະ '/' ຖືກຫຼຸດລົງ. ໃຫ້ສັງເກດວ່າພື້ນທີ່ unquoted ໃດກ່ອນ
ແລະຫຼັງຈາກຮູບແບບຖືກລອກອອກ; ພື້ນທີ່ໃດນຶ່ງພາຍໃນຮູບແບບຈະຕ້ອງຖືກອ້າງອີງ. ທັງ
ຄໍາສັບຕ່າງໆແລະຮູບແບບແມ່ນຂຶ້ນກັບຕົວກໍານົດການ, ຄໍາສັ່ງ, ແລະການທົດແທນເລກຄະນິດສາດ,
ເຊັ່ນດຽວກັນກັບການທົດແທນ tilde.
ສໍາລັບເຫດຜົນທາງປະຫວັດສາດ, ວົງເລັບເປີດແລະປິດອາດຈະຖືກນໍາໃຊ້ແທນ in ແລະ ວ່າ C ຕົວຢ່າງ:
ກໍລະນີ $foo { *) echo ພາທະນາຍຄວາມ ;; }.
ບັນຊີລາຍຊື່ terminators ແມ່ນ:
';;' ຢຸດຫຼັງຈາກບັນຊີລາຍຊື່.
';&' ຕົກຢູ່ໃນບັນຊີລາຍຊື່ຕໍ່ໄປ.
';|' ປະເມີນ tuples ບັນຊີລາຍຊື່ຮູບແບບທີ່ຍັງເຫຼືອ.
ສະຖານະພາບທາງອອກຂອງ ກ ກໍລະນີ ຖະແຫຼງການແມ່ນຂອງການປະຕິບັດ ບັນຊີລາຍຊື່; ຖ້າບໍ່ມີ ບັນຊີລາຍຊື່ is
ຖືກປະຕິບັດແລ້ວ, ສະຖານະການອອກແມ່ນສູນ.
ສໍາລັບການ ຊື່ [ໃນ ຄໍາ ...]; ເຮັດ ບັນຊີລາຍຊື່; ສຳເລັດແລ້ວ
ສໍາລັບແຕ່ລະຄົນ ຄໍາ ໃນບັນຊີລາຍຊື່ຄໍາທີ່ລະບຸ, ພາລາມິເຕີ ຊື່ ຖືກກໍານົດເປັນຄໍາແລະ
ບັນຊີລາຍຊື່ ຖືກປະຕິບັດ. ຖ້າ in ບໍ່ໄດ້ຖືກນໍາໃຊ້ເພື່ອກໍານົດລາຍການຄໍາ, ຕົວກໍານົດການຕໍາແຫນ່ງ
($1, $2, ແລະອື່ນໆ) ຖືກໃຊ້ແທນ. ສໍາລັບເຫດຜົນທາງປະຫວັດສາດ, ວົງເລັບເປີດແລະປິດອາດຈະເປັນ
ໃຊ້ແທນ do ແລະ ເຮັດ ຕົວຢ່າງ: ສໍາລັບການ i; { echo $i; }. ສະຖານະພາບທາງອອກຂອງ ກ ສໍາລັບການ
ຖະແຫຼງການແມ່ນສະຖານະການອອກສຸດທ້າຍຂອງ ບັນຊີລາຍຊື່; ຖ້າ ບັນຊີລາຍຊື່ ບໍ່ເຄີຍຖືກປະຕິບັດ, ສະຖານະການອອກ
ແມ່ນສູນ.
if ບັນຊີລາຍຊື່; ຫຼັງຈາກນັ້ນ ບັນຊີລາຍຊື່; [elif ບັນຊີລາຍຊື່; ຫຼັງຈາກນັ້ນ ບັນຊີລາຍຊື່;] ... [ອື່ນ ບັນຊີລາຍຊື່;] ຟີ
ຖ້າຫາກວ່າສະຖານະການອອກຈາກຄັ້ງທໍາອິດ ບັນຊີລາຍຊື່ ແມ່ນສູນ, ອັນທີສອງ ບັນຊີລາຍຊື່ ຖືກປະຕິບັດ; ຖ້າບໍ່ດັ່ງນັ້ນ,
ໄດ້ ບັນຊີລາຍຊື່ ດັ່ງຕໍ່ໄປນີ້ ເອລີຟ, ຖ້າມີ, ຖືກປະຕິບັດດ້ວຍຜົນສະທ້ອນທີ່ຄ້າຍຄືກັນ. ຂ້າພະເຈົ້າຕົກ
ບັນຊີລາຍຊື່ດັ່ງຕໍ່ໄປນີ້ if ແລະ ເອລີຟs ລົ້ມເຫລວ (ie ອອກຈາກສະຖານະທີ່ບໍ່ແມ່ນສູນ), the ບັນຊີລາຍຊື່
ດັ່ງຕໍ່ໄປນີ້ ອື່ນ ຖືກປະຕິບັດ. ສະຖານະພາບທາງອອກຂອງ an if ຄໍາຖະແຫຼງການແມ່ນວ່າບໍ່ແມ່ນ
ມີເງື່ອນໄຂ ບັນຊີລາຍຊື່ ທີ່ຖືກປະຕິບັດ; ຖ້າບໍ່ມີເງື່ອນໄຂ ບັນຊີລາຍຊື່ ຖືກປະຕິບັດ, ອອກຈາກ
ສະຖານະແມ່ນສູນ.
ເລືອກ ຊື່ [ໃນ ຄໍາ ...]; ເຮັດ ບັນຊີລາຍຊື່; ສຳເລັດແລ້ວ
ໄດ້ ເລືອກ ຖະແຫຼງການສະຫນອງວິທີການອັດຕະໂນມັດໃນການນໍາສະເຫນີຜູ້ໃຊ້ດ້ວຍເມນູ
ແລະເລືອກຈາກມັນ. ບັນຊີລາຍຊື່ enumerated ຂອງລະບຸໄວ້ ຄໍາ(s) ຖືກພິມອອກ
ຂໍ້ຜິດພາດມາດຕະຖານ, ຕິດຕາມດ້ວຍການເຕືອນ (PS3: ປົກກະຕິ '#? '). ຕົວເລກທີ່ສອດຄ້ອງກັບ
ຫນຶ່ງຂອງຄໍາທີ່ enumerated ແລ້ວແມ່ນອ່ານຈາກມາດຕະຖານເຂົ້າ, ຊື່ ຖືກຕັ້ງຄ່າໃຫ້
ຄໍາທີ່ເລືອກ (ຫຼືບໍ່ໄດ້ຕັ້ງຖ້າຫາກວ່າການຄັດເລືອກບໍ່ຖືກຕ້ອງ), REPLY ຖືກຕັ້ງເປັນສິ່ງທີ່ໄດ້ອ່ານ
(ຊ່ອງຊັ້ນນໍາ/ທາງຫລັງຖືກຖອດອອກ), ແລະ ບັນຊີລາຍຊື່ ຖືກປະຕິບັດ. ຖ້າເສັ້ນເປົ່າ (ie
ເລກສູນ ຫຼືຫຼາຍກວ່ານັ້ນ IFS octets) ຖືກປ້ອນ, ເມນູຈະຖືກພິມຄືນໃໝ່ໂດຍບໍ່ຕ້ອງດຳເນີນການ ບັນຊີລາຍຊື່.
ເມື່ອໃດ ບັນຊີລາຍຊື່ ສໍາເລັດ, ບັນຊີລາຍຊື່ enumerated ໄດ້ຖືກພິມອອກຖ້າຫາກວ່າການຕອບເປັນ NULL, prompt ແມ່ນ
ພິມ, ແລະອື່ນໆ. ຂະບວນການນີ້ສືບຕໍ່ໄປຈົນກວ່າໄຟລ໌ສິ້ນສຸດຈະຖືກອ່ານ, ຂັດຂວາງ
ແມ່ນໄດ້ຮັບ, ຫຼື a ພັກຜ່ອນ ຄໍາຖະແຫຼງທີ່ໄດ້ຖືກປະຕິບັດພາຍໃນ loop. ຖ້າ "ໃນຄໍາສັບ ... " ແມ່ນ
ຖືກລະເວັ້ນ, ຕົວກໍານົດການຕໍາແຫນ່ງແມ່ນຖືກນໍາໃຊ້ (ເຊັ່ນ: $1, $2, ແລະອື່ນໆ). ສໍາລັບປະຫວັດສາດ
ເຫດຜົນ, ວົງເລັບເປີດແລະປິດອາດຈະຖືກນໍາໃຊ້ແທນ do ແລະ ເຮັດ ຕົວຢ່າງ: ເລືອກ i; {
echo $i; }. ສະຖານະພາບທາງອອກຂອງ ກ ເລືອກ ຖະແຫຼງການແມ່ນສູນຖ້າ ກ ພັກຜ່ອນ ຖະແຫຼງການແມ່ນ
ໃຊ້ເພື່ອອອກຈາກ loop, ບໍ່ແມ່ນສູນ.
ຈົນກ່ວາ ບັນຊີລາຍຊື່; ເຮັດ ບັນຊີລາຍຊື່; ສຳເລັດແລ້ວ
ນີ້ເຮັດວຽກຄື ໃນຂະນະທີ່, ຍົກເວັ້ນວ່າຮ່າງກາຍໄດ້ຖືກປະຕິບັດພຽງແຕ່ໃນຂະນະທີ່ສະຖານະການອອກຂອງ
ທໍາອິດ ບັນຊີລາຍຊື່ ບໍ່ແມ່ນສູນ.
ໃນຂະນະທີ່ ບັນຊີລາຍຊື່; ເຮັດ ບັນຊີລາຍຊື່; ສຳເລັດແລ້ວ
A ໃນຂະນະທີ່ ເປັນ loop ທີ່ກວດສອບກ່ອນ. ຮ່າງກາຍຂອງມັນຖືກປະຕິບັດເລື້ອຍໆເທົ່າກັບສະຖານະພາບທາງອອກຂອງ
ທໍາອິດ ບັນຊີລາຍຊື່ ແມ່ນສູນ. ສະຖານະພາບທາງອອກຂອງ ກ ໃນຂະນະທີ່ ຖະແຫຼງການແມ່ນສະຖານະການອອກສຸດທ້າຍ
ຂອງ ບັນຊີລາຍຊື່ ໃນຮ່າງກາຍຂອງ loop ໄດ້; ຖ້າຮ່າງກາຍບໍ່ໄດ້ຖືກປະຕິບັດ, ສະຖານະການອອກແມ່ນ
ສູນ.
ຫນ້າທີ່ ຊື່ { ບັນຊີລາຍຊື່; }
ກໍານົດຫນ້າທີ່ ຊື່ (ເບິ່ງ ຫນ້າທີ່ ຂ້າງລຸ່ມນີ້). ໃຫ້ສັງເກດວ່າການປ່ຽນເສັ້ນທາງທີ່ລະບຸໄວ້
ຫຼັງຈາກຄໍານິຍາມຂອງຟັງຊັນຖືກປະຕິບັດທຸກຄັ້ງທີ່ຟັງຊັນຖືກປະຕິບັດ, ບໍ່ແມ່ນເວລາໃດ
ຄໍານິຍາມຟັງຊັນຖືກປະຕິບັດ.
ຊື່() ຄໍາສັ່ງ
ສ່ວນຫຼາຍແມ່ນຄືກັນກັບ ຫນ້າທີ່ (ເບິ່ງ ຫນ້າທີ່ ຂ້າງລຸ່ມນີ້). ຍະຫວ່າງ (ຍະຫວ່າງ ຫຼືແຖບ) ຫຼັງຈາກ
ຊື່ ສ່ວນຫຼາຍຈະຖືກລະເລີຍ.
ຫນ້າທີ່ ຊື່() { ບັນຊີລາຍຊື່; }
ຄືກັນກັບ ຊື່() (bashism). ໄດ້ ຫນ້າທີ່ ຄໍາສໍາຄັນຖືກລະເລີຍ.
ທີ່ໃຊ້ເວລາ [-p] [ທໍ່]
ໄດ້ ຄໍາສັ່ງ ການປະຕິບັດ ພາກສ່ວນອະທິບາຍໄດ້ ທີ່ໃຊ້ເວລາ ຄໍາສະຫງວນ.
(( ການສະແດງອອກ ))
ການສະແດງອອກທາງເລກຄະນິດ ການສະແດງອອກ ຖືກປະເມີນ; ເທົ່າກັບ "ໃຫ້ສະແດງອອກ" (ເບິ່ງ
ເລກຄະນິດສາດ expressions ແລະ ໃຫ້ ຄໍາສັ່ງ, ຂ້າງລຸ່ມນີ້) ໃນໂຄງສ້າງປະສົມ.
[[ ການສະແດງອອກ ]]
ຄ້າຍຄືກັນກັບ ການທົດສອບ ແລະ [ ... ] ຄໍາສັ່ງ (ອະທິບາຍຕໍ່ມາ), ມີດັ່ງຕໍ່ໄປນີ້
ຂໍ້ຍົກເວັ້ນ:
· ການແຍກຊ່ອງຂໍ້ມູນ ແລະການສ້າງຊື່ໄຟລ໌ແມ່ນບໍ່ໄດ້ດໍາເນີນຢູ່ໃນອາກິວເມັນ.
· ໄດ້ -a (AND) ແລະ -o (OR) ຕົວປະຕິບັດການຖືກແທນທີ່ດ້ວຍ '&&' ແລະ '||', ຕາມລໍາດັບ.
· ຜູ້ປະກອບການ (ເຊັ່ນ '-f' , ' = ' , '!') ຈະຕ້ອງບໍ່ໄດ້ອ້າງອີງ.
· ການທົດແທນພາລາມິເຕີ, ຄໍາສັ່ງ, ແລະເລກເລກຖືກປະຕິບັດເປັນການສະແດງອອກ
ການປະເມີນການສະແດງອອກ ແລະຂີ້ກຽດແມ່ນໃຊ້ສໍາລັບ '&&' ແລະ '||' ຜູ້ປະກອບການ.
ນີ້ຫມາຍຄວາມວ່າໃນຄໍາຖະແຫຼງຕໍ່ໄປນີ້, $( ຖືກປະເມີນຖ້າຫາກວ່າແລະພຽງແຕ່ຖ້າຫາກວ່າ
ເອກະສານທີ່ ຟູ ມີຢູ່ແລະສາມາດອ່ານໄດ້:
$ [[ -r foo && $(
· ຕົວປະຕິບັດການທີສອງຂອງ '!=' ແລະ '=' ສະແດງອອກເປັນຊຸດຍ່ອຍຂອງຮູບແບບ (ຕົວຢ່າງ.
ການປຽບທຽບ [[ ຟຸບາ = f*r ]] ສໍາເລັດ). ນີ້ຍັງເຮັດວຽກໂດຍທາງອ້ອມ:
$bar=foobar; baz='f*r'
$ [[ $bar = $baz ]]; ສະທ້ອນ $?
$ [[ $bar = "$baz" ]]; ສະທ້ອນ $?
ບາງທີເປັນເລື່ອງແປກທີ່, ການປຽບທຽບຄັ້ງທໍາອິດປະສົບຜົນສໍາເລັດ, ໃນຂະນະທີ່ທີສອງບໍ່ໄດ້ເຮັດ.
ນີ້ບໍ່ໄດ້ນໍາໃຊ້ກັບ metacharacters extglob ທັງຫມົດ, ໃນປັດຈຸບັນ.
Quoting
ການອ້າງອິງແມ່ນໃຊ້ເພື່ອປ້ອງກັນບໍ່ໃຫ້ແກະບໍ່ປະຕິບັດຕົວລະຄອນຫຼືຄໍາສັບຕ່າງໆໂດຍສະເພາະ. ມີ
ສາມວິທີການອ້າງອີງ. ທໍາອິດ, '\' ອ້າງເຖິງລັກສະນະຕໍ່ໄປນີ້, ເວັ້ນເສຍແຕ່ວ່າມັນຢູ່ທີ່
ທ້າຍແຖວ, ໃນກໍລະນີທັງ '\' ແລະແຖວໃໝ່ຖືກຖອດອອກ. ອັນທີສອງ, ດຽວ
quote ("'") quotes ທຸກສິ່ງທຸກຢ່າງເຖິງ quote ດຽວຕໍ່ໄປ (ອັນນີ້ອາດຈະຂະຫຍາຍເສັ້ນ). ອັນທີສາມ, ກ
ວົງຢືມຄູ່ ('"') quotes ຕົວອັກສອນທັງໝົດ, ຍົກເວັ້ນ '$', '`' ແລະ '\', ຈົນຮອດຕົວຕໍ່ໄປທີ່ບໍ່ໄດ້ໜີ.
ວົງຢືມຄູ່. '$' ແລະ '`' ພາຍໃນວົງຢືມຄູ່ມີຄວາມຫມາຍປົກກະຕິ (ເຊັ່ນ: ພາລາມິເຕີ,
ເລກເລກ, ຫຼືການທົດແທນຄໍາສັ່ງ) ຍົກເວັ້ນບໍ່ມີການແບ່ງພາກສະໜາມຕາມຜົນໄດ້ຮັບ
ຂອງການທົດແທນແບບ double-quoted, ແລະຮູບແບບເກົ່າຂອງການທົດແທນຄໍາສັ່ງມີ
backslash-quoting ສໍາລັບວົງຢືມຄູ່ຖືກເປີດໃຊ້. ຖ້າ '\' ຢູ່ໃນສະຕຣິງທີ່ອ້າງອີງສອງເທົ່າແມ່ນ
ຕາມດ້ວຍ '\', '$', '`', ຫຼື '"', ມັນຖືກແທນທີ່ດ້ວຍຕົວອັກສອນທີສອງ; ຖ້າມັນປະຕິບັດຕາມ
ໂດຍເສັ້ນໃໝ່, ທັງ '\' ແລະແຖວໃໝ່ຖືກຖອດອອກ; ຖ້າບໍ່ດັ່ງນັ້ນ, ທັງ '\' ແລະ
ລັກສະນະຕໍ່ໄປນີ້ບໍ່ປ່ຽນແປງ.
ຖ້າສະຕຣິງທີ່ຍົກມາອັນດຽວຖືກນຳໜ້າດ້ວຍ '$', ການຂະຫຍາຍ backslash ແບບ C (ເບິ່ງ
ຂ້າງລຸ່ມ) ຖືກນຳໃຊ້ (ແມ້ແຕ່ຕົວໜັງສືອ້າງອີງດຽວພາຍໃນສາມາດຖືກຫລົບໜີ ແລະບໍ່ໄດ້ສິ້ນສຸດ
the string then); ຜົນໄດ້ຮັບທີ່ຂະຫຍາຍໄດ້ຖືກປະຕິບັດເປັນສາຍພັນດຽວທີ່ອ້າງອີງ. ຖ້າ ກ
ສະຕຣິງທີ່ອ້າງອີງສອງເທື່ອແມ່ນນຳໜ້າດ້ວຍ '$' ທີ່ບໍ່ໄດ້ອ້າງອີງ, '$' ແມ່ນຖືກລະເລີຍງ່າຍໆ.
backslash ການຂະຫຍາຍຕົວ
ໃນສະຖານທີ່ທີ່ມີການຂະຫຍາຍ backslashes, ບາງ C ແລະ AT&T UNIX ksh ຫຼື GNU bash ແບບ
ແປວ່າ escapes. ເຫຼົ່ານີ້ລວມມີ '\a', '\b', '\f', '\n', '\r', '\t', '\U#########',
'\u####', ແລະ '\v'. ສຳລັບ '\U########' ແລະ '\u####', “#” ຫມາຍເຖິງຕົວເລກເລກຖານສິບຫົກ.
ອາດຈະບໍ່ມີເຖິງສີ່ຫຼືແປດ; ການຫລົບໜີເຫຼົ່ານີ້ແປຈຸດລະຫັດ Unicode ເປັນ UTF-8.
ນອກຈາກນັ້ນ, '\E' ແລະ '\e' ຂະຫຍາຍໄປເປັນຕົວລະຄອນໜີ.
ໃນ ພິມ ໂໝດຢູ່ໃນຕົວ, '\"', '\', ແລະ '\?' ຖືກຍົກເວັ້ນຢ່າງຈະແຈ້ງ; ລຳດັບແປດ
ຕ້ອງມີຕົວເລກບໍ່ເຖິງສາມໂຕເລກ “#” ນຳໜ້າດ້ວຍຕົວເລກສູນ ('\0###');
ລຳດັບເລກຖານສິບຫົກ '\x##' ຖືກຈຳກັດບໍ່ໃຫ້ມີສູງສຸດສອງຕົວເລກຖານສິບຫົກ “#”; ທັງສອງ
ລຳດັບເລກຖານສິບຫົກ ແລະເລກຖານສິບຫົກປ່ຽນເປັນ octets ດິບ; '\#', ບ່ອນທີ່ # ບໍ່ແມ່ນອັນໃດຂ້າງເທິງ,
ແປຄຳອະທິບາຍກັບຄືນເປັນ ອັງກິດ (ສະຫະລັດ) ແປພາສາ \# (backslashes are retained).
ການຂະຫຍາຍ backslash ໃນໂຫມດ C style ແຕກຕ່າງກັນເລັກນ້ອຍ: ລໍາດັບ octal '\###' ຕ້ອງມີ
no digit zero prefixing the one up to three octal digits “#” and yield octets raw;
ລຳດັບເລກຖານສິບຫົກ '\x#*' ກິນຕົວເລກເລກຖານສິບຫົກຢ່າງໂລບມາກ “#” ເທົ່າທີ່ຈະເຮັດໄດ້ ແລະ
ສິ້ນສຸດດ້ວຍຕົວເລກທີ່ບໍ່ແມ່ນເລກຖານສິບຫົກທໍາອິດ; ເຫຼົ່ານີ້ແປຈຸດລະຫັດ Unicode ເປັນ
UTF-8. ລຳດັບ '\c#', ເຊິ່ງ “#” ແມ່ນ octet ໃດ, ແປເປັນ Ctrl-# (ເຊິ່ງໂດຍພື້ນຖານແລ້ວ.
ຫມາຍຄວາມວ່າ, '\c?' ກາຍເປັນ DEL, ທຸກສິ່ງທຸກຢ່າງແມ່ນ bitwise ANDed ກັບ 0x1F). ສຸດທ້າຍ, '\#', ບ່ອນໃດ
# ບໍ່ແມ່ນອັນໃດຂ້າງເທິງ, ແປວ່າ # (ມີ backslash trimmed), ເຖິງແມ່ນວ່າມັນເປັນ.
ແຖວໃໝ່.
ນາມແຝງ
ມີສອງປະເພດຂອງນາມແຝງ: ນາມແຝງຄໍາສັ່ງປົກກະຕິແລະນາມແຝງຕິດຕາມ. ນາມແຝງຄໍາສັ່ງ
ປົກກະຕິແລ້ວແມ່ນໃຊ້ເປັນມືສັ້ນສໍາລັບຄໍາສັ່ງຍາວຫຼືຖືກນໍາໃຊ້ເລື້ອຍໆ. ແກະຂະຫຍາຍອອກ
ນາມແຝງຄໍາສັ່ງ (ເຊັ່ນການປ່ຽນຊື່ນາມແຝງສໍາລັບມູນຄ່າຂອງມັນ) ເມື່ອມັນອ່ານຄໍາທໍາອິດ
ຂອງຄໍາສັ່ງ. ມີການປະມວນຜົນນາມແຝງທີ່ຂະຫຍາຍອອກໃໝ່ເພື່ອກວດເບິ່ງນາມແຝງເພີ່ມເຕີມ. ຖ້າຫາກວ່າຄໍາສັ່ງ
alias ສິ້ນສຸດລົງໃນຊ່ອງຫຼືແຖບ, ຄໍາຕໍ່ໄປນີ້ຍັງຖືກກວດສອບການຂະຫຍາຍນາມແຝງ. ໄດ້
ຂະບວນການຂະຫຍາຍນາມແຝງຢຸດເມື່ອພົບຄຳທີ່ບໍ່ແມ່ນນາມແຝງ, ເມື່ອຄຳສັບທີ່ຍົກມາ
ໄດ້ຖືກພົບເຫັນ, ຫຼືໃນເວລາທີ່ຄໍານາມແຝງທີ່ກໍາລັງຖືກຂະຫຍາຍອອກໄປແມ່ນພົບເຫັນ. ນາມແຝງແມ່ນ
ໂດຍສະເພາະລັກສະນະການໂຕ້ຕອບ: ໃນຂະນະທີ່ພວກເຂົາເກີດຂຶ້ນກັບການເຮັດວຽກໃນສະຄິບແລະໃນ
ເສັ້ນຄໍາສັ່ງໃນບາງກໍລະນີ, ນາມແຝງຖືກຂະຫຍາຍໃນລະຫວ່າງການ lexing, ດັ່ງນັ້ນການນໍາໃຊ້ຂອງມັນຕ້ອງຢູ່ໃນ a
ຕົ້ນໄມ້ຄໍາສັ່ງແຍກຕ່າງຫາກຈາກຄໍານິຍາມຂອງພວກເຂົາ; ຖ້າບໍ່ດັ່ງນັ້ນ, alias ຈະບໍ່ພົບ.
ສັງເກດເຫັນ, ລາຍຊື່ຄໍາສັ່ງ (ແຍກດ້ວຍເຄື່ອງໝາຍຈຸດ, ໃນການປ່ຽນຄໍາສັ່ງດ້ວຍແຖວໃໝ່)
ອາດຈະເປັນຕົ້ນໄມ້ parse ດຽວກັນ.
ນາມແຝງຄໍາສັ່ງຕໍ່ໄປນີ້ແມ່ນຖືກກໍານົດໂດຍອັດຕະໂນມັດໂດຍ shell:
autoload='\typeset -fu'
functions='\typeset -f'
hash='\builtin alias -t'
ປະຫວັດ='\builtin fc -l'
integer='\typeset -i'
local='\typeset'
login='\exec ເຂົ້າສູ່ລະບົບ'
nameref='\typeset -n'
nohup='nohup'
r='\ສ້າງ fc -e -'
type='\builtin whence -v'
ນາມແຝງທີ່ຖືກຕິດຕາມເຮັດໃຫ້ແກະຈື່ບ່ອນທີ່ມັນພົບຄໍາສັ່ງໂດຍສະເພາະ. ທໍາອິດ
ເວລາທີ່ແກະເຮັດການຄົ້ນຫາເສັ້ນທາງສໍາລັບຄໍາສັ່ງທີ່ຖືກຫມາຍເປັນນາມແຝງທີ່ຖືກຕິດຕາມ, ມັນຈະຊ່ວຍປະຢັດ
ເສັ້ນທາງອັນເຕັມທີ່ຂອງຄໍາສັ່ງ. ໃນເວລາຕໍ່ໄປຄໍາສັ່ງຖືກປະຕິບັດ, ແກະຈະກວດເບິ່ງ
ເສັ້ນທາງທີ່ບັນທຶກໄວ້ເພື່ອເບິ່ງວ່າມັນຍັງຖືກຕ້ອງ, ແລະຖ້າເປັນດັ່ງນັ້ນ, ຫຼີກເວັ້ນການຊ້ໍາການຄົ້ນຫາເສັ້ນທາງ.
ນາມແຝງທີ່ຖືກຕິດຕາມສາມາດຖືກລະບຸໄວ້ແລະສ້າງໂດຍໃຊ້ alias -t. ໃຫ້ສັງເກດວ່າການປ່ຽນແປງ PATH
ພາລາມິເຕີລຶບເສັ້ນທາງທີ່ບັນທຶກໄວ້ສໍາລັບນາມແຝງທີ່ຖືກຕິດຕາມທັງຫມົດ. ຖ້າ ຕິດຕາມ ທາງເລືອກໄດ້ຖືກຕັ້ງໄວ້
(ເຊົ່ນ ທີ່ກໍານົດໄວ້ -o ຕິດຕາມ or ທີ່ກໍານົດໄວ້ -h), shell ຕິດຕາມຄໍາສັ່ງທັງຫມົດ. ຕົວເລືອກນີ້ຖືກຕັ້ງ
ອັດຕະໂນມັດສໍາລັບແກະທີ່ບໍ່ມີການໂຕ້ຕອບ. ສໍາລັບ shells ແບບໂຕ້ຕອບ, ພຽງແຕ່ດັ່ງຕໍ່ໄປນີ້
ຄໍາສັ່ງແມ່ນຕິດຕາມອັດຕະໂນມັດ: cat(1) cc(1) chmod(1) cp(1) ວັນ(1) ed(1)
emacs(1) grep(1) ls(1) ເຮັດໃຫ້(1) mv(1) pr(1) rm(1) sed(1) sh(1) vi(1) ແລະ ຜູ້ທີ່(1).
ປ່ຽນແທນ
ຂັ້ນຕອນທໍາອິດທີ່ແກະໃຊ້ໃນການປະຕິບັດຄໍາສັ່ງແບບງ່າຍໆແມ່ນເພື່ອປະຕິບັດການທົດແທນ
ຄໍາສັ່ງຂອງ. ມີສາມປະເພດຂອງການທົດແທນ: ພາລາມິເຕີ, ຄໍາສັ່ງ, ແລະ
ເລກຄະນິດສາດ. ການທົດແທນພາລາມິເຕີ, ເຊິ່ງໄດ້ອະທິບາຍລາຍລະອຽດໃນພາກຕໍ່ໄປ,
ເອົາແບບຟອມ $ຊື່ ຫຼື ${...} ; ການປ່ຽນຄໍາສັ່ງໃຊ້ແບບຟອມ $(ຄໍາສັ່ງ) ຫຼື
(ປະຕິເສດ) `ຄໍາສັ່ງ` ຫຼື (ປະຕິບັດໃນສະພາບແວດລ້ອມປະຈຸບັນ) ${ ຄໍາສັ່ງ;} ແລະເສັ້ນດ່າງ
trailing newlines; ແລະການທົດແທນເລກເລກໃຊ້ໃນຮູບແບບ $((ການສະແດງອອກ)). parsing ໄດ້
ການທົດແທນຄໍາສັ່ງສະພາບແວດລ້ອມໃນປະຈຸບັນຮຽກຮ້ອງໃຫ້ມີຊ່ອງຫວ່າງ, ແຖບຫຼືແຖວໃຫມ່ຫຼັງຈາກການເປີດ
brace ແລະວ່າວົງເລັບປິດຈະຖືກຮັບຮູ້ເປັນຄໍາສໍາຄັນ (ie ແມ່ນນໍາຫນ້າໂດຍເສັ້ນໃຫມ່
ຫຼື semicolon). ພວກເຂົາຍັງຖືກເອີ້ນວ່າ funsubs (ການທົດແທນຫນ້າທີ່) ແລະປະຕິບັດຕົວຄືກັບ
ຫນ້າທີ່ຢູ່ໃນນັ້ນ ທ້ອງຖິ່ນ ແລະ ການກັບຄືນມາ ເຮັດວຽກ, ແລະໃນນັ້ນ ການທ່ອງທ່ຽວ terminates ແກະພໍ່ແມ່; ແກະ
ທາງເລືອກແມ່ນແບ່ງປັນ.
ການປ່ຽນແປງອື່ນຂອງການທົດແທນແມ່ນ valsubs (ການທົດແທນມູນຄ່າ) ${|ຄໍາສັ່ງ;} ເຊິ່ງແມ່ນ
ຍັງຖືກປະຕິບັດໃນສະພາບແວດລ້ອມປະຈຸບັນ, ເຊັ່ນ funsubs, ແຕ່ແບ່ງປັນ I/O ຂອງເຂົາເຈົ້າກັບພໍ່ແມ່;
ແທນທີ່ຈະ, ພວກເຂົາເຈົ້າປະເມີນເຖິງອັນໃດກໍ່ຕາມ, ໃນເບື້ອງຕົ້ນເປົ່າ, ການສະແດງອອກ - ຕົວແປທ້ອງຖິ່ນ REPLY ແມ່ນ
ກໍານົດຢູ່ໃນ ຄໍາສັ່ງs.
ຖ້າການທົດແທນປາກົດຢູ່ນອກວົງຢືມຄູ່, ຜົນໄດ້ຮັບຂອງການທົດແທນແມ່ນ
ໂດຍທົ່ວໄປແມ່ນຂຶ້ນກັບການແບ່ງປັນຄໍາຫຼືພາກສະຫນາມຕາມມູນຄ່າປະຈຸບັນຂອງ IFS
ພາລາມິເຕີ. ພາລາມິເຕີ IFS ກໍານົດບັນຊີລາຍຊື່ຂອງ octets ທີ່ຖືກນໍາໃຊ້ເພື່ອທໍາລາຍສາຍຂຶ້ນ
ເຂົ້າໄປໃນຫຼາຍຄໍາ; octets ໃດໆຈາກພື້ນທີ່ທີ່ກໍານົດໄວ້, ແຖບ, ແລະແຖວໃຫມ່ທີ່ປາກົດຢູ່ໃນ IFS
octets ຖືກເອີ້ນວ່າ "IFS whitespace". ລໍາດັບຂອງຫນຶ່ງຫຼືຫຼາຍ IFS whitespace octets, ໃນ
ປະສົມປະສານກັບສູນ ຫຼືໜຶ່ງບ່ອນທີ່ບໍ່ແມ່ນ IFS octets, ຈຳກັດຊ່ອງຂໍ້ມູນ. ເປັນກໍລະນີພິເສດ,
ຊ່ອງຫວ່າງ IFS ຊັ້ນນໍາ ແລະຕາມຫຼັງແມ່ນຖືກລອກອອກ (ເຊັ່ນວ່າບໍ່ມີຊ່ອງຫວ່າງທີ່ນໍາໜ້າ ຫຼືຕາມຫຼັງ
ສ້າງໂດຍມັນ); ແຖວໜ້າ ຫຼືທາງຫຼັງທີ່ບໍ່ແມ່ນ IFS whitespace ຈະສ້າງຊ່ອງຫວ່າງເປົ່າ.
ຕົວຢ່າງ: ຖ້າ IFS ຖືກຕັ້ງເປັນ “ :”, ແລະ VAR ຖືກຕັ້ງເປັນ
“ ກ : B::D”, ການປ່ຽນແທນ $VAR ໄດ້ຜົນໃນສີ່ຊ່ອງ: 'A',
'B', '' (ຊ່ອງຫວ່າງເປົ່າ), ແລະ 'D'. ໃຫ້ສັງເກດວ່າຖ້າຕົວກໍານົດການ IFS ຖືກຕັ້ງເປັນຫວ່າງເປົ່າ
string, ບໍ່ມີການແຍກພາກສະຫນາມແມ່ນເຮັດ; ຖ້າມັນບໍ່ໄດ້ຖືກຕັ້ງ, ຄ່າເລີ່ມຕົ້ນຂອງພື້ນທີ່, ແຖບ, ແລະ
ເສັ້ນໃຫມ່ຖືກນໍາໃຊ້.
ນອກຈາກນີ້, ຈົ່ງສັງເກດວ່າການແບ່ງປັນພາກສະຫນາມໃຊ້ກັບຜົນໄດ້ຮັບທັນທີທັນໃດຂອງ
ການທົດແທນ. ການນໍາໃຊ້ຕົວຢ່າງທີ່ຜ່ານມາ, ການທົດແທນສໍາລັບ $VAR:E ຜົນໄດ້ຮັບໃນ
ຊ່ອງຂໍ້ມູນ: 'A', 'B', '', ແລະ 'D:E', ບໍ່ແມ່ນ 'A', 'B', '', 'D', ແລະ 'E'. ພຶດຕິກໍານີ້ແມ່ນ POSIX
ສອດຄ້ອງກັນ, ແຕ່ບໍ່ເຂົ້າກັນໄດ້ກັບບາງການປະຕິບັດແກະອື່ນໆທີ່ເຮັດການແບ່ງພາກສະໜາມ
ກ່ຽວກັບຄໍາທີ່ມີການທົດແທນຫຼືໃຊ້ IFS ເປັນຕົວກໍານົດຂອບເຂດສີຂາວທົ່ວໄປ.
ຜົນໄດ້ຮັບຂອງການທົດແທນແມ່ນ, ເວັ້ນເສຍແຕ່ໄດ້ລະບຸໄວ້ເປັນຢ່າງອື່ນ, ຍັງຂຶ້ນກັບການຂະຫຍາຍວົງເລັບ
ແລະການຂະຫຍາຍຊື່ໄຟລ໌ (ເບິ່ງພາກສ່ວນທີ່ກ່ຽວຂ້ອງຂ້າງລຸ່ມນີ້).
ການທົດແທນຄໍາສັ່ງຖືກແທນທີ່ດ້ວຍຜົນຜະລິດທີ່ສ້າງຂຶ້ນໂດຍຄໍາສັ່ງທີ່ລະບຸໄວ້
ແລ່ນຢູ່ໃນ subshell. ສໍາລັບ $(ຄໍາສັ່ງ) ແລະ ${|ຄໍາສັ່ງ;} ແລະ ${ ຄໍາສັ່ງ;} ການທົດແທນ, ປົກກະຕິ
ກົດລະບຽບການອ້າງອີງຖືກໃຊ້ເມື່ອ ຄໍາສັ່ງ ແມ່ນ pared; ຢ່າງໃດກໍຕາມ, ສໍາລັບການປະຕິເສດ `ຄໍາສັ່ງ`ແບບຟອມ, ກ
'\' ຕາມດ້ວຍອັນໃດນຶ່ງຂອງ '$', '`', ຫຼື '\' ຖືກຖອດອອກ (ເປັນ '"' ເມື່ອການທົດແທນເປັນສ່ວນໜຶ່ງ.
of a double-quoted string); backslash '\' ຕິດຕາມດ້ວຍຕົວອັກສອນອື່ນໆແມ່ນບໍ່ປ່ຽນແປງ.
ເປັນກໍລະນີພິເສດໃນການທົດແທນຄໍາສັ່ງ, ຄໍາສັ່ງຂອງແບບຟອມເອກະສານ ຖືກຕີຄວາມໝາຍເປັນ
ຫມາຍຄວາມວ່າການທົດແທນເນື້ອໃນຂອງ ເອກະສານ. ໃຫ້ສັງເກດວ່າ $( ມີຜົນກະທົບດຽວກັນກັບ $(ແມວ ຟູ).
ໃຫ້ສັງເກດວ່າບາງ shells ບໍ່ໃຊ້ recursive parser ສໍາລັບການທົດແທນຄໍາສັ່ງ, ນໍາໄປສູ່
ຄວາມລົ້ມເຫຼວສໍາລັບການກໍ່ສ້າງສະເພາະໃດຫນຶ່ງ; ເພື່ອໃຫ້ສາມາດເຄື່ອນທີ່, ໃຊ້ເປັນການແກ້ໄຂ 'x=$(cat) <<"EOF"' (ຫຼື
newline-keeping 'x=<<"EOF"' extension) ແທນທີ່ຈະເປັນພຽງແຕ່ slurp string. IEEE Std 1003.1
(“POSIX.1”) ແນະນຳໃຫ້ໃຊ້ກໍລະນີຂອງແບບຟອມ 'x=$(case $foo in (bar) echo $bar.
;; (*) echo $baz ;; esac)' ແທນທີ່ຈະ, ເຊິ່ງຈະເຮັດວຽກແຕ່ບໍ່ແມ່ນຕົວຢ່າງສໍາລັບການນີ້
ບັນຫາການພົກພາ.
x=$(ກໍລະນີ $foo ໃນແຖບ) echo $bar ;; *) ສຽງສະທ້ອນ $baz ;; esac)
# ຂ້າງເທິງລົ້ມເຫລວໃນການແຍກວິເຄາະກ່ຽວກັບແກະເກົ່າ; ຂ້າງລຸ່ມນີ້ແມ່ນການແກ້ໄຂ
x=$(eval $(cat)) <<"EOF"
case $foo in bar) echo $bar ;; *) ສຽງສະທ້ອນ $baz ;; esac
EOF
ການທົດແທນເລກເລກຖືກແທນທີ່ດ້ວຍຄ່າຂອງການສະແດງຜົນທີ່ລະບຸໄວ້. ສໍາລັບ
ຕົວຢ່າງ, ຄໍາສັ່ງ ພິມ $((2+3*4)) ສະແດງ 14. ເບິ່ງ ເລກຄະນິດສາດ expressions ສໍາລັບ
ລາຍລະອຽດຂອງການສະແດງອອກ.
ຕົວກໍານົດການ
ພາລາມິເຕີແມ່ນຕົວແປຂອງແກະ; ພວກເຂົາເຈົ້າສາມາດໄດ້ຮັບການມອບຫມາຍມູນຄ່າແລະມູນຄ່າຂອງເຂົາເຈົ້າສາມາດເຂົ້າເຖິງໄດ້
ການນໍາໃຊ້ຕົວກໍານົດການທົດແທນ. ຊື່ພາຣາມິເຕີແມ່ນໜຶ່ງໃນອັນດຽວພິເສດ
ວັກຕອນ ຫຼືຕົວກໍານົດຕົວອັກສອນທີ່ອະທິບາຍໄວ້ຂ້າງລຸ່ມນີ້, ຫຼືຕົວອັກສອນຕາມດ້ວຍສູນ ຫຼື
ຕົວອັກສອນ ຫຼືຕົວເລກເພີ່ມເຕີມ ('_' ນັບເປັນຕົວອັກສອນ). ຮູບແບບສຸດທ້າຍສາມາດຖືກປະຕິບັດເປັນ arrays
ໂດຍການຕໍ່ທ້າຍດັດຊະນີ array ຂອງຮູບແບບ [ຕົວຢ່າງ] ບ່ອນທີ່ ຕົວຢ່າງ ແມ່ນການສະແດງອອກທາງເລກເລກ.
ຕົວຊີ້ວັດ Array ໃນ mksh ແມ່ນຖືກຈຳກັດຢູ່ໃນຂອບເຂດ 0 ຫາ 4294967295, ລວມທັງໝົດ. ນັ້ນແມ່ນ,
ພວກມັນເປັນຈຳນວນເຕັມທີ່ບໍ່ໄດ້ເຊັນ 32-bit.
ການທົດແທນພາລາມິເຕີໃຊ້ແບບຟອມ $ຊື່, ${ຊື່}, ຫຼື ${ຊື່[ຕົວຢ່າງ]} ຢູ່ໃສ ຊື່ ເປັນ
ຊື່ພາລາມິເຕີ. ການທົດແທນອົງປະກອບອາເຣທັງໝົດດ້ວຍ ${ຊື່[*]} ແລະ ${ຊື່[@]} ເຮັດວຽກ
ເທົ່າກັບ $* ແລະ $@ ສໍາລັບຕົວກໍານົດການຕໍາແຫນ່ງ. ຖ້າການທົດແທນຖືກປະຕິບັດໃນ a
ພາຣາມິເຕີ (ຫຼືອົງປະກອບພາລາມິເຕີ array) ທີ່ບໍ່ໄດ້ຕັ້ງ, ສະຕຣິງ null ຖືກທົດແທນ
ເວັ້ນເສຍແຕ່ວ່າ ຄຳນາມ ທາງເລືອກ (ທີ່ກໍານົດໄວ້ -o ຄຳນາມ or ທີ່ກໍານົດໄວ້ -u) ຖືກກໍານົດ, ໃນກໍລະນີທີ່ມີຄວາມຜິດພາດເກີດຂຶ້ນ.
ພາລາມິເຕີສາມາດຖືກກໍາຫນົດຄ່າໃນຫຼາຍວິທີ. ຫນ້າທໍາອິດ, ແກະ implicitly ກໍານົດ
ບາງຕົວກໍານົດການເຊັ່ນ '#', 'PWD', ແລະ '$'; ນີ້ແມ່ນວິທີດຽວທີ່ມີລັກສະນະພິເສດສະເພາະ
ຕົວກໍານົດການຖືກກໍານົດ. ອັນທີສອງ, ພາລາມິເຕີຖືກນໍາເຂົ້າຈາກສະພາບແວດລ້ອມຂອງແກະຢູ່ທີ່
ເລີ່ມຕົ້ນ. ອັນທີສາມ, ພາລາມິເຕີສາມາດຖືກກໍາຫນົດຄ່າໃນເສັ້ນຄໍາສັ່ງ: ຕົວຢ່າງ, FOO=bar
ກໍານົດພາລາມິເຕີ "FOO" ເປັນ "bar"; ການມອບຫມາຍພາລາມິເຕີຫຼາຍສາມາດຖືກມອບໃຫ້ກັບອັນດຽວ
ເສັ້ນຄໍາສັ່ງແລະພວກເຂົາສາມາດຖືກປະຕິບັດຕາມຄໍາສັ່ງແບບງ່າຍໆ, ໃນກໍລະນີນີ້ການມອບຫມາຍແມ່ນ
ມີຜົນກະທົບພຽງແຕ່ສໍາລັບໄລຍະເວລາຂອງຄໍາສັ່ງ (ການມອບຫມາຍດັ່ງກ່າວຍັງຖືກສົ່ງອອກ; ເບິ່ງ
ຂ້າງລຸ່ມນີ້ສໍາລັບຜົນສະທ້ອນຂອງເລື່ອງນີ້). ໃຫ້ສັງເກດວ່າທັງຊື່ພາລາມິເຕີແລະ '=' ຈະຕ້ອງເປັນ
unquoted ສໍາລັບ shell ເພື່ອຮັບຮູ້ການມອບຫມາຍພາລາມິເຕີ. ການກໍ່ສ້າງ FOO+=baz ແມ່ນຍັງ
ຮັບຮູ້; ຄຸນຄ່າເກົ່າແລະໃຫມ່ແມ່ນປະສົມປະສານທັນທີ. ວິທີທີສີ່ຂອງການຕັ້ງຄ່າ
ຕົວກໍານົດການແມ່ນຂຶ້ນກັບ ການສົ່ງອອກ, ທົ່ວໂລກ, ອ່ານຢ່າງດຽວ, ແລະ ປະເພດ ຄໍາສັ່ງ; ເບິ່ງຂອງເຂົາເຈົ້າ
ລາຍລະອຽດໃນ ຄໍາສັ່ງ ການປະຕິບັດ ພາກ. ທີຫ້າ, ສໍາລັບການ ແລະ ເລືອກ loops ກໍານົດພາລາມິເຕີ
ເຊັ່ນດຽວກັນກັບ ໝໍ້, ອ່ານ, ແລະ ທີ່ກໍານົດໄວ້ -A ຄໍາສັ່ງ. ສຸດທ້າຍ, ຕົວກໍານົດການສາມາດຖືກກໍານົດ
ຄ່າທີ່ໃຊ້ຕົວປະຕິບັດການມອບໝາຍພາຍໃນສຳນວນເລກເລກ (ເບິ່ງ ເລກຄະນິດສາດ expressions
ຂ້າງລຸ່ມນີ້) ຫຼືໃຊ້ ${ຊື່=ມູນຄ່າ} ຮູບແບບການທົດແທນພາລາມິເຕີ (ເບິ່ງຂ້າງລຸ່ມນີ້).
ພາລາມິເຕີທີ່ມີຄຸນລັກສະນະການສົ່ງອອກ (ຕັ້ງໂດຍໃຊ້ ການສົ່ງອອກ or ປະເພດ -x ຄໍາສັ່ງ, ຫຼືໂດຍ
ການມອບຫມາຍພາລາມິເຕີປະຕິບັດຕາມຄໍາສັ່ງງ່າຍໆ) ແມ່ນຖືກຈັດໃສ່ໃນສະພາບແວດລ້ອມ (ເບິ່ງ
ກ່ຽວກັບ(7)) ຂອງຄໍາສັ່ງດໍາເນີນການໂດຍ shell ເປັນ ຊື່=ມູນຄ່າ ຄູ່. ຄໍາສັ່ງໃນຕົວກໍານົດການ
ປະກົດຢູ່ໃນສະພາບແວດລ້ອມຂອງຄໍາສັ່ງແມ່ນບໍ່ໄດ້ກໍານົດ. ໃນເວລາທີ່ແກະເລີ່ມຕົ້ນຂຶ້ນ, ມັນ
ສະກັດພາລາມິເຕີແລະມູນຄ່າຂອງພວກມັນອອກຈາກສະພາບແວດລ້ອມຂອງມັນແລະກໍານົດການສົ່ງອອກໂດຍອັດຕະໂນມັດ
ຄຸນລັກສະນະສໍາລັບພາລາມິເຕີເຫຼົ່ານັ້ນ.
ຕົວແກ້ໄຂສາມາດໃຊ້ກັບ ${ຊື່} ຮູບແບບການທົດແທນພາລາມິເຕີ:
${ຊື່:-ຄໍາ}
If ຊື່ ຖືກກໍານົດແລະບໍ່ເປັນ NULL, ມັນໄດ້ຖືກທົດແທນ; ຖ້າບໍ່ດັ່ງນັ້ນ, ຄໍາ ຖືກປ່ຽນແທນ.
${ຊື່:+ຄໍາ}
If ຊື່ ຖືກຕັ້ງແລະບໍ່ແມ່ນ NULL, ຄໍາ ຖືກທົດແທນ; ຖ້າບໍ່ດັ່ງນັ້ນ, ບໍ່ມີຫຍັງຖືກທົດແທນ.
${ຊື່:=ຄໍາ}
If ຊື່ ຖືກກໍານົດແລະບໍ່ເປັນ NULL, ມັນໄດ້ຖືກທົດແທນ; ຖ້າບໍ່ດັ່ງນັ້ນ, ມັນໄດ້ຖືກມອບຫມາຍ ຄໍາ ແລະ
ມູນຄ່າຜົນໄດ້ຮັບຂອງ ຊື່ ຖືກປ່ຽນແທນ.
${ຊື່:?ຄໍາ}
If ຊື່ ຖືກກໍານົດແລະບໍ່ເປັນ NULL, ມັນໄດ້ຖືກທົດແທນ; ຖ້າບໍ່ດັ່ງນັ້ນ, ຄໍາ ຖືກພິມໃສ່
ຄວາມຜິດພາດມາດຕະຖານ (ກ່ອນຫນ້າໂດຍ ຊື່:) ແລະຄວາມຜິດພາດເກີດຂຶ້ນ (ປົກກະຕິເຮັດໃຫ້ການຢຸດເຊົາ
ຂອງ shell script, function, ຫຼື script ທີ່ມາຈາກການໃຊ້ '.' ໃນຕົວ). ຖ້າ ຄໍາ is
ຖືກລະເວັ້ນ, ສະຕຣິງ "ພາຣາມິເຕີ null ຫຼືບໍ່ໄດ້ຕັ້ງ" ຖືກໃຊ້ແທນ. ໃນປັດຈຸບັນມີ bug,
if ຄໍາ ແມ່ນຕົວແປທີ່ຂະຫຍາຍໄປຫາສະຕຣິງ null, ຂໍ້ຄວາມສະແດງຂໍ້ຜິດພາດແມ່ນເຊັ່ນກັນ
ພິມອອກ.
ໃຫ້ສັງເກດວ່າ, ສໍາລັບທັງຫມົດຂ້າງເທິງ, ຄໍາ ຕົວຈິງແລ້ວແມ່ນພິຈາລະນາທີ່ອ້າງເຖິງ, ແລະການວິເຄາະພິເສດ
ກົດລະບຽບນຳໃຊ້. ກົດລະບຽບການວິພາກວິຈານຍັງແຕກຕ່າງກັນກ່ຽວກັບວ່າສຳນວນນັ້ນຖືກອ້າງອີງສອງເທົ່າຫຼືບໍ່: ຄໍາ
ຈາກນັ້ນໃຊ້ກົດລະບຽບການອ້າງອີງຄູ່, ຍົກເວັ້ນລາຄາຄູ່ຕົວມັນເອງ ('"') ແລະການປິດ
brace, ເຊິ່ງ, ຖ້າ backslash ຫນີ, ໄດ້ຮັບການຖອນ quote ຖືກນໍາໃຊ້.
ໃນຕົວແກ້ໄຂຂ້າງເທິງ, ':' ສາມາດຖືກຍົກເລີກ, ໃນກໍລະນີນີ້ເງື່ອນໄຂພຽງແຕ່ຂຶ້ນກັບ
ຊື່ ຖືກຕັ້ງ (ກົງກັນຂ້າມກັບກໍານົດແລະບໍ່ແມ່ນ NULL). ຖ້າ ຄໍາ ຕ້ອງການ, ພາລາມິເຕີ, ຄໍາສັ່ງ,
ເລກເລກ, ແລະການທົດແທນ tilde ແມ່ນປະຕິບັດກັບມັນ; ຖ້າ ຄໍາ ບໍ່ຈໍາເປັນ, ມັນບໍ່ແມ່ນ
ການປະເມີນຜົນ.
ຮູບແບບການທົດແທນພາລາມິເຕີຕໍ່ໄປນີ້ຍັງສາມາດຖືກນໍາໃຊ້ (ຖ້າ ຊື່ ເປັນ array, ໄດ້
ອົງປະກອບທີ່ມີກະແຈ “0” ຈະຖືກແທນທີ່ໃນບໍລິບົດສະເກັດເງິນ):
${#ຊື່}
ຈໍານວນຕົວກໍານົດການຕໍາແຫນ່ງຖ້າ ຊື່ ແມ່ນ '*', '@', ຫຼືບໍ່ໄດ້ລະບຸ; ຖ້າບໍ່ດັ່ງນັ້ນ
ຄວາມຍາວ (ໃນຕົວອັກສອນ) ຂອງຄ່າສະຕຣິງຂອງພາຣາມິເຕີ ຊື່.
${#ຊື່[*]}
${#ຊື່[@]}
ຈຳນວນຂອງອົງປະກອບໃນອາເຣ ຊື່.
${%ຊື່}
ຄວາມກວ້າງ (ໃນຖັນໜ້າຈໍ) ຂອງຄ່າສະຕຣິງຂອງພາຣາມິເຕີ ຊື່, ຫຼື -1 ຖ້າ
${ຊື່} ມີຕົວອັກສອນຄວບຄຸມ.
${!ຊື່}
ຊື່ຂອງຕົວແປທີ່ອ້າງເຖິງໂດຍ ຊື່. ນີ້ຈະເປັນ ຊື່ ຍົກເວັ້ນເວລາ ຊື່ is
ຊື່ອ້າງອີງ (ຕົວແປທີ່ຜູກມັດ), ສ້າງໂດຍ ຊື່ref ຄໍາສັ່ງ (ຊຶ່ງເປັນນາມແຝງ
ສໍາລັບການ ປະເພດ -n).
${!ຊື່[*]}
${!ຊື່[@]}
ຊື່ຂອງດັດຊະນີ (ກະແຈ) ໃນອາເຣ ຊື່.
${ຊື່#ຮູບແບບ}
${ຊື່##ຮູບແບບ}
If ຮູບແບບ ກົງກັບຈຸດເລີ່ມຕົ້ນຂອງຄ່າພາລາມິເຕີ ຊື່, ຂໍ້ຄວາມທີ່ກົງກັນແມ່ນ
ລຶບອອກຈາກຜົນຂອງການທົດແທນ. '#' ອັນດຽວສົ່ງຜົນໃຫ້ສັ້ນທີ່ສຸດ
ການແຂ່ງຂັນ, ແລະທັງສອງຂອງພວກເຂົາເຮັດໃຫ້ການແຂ່ງຂັນທີ່ຍາວທີ່ສຸດ. ບໍ່ສາມາດໃຊ້ກັບ vector ໄດ້
(${*} ຫຼື ${@} ຫຼື ${array[*]} ຫຼື ${array[@]}).
${ຊື່%ຮູບແບບ}
${ຊື່%%ຮູບແບບ}
ເຊັ່ນດຽວກັບ ${..#..} ການທົດແທນ, ແຕ່ມັນລົບອອກຈາກຈຸດສິ້ນສຸດຂອງຄ່າ. ບໍ່ສາມາດຈະ
ນຳໃຊ້ກັບ vector.
${ຊື່/ຮູບແບບ/ສາຍ}
${ຊື່/#ຮູບແບບ/ສາຍ}
${ຊື່/%ຮູບແບບ/ສາຍ}
${ຊື່//ຮູບແບບ/ສາຍ}
ການແຂ່ງຂັນທີ່ຍາວທີ່ສຸດຂອງ ຮູບແບບ ໃນມູນຄ່າຂອງພາລາມິເຕີ ຊື່ ຖືກແທນທີ່ດ້ວຍ string
(ຖືກລຶບຖ້າ string ຫວ່າງເປົ່າ; ເສັ້ນຊ້ອນທ້າຍ ('/') ອາດຈະຖືກລະເວັ້ນໃນກໍລະນີນີ້).
A ປ້າຍຕັດຊັ້ນນໍາຕາມດ້ວຍ '#' ຫຼື '%' ເຮັດໃຫ້ຮູບແບບຖືກຍຶດຢູ່ທີ່
ການເລີ່ມຕົ້ນຫຼືສິ້ນສຸດຂອງມູນຄ່າ, ຕາມລໍາດັບ; ຫວ່າງເປົ່າ unanchored ຮູບແບບs ສາເຫດທີ່ບໍ່ມີ
ການທົດແທນ; ທັບເສັ້ນນຳໜ້າອັນດຽວ ຫຼືການໃຊ້ a ຮູບແບບ ທີ່ກົງກັບຫວ່າງເປົ່າ
string ເຮັດໃຫ້ການທົດແທນເກີດຂຶ້ນພຽງແຕ່ຄັ້ງດຽວ; ສອງ slashes ຊັ້ນນໍາເຮັດໃຫ້ເກີດທັງຫມົດ
ການປະກົດຕົວຂອງຂໍ້ມູນທີ່ກົງກັນໃນຄ່າທີ່ຈະທົດແທນ. ບໍ່ສາມາດໃຊ້ກັບ vector ໄດ້.
ການປະຕິບັດບໍ່ມີປະສິດທິພາບ, ອາດຈະຊ້າ.
${ຊື່:pos:len}
ທໍາອິດ len ລັກສະນະຂອງ ຊື່, ເລີ່ມແຕ່ຕໍາແຫນ່ງ pos, ຖືກທົດແທນ. ທັງສອງ
pos ແລະ:len ເປັນທາງເລືອກ. ຖ້າ pos ແມ່ນທາງລົບ, ການນັບເລີ່ມຕົ້ນໃນຕອນທ້າຍຂອງການ
ຊ່ອຍແນ່; ຖ້າມັນຖືກລະເວັ້ນ, ມັນຈະເລີ່ມຕົ້ນເປັນ 0. ຖ້າ len ຖືກລະເວັ້ນ ຫຼືໃຫຍ່ກວ່າ
ຄວາມຍາວຂອງສາຍທີ່ຍັງເຫຼືອ, ທັງຫມົດຂອງມັນຖືກປ່ຽນແທນ. ທັງສອງ pos ແລະ len ມີ
ປະເມີນເປັນການສະແດງອອກທາງເລກຄະນິດ. ໃນປັດຈຸບັນ, pos ຕ້ອງເລີ່ມຕົ້ນດ້ວຍຊ່ອງຫວ່າງ,
ເປີດວົງເລັບ ຫຼືຕົວເລກທີ່ຈະຮັບຮູ້. ບໍ່ສາມາດໃຊ້ກັບ vector ໄດ້.
${ຊື່@#}
The hash (ໃຊ້ BAFH algorithm) ຂອງການຂະຫຍາຍຕົວຂອງ ຊື່. ນີ້ຍັງຖືກນໍາໃຊ້
ພາຍໃນສໍາລັບ hashables ຂອງແກະ.
${ຊື່@Q}
ການສະແດງອອກທີ່ອ້າງອີງທີ່ປອດໄພສໍາລັບການເຂົ້າໃຫມ່, ມູນຄ່າຂອງມັນແມ່ນມູນຄ່າຂອງ ຊື່
ພາລາມິເຕີ, ຖືກທົດແທນ.
ໃຫ້ສັງເກດວ່າ ຮູບແບບ ອາດຈະຕ້ອງການຂະຫຍາຍຮູບແບບ globbing (@(...)), ດຽວ ('...') ຫຼື double
("...") quote escaping ເວັ້ນເສຍແຕ່ -o sh ຖືກກໍານົດ.
ຕົວກໍານົດການພິເສດຕໍ່ໄປນີ້ແມ່ນກໍານົດ implicitly ໂດຍ shell ແລະບໍ່ສາມາດກໍານົດໂດຍກົງ
ການນໍາໃຊ້ວຽກງານ:
! ID ຂະບວນການຂອງຂະບວນການພື້ນຖານສຸດທ້າຍໄດ້ເລີ່ມຕົ້ນ. ຖ້າບໍ່ມີຂະບວນການພື້ນຖານ
ໄດ້ເລີ່ມຕົ້ນ, ພາລາມິເຕີບໍ່ໄດ້ຕັ້ງ.
# ຈຳນວນຕົວກໍານົດການຕັ້ງ ($1, $2, ແລະອື່ນໆ).
$ PID ຂອງແກະ, ຫຼື PID ຂອງແກະຕົ້ນສະບັບຖ້າມັນເປັນ subshell. ເຮັດ ບໍ່
ໃຊ້ກົນໄກນີ້ສໍາລັບການສ້າງຊື່ໄຟລ໌ຊົ່ວຄາວ; ເບິ່ງ mktemp(1) ແທນ.
- concatenation ຂອງຕົວເລືອກຕົວອັກສອນດຽວໃນປັດຈຸບັນ (ເບິ່ງ ທີ່ກໍານົດໄວ້ ຄໍາສັ່ງຂ້າງລຸ່ມນີ້
ສໍາລັບບັນຊີລາຍຊື່ຂອງທາງເລືອກ).
? ສະຖານະການອອກຂອງຄໍາສັ່ງທີ່ບໍ່ແມ່ນ asynchronous ສຸດທ້າຍຖືກປະຕິບັດ. ຖ້າຄໍາສັ່ງສຸດທ້າຍ
ຖືກຂ້າຕາຍໂດຍສັນຍານ, $? ຖືກຕັ້ງເປັນ 128 ບວກກັບຕົວເລກສັນຍານ, ແຕ່ຫຼາຍທີ່ສຸດແມ່ນ 255.
0 ຊື່ຂອງແກະ, ກໍານົດດັ່ງຕໍ່ໄປນີ້: ການໂຕ້ຖຽງທໍາອິດກັບ mksh ຖ້າມັນແມ່ນ
ຮຽກຮ້ອງໃຫ້ມີ -c ທາງເລືອກແລະການໂຕ້ຖຽງໄດ້ຖືກມອບໃຫ້; ຖ້າບໍ່ດັ່ງນັ້ນ ເອກະສານ ການໂຕ້ຖຽງ, ຖ້າ
ມັນໄດ້ຖືກສະຫນອງ; ຫຼືຊື່ພື້ນຖານທີ່ແກະຖືກເອີ້ນດ້ວຍ (ie argv[0]). $0
ຍັງຖືກຕັ້ງເປັນຊື່ຂອງສະຄຣິບປັດຈຸບັນ ຫຼືຊື່ຂອງຟັງຊັນປັດຈຸບັນ,
ຖ້າມັນຖືກກໍານົດດ້ວຍ ຫນ້າທີ່ ຄໍາສໍາຄັນ (ເຊັ່ນການທໍາງານແບບ Korn shell).
1.. 9 ຕົວກໍານົດການຕໍາແຫນ່ງເກົ້າທໍາອິດທີ່ສະຫນອງໃຫ້ແກ່ແກະ, ຫນ້າທີ່, ຫຼື
script ທີ່ມາຈາກການນໍາໃຊ້ '.' ໃນຕົວ. ຕົວກໍານົດການຕໍາແຫນ່ງເພີ່ມເຕີມອາດຈະເປັນ
ເຂົ້າເຖິງໂດຍໃຊ້ ${ຈໍານວນ}.
* ຕົວກໍານົດການຕໍາແຫນ່ງທັງຫມົດ (ຍົກເວັ້ນ 0), ເຊັ່ນ: $1, $2, $3, ...
ຖ້າໃຊ້ນອກວົງຢືມຄູ່, ພາລາມິເຕີແມ່ນຄໍາທີ່ແຍກຕ່າງຫາກ (ເຊິ່ງຂຶ້ນກັບ
ການແຍກຄໍາສັບ); ຖ້າໃຊ້ພາຍໃນວົງຢືມຄູ່, ພາລາມິເຕີຈະຖືກແຍກອອກດ້ວຍ
ຕົວອັກສອນທຳອິດຂອງພາຣາມິເຕີ IFS (ຫຼືສະຕຣິງຫວ່າງເປົ່າຖ້າ IFS ເປັນ NULL).
@ ຄືກັນກັບ $*, ເວັ້ນເສຍແຕ່ວ່າມັນຖືກນໍາໃຊ້ພາຍໃນວົງຢືມຄູ່, ໃນກໍລະນີທີ່ມີຄໍາແຍກຕ່າງຫາກ
ສ້າງຂຶ້ນສໍາລັບແຕ່ລະຕົວກໍານົດການຕໍາແຫນ່ງ. ຖ້າບໍ່ມີຕົວກໍານົດການຕໍາແຫນ່ງ, ບໍ່ມີ
ຄໍາທີ່ຖືກສ້າງຂຶ້ນ. $@ ສາມາດຖືກນໍາໃຊ້ເພື່ອເຂົ້າເຖິງການໂຕ້ຖຽງ, verbatim, ໂດຍບໍ່ມີການສູນເສຍ
ອາກິວເມັນ NULL ຫຼືການແຍກອາກິວເມັນດ້ວຍຍະຫວ່າງ.
ພາຣາມິເຕີຕໍ່ໄປນີ້ຖືກຕັ້ງ ແລະ/ຫຼືໃຊ້ໂດຍແກະ:
_ (underscore) ເມື່ອຄໍາສັ່ງພາຍນອກຖືກປະຕິບັດໂດຍ shell, ພາລາມິເຕີນີ້
ຖືກກໍານົດໄວ້ໃນສະພາບແວດລ້ອມຂອງຂະບວນການໃຫມ່ໄປສູ່ເສັ້ນທາງທີ່ຖືກປະຕິບັດ
ຄໍາສັ່ງ. ໃນການນໍາໃຊ້ແບບໂຕ້ຕອບ, ພາລາມິເຕີນີ້ຍັງຖືກຕັ້ງຢູ່ໃນແກ່ນຂອງພໍ່ແມ່
ຄໍາສຸດທ້າຍຂອງຄໍາສັ່ງທີ່ຜ່ານມາ.
BASHPID PID ຂອງ shell ຫຼື subshell.
CDPATH ເຊັ່ນດຽວກັນກັບເສັ້ນທາງ, ແຕ່ໃຊ້ເພື່ອແກ້ໄຂການໂຕ້ຖຽງກັບ cd ຄໍາສັ່ງໃນຕົວ. ຫມາຍເຫດ
ວ່າ ຖ້າ CDPATH ຖືກຕັ້ງ ແລະບໍ່ມີ '.' ຫຼືອົງປະກອບສະຕຣິງຫວ່າງເປົ່າ, ໄດ້
ໄດເລກະທໍລີປະຈຸບັນບໍ່ໄດ້ຖືກຄົ້ນຫາ. ນອກຈາກນີ້, ໄດ້ cd ຄໍາສັ່ງໃນຕົວຈະສະແດງ
ໄດເລກະທໍລີຜົນໄດ້ຮັບໃນເວລາທີ່ການຈັບຄູ່ຖືກພົບເຫັນຢູ່ໃນເສັ້ນທາງຄົ້ນຫາໃດໆນອກເຫນືອຈາກ
ເສັ້ນທາງເປົ່າ.
COLUMNS ກໍານົດເປັນຈໍານວນຖັນໃນ terminal ຫຼືປ່ອງຢ້ຽມ. ຕັ້ງສະເໝີ, ຄ່າເລີ່ມຕົ້ນ
ເຖິງ 80, ເວັ້ນເສຍແຕ່ຄ່າຕາມລາຍງານໂດຍ stty(1) ບໍ່ແມ່ນສູນແລະ sane ພຽງພໍ
(ຕໍາ່ສຸດທີ່ 12x3); ຄ້າຍຄືກັນສໍາລັບ LINES. ພາລາມິເຕີນີ້ຖືກນໍາໃຊ້ໂດຍ
ຮູບແບບການແກ້ໄຂເສັ້ນແບບໂຕ້ຕອບ, ແລະໂດຍ ເລືອກ, ທີ່ກໍານົດໄວ້ -o, ແລະ ຂ້າ -l ຄໍາສັ່ງ
ເພື່ອຈັດຮູບແບບຖັນຂໍ້ມູນ. ການນໍາເຂົ້າຈາກສະພາບແວດລ້ອມຫຼືບໍ່ໄດ້ຕັ້ງຄ່າ
ຕົວກໍານົດການນີ້ເອົາການຜູກມັດກັບຂະຫນາດ terminal ຕົວຈິງໃນເງື່ອນໄຂຂອງ
ມູນຄ່າທີ່ສະຫນອງໃຫ້.
ENV ຖ້າພົບພາລາມິເຕີນີ້ຖືກຕັ້ງຫຼັງຈາກໄຟລ໌ໂປຣໄຟລ໌ໃດຖືກປະຕິບັດແລ້ວ,
ມູນຄ່າຂະຫຍາຍແມ່ນໃຊ້ເປັນໄຟລ໌ເລີ່ມຕົ້ນຂອງ shell. ໂດຍປົກກະຕິມັນປະກອບດ້ວຍຫນ້າທີ່
ແລະຄໍານິຍາມນາມແຝງ.
ERRNO ຄ່າຈຳນວນເຕັມຂອງ Shell's ຜິດພາດ ຕົວແປ. ມັນຊີ້ໃຫ້ເຫັນເຫດຜົນສຸດທ້າຍ
ການໂທລະບົບລົ້ມເຫລວ. ຍັງບໍ່ທັນໄດ້ປະຕິບັດ.
EXECSHELL ຖ້າຕັ້ງ, ພາລາມິເຕີນີ້ສົມມຸດວ່າມີແກະທີ່ຈະໃຊ້
ປະຕິບັດຄໍາສັ່ງນັ້ນ ຍົກເວັ້ນ(2) ລົ້ມເຫລວໃນການປະຕິບັດແລະທີ່ບໍ່ໄດ້ເລີ່ມຕົ້ນດ້ວຍ a
“#!ຫອຍ” ລໍາດັບ.
FCEDIT ບັນນາທິການທີ່ໃຊ້ໂດຍ fc ຄໍາສັ່ງ (ເບິ່ງຂ້າງລຸ່ມນີ້).
FPATH ຄືກັນກັບເສັ້ນທາງ, ແຕ່ໃຊ້ເມື່ອຟັງຊັນທີ່ບໍ່ໄດ້ກຳນົດໄວ້ເພື່ອຄົ້ນຫາໄຟລ໌
ການກໍານົດຫນ້າທີ່. ມັນຍັງຖືກຄົ້ນຫາເມື່ອບໍ່ສາມາດຊອກຫາຄໍາສັ່ງໂດຍໃຊ້
ເສັ້ນທາງ. ເບິ່ງ ຫນ້າທີ່ ຂ້າງລຸ່ມສໍາລັບຂໍ້ມູນເພີ່ມເຕີມ.
HISTFILE ຊື່ຂອງໄຟລ໌ທີ່ໃຊ້ໃນການເກັບຮັກສາປະຫວັດຄໍາສັ່ງ. ເມື່ອມອບໝາຍໃຫ້ ຫຼືບໍ່ໄດ້ຕັ້ງ,
ໄຟລ ໌ ໄດ້ ຖືກ ເປີດ, ປະ ຫວັດ ສາດ ໄດ້ ຖືກ ຕັດ ຫຼັງ ຈາກ ນັ້ນ loaded ຈາກ ໄຟລ ໌; ຕໍ່ມາ
ຄໍາສັ່ງໃຫມ່ (ອາດຈະປະກອບດ້ວຍຫຼາຍເສັ້ນ) ຖືກຕໍ່ທ້າຍເມື່ອພວກມັນ
ລວບລວມສົບຜົນສໍາເລັດ. ນອກຈາກນີ້, ການຮຽກຮ້ອງຫຼາຍຂອງແກະຈະແບ່ງປັນ
ປະຫວັດສາດຖ້າຫາກວ່າຕົວກໍານົດການ HISTFILE ຂອງເຂົາເຈົ້າຊີ້ໃຫ້ເຫັນເຖິງໄຟລ໌ດຽວກັນ.
ຫມາຍເຫດ: ຖ້າ HISTFILE ບໍ່ຖືກຕັ້ງ ຫຼືຫວ່າງເປົ່າ, ບໍ່ມີໄຟລ໌ປະຫວັດສາດຖືກນໍາໃຊ້. ນີ້ແມ່ນ
ແຕກຕ່າງຈາກ AT&T UNIX ksh.
HISTSIZE ຈໍານວນຄໍາສັ່ງປົກກະຕິເກັບຮັກສາໄວ້ສໍາລັບປະຫວັດສາດ. ຄ່າເລີ່ມຕົ້ນແມ່ນ 2047. ເຮັດ
ບໍ່ໄດ້ຕັ້ງຄ່ານີ້ເປັນຄ່າທີ່ສູງບ້າເຊັ່ນ 1000000000 ເພາະວ່າ mksh ສາມາດເຮັດໄດ້
ຫຼັງຈາກນັ້ນບໍ່ໄດ້ຈັດສັນຄວາມຊົງຈໍາພຽງພໍສໍາລັບປະຫວັດສາດແລະຈະບໍ່ເລີ່ມຕົ້ນ.
ຫນ້າທໍາອິດ ໄດເລກະທໍລີເລີ່ມຕົ້ນສໍາລັບ cd ຄໍາສັ່ງແລະຄ່າທີ່ຖືກທົດແທນສໍາລັບການ
ບໍ່ມີເງື່ອນໄຂ ~ (ເບິ່ງ ເຄື່ອງ ໝາຍ ສຳ ນຽງ ການຂະຫຍາຍຕົວ ດ້ານລຸ່ມ).
IFS ຕົວແຍກພາກສະຫນາມພາຍໃນ, ຖືກນໍາໃຊ້ໃນລະຫວ່າງການທົດແທນແລະໂດຍ ອ່ານ ຄໍາສັ່ງ, to
ແບ່ງຄ່າເປັນການໂຕ້ຖຽງທີ່ແຕກຕ່າງກັນ; ປົກກະຕິຕັ້ງເປັນຍະຫວ່າງ, ແຖບ, ແລະແຖວໃໝ່.
ເບິ່ງ ປ່ຽນແທນ ຂ້າງເທິງ ສຳ ລັບລາຍລະອຽດ.
ຫມາຍເຫດ: ພາລາມິເຕີນີ້ບໍ່ໄດ້ນໍາເຂົ້າຈາກສະພາບແວດລ້ອມໃນເວລາທີ່ແກະແມ່ນ
ເລີ່ມຕົ້ນ.
KSHEGID ID ກຸ່ມທີ່ມີປະສິດທິພາບຂອງ shell.
KSHGID ID ກຸ່ມທີ່ແທ້ຈິງຂອງ shell.
KSHUID ລະຫັດຜູ້ໃຊ້ທີ່ແທ້ຈິງຂອງແກະ.
KSH_VERSION ຊື່ ແລະລຸ້ນຂອງແກະ (ອ່ານເທົ່ານັ້ນ). ເບິ່ງຄໍາສັ່ງສະບັບ
in Emacs ການແກ້ໄຂ ຮູບແບບການ ແລະ Vi ການແກ້ໄຂ ຮູບແບບການ ພາກສ່ວນ, ຂ້າງລຸ່ມນີ້.
LINENO ໝາຍເລກແຖວຂອງຟັງຊັນ ຫຼື shell script ທີ່ກຳລັງເປັນຢູ່
ປະຕິບັດ.
LINES ຕັ້ງເປັນຈໍານວນເສັ້ນຢູ່ໃນ terminal ຫຼືປ່ອງຢ້ຽມ. ຕັ້ງໄວ້ສະເໝີ, ຕັ້ງເປັນຄ່າເລີ່ມຕົ້ນ
24. ເບິ່ງ COLUMNS.
EPOCHREALTIME
ເວລານັບຕັ້ງແຕ່ຍຸກ, ດັ່ງທີ່ກັບຄືນມາໂດຍ gettime ofday(2), ຟໍແມັດເປັນທົດສະນິຍົມ
tv_sec ຕາມດ້ວຍຈຸດ ('.') ແລະ tv_usec padded ກັບແທ້ຫົກທົດສະນິຍົມ
ຕົວເລກ.
OLDPWD ໄດເລກະທໍລີທີ່ເຮັດວຽກຜ່ານມາ. ບໍ່ໄດ້ຕັ້ງຖ້າ cd ບໍ່ໄດ້ປ່ຽນແປງຢ່າງສໍາເລັດຜົນ
ໄດເລກະທໍລີຕັ້ງແຕ່ແກະເລີ່ມຕົ້ນ, ຫຼືຖ້າແກະບໍ່ຮູ້ວ່າມັນຢູ່ໃສ.
OPTARG ເມື່ອໃຊ້ ໝໍ້, ມັນປະກອບດ້ວຍການໂຕ້ຖຽງສໍາລັບທາງເລືອກທີ່ແຍກວິເຄາະ, ຖ້າມັນ
ຕ້ອງການຫນຶ່ງ.
OPTIND ດັດຊະນີຂອງ argument ຕໍ່ໄປທີ່ຈະດໍາເນີນການໃນເວລາທີ່ການນໍາໃຊ້ ໝໍ້. ການມອບໝາຍ 1
ກັບພາລາມິເຕີນີ້ເຮັດໃຫ້ເກີດ ໝໍ້ ເພື່ອປະມວນຜົນການໂຕ້ຖຽງຕັ້ງແຕ່ເລີ່ມຕົ້ນ
ໃນຄັ້ງຕໍ່ໄປມັນຖືກຮຽກຮ້ອງ.
ເສັ້ນທາງ A ຈໍ້າສອງເມັດ (ເຄື່ອງໝາຍຈຸດໃນ OS/2) ແຍກລາຍຊື່ໄດເລກະທໍລີທີ່ຊອກຫາ
ໃນເວລາທີ່ຊອກຫາຄໍາສັ່ງແລະໄຟລ໌ທີ່ມາຈາກການນໍາໃຊ້ '.' ຄໍາສັ່ງ (ເບິ່ງຂ້າງລຸ່ມນີ້).
ສະຕຣິງຫວ່າງເປົ່າທີ່ເປັນຜົນມາຈາກຈໍ້າສອງເມັດ ຫຼື ແຖວໜ້າ ຫຼືສອງອັນຕິດກັນ
ຈໍ້າສອງເມັດ, ຖືກປະຕິບັດເປັນ '.' (ໄດເລກະທໍລີປະຈຸບັນ).
PGRP ID ຂະບວນການຂອງຜູ້ນໍາກຸ່ມຂະບວນການ Shell.
PIPESTATUS array ທີ່ບັນຈຸລະຫັດຄວາມຜິດພາດ (ສະຖານະການອອກ), ຫນຶ່ງຕໍ່ຫນຶ່ງ, ຂອງສຸດທ້າຍ.
ທໍ່ແລ່ນຢູ່ທາງໜ້າ.
PPID ID ຂະບວນການຂອງພໍ່ແມ່ຂອງແກະ.
PS1 ການເຕືອນຕົ້ນຕໍສໍາລັບ shells ແບບໂຕ້ຕອບ. ພາລາມິເຕີ, ຄໍາສັ່ງ, ແລະເລກເລກ
ການທົດແທນແມ່ນປະຕິບັດ, ແລະ '!' ຖືກແທນທີ່ດ້ວຍຄໍາສັ່ງປະຈຸບັນ
ເລກ (ເບິ່ງ fc ຄໍາສັ່ງຂ້າງລຸ່ມນີ້). ຕົວໜັງສື '!' ສາມາດໄດ້ຮັບການກະຕຸ້ນເຕືອນໂດຍ
ວາງ '!!' ໃນ PS1.
ການເຕືອນເລີ່ມຕົ້ນແມ່ນ '$' ສໍາລັບຜູ້ໃຊ້ທີ່ບໍ່ແມ່ນຮາກ, '#' ສໍາລັບຮາກ. ຖ້າ mksh is
invoked ໂດຍ root ແລະ PS1 ບໍ່ມີຕົວອັກສອນ '#', ຄ່າເລີ່ມຕົ້ນ
ຈະຖືກນໍາໃຊ້ເຖິງແມ່ນວ່າ PS1 ມີຢູ່ໃນສະພາບແວດລ້ອມແລ້ວ.
ໄດ້ mksh ການແຜ່ກະຈາຍມາພ້ອມກັບຕົວຢ່າງ dot.mkshrc ປະກອບດ້ວຍຊັບຊ້ອນ
ຕົວຢ່າງ, ແຕ່ເຈົ້າອາດຈະມັກອັນຕໍ່ໄປນີ້ (ໃຫ້ສັງເກດວ່າ
${HOSTNAME:=$(hostname)} ແລະຂໍ້ແຍກຄວາມແຕກຕ່າງຂອງ root-vs-user ແມ່ນ (ໃນ
ຕົວຢ່າງນີ້) ຖືກປະຕິບັດໃນເວລາມອບຫມາຍ PS1, ໃນຂະນະທີ່ $USER ແລະ $PWD ແມ່ນ
escaped ແລະດັ່ງນັ້ນຈະໄດ້ຮັບການປະເມີນຜົນໃນແຕ່ລະຄັ້ງທີ່ກະຕຸ້ນການສະແດງໃຫ້ເຫັນ):
PS1='${USER:=$(id -un)}'"@${HOSTNAME:=$(hostname)}:\$PWD $(
ຖ້າ (( USER_ID )); ຈາກນັ້ນພິມ \$; ພິມອື່ນ \#; fi) "
ໃຫ້ສັງເກດວ່ານັບຕັ້ງແຕ່ບັນນາທິການບັນທັດຄໍາສັ່ງພະຍາຍາມຄິດອອກວ່າດົນປານໃດ prompt
ແມ່ນ (ສະນັ້ນເຂົາເຈົ້າຮູ້ວ່າມັນໄກປານໃດມັນແມ່ນກັບແຂບຂອງຫນ້າຈໍໄດ້) , ຫນີລະຫັດໃນ
ການກະຕຸ້ນເຕືອນມີແນວໂນ້ມທີ່ຈະເຮັດໃຫ້ສິ່ງທີ່ສັບສົນ. ທ່ານສາມາດບອກແກະບໍ່ໃຫ້ນັບທີ່ແນ່ນອນ
ລໍາດັບ (ເຊັ່ນ: ລະຫັດຫນີ) ໂດຍການນໍາຫນ້າການເຕືອນຂອງທ່ານດ້ວຍຕົວອັກສອນ
(ເຊັ່ນ: Ctrl-A) ຕິດຕາມດ້ວຍການສົ່ງກັບ carriage ແລະຫຼັງຈາກນັ້ນ delimiting ການຫນີ
ລະຫັດທີ່ມີຕົວອັກສອນນີ້. ການປະກົດຕົວໃດໆຂອງລັກສະນະນັ້ນຢູ່ໃນການກະຕຸ້ນເຕືອນແມ່ນ
ບໍ່ໄດ້ພິມ. ໂດຍວິທີທາງການ, ບໍ່ໄດ້ຕໍານິຕິຕຽນຂ້າພະເຈົ້າສໍາລັບການ hack ນີ້; ມັນມາຈາກ
ຕົ້ນສະບັບ ksh88(1), ເຊິ່ງໄດ້ພິມຕົວອັກສອນຕົວກໍານົດຂອບເຂດເພື່ອໃຫ້ທ່ານອອກຈາກ
ໂຊກດີຖ້າຫາກວ່າທ່ານບໍ່ມີຕົວອັກສອນທີ່ບໍ່ແມ່ນການພິມ.
ເນື່ອງຈາກ Backslashes ແລະລັກສະນະພິເສດອື່ນໆອາດຈະຖືກຕີຄວາມຫມາຍໂດຍແກະ,
ເພື່ອຕັ້ງ PS1 ອອກຈາກ backslash ຕົວມັນເອງ, ຫຼືໃຊ້ວົງຢືມສອງເທົ່າ. ໄດ້
ສຸດທ້າຍແມ່ນປະຕິບັດຫຼາຍ. ນີ້ແມ່ນຕົວຢ່າງທີ່ສັບສົນຫຼາຍ, ຫຼີກເວັ້ນການໂດຍກົງ
ໃສ່ຕົວອັກສອນພິເສດ (ຕົວຢ່າງ: ^V ໃນຮູບແບບການແກ້ໄຂ emacs), ເຊິ່ງ
ຝັງໄດເລກະທໍລີທີ່ເຮັດວຽກໃນປະຈຸບັນ, ໃນວິດີໂອປີ້ນກັບກັນ (ສີຈະເຮັດວຽກ,
ເຊັ່ນດຽວກັນ), ໃນສະຕຣິງ prompt:
x=$(ພິມ \\001)
PS1="$x$(ພິມ \\r)$x$(tput so)$x\$PWD$x$(tput se)$x>"
ເນື່ອງຈາກຄໍາແນະນໍາທີ່ເຂັ້ມແຂງຈາກ David G. Korn, mksh ໃນປັດຈຸບັນຍັງສະຫນັບສະຫນູນ
ແບບຟອມຕໍ່ໄປນີ້:
PS1=$'\1\r\1\e[7m\1$PWD\1\e[0m\1> '
PS2 Secondary prompt string, ໂດຍຄ່າເລີ່ມຕົ້ນ '> ', ໃຊ້ເມື່ອຕ້ອງການປ້ອນຂໍ້ມູນເພີ່ມເຕີມເພື່ອ
ສໍາເລັດຄໍາສັ່ງ.
PS3 Prompt ໃຊ້ໂດຍ ເລືອກ ຖະແຫຼງການໃນເວລາອ່ານການເລືອກເມນູ. ຄ່າເລີ່ມຕົ້ນ
ແມ່ນ '#? '.
PS4 ໃຊ້ເພື່ອນຳໜ້າຄຳສັ່ງທີ່ພິມອອກໃນລະຫວ່າງການປະຕິບັດການຕິດຕາມ (ເບິ່ງ ທີ່ກໍານົດໄວ້
-x ຄໍາສັ່ງຂ້າງລຸ່ມນີ້). ຕົວກໍານົດການ, ຄໍາສັ່ງ, ແລະການທົດແທນເລກເລກແມ່ນ
ປະຕິບັດກ່ອນທີ່ມັນຈະພິມອອກ. ຄ່າເລີ່ມຕົ້ນແມ່ນ '+'. ທ່ານອາດຈະຕ້ອງການກໍານົດມັນ
ເປັນ '[$EPOCHREALTIME] ' ແທນ, ເພື່ອລວມເອົາເວລາ.
PWD ໄດເລກະທໍລີທີ່ເຮັດວຽກໃນປະຈຸບັນ. ອາດບໍ່ໄດ້ຕັ້ງ ຫຼື NULL ຖ້າແກະບໍ່ຮູ້
ມັນຢູ່ໃສ.
RANDOM ແຕ່ລະຄັ້ງທີ່ RANDOM ຖືກອ້າງອີງ, ມັນຖືກມອບຫມາຍເປັນຕົວເລກລະຫວ່າງ 0 ແລະ 32767
ຈາກ Linear Congruential PRNG ກ່ອນ.
Reply Default parameter for the ອ່ານ ສັ່ງຖ້າບໍ່ມີຊື່. ຍັງໃຊ້ໃນ
ເລືອກ loops ເພື່ອເກັບຄ່າທີ່ຖືກອ່ານຈາກການປ້ອນຂໍ້ມູນມາດຕະຖານ.
SECONDS ຈໍານວນວິນາທີນັບຕັ້ງແຕ່ແກະເລີ່ມຕົ້ນຫຼື, ຖ້າພາລາມິເຕີໄດ້
ມອບຫມາຍຄ່າຈໍານວນເຕັມ, ຈໍານວນວິນາທີນັບຕັ້ງແຕ່ການມອບຫມາຍບວກກັບ
ຄ່າທີ່ໄດ້ຮັບການມອບຫມາຍ.
TMOUT ຖ້າຕັ້ງເປັນຈຳນວນບວກໃນ shell ແບບໂຕ້ຕອບ, ມັນຈະລະບຸຄ່າສູງສຸດ
ຈໍານວນວິນາທີແກະຈະລໍຖ້າສໍາລັບການປ້ອນຂໍ້ມູນຫຼັງຈາກການພິມຕົ້ນຕໍ
prompt (PS1). ຖ້າເວລາເກີນ, ແກະອອກ.
TMPDIR ໄດເລກະທໍລີໄຟລ໌ shell ຊົ່ວຄາວຖືກສ້າງຂື້ນໃນ. ຖ້າພາລາມິເຕີນີ້ບໍ່ແມ່ນ
ຕັ້ງ, ຫຼືບໍ່ມີເສັ້ນທາງຢ່າງແທ້ຈິງຂອງໄດເລກະທໍລີທີ່ສາມາດຂຽນໄດ້, ຊົ່ວຄາວ
ໄຟລ໌ຖືກສ້າງຂື້ນໃນ / tmp.
USER_ID ID ຜູ້ໃຊ້ທີ່ມີປະສິດທິພາບຂອງ shell.
ເຄື່ອງ ໝາຍ ສຳ ນຽງ ການຂະຫຍາຍຕົວ
ການຂະຫຍາຍ Tilde ທີ່ເຮັດໃນຂະຫນານກັບການປ່ຽນຕົວກໍານົດການ, ແມ່ນເຮັດໃນຄໍາສັບຕ່າງໆ
ເລີ່ມຕົ້ນດ້ວຍ unquoted '~'. ຕົວອັກສອນຕໍ່ໄປນີ້ tilde, ເຖິງ '/' ທໍາອິດ, if
ໃດ, ຖືວ່າເປັນຊື່ເຂົ້າສູ່ລະບົບ. ຖ້າຊື່ເຂົ້າສູ່ລະບົບຫວ່າງເປົ່າ, '+', ຫຼື '-', ຄ່າຂອງ
ພາຣາມິເຕີ HOME, PWD, ຫຼື OLDPWD ຖືກປ່ຽນແທນ, ຕາມລໍາດັບ. ຖ້າບໍ່ດັ່ງນັ້ນ, ລະຫັດຜ່ານ
ໄຟລ໌ຖືກຄົ້ນຫາສໍາລັບຊື່ເຂົ້າສູ່ລະບົບ, ແລະການສະແດງອອກ tilde ຖືກແທນທີ່ດ້ວຍຜູ້ໃຊ້
ໄດເລກະທໍລີບ້ານ. ຖ້າຫາກວ່າຊື່ເຂົ້າສູ່ລະບົບບໍ່ໄດ້ພົບເຫັນຢູ່ໃນໄຟລ໌ລະຫັດຜ່ານຫຼືຖ້າຫາກວ່າການອ້າງອີງໃດຫນຶ່ງຫຼື
ການທົດແທນພາລາມິເຕີເກີດຂື້ນໃນຊື່ເຂົ້າສູ່ລະບົບ, ບໍ່ມີການປ່ຽນແທນໃດໆ.
ໃນການມອບຫມາຍພາລາມິເຕີ (ເຊັ່ນ: ຄໍາສັ່ງທີ່ນໍາຫນ້າແບບງ່າຍດາຍຫຼືສິ່ງທີ່ເກີດຂື້ນໃນ
ການໂຕ້ຖຽງຂອງ alias, ການສົ່ງອອກ, ທົ່ວໂລກ, ອ່ານຢ່າງດຽວ, ແລະ ປະເພດ), ການຂະຫຍາຍ tilde ແມ່ນເຮັດຫຼັງຈາກນັ້ນ
ການມອບໝາຍໃດໆກໍຕາມ (ເຊັ່ນ: ຫຼັງຈາກເຄື່ອງໝາຍເທົ່າກັບ) ຫຼືຫຼັງຈາກຈໍ້າສອງເມັດທີ່ບໍ່ໄດ້ອ້າງອີງ (':'); ຊື່ເຂົ້າສູ່ລະບົບ
ຍັງຖືກຈຳກັດດ້ວຍຈໍ້າສອງເມັດ.
ໄດເຣັກທໍຣີຫຼັກຂອງຊື່ເຂົ້າສູ່ລະບົບທີ່ຂະຫຍາຍໄປກ່ອນໜ້ານີ້ຖືກເກັບໄວ້ໃນຖານຄວາມຈຳ ແລະນຳໃຊ້ຄືນໃໝ່. ໄດ້ alias -d
ຄໍາສັ່ງອາດຈະຖືກນໍາໃຊ້ເພື່ອລາຍການ, ການປ່ຽນແປງ, ແລະເພີ່ມໃນຖານຄວາມຈໍານີ້ (eg alias -d
fac=/usr/ທ້ອງຖິ່ນ/ສິ່ງອຳນວຍຄວາມສະດວກ; cd ~fac/bin).
Brace ການຂະຫຍາຍຕົວ (ສະຫຼັບ)
ການສະແດງອອກຂອງ brace ມີຮູບແບບດັ່ງຕໍ່ໄປນີ້:
ຄຳ ນຳ ໜ້າ{p1, ... ,strN}បច្ច័យ
ການສະແດງອອກແມ່ນຂະຫຍາຍອອກໄປ N ຄໍາສັບຕ່າງໆ, ແຕ່ລະຄໍາແມ່ນ concatenation ຂອງ ຄຳ ນຳ ໜ້າ, stri,
ແລະ បច្ច័យ (ເຊັ່ນ: “a{c,b{X,Y},d}e” ຂະຫຍາຍເປັນສີ່ຄຳ: “ace”, “abXe”, “abYe”, ແລະ “ade”).
ດັ່ງທີ່ບັນທຶກໄວ້ໃນຕົວຢ່າງ, ການສະແດງອອກຂອງວົງເລັບສາມາດຖືກວາງໄວ້ແລະຄໍາທີ່ຜົນໄດ້ຮັບບໍ່ແມ່ນ
ຈັດຮຽງ. ການສະແດງຜົນວົງເລັບຕ້ອງມີເຄື່ອງໝາຍຈຸດທີ່ບໍ່ໄດ້ອ້າງອີງ (',') ເພື່ອໃຫ້ມີການຂະຫຍາຍ (ຕົວຢ່າງ
{} ແລະ {foo} ບໍ່ໄດ້ຂະຫຍາຍຕົວ). ການຂະຫຍາຍສາຍແຂນແມ່ນປະຕິບັດຫຼັງຈາກການປ່ຽນຕົວກໍານົດການ
ແລະກ່ອນການສ້າງຊື່ໄຟລ໌.
ເອກະສານ ຊື່ ຮູບແບບການ
ຮູບແບບຊື່ໄຟລ໌ແມ່ນຄຳສັບທີ່ປະກອບດ້ວຍໜຶ່ງ ຫຼືຫຼາຍກວ່ານັ້ນ '?', '*', '+', '@', ຫຼື '!'
ຕົວອັກສອນ ຫຼື “[..]” ລຳດັບ. ເມື່ອການຂະຫຍາຍເຊືອກຜູກໄດ້ຖືກປະຕິບັດ, ແກະຈະປ່ຽນແທນ
ຮູບແບບຊື່ໄຟລ໌ທີ່ມີຊື່ຄັດເລືອກຂອງໄຟລ໌ທັງຫມົດທີ່ກົງກັບຮູບແບບ (ຖ້າບໍ່ມີ
ໄຟລ໌ກົງກັນ, ຄໍາສັບຖືກປະໄວ້ບໍ່ປ່ຽນແປງ). ອົງປະກອບຂອງຮູບແບບມີຄວາມຫມາຍດັ່ງຕໍ່ໄປນີ້:
? ກົງກັບຕົວອັກສອນດຽວ.
* ກົງກັບລໍາດັບຂອງ octets ໃດ.
[..] ກົງກັບ octets ໃດນຶ່ງພາຍໃນວົງເລັບ. ຂອບເຂດຂອງ octets ສາມາດຖືກກໍານົດໂດຍ
ການແຍກສອງເລກ octets ດ້ວຍ '-' (ເຊັ່ນ: “[a0-9]” ກົງກັບຕົວອັກສອນ 'a' ຫຼືຕົວເລກໃດນຶ່ງ).
ເພື່ອເປັນຕົວແທນຂອງຕົວມັນເອງ, '-' ຈະຕ້ອງຖືກອ້າງອີງ ຫຼື octet ທໍາອິດ ຫຼືສຸດທ້າຍ
ໃນບັນຊີລາຍຊື່ octet. ເຊັ່ນດຽວກັນ, a ']' ຕ້ອງໄດ້ຮັບການອ້າງອີງຫຼື octet ທໍາອິດໃນບັນຊີລາຍຊື່
ຖ້າຫາກວ່າມັນແມ່ນການເປັນຕົວແທນຂອງຕົວມັນເອງແທນທີ່ຈະເປັນໃນຕອນທ້າຍຂອງບັນຊີລາຍຊື່. ນອກຈາກນີ້, a '!' ປະກົດ
ໃນຕອນເລີ່ມຕົ້ນຂອງບັນຊີລາຍຊື່ມີຄວາມຫມາຍພິເສດ (ເບິ່ງຂ້າງລຸ່ມນີ້), ດັ່ງນັ້ນເພື່ອເປັນຕົວແທນຂອງມັນເອງ
ຕ້ອງໄດ້ຮັບການອ້າງອີງຫຼືປາກົດໃນພາຍຫຼັງໃນບັນຊີລາຍຊື່.
[!..] ເຊັ່ນດຽວກັບ [..], ຍົກເວັ້ນມັນກົງກັບ octet ໃດທີ່ບໍ່ໄດ້ຢູ່ໃນວົງເລັບ.
*(ຮູບແບບ|...|ຮູບແບບ)
ຈັບຄູ່ສະຕຣິງຂອງ octets ທີ່ກົງກັບສູນ ຫຼືຫຼາຍກວ່າການປະກົດຕົວຂອງສິ່ງທີ່ລະບຸ
ຮູບແບບ. ຕົວຢ່າງ: ຮູບແບບ *(ຟູ|ແຖບ) ກົງກັບສາຍ "", "foo", "bar",
"foobarfoo", ແລະອື່ນໆ.
+(ຮູບແບບ|...|ຮູບແບບ)
ກົງກັບສະຕຣິງຂອງ octets ໃດນຶ່ງທີ່ກົງກັບໜຶ່ງ ຫຼືຫຼາຍກວ່າການປະກົດຕົວທີ່ລະບຸໄວ້
ຮູບແບບ. ຕົວຢ່າງ: ຮູບແບບ +(ຟູ|ແຖບ) ກົງກັບສາຍ "foo", "bar",
"foobar", ແລະອື່ນໆ.
?(ຮູບແບບ|...|ຮູບແບບ)
ຈັບຄູ່ສະຕຣິງຫວ່າງເປົ່າ ຫຼືສະຕຣິງທີ່ກົງກັບໜຶ່ງໃນຮູບແບບທີ່ລະບຸ.
ຕົວຢ່າງ: ຮູບແບບ ?(ຟູ|ແຖບ) ກົງກັບສາຍ "", "foo", ແລະ "bar".
@(ຮູບແບບ|...|ຮູບແບບ)
ຈັບຄູ່ສະຕຣິງທີ່ກົງກັບໜຶ່ງໃນຮູບແບບທີ່ລະບຸ. ຕົວຢ່າງ: ຮູບແບບ
@(foo|ແຖບ) ກົງກັບສາຍ “foo” ແລະ “bar” ເທົ່ານັ້ນ.
!(ຮູບແບບ|...|ຮູບແບບ)
ຈັບຄູ່ສະຕຣິງໃດນຶ່ງທີ່ບໍ່ກົງກັບຮູບແບບທີ່ລະບຸໄວ້. ຕົວຢ່າງ: ໄດ້
ຮູບແບບ !(ຟູ|ແຖບ) ກົງກັບສາຍທັງໝົດຍົກເວັ້ນ “foo” ແລະ “bar”; ຮູບແບບ !(*)
ຈັບຄູ່ບໍ່ມີສາຍ; ຮູບແບບ !(?)* ກົງກັບສະຕຣິງທັງໝົດ (ຄິດກ່ຽວກັບມັນ).
ໃຫ້ສັງເກດວ່າການສັບສົນ, ໂດຍສະເພາະກັບທາງເລືອກ, ແມ່ນຊ້າ; ການນໍາໃຊ້ແຍກຕ່າງຫາກ
ການປຽບທຽບອາດຈະ (ຫຼືອາດຈະບໍ່) ໄວກວ່າ.
ໃຫ້ສັງເກດວ່າ mksh (ແລະ pdksh) ບໍ່ເຄີຍກົງກັບ '.' ແລະ '..', ແຕ່ AT&T UNIX ksh, Bourne sh, ແລະ GNU
bash ເຮັດແນວໃດ.
ຈື່ໄວ້ວ່າບໍ່ມີອົງປະກອບຂອງຮູບແບບຂ້າງເທິງນີ້ກົງກັບໄລຍະເວລາ ('.') ໃນຕອນຕົ້ນຂອງ a
ຊື່ໄຟລ໌ ຫຼື slash ('/'), ເຖິງແມ່ນວ່າພວກມັນຖືກໃຊ້ຢ່າງຈະແຈ້ງໃນລໍາດັບ [..]; ຍັງ, ໄດ້
ຊື່ '.' ແລະ '..' ບໍ່ເຄີຍຖືກຈັບຄູ່, ເຖິງແມ່ນວ່າຈະເປັນຮູບແບບ '.*'.
ຖ້າ ເຄື່ອງໝາຍ ທາງເລືອກແມ່ນຖືກກໍານົດ, ໄດເລກະທໍລີໃດໆທີ່ເປັນຜົນມາຈາກການສ້າງຊື່ໄຟລ໌ແມ່ນ
ໝາຍດ້ວຍ '/'.
ການປ້ອນຂໍ້ມູນ / ຜົນຜະລິດ ຕົວຊີ້ທິດທາງ
ເມື່ອຄໍາສັ່ງຖືກປະຕິບັດ, ການປ້ອນຂໍ້ມູນມາດຕະຖານຂອງມັນ, ຜົນຜະລິດມາດຕະຖານ, ແລະຄວາມຜິດພາດມາດຕະຖານ (ໄຟລ໌
descriptors 0, 1, ແລະ 2, ຕາມລໍາດັບ) ໂດຍປົກກະຕິແມ່ນສືບທອດມາຈາກແກະ. ສາມ
ຂໍ້ຍົກເວັ້ນນີ້ແມ່ນຄໍາສັ່ງໃນທໍ່, ສໍາລັບການປ້ອນຂໍ້ມູນມາດຕະຖານແລະ / ຫຼືມາດຕະຖານ
ຜົນຜະລິດແມ່ນການຕັ້ງຄ່າໂດຍທໍ່, ຄໍາສັ່ງ asynchronous ສ້າງຂຶ້ນໃນເວລາທີ່ການຄວບຄຸມວຽກ
ປິດການໃຊ້ງານ, ເຊິ່ງການປ້ອນຂໍ້ມູນມາດຕະຖານໃນເບື້ອງຕົ້ນແມ່ນຕັ້ງມາຈາກ / dev / null, ແລະຄໍາສັ່ງສໍາລັບ
ເຊິ່ງມີການກຳນົດການປ່ຽນເສັ້ນທາງຕໍ່ໄປນີ້:
>ເອກະສານ ຜົນຜະລິດມາດຕະຖານຖືກໂອນໄປຫາ ເອກະສານທີ່ຢູ່ ຖ້າຫາກວ່າ ເອກະສານ ບໍ່ມີ, ມັນຖືກສ້າງຂຶ້ນ;
ຖ້າມັນມີຢູ່, ເປັນໄຟລ໌ປົກກະຕິ, ແລະ noclobber ທາງເລືອກແມ່ນໄດ້ຖືກຕັ້ງ, ມີຄວາມຜິດພາດ
ເກີດຂຶ້ນ; ຖ້າບໍ່ດັ່ງນັ້ນ, ໄຟລ໌ຈະຖືກຕັດອອກ. ໃຫ້ສັງເກດວ່ານີ້ຫມາຍຄວາມວ່າຄໍາສັ່ງ cmd
<foo > ຟູ ຈະເປີດ ຟູ ສໍາລັບການອ່ານແລະຫຼັງຈາກນັ້ນຕັດມັນເມື່ອມັນເປີດມັນສໍາລັບ
ຂຽນ, ກ່ອນ cmd ໄດ້ຮັບໂອກາດທີ່ຈະອ່ານຕົວຈິງ ຟູ.
>|ເອກະສານ ຄືກັນກັບ >ຍົກເວັ້ນໄຟລ໌ຖືກຕັດອອກ, ເຖິງແມ່ນວ່າ noclobber ທາງເລືອກແມ່ນກໍານົດໄວ້.
>>ເອກະສານ ຄືກັນກັບ >, ຍົກເວັ້ນຖ້າ ເອກະສານ ມີຢູ່ແລ້ວ, ມັນຈະຖືກຕໍ່ທ້າຍແທນທີ່ຈະຖືກຕັດອອກ.
ນອກຈາກນີ້, ໄຟລ໌ໄດ້ຖືກເປີດຢູ່ໃນຮູບແບບເພີ່ມເຕີມ, ດັ່ງນັ້ນການຂຽນສະເຫມີໄປໃນຕອນທ້າຍຂອງ
ໄຟລ໌ (ເບິ່ງ ເປີດ(2)).
<ເອກະສານ ການປ້ອນຂໍ້ມູນມາດຕະຖານຖືກປ່ຽນເສັ້ນທາງຈາກ ເອກະສານ, ເຊິ່ງເປີດສໍາລັບການອ່ານ.
<>ເອກະສານ ຄືກັນກັບ <, ຍົກເວັ້ນໄຟລ໌ຖືກເປີດສໍາລັບການອ່ານແລະຂຽນ.
<<marker ຫຼັງຈາກການອ່ານບັນຊີຄໍາສັ່ງທີ່ປະກອບດ້ວຍການປ່ຽນເສັ້ນທາງປະເພດນີ້ (ເອີ້ນວ່າ a
"ທີ່ນີ້ເອກະສານ"), ແກະຄັດລອກເສັ້ນຈາກແຫຼ່ງຄໍາສັ່ງເຂົ້າໄປໃນ a
ໄຟລ໌ຊົ່ວຄາວຈົນກ່ວາເສັ້ນກົງກັນ marker ອ່ານແລ້ວ. ໃນເວລາທີ່ຄໍາສັ່ງແມ່ນ
ປະຕິບັດແລ້ວ, ວັດສະດຸປ້ອນມາດຕະຖານຖືກປ່ຽນເສັ້ນທາງຈາກໄຟລ໌ຊົ່ວຄາວ. ຖ້າ marker
ບໍ່ມີຕົວອັກສອນທີ່ອ້າງອີງ, ເນື້ອໃນຂອງໄຟລ໌ຊົ່ວຄາວຈະຖືກປະມວນຜົນ
ຄືກັບວ່າຖືກຫຸ້ມຢູ່ໃນວົງຢືມສອງເທົ່າແຕ່ລະຄັ້ງທີ່ຄໍາສັ່ງຖືກປະຕິບັດ, ດັ່ງນັ້ນພາລາມິເຕີ,
ຄຳສັ່ງ, ແລະການປ່ຽນເລກເລກຖືກປະຕິບັດ, ພ້ອມກັບ backslash ('\')
ໜີໄປສຳລັບ '$', '`', '\', ແລະ '\newline', ແຕ່ບໍ່ແມ່ນສຳລັບ '"'. ຖ້າຫຼາຍອັນນີ້
ເອກະສານຖືກໃຊ້ຢູ່ໃນເສັ້ນຄໍາສັ່ງດຽວກັນ, ມັນຖືກບັນທຶກໄວ້ໃນຄໍາສັ່ງ.
ຖ້າບໍ່ marker ໄດ້ຖືກມອບໃຫ້, ເອກະສານຢູ່ທີ່ນີ້ສິ້ນສຸດລົງໃນເວລາຕໍ່ໄປ << ແລະການທົດແທນ
ຈະໄດ້ຮັບການປະຕິບັດ. ຖ້າ marker ແມ່ນພຽງແຕ່ຊຸດຂອງ "''" ຫຼືຄູ່ '""' ເທົ່ານັ້ນ.
ຄໍາເວົ້າທີ່ບໍ່ມີຫຍັງຢູ່ໃນລະຫວ່າງ, ເອກະສານທີ່ນີ້ສິ້ນສຸດລົງຢູ່ແຖວຫວ່າງຕໍ່ໄປ
ແລະການທົດແທນຈະບໍ່ຖືກປະຕິບັດ.
<<-marker ຄືກັນກັບ <<, ຍົກເວັ້ນແຖບຊັ້ນນໍາຖືກຖອດອອກຈາກແຖວໃນເອກະສານທີ່ນີ້.
<<ຄໍາ ຄືກັນກັບ <<, ຍົກເວັ້ນນັ້ນ ຄໍາ is ເອກະສານຢູ່ທີ່ນີ້. ອັນນີ້ເອີ້ນວ່າ ທີ່ນີ້
string
<&fd ການປ້ອນຂໍ້ມູນມາດຕະຖານຖືກຊໍ້າກັນຈາກຕົວອະທິບາຍໄຟລ໌ fd. fd ສາມາດເປັນຕົວເລກ,
ຊີ້ບອກຈໍານວນຂອງຕົວອະທິບາຍໄຟລ໌ທີ່ມີຢູ່ແລ້ວ; ຕົວອັກສອນ 'p', ຊີ້ບອກ
ຕົວອະທິບາຍໄຟລ໌ທີ່ກ່ຽວຂ້ອງກັບຜົນຜະລິດຂອງຂະບວນການຮ່ວມມືໃນປະຈຸບັນ; ຫຼື
ຕົວອັກສອນ '-', ຊີ້ບອກການປ້ອນຂໍ້ມູນມາດຕະຖານຖືກປິດ. ໃຫ້ສັງເກດວ່າ fd is
ຈໍາກັດພຽງແຕ່ຕົວເລກດຽວໃນການປະຕິບັດ shell ສ່ວນໃຫຍ່.
>&fd ຄືກັນກັບ <&, ຍົກເວັ້ນການດໍາເນີນງານແມ່ນເຮັດຢູ່ໃນຜົນຜະລິດມາດຕະຖານ.
&>ເອກະສານ ຄືກັນກັບ >ເອກະສານ 2> & 1. ນີ້ແມ່ນ GNU ທີ່ຖືກປະຕິເສດ bash ການຂະຫຍາຍສະຫນັບສະຫນູນ
by mksh ເຊິ່ງຍັງສະຫນັບສະຫນູນຕົວເລກ fd ທີ່ຊັດເຈນກ່ອນຫນ້າ, ສໍາລັບການຍົກຕົວຢ່າງ,
3&>ເອກະສານ ແມ່ນຄືກັນກັບ 3>ເອກະສານ 2> & 3 in mksh ແຕ່ syntax ຜິດພາດໃນ GNU bash.
&>|ເອກະສານ, &>>ເອກະສານ, &>&fd
ຄືກັນກັບ >|ເອກະສານ, >>ເອກະສານ, ຫຼື >&fd, ຕາມດ້ວຍ 2> & 1, ດັ່ງຂ້າງເທິງ. ພວກນີ້ແມ່ນ mksh
extensions
ໃນໃດໆຂອງການປ່ຽນເສັ້ນທາງຂ້າງເທິງ, ຕົວອະທິບາຍໄຟລ໌ທີ່ຖືກປ່ຽນເສັ້ນທາງ (ເຊັ່ນມາດຕະຖານ
input ຫຼືມາດຕະຖານຜົນຜະລິດ) ສາມາດໃຫ້ຢ່າງຊັດເຈນໂດຍການນໍາຫນ້າການປ່ຽນເສັ້ນທາງທີ່ມີຕົວເລກ
(ແບບພົກພາ, ພຽງແຕ່ຕົວເລກດຽວ). ຕົວກໍານົດການ, ຄໍາສັ່ງ, ແລະການທົດແທນເລກເລກ, tilde
ການທົດແທນ, ແລະ (ຖ້າ shell ແມ່ນໂຕ້ຕອບ) ການສ້າງຊື່ໄຟລ໌ແມ່ນດໍາເນີນການທັງຫມົດ
ໄດ້ ເອກະສານ, marker, ແລະ fd ການໂຕ້ຖຽງຂອງການປ່ຽນເສັ້ນທາງ. ໃຫ້ສັງເກດວ່າ, ຢ່າງໃດກໍຕາມ, ຜົນໄດ້ຮັບຂອງໃດໆ
ການສ້າງຊື່ໄຟລ໌ແມ່ນໃຊ້ພຽງແຕ່ຖ້າໄຟລ໌ດຽວຖືກຈັບຄູ່; ຖ້າຫຼາຍໄຟລ໌ກົງກັນ, the
ຄໍາທີ່ມີຕົວອັກສອນສ້າງຊື່ໄຟລ໌ທີ່ຂະຫຍາຍຖືກນໍາໃຊ້. ໃຫ້ສັງເກດວ່າຢູ່ໃນຈໍາກັດ
shells, ການປ່ຽນເສັ້ນທາງທີ່ສາມາດສ້າງໄຟລ໌ບໍ່ສາມາດຖືກນໍາໃຊ້.
ສໍາລັບຄໍາສັ່ງແບບງ່າຍດາຍ, ການປ່ຽນເສັ້ນທາງອາດຈະປາກົດຢູ່ບ່ອນໃດກໍ່ຕາມໃນຄໍາສັ່ງ; ສໍາລັບຄໍາສັ່ງປະສົມ
(if ຖະແຫຼງການ, ແລະອື່ນໆ), ການປ່ຽນເສັ້ນທາງໃດໆຕ້ອງປາກົດຢູ່ໃນຕອນທ້າຍ. ການປ່ຽນເສັ້ນທາງຖືກປະມວນຜົນ
ຫຼັງຈາກການສ້າງທໍ່ແລະໃນຄໍາສັ່ງທີ່ເຂົາເຈົ້າໄດ້ຮັບ, ດັ່ງນັ້ນຕໍ່ໄປນີ້ຈະພິມເປັນ
ຄວາມຜິດພາດທີ່ມີຕົວເລກແຖວຕໍ່ຫນ້າມັນ:
$ cat /foo/bar 2>&1 >/dev/null | pr -n -t
ຕົວອະທິບາຍໄຟລ໌ທີ່ສ້າງຂຶ້ນໂດຍການປ່ຽນເສັ້ນທາງ I/O ແມ່ນເປັນສ່ວນຕົວຕໍ່ກັບແກະ.
ເລກຄະນິດສາດ expressions
ການສະແດງອອກເລກເລກຈຳນວນເຕັມສາມາດໃຊ້ກັບ ໃຫ້ ຄໍາສັ່ງ, ພາຍໃນ $((..)) expressions,
ພາຍໃນການອ້າງອີງ array (ເຊັ່ນ ຊື່[ຕົວຢ່າງ]), ເປັນການໂຕ້ຖຽງຕົວເລກກັບ ການທົດສອບ ຄໍາສັ່ງ, ແລະເປັນ
ຄ່າຂອງການມອບໝາຍໃຫ້ກັບພາຣາມິເຕີຈຳນວນເຕັມ. ການເຕືອນໄພ: ນີ້ຍັງມີຜົນກະທົບ implicit
ການແປງເປັນຈໍານວນເຕັມ, ຕົວຢ່າງເຊັ່ນເຮັດໂດຍ ໃຫ້ ຄໍາສັ່ງ. ບໍ່ເຄີຍ ໃຊ້ຜູ້ໃຊ້ທີ່ບໍ່ໄດ້ເລືອກ
ວັດສະດຸປ້ອນ, ຕົວຢ່າງຈາກສະພາບແວດລ້ອມ, ໃນເລກຄະນິດສາດ!
ການສະແດງອອກແມ່ນຄິດໄລ່ໂດຍໃຊ້ເລກເລກເລກທີ່ລົງນາມ ແລະ mksh_ari_t ປະເພດ (ເຊັນຊື່ 32-bit
integer), ເວັ້ນເສຍແຕ່ວ່າພວກເຂົາເລີ່ມຕົ້ນດ້ວຍຕົວອັກສອນ '#' sole, ໃນກໍລະນີນີ້ພວກເຂົາໃຊ້ mksh_uari_t (a
ຈໍານວນ 32-bit unsigned).
ການສະແດງອອກອາດມີຕົວລະບຸຕົວລະບຸພາຣາມີເຕີ alpha-numeric, array references, ແລະ integer.
ຄົງທີ່ແລະອາດຈະຖືກລວມເຂົ້າກັບຕົວປະຕິບັດການ C ຕໍ່ໄປນີ້ (ລາຍຊື່ແລະຈັດກຸ່ມຢູ່ໃນ
ເພີ່ມຂຶ້ນຕາມລໍາດັບຂອງການນໍາພາ):
ຕົວປະຕິບັດການ Unary:
+ - ! ~ ++ --
ຕົວປະຕິບັດການໄບນາຣີ:
,
= += -= *= /= %= <<<= >>>= <<=>>= &= ^= |=
||
&&
|
^
&
==! =
<<=>> =
<<<>>> <<>>
+ -
* /%
ຜູ້ໃຫ້ບໍລິການ Ternary:
?: (ຄວາມສຳຄັນແມ່ນສູງກວ່າການມອບໝາຍໃນທັນທີ)
ຜູ້ປະກອບການຈັດກຸ່ມ:
()
ຕົວເລກຄົງທີ່ ແລະການສະແດງຜົນຈຳນວນເຕັມແມ່ນຄຳນວນໂດຍໃຊ້ຄວາມກວ້າງ 32-ບິດ, ເຊັນຊື່ ຫຼື
unsigned, type with silent wraparound on integer overflow. ຈໍານວນຄົງທີ່ອາດຈະເປັນ
ລະບຸດ້ວຍຖານທີ່ມັກໂດຍການນຳໃຊ້ຕົວໝາຍ ຖານ#ຈໍານວນ, ບ່ອນທີ່ ຖານ ເປັນທົດສະນິຍົມ
ຈຳນວນເຕັມທີ່ລະບຸຖານ, ແລະ ຈໍານວນ ແມ່ນຕົວເລກໃນຖານທີ່ລະບຸ. ນອກຈາກນັ້ນ,
ຈຳນວນເຕັມ base-16 ອາດຈະຖືກລະບຸໂດຍການນຳໜ້າພວກມັນດ້ວຍ '0x' (ຕົວພິມນ້ອຍໃຫຍ່) ທັງໝົດ.
ຮູບແບບຂອງການສະແດງອອກເລກຄະນິດສາດ, ຍົກເວັ້ນເປັນການໂຕ້ຖຽງຕົວເລກກັບ ການທົດສອບ ຄໍາສັ່ງໃນຕົວ.
ການນຳໜ້າຕົວເລກດ້ວຍເລກສູນ ('0') ບໍ່ໄດ້ເຮັດໃຫ້ເກີດການຕີຄວາມໝາຍເປັນເລກແປດ, ດັ່ງທີ່
ມັນບໍ່ປອດໄພທີ່ຈະເຮັດ.
ເປັນພິເສດ mksh ສ່ວນຂະຫຍາຍ, ຕົວເລກໃສ່ຖານຂອງອັນໜຶ່ງແມ່ນຖືວ່າເປັນອັນໃດນຶ່ງ (8-bit
ໂປ່ງໃສ) ASCII ຫຼື Unicode codepoints, ຂຶ້ນກັບ shell's utf8-mode ທຸງ (ປັດຈຸບັນ
ການຕັ້ງຄ່າ). AT&T UNIX ksh93 syntax ຂອງ “'x'” ແທນ “1#x” ຍັງຮອງຮັບ. ຫມາຍເຫດ
NUL bytes (ຄ່າລວມຂອງສູນ) ບໍ່ສາມາດໃຊ້ໄດ້. ຕົວກໍານົດການທີ່ບໍ່ໄດ້ຕັ້ງຫຼືຫວ່າງເປົ່າ
ປະເມີນເປັນ 0 ໃນບໍລິບົດຈຳນວນເຕັມ. ໃນໂຫມດ Unicode, octets ດິບຖືກແຜນທີ່ເຂົ້າໄປໃນຂອບເຂດ
EF80..EFFF ຄືກັບ OPTU-8, ເຊິ່ງຢູ່ໃນ PUA ແລະໄດ້ຖືກມອບໝາຍໂດຍ CSUR ສໍາລັບການນໍາໃຊ້ນີ້. ຖ້າ
ຫຼາຍກວ່າໜຶ່ງ octet ໃນໂໝດ ASCII, ຫຼື ລຳດັບຂອງຫຼາຍກວ່າໜຶ່ງ octet ບໍ່ສ້າງເປັນທີ່ຖືກຕ້ອງ
ແລະລໍາດັບ CESU-8 ຫນ້ອຍທີ່ສຸດແມ່ນຜ່ານ, ພຶດຕິກໍາແມ່ນບໍ່ໄດ້ກໍານົດ (ປົກກະຕິແລ້ວ, ແກະຈະເອົາລູກອອກ.
ມີຄວາມຜິດພາດ parse, ແຕ່ບໍ່ຄ່ອຍຈະສໍາເລັດ, e.g. ໃນລໍາດັບ C2 20). ນັ້ນແມ່ນເຫດຜົນທີ່ທ່ານ
ຄວນໃຊ້ໂຫມດ ASCII ສະເໝີ ເວັ້ນເສຍແຕ່ວ່າທ່ານຮູ້ວ່າການປ້ອນຂໍ້ມູນມີຮູບແບບ UTF-8 ຢູ່ໃນ
ລະດັບຂອງ 0000..FFDD ຖ້າທ່ານໃຊ້ຄຸນສົມບັດນີ້, ກົງກັນຂ້າມກັບ ອ່ານ -a.
ຜູ້ປະກອບການໄດ້ຖືກປະເມີນດັ່ງຕໍ່ໄປນີ້:
unary +
ຜົນໄດ້ຮັບແມ່ນການໂຕ້ຖຽງ (ລວມເຖິງຄວາມສົມບູນ).
unary -
ການປະຕິເສດ.
! ເຫດຜົນບໍ່; ຜົນໄດ້ຮັບແມ່ນ 1 ຖ້າອາກິວເມັນແມ່ນສູນ, 0 ຖ້າບໍ່ແມ່ນ.
~ ເລກຄະນິດສາດ (ບິດ-ສະຫລາດ) ບໍ່ແມ່ນ.
++ ເພີ່ມຂຶ້ນ; ຕ້ອງຖືກນຳໃຊ້ກັບພາລາມິເຕີ (ບໍ່ແມ່ນຕົວໜັງສື ຫຼືສຳນວນອື່ນ).
ພາລາມິເຕີແມ່ນເພີ່ມຂຶ້ນໂດຍ 1. ເມື່ອໃຊ້ເປັນຕົວປະຕິບັດການນໍາຫນ້າ, ຜົນໄດ້ຮັບ
ແມ່ນມູນຄ່າທີ່ເພີ່ມຂຶ້ນຂອງພາລາມິເຕີ; ເມື່ອໃຊ້ເປັນຕົວປະຕິບັດການ postfix,
ຜົນໄດ້ຮັບແມ່ນຄ່າຕົ້ນສະບັບຂອງພາລາມິເຕີ.
-- ຄ້າຍຄືກັບ ++, ຍົກເວັ້ນພາຣາມິເຕີຈະຖືກຫຼຸດລົງໂດຍ 1.
, ແຍກສອງສໍານວນເລກເລກ; ເບື້ອງຊ້າຍແມ່ນປະເມີນກ່ອນ,
ແລ້ວສິດ. ຜົນໄດ້ຮັບແມ່ນມູນຄ່າຂອງການສະແດງຢູ່ເບື້ອງຂວາມື
ຂ້າງຄຽງ.
= ການມອບໝາຍ; ຕົວແປຢູ່ເບື້ອງຊ້າຍແມ່ນຕັ້ງເປັນຄ່າຢູ່ເບື້ອງຂວາ.
+= -= *= /= %= <<<= >>>= <<=>>= &= ^= |=
ຜູ້ປະຕິບັດການມອບຫມາຍ.var><op>=ຕົວຢ່າງ> ຄືກັນກັບvar>=var><op><ຕົວຢ່າງ>,
ໂດຍມີຕົວປະຕິບັດການກ່ອນໜ້າໃນຕົວຢ່າງ> ຮັກສາໄວ້. ຕົວຢ່າງ, “var1 *= 5 +
3” ແມ່ນຄືກັນກັບການລະບຸ “var1 = var1 * (5 + 3)”.
|| ເຫດຜົນ OR; ຜົນໄດ້ຮັບແມ່ນ 1 ຖ້າອາກິວເມັນບໍ່ແມ່ນສູນ, 0 ຖ້າບໍ່ແມ່ນ. ໄດ້
ອາກິວເມັນຂວາຖືກປະເມີນພຽງແຕ່ຖ້າອາກິວເມັນຊ້າຍເປັນສູນເທົ່ານັ້ນ.
&& ມີເຫດຜົນ AND; ຜົນໄດ້ຮັບແມ່ນ 1 ຖ້າອາກິວເມັນທັງສອງບໍ່ແມ່ນສູນ, 0 ຖ້າບໍ່ແມ່ນ. ໄດ້
ອາກິວເມັນຂວາຖືກປະເມີນພຽງແຕ່ຖ້າອາກິວເມັນຊ້າຍບໍ່ແມ່ນສູນ.
| ເລກເລກ (ບິດ-ສະຫລາດ) OR.
^ ເລກຄະນິດສາດ (ບິດ-ສະຫລາດ) XOR (ສະເພາະ-OR).
& ເລກເລກ (ບິດ-ສະຫລາດ) AND.
== ເທົ່າກັນ; ຜົນໄດ້ຮັບແມ່ນ 1 ຖ້າອາກິວເມັນທັງສອງເທົ່າກັບ, 0 ຖ້າບໍ່ແມ່ນ.
!= ບໍ່ເທົ່າກັນ; ຜົນໄດ້ຮັບແມ່ນ 0 ຖ້າອາກິວເມັນທັງສອງເທົ່າກັບ, 1 ຖ້າບໍ່ແມ່ນ.
< ຫນ້ອຍກວ່າ; ຜົນໄດ້ຮັບແມ່ນ 1 ຖ້າການໂຕ້ຖຽງຊ້າຍຫນ້ອຍກວ່າຂວາ, 0 ຖ້າ
ບໍ່.
<= > >=
ໜ້ອຍກວ່າ ຫຼື ເທົ່າກັນ, ໃຫຍ່ກວ່າ, ໃຫຍ່ກວ່າ ຫຼື ເທົ່າກັນ. ເບິ່ງ <.
<<<>>>
ໝຸນຊ້າຍ (ຂວາ); ຜົນໄດ້ຮັບແມ່ນຄ້າຍຄືກັນກັບການປ່ຽນແປງ (ເບິ່ງ <<) ຍົກເວັ້ນແຕ່ວ່າ
bits ຍ້າຍອອກຢູ່ປາຍຫນຶ່ງແມ່ນຍ້າຍໄປຢູ່ໃນອີກສົ້ນຫນຶ່ງ, ແທນທີ່ຈະເປັນສູນ
ຫຼື ເຊັນບົດບັນທຶກ.
<< >> Shift ຊ້າຍ (ຂວາ); ຜົນໄດ້ຮັບແມ່ນການໂຕ້ຖຽງຊ້າຍກັບບິດຂອງມັນປ່ຽນຊ້າຍ
(ຂວາ) ໂດຍຈໍານວນທີ່ໃຫ້ຢູ່ໃນການໂຕ້ຖຽງທີ່ຖືກຕ້ອງ.
+ - * /
ການບວກ, ການລົບ, ການຄູນ, ແລະການຫານ.
% ສ່ວນທີ່ເຫຼືອ; ຜົນໄດ້ຮັບແມ່ນ symmetric ສ່ວນທີ່ເຫຼືອຂອງການແບ່ງປັນຊ້າຍ
ການໂຕ້ຖຽງໂດຍສິດ. ເພື່ອໃຫ້ໄດ້ໂມດູລທາງຄະນິດສາດຂອງ “a ຕ້ານ b”, ໃຊ້
ສູດ “(a % b + b) % b”.
<arg1>?arg2>:arg3>
ຖ້າarg1> ບໍ່ແມ່ນສູນ, ຜົນໄດ້ຮັບແມ່ນarg2> ; ຖ້າບໍ່ດັ່ງນັ້ນຜົນໄດ້ຮັບແມ່ນarg3>.
ການໂຕ້ຖຽງທີ່ບໍ່ແມ່ນຜົນໄດ້ຮັບບໍ່ໄດ້ຖືກປະເມີນ.
ຂະບວນການຮ່ວມກັນ
ຂະບວນການຮ່ວມກັນ (ເຊິ່ງເປັນທໍ່ທີ່ສ້າງດ້ວຍຕົວປະຕິບັດການ '|&') ແມ່ນຂະບວນການບໍ່ຊິ້ງໂຄນ.
ວ່າ shell ທັງສອງສາມາດຂຽນເຖິງ (ການນໍາໃຊ້ ພິມ -p) ແລະອ່ານຈາກ (ການນໍາໃຊ້ ອ່ານ -p). ວັດສະດຸປ້ອນ
ແລະຜົນຜະລິດຂອງຂະບວນການຮ່ວມມືຍັງສາມາດຫມູນໃຊ້ໄດ້ >&p ແລະ <&p ການປ່ຽນເສັ້ນທາງ,
ຕາມລໍາດັບ. ເມື່ອຂະບວນການການຮ່ວມມືໄດ້ເລີ່ມຕົ້ນຂຶ້ນແລ້ວ, ອີກອັນໜຶ່ງບໍ່ສາມາດເລີ່ມຕົ້ນໄດ້ຈົນກວ່າການຮ່ວມມື.
ຂະບວນການອອກຈາກຂະບວນການ, ຫຼືຈົນກ່ວາການປ້ອນຂໍ້ມູນຂອງຂະບວນການຮ່ວມກັນໄດ້ຖືກປ່ຽນເສັ້ນທາງໂດຍໃຊ້ exec n>&p
ການປ່ຽນເສັ້ນທາງ. ຖ້າການປ້ອນຂໍ້ມູນຂອງຂະບວນການຮ່ວມມືຖືກປ່ຽນເສັ້ນທາງດ້ວຍວິທີນີ້, ຂະບວນການຮ່ວມມືຕໍ່ໄປຈະເປັນ
ເລີ່ມຕົ້ນຈະແບ່ງປັນຜົນຜະລິດກັບຂະບວນການຮ່ວມມືທໍາອິດ, ເວັ້ນເສຍແຕ່ວ່າຜົນຜະລິດເບື້ອງຕົ້ນ
ຂະບວນການຮ່ວມກັນໄດ້ຖືກປ່ຽນເສັ້ນທາງໂດຍໃຊ້ exec n<&p ການປ່ຽນເສັ້ນທາງ.
ຂໍ້ສັງເກດບາງອັນກ່ຽວກັບຂະບວນການຮ່ວມມື:
· ວິທີດຽວທີ່ຈະປິດການປ້ອນຂໍ້ມູນຂອງຂະບວນການຮ່ວມ (ດັ່ງນັ້ນຂະບວນການຮ່ວມມືອ່ານເອກະສານສິ້ນສຸດ) ແມ່ນ.
ເພື່ອປ່ຽນເສັ້ນທາງການປ້ອນຂໍ້ມູນໄປຫາຕົວອະທິບາຍໄຟລ໌ຕົວເລກ ແລະຈາກນັ້ນປິດຕົວອະທິບາຍໄຟລ໌ນັ້ນ:
exec 3>&p; exec 3>&-
· ເພື່ອໃຫ້ຂະບວນການຮ່ວມກັນແບ່ງປັນຜົນຜະລິດທົ່ວໄປ, ແກະຕ້ອງຮັກສາການຂຽນ
ສ່ວນຂອງທໍ່ຜົນຜະລິດເປີດ. ນີ້ຫມາຍຄວາມວ່າການສິ້ນສຸດຂອງໄຟລ໌ຈະບໍ່ຖືກກວດພົບຈົນກ່ວາ
ຂະບວນການຮ່ວມມືທັງໝົດທີ່ແບ່ງປັນຜົນຜະລິດຂອງຂະບວນການຮ່ວມໄດ້ອອກໄປ (ເມື່ອພວກມັນທັງໝົດອອກ,
shell ປິດສໍາເນົາທໍ່ຂອງມັນ). ນີ້ສາມາດຫຼີກເວັ້ນໄດ້ໂດຍການປ່ຽນເສັ້ນທາງຜົນຜະລິດໄປຫາ a
ຕົວອະທິບາຍໄຟລ໌ຕົວເລກ (ອັນນີ້ຍັງເຮັດໃຫ້ shell ປິດສຳເນົາຂອງມັນ). ໃຫ້ສັງເກດວ່າ
ພຶດຕິກໍານີ້ແມ່ນແຕກຕ່າງກັນເລັກນ້ອຍຈາກເປືອກ Korn ຕົ້ນສະບັບທີ່ປິດສໍາເນົາຂອງມັນ
ຂອງສ່ວນການຂຽນຂອງຜົນຜະລິດຂອງຂະບວນການຮ່ວມມືໃນເວລາທີ່ຂະບວນການຮ່ວມມືທີ່ເລີ່ມຕົ້ນບໍ່ດົນມານີ້ທີ່ສຸດ
(ແທນທີ່ຈະເປັນເວລາທີ່ຂະບວນການຮ່ວມກັນການແບ່ງປັນທັງຫມົດ) ອອກ.
· ພິມ -p ຈະບໍ່ສົນໃຈສັນຍານ SIGPIPE ໃນລະຫວ່າງການຂຽນ ຖ້າສັນຍານບໍ່ໄດ້ຖືກດັກ ຫຼື
ບໍ່ສົນໃຈ; ອັນດຽວກັນແມ່ນເປັນຄວາມຈິງຖ້າຫາກວ່າການປ້ອນຂໍ້ມູນຮ່ວມຂະບວນການໄດ້ຖືກຊ້ໍາກັນກັບໄຟລ໌ອື່ນ
ຕົວອະທິບາຍແລະ ພິມ -un ຖືກນໍາໃຊ້.
ຫນ້າທີ່
ຟັງຊັນແມ່ນຖືກກໍານົດໂດຍໃຊ້ Korn shell ຫນ້າທີ່ function-name syntax ຫຼື
Bourne/POSIX shell function-name() syntax (ເບິ່ງຂ້າງລຸ່ມນີ້ສໍາລັບຄວາມແຕກຕ່າງລະຫວ່າງສອງ
ແບບຟອມ). ຟັງຊັນແມ່ນຄ້າຍຄື .-scripts (ie scripts ມາຈາກການນໍາໃຊ້ '.' built-in) ໃນນັ້ນ.
ພວກເຂົາເຈົ້າໄດ້ຖືກປະຕິບັດໃນສະພາບແວດລ້ອມໃນປະຈຸບັນ. ແນວໃດກໍ່ຕາມ, ບໍ່ຄືກັບ .-scripts, shell arguments
(ເຊັ່ນ: ຕົວກໍານົດການຕໍາແຫນ່ງ $1, $2, ແລະອື່ນໆ) ບໍ່ເຄີຍເຫັນຢູ່ໃນພວກມັນ. ໃນເວລາທີ່ແກະແມ່ນ
ການກໍານົດທີ່ຕັ້ງຂອງຄໍາສັ່ງ, ຫນ້າທີ່ຄົ້ນຫາຫຼັງຈາກການກໍ່ສ້າງພິເສດ
ຄໍາສັ່ງ, ກ່ອນທີ່ຈະ buildins ແລະ PATH ໄດ້ຖືກຄົ້ນຫາ.
ຟັງຊັນທີ່ມີຢູ່ແລ້ວອາດຈະຖືກລຶບໂດຍໃຊ້ ກຳ ນົດ -f function-name. ບັນຊີລາຍຊື່ຂອງຫນ້າທີ່ສາມາດເຮັດໄດ້
ໄດ້ຮັບການນໍາໃຊ້ ປະເພດ +f ແລະຄໍານິຍາມຫນ້າທີ່ສາມາດໄດ້ຮັບການລະບຸໄວ້ໂດຍນໍາໃຊ້ ປະເພດ -f.
ໄດ້ ອັດຕະໂນມັດ ຄໍາສັ່ງ (ຊຶ່ງເປັນນາມແຝງສໍາລັບ ປະເພດ -fu) ອາດຈະຖືກນໍາໃຊ້ເພື່ອສ້າງ undefined
functions: ເມື່ອຟັງຊັນທີ່ບໍ່ໄດ້ກໍານົດຖືກປະຕິບັດ, shell ຄົ້ນຫາເສັ້ນທາງທີ່ລະບຸໄວ້ໃນ
ພາລາມິເຕີ FPATH ສໍາລັບໄຟລ໌ທີ່ມີຊື່ດຽວກັນກັບຟັງຊັນທີ່, ຖ້າພົບ, ຈະຖືກອ່ານ
ແລະປະຕິບັດ. ຖ້າຫາກວ່າຫຼັງຈາກການປະຕິບັດໄຟລ໌ໄດ້ພົບເຫັນຫນ້າທີ່ທີ່ມີຊື່ໄດ້ຖືກກໍານົດ, ໄດ້
ຟັງຊັນຖືກປະຕິບັດ; ຖ້າບໍ່ດັ່ງນັ້ນ, ການຄົ້ນຫາຄໍາສັ່ງປົກກະຕິແມ່ນສືບຕໍ່ (ເຊັ່ນ: shell
ຄົ້ນຫາຕາຕະລາງຄໍາສັ່ງທີ່ມີຢູ່ໃນປົກກະຕິແລະ PATH). ໃຫ້ສັງເກດວ່າຖ້າຄໍາສັ່ງບໍ່ພົບ
ການນໍາໃຊ້ PATH, ມີຄວາມພະຍາຍາມທີ່ຈະໂຫລດຟັງຊັນອັດຕະໂນມັດໂດຍໃຊ້ FPATH (ນີ້ແມ່ນບໍ່ມີເອກະສານ.
ຄຸນລັກສະນະຂອງແກະ Korn ຕົ້ນສະບັບ).
ຟັງຊັນສາມາດມີສອງຄຸນລັກສະນະ, "ຕິດຕາມ" ແລະ "ສົ່ງອອກ", ເຊິ່ງສາມາດຕັ້ງຄ່າໄດ້ ປະເພດ -ft
ແລະ ປະເພດ -fx, ຕາມລໍາດັບ. ເມື່ອຟັງຊັນ traced ຖືກປະຕິບັດ, shell ຂອງ xtrace
ທາງເລືອກແມ່ນເປີດສໍາລັບໄລຍະເວລາຂອງຟັງຊັນ. ຄຸນລັກສະນະຂອງຫນ້າທີ່ "ສົ່ງອອກ" ແມ່ນ
ປະຈຸບັນບໍ່ໄດ້ໃຊ້. ໃນແກະ Korn ຕົ້ນສະບັບ, ຫນ້າທີ່ສົ່ງອອກແມ່ນເຫັນໄດ້ຈາກແກະ
scripts ທີ່ຖືກປະຕິບັດ.
ເນື່ອງຈາກຟັງຊັນຕ່າງໆຖືກປະຕິບັດໃນສະພາບແວດລ້ອມຂອງແກະໃນປະຈຸບັນ, ການມອບຫມາຍພາລາມິເຕີໄດ້ເຮັດ
ຟັງຊັນພາຍໃນແມ່ນເຫັນໄດ້ຫຼັງຈາກຟັງຊັນສໍາເລັດ. ຖ້ານີ້ບໍ່ແມ່ນສິ່ງທີ່ຕ້ອງການ
ຜົນກະທົບ, ໄດ້ ປະເພດ ຄໍາສັ່ງສາມາດນໍາໃຊ້ພາຍໃນຟັງຊັນເພື່ອສ້າງພາລາມິເຕີທ້ອງຖິ່ນ. ຫມາຍເຫດ
ວ່າ AT&T UNIX ksh93 ໃຊ້ຂອບເຂດຄົງທີ່ (ໜຶ່ງຂອບເຂດທົ່ວໂລກ, ຂອບເຂດທ້ອງຖິ່ນຕໍ່ຟັງຊັນ)
ແລະອະນຸຍາດໃຫ້ຕົວແປທ້ອງຖິ່ນພຽງແຕ່ກ່ຽວກັບຟັງຊັນແບບ Korn, ໃນຂະນະທີ່ mksh ໃຊ້ຂອບເຂດແບບເຄື່ອນໄຫວ
(ຂອບເຂດຂອງທ້ອງຖິ່ນທີ່ແຕກຕ່າງກັນ). ໃຫ້ສັງເກດວ່າຕົວກໍານົດການພິເສດ (ຕົວຢ່າງ $$, $!) ບໍ່ສາມາດເປັນ
ຂອບເຂດໃນລັກສະນະນີ້.
ສະຖານະການອອກຂອງຟັງຊັນແມ່ນຄໍາສັ່ງສຸດທ້າຍທີ່ຖືກປະຕິບັດໃນຟັງຊັນ. ກ
ຟັງຊັນສາມາດເຮັດໄດ້ເພື່ອໃຫ້ສໍາເລັດທັນທີໂດຍໃຊ້ ການກັບຄືນມາ ຄໍາສັ່ງ; ອັນນີ້ອາດຈະຖືກໃຊ້ເຊັ່ນກັນ
ເພື່ອລະບຸສະຖານະການອອກຢ່າງຈະແຈ້ງ.
ຫນ້າທີ່ກໍານົດດ້ວຍ ຫນ້າທີ່ ຄໍາສະຫງວນແມ່ນຖືກປະຕິບັດແຕກຕ່າງກັນໃນຕໍ່ໄປນີ້
ວິທີການຈາກຫນ້າທີ່ກໍານົດດ້ວຍ () ຫມາຍເຫດ:
· ຄ່າພາລາມິເຕີ $0 ຖືກຕັ້ງເປັນຊື່ຂອງຟັງຊັນ (ຟັງຊັນແບບ Bourne ປ່ອຍໃຫ້ $0
ບໍ່ໄດ້ແຕະຕ້ອງ).
· ການມອບໝາຍພາຣາມິເຕີກ່ອນໜ້າການໂທຈະບໍ່ຖືກເກັບໄວ້ໃນສະພາບແວດລ້ອມຂອງແກະ
(ການປະຕິບັດຫນ້າທີ່ແບບ Bourne ຈະຮັກສາການມອບຫມາຍ).
· OPTIND ຖືກບັນທຶກ / ປັບແລະຟື້ນຟູໃນການເຂົ້າແລະອອກຈາກຫນ້າທີ່ດັ່ງນັ້ນ ໝໍ້ ສາມາດ
ໃຊ້ຢ່າງຖືກຕ້ອງທັງພາຍໃນແລະນອກຟັງຊັນ (ຟັງຊັນແບບ Bourne ອອກຈາກ OPTIND
untouched, ສະນັ້ນການນໍາໃຊ້ ໝໍ້ ພາຍໃນຟັງຊັນຂັດຂວາງການນໍາໃຊ້ ໝໍ້ ນອກ
ໜ້າ ທີ່).
· ຕົວເລືອກ Shell (ທີ່ກໍານົດໄວ້ -o) ມີຂອບເຂດທ້ອງຖິ່ນ, ເຊັ່ນ: ການປ່ຽນແປງພາຍໃນຟັງຊັນຖືກຕັ້ງຄືນໃຫມ່
ທາງອອກຂອງມັນ.
ໃນອະນາຄົດ, ຄວາມແຕກຕ່າງຕໍ່ໄປນີ້ອາດຈະຖືກເພີ່ມ:
· ສະພາບແວດລ້ອມກັບດັກ / ສັນຍານແຍກຕ່າງຫາກຈະຖືກນໍາໃຊ້ໃນລະຫວ່າງການປະຕິບັດຫນ້າທີ່. ນີ້
ຈະຫມາຍຄວາມວ່າໃສ່ກັບດັກທີ່ຕັ້ງຢູ່ໃນຫນ້າທີ່ຈະບໍ່ສົ່ງຜົນກະທົບຕໍ່ກັບດັກຂອງຫອຍແລະສັນຍານ
ທີ່ບໍ່ໄດ້ຖືກລະເລີຍໃນແກະ (ແຕ່ອາດຈະຖືກດັກ) ຈະມີຜົນກະທົບໃນຕອນຕົ້ນຂອງພວກເຂົາໃນ
ຫນ້າທີ່.
· ດັກ EXIT, ຖ້າຕັ້ງຢູ່ໃນຟັງຊັນ, ຈະຖືກປະຕິບັດຫຼັງຈາກຟັງຊັນກັບຄືນມາ.
ຄໍາສັ່ງ ການປະຕິບັດ
ຫຼັງຈາກການປະເມີນຜົນຂອງການໂຕ້ຖຽງເສັ້ນຄໍາສັ່ງ, redirections, ແລະການມອບຫມາຍພາລາມິເຕີ, ໄດ້
ປະເພດຂອງຄໍາສັ່ງແມ່ນຖືກກໍານົດ: ຄໍາສັ່ງພິເສດໃນຕົວ, ຟັງຊັນ, buildin ປົກກະຕິ, ຫຼື
ຊື່ຂອງໄຟລ໌ທີ່ຈະດໍາເນີນການພົບເຫັນໂດຍໃຊ້ພາລາມິເຕີ PATH. ການກວດສອບແມ່ນເຮັດຢູ່ໃນ
ຄໍາສັ່ງຂ້າງເທິງ. ຄໍາສັ່ງພິເສດທີ່ສ້າງຂຶ້ນໃນນັ້ນແຕກຕ່າງຈາກຄໍາສັ່ງອື່ນໆໃນ PATH ນັ້ນ
ຕົວກໍານົດການບໍ່ໄດ້ຖືກນໍາໃຊ້ເພື່ອຊອກຫາພວກເຂົາ, ຄວາມຜິດພາດໃນລະຫວ່າງການປະຕິບັດຂອງເຂົາເຈົ້າສາມາດເຮັດໃຫ້ເກີດການທີ່ບໍ່ແມ່ນ.
interactive shell ເພື່ອອອກ, ແລະກໍານົດພາລາມິເຕີທີ່ຖືກກໍານົດໄວ້ກ່ອນຄໍາສັ່ງ
ຖືກເກັບຮັກສາໄວ້ຫຼັງຈາກຄໍາສັ່ງສໍາເລັດ. ຄໍາສັ່ງສ້າງໃນແບບປົກກະຕິແມ່ນແຕກຕ່າງກັນພຽງແຕ່ໃນນັ້ນ
ພາລາມິເຕີ PATH ບໍ່ໄດ້ຖືກນໍາໃຊ້ເພື່ອຊອກຫາພວກມັນ.
ຕົ້ນສະບັບ ksh ແລະ POSIX ແຕກຕ່າງກັນບາງຢ່າງທີ່ຄໍາສັ່ງຖືກພິຈາລະນາພິເສດຫຼື
ປົກກະຕິ.
POSIX ອຸປະໂພກໃນຕົວພິເສດ:
., :, ພັກຜ່ອນ, ດໍາເນີນການຕໍ່, ການປະເມີນ, exec, ການທ່ອງທ່ຽວ, ການສົ່ງອອກ, ອ່ານຢ່າງດຽວ, ການກັບຄືນມາ, ທີ່ກໍານົດໄວ້, ປ່ຽນແປງ, ເວລາ, ຈັ່ນຈັບ,
ກຳ ນົດ
ເພີ່ມເຕີມ mksh ຄໍາສັ່ງຮັກສາການມອບຫມາຍ:
ປຸກສ້າງ, ທົ່ວໂລກ, ແຫຼ່ງ, ປະເພດ, ລໍຖ້າ
Builtins ທີ່ບໍ່ພິເສດ:
[, alias, bg, ຜູກ, cat, cd, ຄໍາສັ່ງ, echo, ທີ່ບໍ່ຖືກຕ້ອງ, fc, fg, ໝໍ້, ວຽກເຮັດງານທໍາ, ຂ້າ, ໃຫ້, ພິມ,
ນອນd, ອ່ານ, ເສັ້ນທາງທີ່ແທ້ຈິງ, ປ່ຽນຊື່, ນອນ, suspends, ການທົດສອບ, ທີ່ແທ້ຈິງ, ສູງສຸດ, ໜ້າ ກາກ, ນາມແຝງ, ມາຈາກໃສ
ເມື່ອປະເພດຂອງຄໍາສັ່ງໄດ້ຖືກກໍານົດ, ການກໍານົດພາລາມິເຕີແຖວຄໍາສັ່ງແມ່ນ
ປະຕິບັດແລະສົ່ງອອກສໍາລັບໄລຍະເວລາຂອງຄໍາສັ່ງ.
ຕໍ່ໄປນີ້ອະທິບາຍເຖິງຄໍາສັ່ງທີ່ສ້າງຂຶ້ນໃນແບບພິເສດ ແລະປົກກະຕິ ແລະທີ່ຄ້າຍກັບ builtin ສະຫງວນໄວ້
ຄຳ ເວົ້າ:
. ເອກະສານ [arg ...]
ອັນນີ້ເອີ້ນວ່າ "ຈຸດ". ປະຕິບັດຄໍາສັ່ງໃນ ເອກະສານ ໃນປະຈຸບັນ
ສະພາບແວດລ້ອມ. ໄຟລ໌ຖືກຄົ້ນຫາຢູ່ໃນໄດເລກະທໍລີຂອງ PATH. ຖ້າມີການໂຕ້ຖຽງ
ໃຫ້, ຕົວກໍານົດການຕໍາແຫນ່ງອາດຈະຖືກນໍາໃຊ້ເພື່ອເຂົ້າເຖິງພວກເຂົາໃນຂະນະທີ່ ເອກະສານ ແມ່ນໄດ້ຖືກ
ປະຕິບັດ. ຖ້າບໍ່ມີການໂຕ້ຖຽງໃດໆ, ຕົວກໍານົດການຕໍາແຫນ່ງແມ່ນຂອງ
ສະພາບແວດລ້ອມຄໍາສັ່ງຖືກນໍາໃຊ້ໃນ.
: [...]
ຄໍາສັ່ງ null. ສະຖານະອອກຖືກຕັ້ງເປັນສູນ.
[ ການສະແດງອອກ ]
ເບິ່ງ ການທົດສອບ.
alias [-d | -t [-r] | +-x] [-p] [+] [ຊື່ [=ມູນຄ່າ] ...]
ໂດຍບໍ່ມີການໂຕ້ຖຽງ, alias ລາຍຊື່ນາມແຝງທັງໝົດ. ສໍາລັບຊື່ທີ່ບໍ່ມີຄ່າໃດໆ, the
ນາມແຝງທີ່ມີຢູ່ແມ່ນລະບຸໄວ້. ຊື່ໃດນຶ່ງທີ່ມີມູນຄ່າກໍານົດນາມແຝງ (ເບິ່ງ ນາມແຝງ
ຂ້າງເທິງ).
ເມື່ອລາຍຊື່ນາມແຝງ, ຫນຶ່ງໃນສອງຮູບແບບຖືກນໍາໃຊ້. ໂດຍປົກກະຕິ, ນາມແຝງຖືກລະບຸໄວ້ເປັນ
ຊື່=ມູນຄ່າ, ບ່ອນທີ່ ມູນຄ່າ ແມ່ນອ້າງອີງ. ຖ້າຕົວເລືອກຖືກນຳໜ້າດ້ວຍ '+', ຫຼືດ່ຽວ '+'
ແມ່ນໃຫ້ຢູ່ໃນເສັ້ນຄໍາສັ່ງ, ເທົ່ານັ້ນ ຊື່ ຖືກພິມອອກ.
ໄດ້ -d ທາງເລືອກເຮັດໃຫ້ນາມແຝງໄດເລກະທໍລີທີ່ຖືກນໍາໃຊ້ໃນການຂະຫຍາຍ tilde ຈະຖືກລະບຸໄວ້
ຫຼືຕັ້ງ (ເບິ່ງ ເຄື່ອງ ໝາຍ ສຳ ນຽງ ການຂະຫຍາຍຕົວ ຂ້າງເທິງ).
ຖ້າ -p ທາງເລືອກແມ່ນຖືກນໍາໃຊ້, ແຕ່ລະນາມແຝງແມ່ນນໍາຫນ້າດ້ວຍສະຕຣິງ "alias".
ໄດ້ -t ທາງເລືອກຊີ້ໃຫ້ເຫັນວ່ານາມແຝງທີ່ຕິດຕາມແມ່ນຈະຖືກລະບຸໄວ້ / ຕັ້ງ (ຄ່າທີ່ລະບຸໄວ້
ຢູ່ໃນເສັ້ນຄໍາສັ່ງຖືກລະເລີຍສໍາລັບນາມແຝງທີ່ຖືກຕິດຕາມ). ໄດ້ -r ທາງເລືອກຊີ້ໃຫ້ເຫັນວ່າ
ນາມແຝງທີ່ຕິດຕາມທັງໝົດຈະຖືກຣີເຊັດ.
ໄດ້ -x ຊຸດທາງເລືອກ (+x clears) ຄຸນລັກສະນະການສົ່ງອອກຂອງນາມແຝງ, ຫຼື, ຖ້າບໍ່ມີຊື່
ໃຫ້, ລາຍຊື່ນາມແຝງທີ່ມີຄຸນລັກສະນະການສົ່ງອອກ (ການສົ່ງອອກນາມແຝງບໍ່ມີ
ຜົນກະທົບ).
bg [ວຽກເຮັດງານທໍາ ...]
ສືບຕໍ່ວຽກທີ່ຢຸດເຊົາທີ່ລະບຸໄວ້ໃນພື້ນຫຼັງ. ຖ້າຫາກວ່າບໍ່ມີການກໍານົດວຽກເຮັດງານທໍາ, %+
ແມ່ນສົມມຸດ. ເບິ່ງ ວຽກເຮັດງານທໍາ ການຄວບຄຸມ ຂ້າງລຸ່ມສໍາລັບຂໍ້ມູນເພີ່ມເຕີມ.
ຜູກ [-l]
ການຜູກມັດໃນປະຈຸບັນແມ່ນໄດ້ລະບຸໄວ້. ຖ້າ -l ທຸງຊາດຖືກມອບໃຫ້, ຜູກ ແທນທີ່ຈະເປັນລາຍການ
ຊື່ຂອງຫນ້າທີ່ທີ່ກະແຈອາດຈະຖືກຜູກມັດ. ເບິ່ງ Emacs ການແກ້ໄຂ ຮູບແບບການ ສໍາລັບການຫຼາຍ
ຂໍ້ມູນຂ່າວສານ.
ຜູກ [-m] string=[ທົດແທນ] ...
ຜູກ string=[ການແກ້ໄຂຄໍາສັ່ງ] ...
ຄໍາສັ່ງການແກ້ໄຂທີ່ກໍານົດໄວ້ແມ່ນຜູກພັນກັບການໃຫ້ string, ເຊິ່ງຄວນປະກອບດ້ວຍ a
ຄວບຄຸມຕົວອັກສອນເປັນທາງເລືອກທີ່ນຳໜ້າດ້ວຍໜຶ່ງໃນສອງຕົວອັກສອນຄຳນຳໜ້າ ແລະ
ທາງເລືອກທີ່ປະສົບຜົນສໍາເລັດໂດຍລັກສະນະ tilde. ການປ້ອນຂໍ້ມູນໃນອະນາຄົດຂອງ string ຈະເຮັດໃຫ້ເກີດການ
ການແກ້ໄຂຄໍາສັ່ງທີ່ຈະເອີ້ນທັນທີ. ຖ້າ -m ທຸງແມ່ນໃຫ້, ລະບຸໄວ້
ການປ້ອນຂໍ້ມູນ string ຫຼັງຈາກນັ້ນຈະໄດ້ຮັບການທົດແທນທັນທີໂດຍການໃຫ້ ທົດແທນ string
ເຊິ່ງອາດມີຄຳສັ່ງການແກ້ໄຂ ແຕ່ບໍ່ແມ່ນມາໂຄຣອື່ນ. ຖ້າ tilde postfix ແມ່ນ
ໃຫ້, tilde ຕິດຕາມຫນຶ່ງຫຼືສອງ prefices ແລະລັກສະນະການຄວບຄຸມຖືກລະເລີຍ,
ຕົວອັກສອນຕໍ່ທ້າຍອື່ນໆຈະຖືກປະມວນຜົນຫຼັງຈາກນັ້ນ.
ຕົວອັກສອນຄວບຄຸມອາດຈະຖືກຂຽນໂດຍໃຊ້ເຄື່ອງໝາຍຫຍໍ້ໜ້າເຊັ່ນ ^X ແທນ Ctrl-X.
ໃຫ້ສັງເກດວ່າເຖິງແມ່ນວ່າພຽງແຕ່ສອງຕົວອັກສອນຄໍານໍາຫນ້າ (ປົກກະຕິແລ້ວ ESC ແລະ ^X) ໄດ້ຮັບການສະຫນັບສະຫນູນ,
ບາງລໍາດັບຫຼາຍຕົວອັກສອນສາມາດໄດ້ຮັບການສະຫນັບສະຫນູນ.
ການຜູກມັດເລີ່ມຕົ້ນຕໍ່ໄປນີ້ສະແດງໃຫ້ເຫັນວິທີການປຸ່ມລູກສອນ, ເຮືອນ, ທ້າຍ ແລະປຸ່ມລຶບ
ໃນ BSD wsvt25, xterm-xfree86 ຫຼື terminal ຫນ້າຈໍ GNU ຖືກຜູກມັດ (ແນ່ນອນບາງອັນ.
ລໍາດັບການຫລົບຫນີຈະບໍ່ເຮັດວຽກໄດ້ດີພໍສົມຄວນ):
bind '^X'=ຄຳນຳໜ້າ-2
bind '^[['=prefix-2
bind '^XA'=ປະຫວັດສາດຂຶ້ນ
bind '^XB'=ປະຫວັດຫຍໍ້
bind '^XC'=forward-char
bind '^XD'=backward-char
bind '^X1~'=beginning-of-line
bind '^X7~'=beginning-of-line
bind '^XH'=ການເລີ່ມຕົ້ນຂອງແຖວ
bind '^X4~'= end-of-line
bind '^X8~'= end-of-line
bind '^XF'=ສິ້ນສຸດຂອງແຖວ
bind '^X3~'=delete-char-forward
ພັກຜ່ອນ [ລະດັບ]
ອອກຈາກ ລະດັບth ພາຍໃນທີ່ສຸດ ສໍາລັບການ, ເລືອກ, ຈົນກ່ວາ, ຫຼື ໃນຂະນະທີ່ ວົນ. ລະດັບ ຄ່າເລີ່ມຕົ້ນເປັນ 1.
ປຸກສ້າງ [--] ຄໍາສັ່ງ [arg ...]
ປະຕິບັດຄໍາສັ່ງໃນຕົວ ຄໍາສັ່ງ.
cat [-u] [ເອກະສານ ...]
ອ່ານໄຟລ໌ຕາມລໍາດັບ, ໃນຄໍາສັ່ງເສັ້ນຄໍາສັ່ງ, ແລະຂຽນໃຫ້ເຂົາເຈົ້າກັບຜົນຜະລິດມາດຕະຖານ.
ຖ້າຫາກວ່າເປັນ ເອກະສານ ເປັນຂີດດຽວ ('-') ຫຼືບໍ່ມີ, ອ່ານຈາກວັດສະດຸປ້ອນມາດຕະຖານ. ສໍາລັບໂດຍກົງ
ການໂທໃນຕົວ, POSIX -u ທາງເລືອກແມ່ນສະຫນັບສະຫນູນເປັນ no-op. ສໍາລັບການໂທຈາກ shell, ຖ້າ
ທາງເລືອກໃດຫນຶ່ງແມ່ນໄດ້ຮັບການ, ພາຍນອກ cat(1) ຜົນປະໂຫຍດແມ່ນມັກຫຼາຍກວ່າ buildin.
cd [-L] [dir]
cd -P [-e] [dir]
chdir [-eLP] [dir]
ຕັ້ງຄ່າໄດເລກະທໍລີທີ່ເຮັດວຽກເປັນ dir. ຖ້າພາລາມິເຕີ CDPATH ຖືກຕັ້ງ, ມັນຈະສະແດງລາຍການ
ເສັ້ນທາງຄົ້ນຫາສໍາລັບໄດເລກະທໍລີທີ່ມີ dir. ເສັ້ນທາງ NULL ຫມາຍຄວາມວ່າປະຈຸບັນ
ໄດເລກະທໍລີ. ຖ້າ dir ພົບເຫັນຢູ່ໃນອົງປະກອບໃດໆຂອງເສັ້ນທາງການຊອກຫາ CDPATH ນອກເຫນືອຈາກ
ເສັ້ນທາງ NULL, ຊື່ຂອງໄດເລກະທໍລີທີ່ເຮັດວຽກໃຫມ່ຈະຖືກຂຽນເປັນຜົນຜະລິດມາດຕະຖານ.
If dir ຫາຍໄປ, ໄດເຣັກທໍຣີບ້ານ HOME ຖືກໃຊ້. ຖ້າ dir ແມ່ນ '-', ທີ່ຜ່ານມາ
ໄດເລກະທໍລີເຮັດວຽກຖືກນໍາໃຊ້ (ເບິ່ງພາລາມິເຕີ OLDPWD).
ຖ້າ -L ທາງເລືອກ (ເສັ້ນທາງຢ່າງມີເຫດຜົນ) ຖືກນໍາໃຊ້ຫຼືຖ້າຫາກວ່າ ທາງດ້ານຮ່າງກາຍ ບໍ່ໄດ້ຕັ້ງທາງເລືອກ (ເບິ່ງ
ທີ່ກໍານົດໄວ້ command below), ອ້າງອີງເຖິງ '..' in dir ແມ່ນກ່ຽວຂ້ອງກັບເສັ້ນທາງທີ່ໃຊ້ເພື່ອໄປເຖິງ
ໄດເລກະທໍລີ. ຖ້າ -P ທາງເລືອກ (ທາງດ້ານຮ່າງກາຍ) ຖືກນໍາໃຊ້ຫຼືຖ້າຫາກວ່າ ທາງດ້ານຮ່າງກາຍ ທາງເລືອກແມ່ນ
ຕັ້ງ, '..' ແມ່ນກ່ຽວຂ້ອງກັບຕົ້ນໄມ້ລະບົບໄຟລ໌. PWD ແລະ OLDPWD
ຕົວກໍານົດການໄດ້ຖືກປັບປຸງເພື່ອສະທ້ອນໃຫ້ເຫັນໄດເລກະທໍລີທີ່ເຮັດວຽກໃນປະຈຸບັນແລະເກົ່າ,
ຕາມລໍາດັບ. ຖ້າ -e ທາງເລືອກແມ່ນກໍານົດສໍາລັບການຜ່ານລະບົບໄຟລ໌ທາງດ້ານຮ່າງກາຍ, ແລະ PWD
ບໍ່ສາມາດຕັ້ງຄ່າໄດ້, ລະຫັດອອກແມ່ນ 1; ຫຼາຍກວ່າ 1 ຖ້າມີຂໍ້ຜິດພາດເກີດຂຶ້ນ, 0
ຖ້າບໍ່ດັ່ງນັ້ນ.
cd [-eLP] ອາຍຸ ໃຫມ່
chdir [-eLP] ອາຍຸ ໃຫມ່
ຊ່ອຍແນ່ ໃຫມ່ ຖືກແທນທີ່ ອາຍຸ ໃນໄດເລກະທໍລີປະຈຸບັນ, ແລະແກະ
ພະຍາຍາມປ່ຽນໄປຫາໄດເລກະທໍລີໃຫມ່.
ຄໍາສັ່ງ [-pVv] cmd [arg ...]
ຖ້າບໍ່ແມ່ນ -v neither -V ທາງເລືອກແມ່ນໄດ້ຮັບ, cmd ຖືກປະຕິບັດຢ່າງແທ້ຈິງຄືກັບວ່າ ຄໍາສັ່ງ ໄດ້
ບໍ່ໄດ້ຖືກລະບຸໄວ້, ມີສອງຂໍ້ຍົກເວັ້ນ: ທໍາອິດ, cmd ບໍ່ສາມາດເປັນການເຮັດວຽກຂອງແກະ; ແລະ
ອັນທີສອງ, ຄໍາສັ່ງພິເສດໃນຕົວຈະສູນເສຍຄວາມພິເສດຂອງພວກເຂົາ (ເຊັ່ນການປ່ຽນເສັ້ນທາງແລະ
ຄວາມຜິດພາດຜົນປະໂຫຍດບໍ່ໄດ້ເຮັດໃຫ້ແກະອອກ, ແລະການມອບຫມາຍຄໍາສັ່ງບໍ່ແມ່ນ
ຖາວອນ).
ຖ້າ -p ທາງເລືອກແມ່ນໄດ້ຮັບ, ເປັນເສັ້ນທາງການຊອກຫາໃນຕອນຕົ້ນໄດ້ຖືກນໍາໃຊ້ແທນທີ່ຈະເປັນມູນຄ່າປະຈຸບັນ
ຂອງ PATH, ມູນຄ່າຕົວຈິງແມ່ນຂຶ້ນກັບລະບົບ.
ຖ້າ -v ທາງເລືອກແມ່ນໃຫ້, ແທນທີ່ຈະປະຕິບັດ cmd, ຂໍ້ມູນກ່ຽວກັບສິ່ງທີ່ຈະເປັນ
ປະຕິບັດແມ່ນໄດ້ຮັບ (ແລະດຽວກັນແມ່ນເຮັດໄດ້ສໍາລັບການ arg ...). ສໍາລັບ buildins, ຫນ້າທີ່ແລະ
ຄໍາສໍາຄັນ, ຊື່ຂອງພວກເຂົາຖືກພິມອອກງ່າຍດາຍ; ສໍາລັບນາມແຝງ, ຄໍາສັ່ງທີ່ກໍານົດພວກມັນແມ່ນ
ພິມ; ສໍາລັບອຸປະກອນທີ່ພົບເຫັນໂດຍການຊອກຫາພາລາມິເຕີ PATH, ເສັ້ນທາງອັນເຕັມທີ່ຂອງ
ຄໍາສັ່ງຖືກພິມອອກ. ຖ້າບໍ່ພົບຄໍາສັ່ງ (ເຊັ່ນ: ການຄົ້ນຫາເສັ້ນທາງລົ້ມເຫລວ), ບໍ່ມີຫຍັງເລີຍ
ພິມອອກແລະ ຄໍາສັ່ງ ອອກດ້ວຍສະຖານະທີ່ບໍ່ແມ່ນສູນ. ໄດ້ -V ທາງເລືອກແມ່ນຄ້າຍຄື -v
ທາງເລືອກ, ຍົກເວັ້ນມັນເປັນ verbose ຫຼາຍ.
ດໍາເນີນການຕໍ່ [ລະດັບ]
ໄປຫາຈຸດເລີ່ມຕົ້ນຂອງ ລະດັບth ພາຍໃນທີ່ສຸດ ສໍາລັບການ, ເລືອກ, ຈົນກ່ວາ, ຫຼື ໃນຂະນະທີ່ ວົນ.
ລະດັບ ຄ່າເລີ່ມຕົ້ນເປັນ 1.
echo [-ອີນ] [arg ...]
ຄໍາເຕືອນ: ປະໂຫຍດນີ້ແມ່ນບໍ່ສາມາດເຄື່ອນທີ່; ໃຊ້ Korn shell buildin ພິມ ແທນທີ່ຈະເປັນ.
ພິມຂໍ້ໂຕ້ແຍ້ງຂອງມັນ (ແຍກດ້ວຍຍະຫວ່າງ) ຕາມດ້ວຍແຖວໃໝ່, ເປັນມາດຕະຖານ
ຜົນຜະລິດ. ແຖວໃໝ່ຈະຖືກສະກັດກັ້ນຫາກການໂຕ້ແຍ້ງໃດໜຶ່ງມີ backslash
ລຳດັບ '\c'. ເບິ່ງ ພິມ ຄໍາສັ່ງຂ້າງລຸ່ມນີ້ສໍາລັບບັນຊີລາຍຊື່ຂອງລໍາດັບ backslash ອື່ນໆ
ທີ່ຖືກຮັບຮູ້.
ທາງເລືອກແມ່ນໄດ້ສະຫນອງໃຫ້ສໍາລັບການເຂົ້າກັນໄດ້ກັບ BSD shell scripts. ໄດ້ -n ທາງເລືອກ
ສະກັດກັ້ນເສັ້ນໃຫມ່ຕິດຕາມ, -e ເປີດໃຊ້ການຕີຄວາມໝາຍ backslash (no-op, ນັບຕັ້ງແຕ່
ນີ້ແມ່ນເຮັດຕາມປົກກະຕິ), ແລະ -E ສະກັດກັ້ນການຕີຄວາມໝາຍ backslash.
ຖ້າ ບວກ or sh ທາງເລືອກແມ່ນໄດ້ຖືກຕັ້ງໄວ້ຫຼືນີ້ແມ່ນການໂທ builtin ໂດຍກົງ, ພຽງແຕ່ຄັ້ງທໍາອິດ
ການໂຕ້ຖຽງຖືກປະຕິບັດເປັນທາງເລືອກ, ແລະພຽງແຕ່ຖ້າມັນແມ່ນແທ້ "-n”. Backslash
ການຕີຄວາມໝາຍຖືກປິດໄວ້.
ການປະເມີນ ຄໍາສັ່ງ ...
arguments ແມ່ນ concatenated (ມີຊ່ອງຫວ່າງລະຫວ່າງພວກມັນ) ເພື່ອສ້າງເປັນສາຍດຽວ
ເຊິ່ງຫຼັງຈາກນັ້ນ shell parses ແລະປະຕິບັດໃນສະພາບແວດລ້ອມປະຈຸບັນ.
exec [-a argv0] [-c] [ຄໍາສັ່ງ [arg ...]]
ຄໍາສັ່ງຖືກປະຕິບັດໂດຍບໍ່ມີການ forking, ທົດແທນຂະບວນການແກະ. ນີ້ແມ່ນ
ໃນປັດຈຸບັນຢ່າງແທ້ຈິງ, ie exec ບໍ່ເຄີຍກັບຄືນມາ, ເຖິງແມ່ນວ່າ ຄໍາສັ່ງ ບໍ່ພົບ. ໄດ້
-a ທາງເລືອກອະນຸຍາດໃຫ້ກໍານົດຄ່າ argv[0] ທີ່ແຕກຕ່າງກັນ, ແລະ -c ອະນາໄມສະພາບແວດລ້ອມ
ກ່ອນທີ່ຈະດໍາເນີນການຂະບວນການເດັກ, ຍົກເວັ້ນສໍາລັບ _ ການປ່ຽນແປງແລະການມອບຫມາຍໂດຍກົງ.
ຖ້າບໍ່ມີຄໍາສັ່ງໃຫ້ຍົກເວັ້ນການປ່ຽນເສັ້ນທາງ I/O, ການປ່ຽນເສັ້ນທາງ I/O ແມ່ນຖາວອນ
ແລະແກະບໍ່ໄດ້ຖືກທົດແທນ. ຕົວອະທິບາຍໄຟລ໌ໃດນຶ່ງທີ່ໃຫຍ່ກວ່າ 2 ທີ່ຖືກເປີດ
or dup(2)'d ໃນວິທີການນີ້ບໍ່ໄດ້ຖືກເຮັດໃຫ້ສາມາດໃຊ້ໄດ້ກັບຄໍາສັ່ງປະຕິບັດອື່ນໆ (ie
ຄໍາສັ່ງທີ່ບໍ່ໄດ້ສ້າງຂຶ້ນໃນ shell). ໃຫ້ສັງເກດວ່າແກະ Bourne ແຕກຕ່າງກັນ
ທີ່ນີ້; ມັນຜ່ານຕົວອະທິບາຍໄຟລ໌ເຫຼົ່ານີ້.
ການທ່ອງທ່ຽວ [ສະຖານະພາບ]
ແກະອອກດ້ວຍສະຖານະທາງອອກທີ່ລະບຸໄວ້. ຖ້າ ສະຖານະພາບ ບໍ່ໄດ້ລະບຸໄວ້, ທາງອອກ
ສະຖານະພາບແມ່ນມູນຄ່າປະຈຸບັນຂອງ $? ພາລາມິເຕີ.
ການສົ່ງອອກ [-p] [ພາລາມິເຕີ[=ມູນຄ່າ]]
ກໍານົດຄຸນລັກສະນະການສົ່ງອອກຂອງພາລາມິເຕີທີ່ມີຊື່. ຕົວກໍານົດການສົ່ງອອກແມ່ນຜ່ານເຂົ້າ
ສະພາບແວດລ້ອມເພື່ອປະຕິບັດຄໍາສັ່ງ. ຖ້າຄ່າຖືກລະບຸ, ພາລາມິເຕີທີ່ມີຊື່
ຍັງຖືກມອບໝາຍ.
ຖ້າບໍ່ມີຕົວກໍານົດການຖືກກໍານົດ, ພາລາມິເຕີທັງຫມົດທີ່ມີຄຸນລັກສະນະການສົ່ງອອກທີ່ກໍານົດໄວ້
ພິມຫນຶ່ງຕໍ່ແຖວ; ທັງຊື່ຂອງເຂົາເຈົ້າ, ຫຼື, ຖ້າ '-' ທີ່ບໍ່ມີຕົວອັກສອນທາງເລືອກແມ່ນ
ລະບຸ, name=value pairs, ຫຼື, with -p, ການສົ່ງອອກ ຄໍາສັ່ງທີ່ເຫມາະສົມສໍາລັບການເຂົ້າໃຫມ່.
ທີ່ບໍ່ຖືກຕ້ອງ ຄຳສັ່ງທີ່ອອກດ້ວຍສະຖານະທີ່ບໍ່ແມ່ນສູນ.
fc [-e ບັນນາທິການ | -l [-n]] [-r] [ຄັ້ງທໍາອິດ [ສຸດທ້າຍ]]
ຄັ້ງທໍາອິດ ແລະ ສຸດທ້າຍ ເລືອກຄໍາສັ່ງຈາກປະຫວັດສາດ. ຄໍາສັ່ງສາມາດຖືກເລືອກໂດຍປະຫວັດສາດ
ຕົວເລກ (ຕົວເລກລົບກັບຫຼັງຈາກປັດຈຸບັນ, ຫຼ້າສຸດ, ແຖວ) ຫຼື a
string ລະບຸຄໍາສັ່ງຫຼ້າສຸດທີ່ເລີ່ມຕົ້ນດ້ວຍ string ນັ້ນ. ໄດ້ -l ທາງເລືອກ
ລາຍຊື່ຄໍາສັ່ງກ່ຽວກັບຜົນຜະລິດມາດຕະຖານ, ແລະ -n ຍັບຍັ້ງຕົວເລກຄໍາສັ່ງເລີ່ມຕົ້ນ.
ໄດ້ -r ທາງເລືອກແມ່ນປີ້ນກັບລໍາດັບຂອງບັນຊີລາຍຊື່. ໂດຍບໍ່ມີການ -l, ຄໍາສັ່ງທີ່ເລືອກແມ່ນ
ແກ້ໄຂໂດຍບັນນາທິການທີ່ລະບຸໄວ້ກັບ -e ທາງເລືອກ, ຫຼືຖ້າບໍ່ມີ -e ຖືກກໍານົດ, ໄດ້
ບັນນາທິການລະບຸໂດຍພາລາມິເຕີ FCEDIT (ຖ້າພາລາມິເຕີນີ້ບໍ່ໄດ້ຕັ້ງ, /bin/ed is
ໃຊ້), ແລະຫຼັງຈາກນັ້ນປະຕິບັດໂດຍແກະ.
fc -e - | -s [-g] [ອາຍຸ=ໃຫມ່] [ຄຳ ນຳ ໜ້າ]
ປະຕິບັດຄໍາສັ່ງທີ່ເລືອກຄືນໃຫມ່ (ຄໍາສັ່ງທີ່ຜ່ານມາໂດຍຄ່າເລີ່ມຕົ້ນ) ຫຼັງຈາກປະຕິບັດ
ການທົດແທນທາງເລືອກຂອງ ອາຍຸ ກັບ ໃຫມ່ທີ່ຢູ່ ຖ້າຫາກວ່າ -g ແມ່ນລະບຸໄວ້, ປະກົດການທັງຫມົດຂອງ
ອາຍຸ ຖືກທົດແທນດ້ວຍ ໃຫມ່. ຄວາມ ໝາຍ ຂອງ -e - ແລະ -s ແມ່ນຄືກັນ: Re: ປະຕິບັດ
ຄໍາສັ່ງທີ່ເລືອກໂດຍບໍ່ມີການຮຽກຮ້ອງບັນນາທິການ. ຄໍາສັ່ງນີ້ມັກຈະຖືກເຂົ້າເຖິງດ້ວຍ
ທີ່ກໍານົດໄວ້ລ່ວງຫນ້າ: alias r='fc -e -'
fg [ວຽກເຮັດງານທໍາ ...]
ສືບຕໍ່ວຽກທີ່ລະບຸໄວ້ຢູ່ເບື້ອງໜ້າ. ຖ້າຫາກວ່າບໍ່ມີການກໍານົດວຽກເຮັດງານທໍາ, %+ is
ຄາດ. ເບິ່ງ ວຽກເຮັດງານທໍາ ການຄວບຄຸມ ຂ້າງລຸ່ມສໍາລັບຂໍ້ມູນເພີ່ມເຕີມ.
ໝໍ້ optstring ຊື່ [arg ...]
ໃຊ້ໂດຍຂັ້ນຕອນ shell ເພື່ອວິເຄາະອາກິວເມັນທີ່ລະບຸ (ຫຼືຕົວກໍານົດການຕໍາແຫນ່ງ,
ຖ້າບໍ່ມີການໂຕ້ຖຽງແມ່ນໃຫ້) ແລະກວດເບິ່ງທາງເລືອກທາງດ້ານກົດຫມາຍ. optstring ປະກອບດ້ວຍ
ຕົວອັກສອນທາງເລືອກທີ່ ໝໍ້ ແມ່ນເພື່ອຮັບຮູ້. ຖ້າຈົດຫມາຍຖືກຕິດຕາມດ້ວຍຈໍ້າສອງເມັດ, the
ທາງເລືອກແມ່ນຄາດວ່າຈະມີການໂຕ້ຖຽງ. ທາງເລືອກທີ່ບໍ່ເອົາການໂຕ້ຖຽງອາດຈະເປັນ
ຈັດກຸ່ມຢູ່ໃນການໂຕ້ຖຽງດຽວ. ຖ້າທາງເລືອກໃຊ້ເວລາການໂຕ້ຖຽງແລະທາງເລືອກ
ລັກສະນະບໍ່ແມ່ນລັກສະນະສຸດທ້າຍຂອງການໂຕ້ຖຽງທີ່ມັນຖືກພົບເຫັນຢູ່ໃນ, ສ່ວນທີ່ເຫຼືອຂອງ
ການໂຕ້ຖຽງໄດ້ຖືກປະຕິບັດເພື່ອເປັນການໂຕ້ຖຽງຂອງທາງເລືອກ; ຖ້າບໍ່ດັ່ງນັ້ນ, ການໂຕ້ຖຽງຕໍ່ໄປແມ່ນ
ການໂຕ້ຖຽງຂອງທາງເລືອກ.
ແຕ່ລະຄັ້ງ ໝໍ້ ຖືກເອີ້ນ, ມັນວາງຕົວເລືອກຕໍ່ໄປໃນພາລາມິເຕີ shell ຊື່
ແລະດັດຊະນີຂອງການໂຕ້ຖຽງທີ່ຈະດໍາເນີນການໂດຍການໂທຫາຕໍ່ໄປ ໝໍ້ ໃນ
ພາຣາມິເຕີ shell OPTIND. ຖ້າທາງເລືອກໄດ້ຖືກນໍາສະເຫນີດ້ວຍ '+', ທາງເລືອກທີ່ວາງໄວ້
in ຊື່ ຖືກນຳໜ້າດ້ວຍ '+'. ເມື່ອທາງເລືອກທີ່ຕ້ອງການການໂຕ້ຖຽງ, ໝໍ້ ສະຖານທີ່
ມັນຢູ່ໃນຕົວກໍານົດການແກະ OPTARG.
ເມື່ອທາງເລືອກທີ່ຜິດກົດຫມາຍຫຼືການໂຕ້ຖຽງທາງເລືອກທີ່ຂາດຫາຍໄປແມ່ນພົບ, ເຄື່ອງຫມາຍຄໍາຖາມ
ຫຼື ຈໍ້າສອງເມັດຖືກວາງໄວ້ໃນ ຊື່ (ຊີ້ໃຫ້ເຫັນທາງເລືອກທີ່ຜິດກົດຫມາຍຫຼືການໂຕ້ຖຽງທີ່ຂາດຫາຍໄປ,
ຕາມລໍາດັບ) ແລະ OPTARG ຖືກກໍານົດເປັນຕົວອັກສອນທາງເລືອກທີ່ເຮັດໃຫ້ເກີດບັນຫາ.
ຍິ່ງໄປກວ່ານັ້ນ, ຖ້າ optstring ບໍ່ໄດ້ເລີ່ມຕົ້ນດ້ວຍຈໍ້າສອງເມັດ, ເຄື່ອງໝາຍຄໍາຖາມຖືກວາງໄວ້ໃນ
ຊື່, OPTARG ບໍ່ໄດ້ຕັ້ງ, ແລະຂໍ້ຄວາມສະແດງຂໍ້ຜິດພາດຖືກພິມອອກເປັນຄວາມຜິດພາດມາດຕະຖານ.
ເມື່ອສິ້ນສຸດທາງເລືອກແມ່ນພົບ, ໝໍ້ ອອກໄປດ້ວຍທາງອອກທີ່ບໍ່ແມ່ນສູນ
ສະຖານະ. ຕົວເລືອກສິ້ນສຸດຢູ່ທີ່ການໂຕ້ຖຽງທໍາອິດ (ທີ່ບໍ່ແມ່ນທາງເລືອກ) ການໂຕ້ຖຽງທີ່ບໍ່ເລີ່ມຕົ້ນ
ດ້ວຍ '-', ຫຼືເມື່ອພົບກັບການໂຕ້ຖຽງ '--'.
ສາມາດຣີເຊັດຕົວເລືອກການແຍກວິເຄາະໄດ້ໂດຍການຕັ້ງ OPTIND ເປັນ 1 (ອັນນີ້ແມ່ນເຮັດໂດຍອັດຕະໂນມັດ
ທຸກຄັ້ງທີ່ແກະ ຫຼືຂັ້ນຕອນການແກະຖືກເອີ້ນ).
ຄຳເຕືອນ: ການປ່ຽນຄ່າຂອງພາຣາມິເຕີ shell OPTIND ເປັນຄ່າອື່ນທີ່ບໍ່ແມ່ນ 1, ຫຼື
parsing ຊຸດທີ່ແຕກຕ່າງກັນຂອງ argument ໂດຍບໍ່ມີການ reset OPTIND, ອາດຈະນໍາໄປສູ່ການບໍ່ຄາດຄິດ
ຜົນໄດ້ຮັບ.
ທົ່ວໂລກ ...
ເບິ່ງ ປະເພດ.
hash [-r] [ຊື່ ...]
ໂດຍບໍ່ມີການໂຕ້ຖຽງ, ທຸກຊື່ເສັ້ນທາງຄໍາສັ່ງທີ່ສາມາດປະຕິບັດໄດ້ hashed ໄດ້ຖືກລະບຸໄວ້. ໄດ້ -r ທາງເລືອກ
ເຮັດໃຫ້ຄໍາສັ່ງ hash ທັງຫມົດຖືກລຶບອອກຈາກຕາຕະລາງ hash. ແຕ່ລະ ຊື່ ຖືກຄົ້ນຫາ
ຄືກັບວ່າມັນເປັນຊື່ຄໍາສັ່ງແລະເພີ່ມໃສ່ຕາຕະລາງ hash ຖ້າມັນເປັນການປະຕິບັດ
ຄໍາສັ່ງ.
ວຽກເຮັດງານທໍາ [-lnp] [ວຽກເຮັດງານທໍາ ...]
ສະແດງຂໍ້ມູນກ່ຽວກັບວຽກທີ່ລະບຸໄວ້; ຖ້າບໍ່ມີວຽກຖືກລະບຸ, ວຽກທັງໝົດ
ຖືກສະແດງ. ໄດ້ -n ທາງເລືອກເຮັດໃຫ້ຂໍ້ມູນຖືກສະແດງພຽງແຕ່ສໍາລັບວຽກທີ່
ໄດ້ປ່ຽນສະຖານະຕັ້ງແຕ່ການແຈ້ງເຕືອນຄັ້ງສຸດທ້າຍ. ຖ້າ -l ທາງເລືອກແມ່ນການນໍາໃຊ້, ໄດ້
ID ຂະບວນການຂອງແຕ່ລະຂະບວນການໃນວຽກແມ່ນໄດ້ລະບຸໄວ້. ໄດ້ -p ທາງເລືອກທີ່ເຮັດໃຫ້ເກີດພຽງແຕ່
ກຸ່ມຂະບວນການຂອງແຕ່ລະວຽກທີ່ຈະພິມ. ເບິ່ງ ວຽກເຮັດງານທໍາ ການຄວບຄຸມ ຂ້າງລຸ່ມນີ້ສໍາລັບຮູບແບບຂອງ ວຽກເຮັດງານທໍາ
ແລະວຽກທີ່ສະແດງ.
ຂ້າ [-s ນາມ | -ສັນຍາລັກ | -ນາມ] { ວຽກເຮັດງານທໍາ | pid | pgrp } ...
ສົ່ງສັນຍານທີ່ລະບຸໄວ້ໃນວຽກທີ່ກໍານົດໄວ້, IDs ຂະບວນການ, ຫຼືກຸ່ມຂະບວນການ. ຖ້າ
ບໍ່ມີສັນຍານທີ່ລະບຸໄວ້, ສັນຍານ TERM ຖືກສົ່ງ. ຖ້າວຽກຖືກກໍານົດ, ສັນຍານ
ຖືກສົ່ງໄປຫາກຸ່ມຂະບວນການຂອງວຽກ. ເບິ່ງ ວຽກເຮັດງານທໍາ ການຄວບຄຸມ ຂ້າງລຸ່ມນີ້ສໍາລັບຮູບແບບຂອງ ວຽກເຮັດງານທໍາ.
ຂ້າ -l [ສະຖານະການອອກ ...]
ພິມຊື່ສັນຍານທີ່ສອດຄ້ອງກັບ ສະຖານະການອອກ. ຖ້າບໍ່ມີການລະບຸການໂຕ້ຖຽງ, ກ
ບັນຊີລາຍຊື່ຂອງສັນຍານທັງຫມົດ, ຕົວເລກຂອງເຂົາເຈົ້າ, ແລະລາຍລະອຽດສັ້ນຂອງເຂົາເຈົ້າໄດ້ຖືກພິມອອກ.
ໃຫ້ [ການສະແດງອອກ ...]
ແຕ່ລະສະແດງອອກໄດ້ຖືກປະເມີນ (ເບິ່ງ ເລກຄະນິດສາດ expressions ຂ້າງເທິງ). ຖ້າຫາກວ່າການສະແດງອອກທັງຫມົດ
ໄດ້ຖືກປະເມີນຢ່າງສໍາເລັດຜົນ, ສະຖານະການອອກແມ່ນ 0 (1) ຖ້າການສະແດງອອກສຸດທ້າຍຖືກປະເມີນ
ຫາບໍ່ແມ່ນສູນ (ສູນ). ຖ້າມີຂໍ້ຜິດພາດເກີດຂຶ້ນໃນລະຫວ່າງການວິເຄາະ ຫຼືການປະເມີນ
ການສະແດງອອກ, ສະຖານະພາບທາງອອກແມ່ນໃຫຍ່ກວ່າ 1. ເນື່ອງຈາກການສະແດງອອກອາດຈະຕ້ອງການ
ອ້າງອີງ, (( ຕົວຢ່າງ )) ແມ່ນນ້ໍາຕານ syntactic ສໍາລັບ { let 'ຕົວຢ່າງ' ; }.
ໃຫ້] ນາມແຝງທີ່ໃຊ້ພາຍໃນ ໃຫ້.
mknod [-m ຮູບແບບການ] ຊື່ b|c ທີ່ສໍາຄັນ ເລັກນ້ອຍ
mknod [-m ຮູບແບບການ] ຊື່ p
ສ້າງໄຟລ໌ພິເສດຂອງອຸປະກອນ. ປະເພດໄຟລ໌ອາດຈະເປັນ b (ອຸປະກອນປະເພດຕັນ), c
(ອຸປະກອນປະເພດຕົວອັກສອນ), ຫຼື p (ຊື່ທໍ່, FIFO). ໄຟລ໌ທີ່ສ້າງຂຶ້ນອາດຈະຖືກແກ້ໄຂ
ອີງຕາມການຂອງຕົນ ຮູບແບບການ (ຜ່ານ -m ທາງເລືອກ) ທີ່ສໍາຄັນ (ຈໍານວນອຸປະກອນທີ່ສໍາຄັນ), ແລະ ເລັກນ້ອຍ
(ຈໍານວນອຸປະກອນເລັກນ້ອຍ). ນີ້ບໍ່ແມ່ນປົກກະຕິສ່ວນຫນຶ່ງຂອງ mksh; ຢ່າງໃດກໍຕາມ, ຜູ້ຈໍາຫນ່າຍອາດຈະ
ໄດ້ເພີ່ມນີ້ເປັນ buildin ເປັນ hack ຄວາມໄວ.
ພິມ [- nprsu[n] | -R [- ໃນ]] [ການໂຕ້ຖຽງ ...]
ພິມ ພິມການໂຕ້ຖຽງຂອງມັນຢູ່ໃນຜົນຜະລິດມາດຕະຖານ, ແຍກອອກໂດຍຊ່ອງຫວ່າງແລະສິ້ນສຸດລົງ
ກັບແຖວໃໝ່. ໄດ້ -n ທາງເລືອກສະກັດກັ້ນເສັ້ນໃຫມ່. ໂດຍຄ່າເລີ່ມຕົ້ນ, ບາງ C ຫນີ
ຖືກແປ. ເຫຼົ່ານີ້ລວມມີສິ່ງທີ່ໄດ້ກ່າວມາໃນ backslash ການຂະຫຍາຍຕົວ ຂ້າງເທິງ, ເຊັ່ນດຽວກັນ
ເປັນ '\c', ເຊິ່ງເທົ່າກັບການໃຊ້ -n ທາງເລືອກ. ການຂະຫຍາຍ backslash ອາດຈະເປັນ
inhibited ກັບ -r ທາງເລືອກ. ທ -s ທາງເລືອກພິມໄປທີ່ໄຟລ໌ປະຫວັດສາດແທນທີ່ຈະເປັນ
ຜົນຜະລິດມາດຕະຖານ; ໄດ້ -u ທາງເລືອກພິມໄປຫາຕົວອະທິບາຍໄຟລ໌ n (n ເລີ່ມຕົ້ນເປັນ 1 ຖ້າ
ຍົກເວັ້ນ); ແລະ -p ທາງເລືອກພິມໄປຫາຂະບວນການຮ່ວມມື (ເບິ່ງ ຂະບວນການຮ່ວມກັນ ຂ້າງເທິງ).
ໄດ້ -R ທາງເລືອກແມ່ນໃຊ້ເພື່ອເຮັດຕາມ, ໃນບາງລະດັບ, BSD echo(1) ຄໍາສັ່ງທີ່ເຮັດໄດ້
ບໍ່ປະມວນຜົນລໍາດັບ '\' ເວັ້ນເສຍແຕ່ວ່າ -e ທາງເລືອກແມ່ນໃຫ້. ດັ່ງຂ້າງເທິງ, ໄດ້ -n ທາງເລືອກ
ສະກັດກັ້ນເສັ້ນໃໝ່ທີ່ຕິດຢູ່.
printf ຮູບແບບ [ກະທູ້ທີ່ ...]
ຮູບແບບຜົນຜະລິດ. ປະມານດຽວກັນກັບ printf(1), ປະໂຫຍດ, ຍົກເວັ້ນມັນໃຊ້
ຄືກັນ backslash ການຂະຫຍາຍຕົວ ແລະລະຫັດ I/O ແລະບໍ່ໄດ້ຈັດການກັບຈຸດທີ່ເລື່ອນໄດ້
ສ່ວນທີ່ເຫຼືອຂອງ mksh. ຜົນປະໂຫຍດພາຍນອກແມ່ນມັກຫຼາຍກວ່າຕົວສ້າງ. ນີ້ບໍ່ແມ່ນ
ປົກກະຕິແລ້ວສ່ວນຫນຶ່ງຂອງ mksh; ຢ່າງໃດກໍຕາມ, ຜູ້ຈັດຈໍາຫນ່າຍອາດຈະໄດ້ເພີ່ມນີ້ເປັນ buildin ເປັນ
hack ຄວາມໄວ. ຢ່າໃຊ້ໃນລະຫັດໃຫມ່.
ນອນd [-LP]
ພິມໄດເລກະທໍລີທີ່ເຮັດວຽກໃນປະຈຸບັນ. ຖ້າ -L ທາງເລືອກແມ່ນການນໍາໃຊ້ຫຼືຖ້າຫາກວ່າ ທາງດ້ານຮ່າງກາຍ
ບໍ່ໄດ້ຕັ້ງທາງເລືອກ (ເບິ່ງ ທີ່ກໍານົດໄວ້ ຄໍາສັ່ງຂ້າງລຸ່ມນີ້), ເສັ້ນທາງຢ່າງມີເຫດຜົນຖືກພິມອອກ (ie the
ເສັ້ນທາງທີ່ເຄີຍໃຊ້ cd ໄປຫາລະບົບປະຈຸບັນ). ຖ້າ -P ທາງເລືອກ (ເສັ້ນທາງທາງດ້ານຮ່າງກາຍ) ຖືກນໍາໃຊ້
ຫຼືຖ້າວ່າ ທາງດ້ານຮ່າງກາຍ ທາງເລືອກແມ່ນໄດ້ຖືກກໍານົດ, ເສັ້ນທາງທີ່ກໍານົດຈາກລະບົບໄຟລ໌ (ໂດຍ
ຕໍ່ໄປນີ້ '..' ໄປຫາໄດເລກະທໍລີຮາກ) ຖືກພິມອອກ.
ອ່ານ [-A | -a] [-d x] [-N z | -n z] [-p | -u[n]] [-t n] [-rs] [p ...]
ອ່ານເສັ້ນການປ້ອນຂໍ້ມູນ, ແຍກການປ້ອນຂໍ້ມູນເຂົ້າໄປໃນຊ່ອງຂໍ້ມູນໂດຍໃຊ້ພາລາມິເຕີ IFS (ເບິ່ງ
ປ່ຽນແທນ ຂ້າງເທິງ), ແລະມອບຫມາຍແຕ່ລະພາກສະຫນາມໃຫ້ກັບພາລາມິເຕີທີ່ລະບຸ p. ຖ້າບໍ່
ພາລາມິເຕີຖືກລະບຸ, ພາລາມິເຕີ REPLY ຖືກນໍາໃຊ້ເພື່ອເກັບຜົນໄດ້ຮັບ. ກັບ
-A ແລະ -a ທາງເລືອກ, ພຽງແຕ່ບໍ່ມີຫຼືຫນຶ່ງຕົວກໍານົດການທີ່ຖືກຍອມຮັບ. ຖ້າມີຫຼາຍກວ່ານັ້ນ
ຕົວກໍານົດການຫຼາຍກ່ວາພາກສະຫນາມ, ຕົວກໍານົດການເພີ່ມເຕີມແມ່ນຕັ້ງເປັນ string ເປົ່າຫຼື 0; ຖ້າ
ມີຊ່ອງຂໍ້ມູນຫຼາຍກວ່າພາລາມິເຕີ, ຕົວກໍານົດການສຸດທ້າຍແມ່ນມອບຫມາຍສ່ວນທີ່ເຫຼືອ
ທົ່ງນາ (ລວມທັງຕົວແຍກຄໍາສັບ).
ຕົວເລືອກມີດັ່ງນີ້:
-A ເກັບຮັກສາຜົນໄດ້ຮັບເຂົ້າໄປໃນພາລາມິເຕີ p (ຫຼື REPLY) ເປັນ array ຂອງຄໍາສັບຕ່າງໆ.
-a ເກັບຮັກສາຜົນໄດ້ຮັບໂດຍບໍ່ມີການແຍກຄໍາສັບເຂົ້າໄປໃນພາລາມິເຕີ p (ຫຼືຕອບ) ເປັນ
array ຂອງຕົວອັກສອນ (ຕົວອັກສອນກວ້າງຖ້າ utf8-mode ທາງເລືອກແມ່ນໄດ້ຮັບການປະຕິບັດ,
octets ຖ້າບໍ່ດັ່ງນັ້ນ); codepoints ຖືກເຂົ້າລະຫັດເປັນຕົວເລກທົດສະນິຍົມຕາມຄ່າເລີ່ມຕົ້ນ.
-d x ໃຊ້ byte ທໍາອິດ x, NUL ຖ້າຫວ່າງເປົ່າ, ແທນຕົວອັກສອນ ASCII ແຖວໃໝ່
ເປັນຕົວຂັ້ນເສັ້ນຂາເຂົ້າ.
-N z ແທນທີ່ຈະອ່ານຈົນຈົບເສັ້ນ, ອ່ານແທ້ z ໄບຕ໌. ຖ້າ EOF ຫຼື a
ໝົດເວລາເກີດຂຶ້ນ, ການອ່ານບາງສ່ວນຖືກສົ່ງຄືນດ້ວຍສະຖານະອອກ 1.
-n z ແທນທີ່ຈະອ່ານຈົນຈົບເສັ້ນ, ອ່ານເຖິງ z bytes ແຕ່ກັບຄືນມາທັນທີ
ໄບຕ໌ໃດນຶ່ງຖືກອ່ານ, ຕົວຢ່າງ: ຈາກອຸປະກອນປາຍທາງຊ້າ, ຫຼືຖ້າ EOF ຫຼືໝົດເວລາ
ເກີດຂື້ນ.
-p ອ່ານຈາກຂະບວນການຮ່ວມມືທີ່ມີການເຄື່ອນໄຫວໃນປັດຈຸບັນ, ເບິ່ງ ຂະບວນການຮ່ວມກັນ ຂ້າງເທິງສໍາລັບລາຍລະອຽດ
ກ່ຽວກັບເລື່ອງນີ້.
-u[n] ອ່ານຈາກຕົວອະທິບາຍໄຟລ໌ n (ຄ່າເລີ່ມຕົ້ນເປັນ 0, ເຊັ່ນ: ການປ້ອນຂໍ້ມູນມາດຕະຖານ). ໄດ້
ການໂຕ້ຖຽງຈະຕ້ອງປະຕິບັດຕາມລັກສະນະທາງເລືອກໃນທັນທີ.
-t n ຂັດຂວາງການອ່ານຫຼັງຈາກ n ວິນາທີ (ລະບຸເປັນຄ່າທົດສະນິຍົມບວກກັບ an
ສ່ວນເສດສ່ວນທາງເລືອກ). ສະຖານະພາບທາງອອກຂອງ ອ່ານ ແມ່ນ 1 ຖ້າໝົດເວລາ
ເກີດຂຶ້ນ, ແຕ່ການອ່ານບາງສ່ວນອາດຈະຍັງຖືກສົ່ງຄືນ.
-r ໂດຍປົກກະຕິ, ຕົວອັກສອນ backslash ASCII ຫນີຈາກຄວາມຫມາຍພິເສດຂອງ
ລັກສະນະດັ່ງຕໍ່ໄປນີ້ແລະຖືກຖອດອອກຈາກວັດສະດຸປ້ອນ; ອ່ານ ບໍ່ຢຸດເມື່ອ
ພົບກັບລໍາດັບ backslash-newline ແລະບໍ່ໄດ້ເກັບຮັກສາເສັ້ນໃຫມ່ນັ້ນຢູ່ໃນ
ຜົນ. ຕົວເລືອກນີ້ເປີດໃຊ້ໂໝດດິບ, ເຊິ່ງບໍ່ແມ່ນ backslashes
ການປຸງແຕ່ງ.
-s ເສັ້ນປ້ອນຂໍ້ມູນຖືກບັນທຶກໄວ້ໃນປະຫວັດ.
ຖ້າ input ເປັນ terminal, ທັງສອງ -N ແລະ -n ທາງເລືອກທີ່ກໍານົດມັນເຂົ້າໄປໃນໂຫມດດິບ; ເຂົາເຈົ້າ
ອ່ານໄຟລ໌ທັງຫມົດຖ້າ -1 ຖືກຜ່ານເປັນ z ການໂຕ້ຖຽງ.
ພາລາມິເຕີທໍາອິດອາດມີເຄື່ອງຫມາຍຄໍາຖາມແລະສະຕຣິງຕໍ່ຫນ້າມັນ, ໃນນັ້ນ
ກໍລະນີສະຕຣິງໄດ້ຖືກນໍາໃຊ້ເປັນການກະຕຸ້ນເຕືອນ (ພິມອອກເປັນຄວາມຜິດພາດມາດຕະຖານກ່ອນທີ່ຈະມີການປ້ອນຂໍ້ມູນໃດໆ
ອ່ານ) ຖ້າການປ້ອນຂໍ້ມູນແມ່ນ a tty(4) (ຕ.ຢ ອ່ານ nfoo?'ເລກ of foos: ').
ຖ້າບໍ່ມີການອ່ານຂໍ້ມູນ ຫຼືເວລາໝົດເວລາເກີດຂຶ້ນ, ອ່ານ ອອກດ້ວຍສະຖານະທີ່ບໍ່ແມ່ນສູນ.
ອີກປະການຫນຶ່ງ handy ຂອງ tricks: ຖ້າ ອ່ານ ແມ່ນດໍາເນີນການໃນ loop ເຊັ່ນ ໃນຂະນະທີ່ ອ່ານ ຟູ; do ... ;
ເຮັດ ຫຼັງຈາກນັ້ນ, ຊ່ອງຫວ່າງຊັ້ນນໍາຈະຖືກລຶບອອກ (IFS) ແລະດໍາເນີນການກັບ backslashes. ເຈົ້າ
ອາດຈະຕ້ອງການໃຊ້ ໃນຂະນະທີ່ IFS= ອ່ານ -r ຟູ; do ... ; ເຮັດ ສໍາລັບ I/O ທີ່ເປັນປະສິດທິພາບ. ເຊັ່ນດຽວກັນ,
ໃນເວລາທີ່ການນໍາໃຊ້ -a ທາງເລືອກ, ການນໍາໃຊ້ -r ທາງເລືອກອາດຈະລະມັດລະວັງ; ຄືກັນ
ສໍາລັບ:
ຊອກຫາ. -type f -print0 |& \
ໃນຂະນະທີ່ IFS = ອ່ານ -d '' -pr ຊື່ໄຟລ໌; ເຮັດ
print -r -- "ພົບ <${filename#./}>"
ເຮັດ
loop ພາຍໃນຈະຖືກປະຕິບັດໃນ subshell ແລະການປ່ຽນແປງຕົວແປບໍ່ສາມາດເປັນ
ຂະຫຍາຍພັນຖ້າຖືກປະຕິບັດໃນທໍ່ສົ່ງ:
ບາ | ບາສ | ໃນຂະນະທີ່ອ່ານ foo; ເຮັດ ... ; ສຳເລັດແລ້ວ
ໃຊ້ຂະບວນການຮ່ວມກັນແທນ:
ບາ | ບາສ |&
ໃນຂະນະທີ່ອ່ານ -p foo; ເຮັດ ... ; ສຳເລັດແລ້ວ
exec 3>&p; exec 3>&-
ອ່ານຢ່າງດຽວ [-p] [ພາລາມິເຕີ [=ມູນຄ່າ] ...]
ກໍານົດຄຸນລັກສະນະການອ່ານເທົ່ານັ້ນຂອງພາລາມິເຕີທີ່ມີຊື່. ຖ້າຄຸນຄ່າແມ່ນໃຫ້,
ພາລາມິເຕີຖືກຕັ້ງໃຫ້ພວກເຂົາກ່ອນທີ່ຈະກໍານົດຄຸນລັກສະນະ. ເມື່ອຕົວກໍານົດການຖືກສ້າງຂື້ນ
read-only, ມັນບໍ່ສາມາດຖືກຍົກເລີກແລະຄ່າຂອງມັນບໍ່ສາມາດປ່ຽນແປງໄດ້.
ຖ້າບໍ່ມີຕົວກໍານົດການຖືກກໍານົດ, ຊື່ຂອງພາລາມິເຕີທັງຫມົດທີ່ມີແບບອ່ານເທົ່ານັ້ນ
ຄຸນລັກສະນະແມ່ນພິມຫນຶ່ງຕໍ່ແຖວ, ເວັ້ນເສຍແຕ່ວ່າ -p ທາງເລືອກແມ່ນຖືກນໍາໃຊ້, ໃນກໍລະນີນີ້
ອ່ານຢ່າງດຽວ ຄໍາສັ່ງກໍານົດຕົວກໍານົດການອ່ານເທົ່ານັ້ນ, ລວມທັງຄ່າຂອງພວກມັນ, ແມ່ນ
ພິມອອກ.
ເສັ້ນທາງທີ່ແທ້ຈິງ [--] ຊື່
ພິມຊື່ເສັ້ນທາງຢ່າງແທ້ຈິງທີ່ແກ້ໄຂແລ້ວທີ່ສອດຄ້ອງກັນ ຊື່ທີ່ຢູ່ ຖ້າຫາກວ່າ ຊື່ ຈົບລົງດ້ວຍ ກ
slash ('/'), ມັນຍັງຖືກກວດສອບການມີຢູ່ແລະບໍ່ວ່າຈະເປັນໄດເລກະທໍລີ;
ຖ້າບໍ່ດັ່ງນັ້ນ, ເສັ້ນທາງທີ່ແທ້ຈິງ ຕອບ 0 ຖ້າຊື່ເສັ້ນທາງນັ້ນມີຢູ່ ຫຼືສາມາດສ້າງໄດ້
ທັນທີ, ie ທັງຫມົດແຕ່ອົງປະກອບສຸດທ້າຍມີຢູ່ແລະເປັນໄດເລກະທໍລີ.
ປ່ຽນຊື່ [--] ຈາກ to
ປ່ຽນຊື່ໄຟລ໌ ຈາກ to to. ທັງສອງຈະຕ້ອງເປັນຊື່ເສັ້ນທາງທີ່ສົມບູນ ແລະຢູ່ໃນອຸປະກອນດຽວກັນ.
buildin ນີ້ມີຈຸດປະສົງສໍາລັບສະຖານະການສຸກເສີນທີ່ /bin/mv ກາຍເປັນບໍ່ສາມາດໃຊ້ໄດ້, ແລະ
ໂທໂດຍກົງ ປ່ຽນຊື່(2).
ການກັບຄືນມາ [ສະຖານະພາບ]
ສົ່ງຄືນຈາກຟັງຊັນ ຫຼື . script, ກັບສະຖານະການອອກ ສະຖານະພາບ. ຖ້າບໍ່ ສະຖານະພາບ ແມ່ນໃຫ້,
ສະຖານະການອອກຂອງຄໍາສັ່ງປະຕິບັດສຸດທ້າຍຖືກນໍາໃຊ້. ຖ້າໃຊ້ນອກຟັງຊັນ
or . script, ມັນມີຜົນກະທົບດຽວກັນກັບ ການທ່ອງທ່ຽວ. ໃຫ້ສັງເກດວ່າ mksh ປິ່ນປົວທັງສອງ profile ແລະ
ENV ໄຟລ໌ເປັນ . scripts, ໃນຂະນະທີ່ Korn shell ຕົ້ນສະບັບພຽງແຕ່ປະຕິບັດຕໍ່ໂປຣໄຟລ໌ .
ອັກສອນ.
ທີ່ກໍານົດໄວ້ [+-abCefhiklmnprsUuvXx] [+-o ທາງເລືອກ] [+-A ຊື່] [--] [arg ...]
ໄດ້ ທີ່ກໍານົດໄວ້ ຄໍາສັ່ງສາມາດຖືກນໍາໃຊ້ເພື່ອກໍານົດ (-) ຫຼືຈະແຈ້ງ (+) ຕົວເລືອກແກະ, ກໍານົດຕໍາແຫນ່ງ
ພາລາມິເຕີ, ຫຼືກໍານົດພາລາມິເຕີ array. ທາງເລືອກສາມາດປ່ຽນແປງໄດ້ໂດຍໃຊ້ +-o ທາງເລືອກ
syntax, ບ່ອນທີ່ ທາງເລືອກ ແມ່ນຊື່ຍາວຂອງທາງເລືອກ, ຫຼືການນໍາໃຊ້ +-ຈົດຫມາຍ syntax,
ບ່ອນທີ່ ຈົດຫມາຍ ແມ່ນຊື່ຕົວອັກສອນດຽວຂອງທາງເລືອກ (ບໍ່ແມ່ນທາງເລືອກທັງຫມົດທີ່ມີຕົວອັກສອນດຽວ
ຊື່). ຕາຕະລາງຕໍ່ໄປນີ້ລາຍຊື່ທັງສອງຕົວອັກສອນທາງເລືອກ (ຖ້າພວກເຂົາມີ) ແລະຊື່ຍາວ
ພ້ອມກັບຄໍາອະທິບາຍກ່ຽວກັບສິ່ງທີ່ທາງເລືອກເຮັດ:
-A ຊື່
ກໍານົດອົງປະກອບຂອງພາລາມິເຕີ array ຊື່ to arg ... If -A ຖືກນໍາໃຊ້, ໄດ້
array ແມ່ນ reset (ie emptied) ທໍາອິດ; ຖ້າ +A ຖືກນໍາໃຊ້, ອົງປະກອບ N ທໍາອິດຖືກກໍານົດ
(ບ່ອນທີ່ N ແມ່ນຈໍານວນຂອງການໂຕ້ຖຽງ); ສ່ວນທີ່ເຫຼືອແມ່ນປະໄວ້ untouched.
syntax ທາງເລືອກສໍາລັບຄໍາສັ່ງ ທີ່ກໍານົດໄວ້ -A ຟູ -- a b c ເຊິ່ງເຂົ້າກັນໄດ້ກັບ
GNU bash ແລະຍັງໄດ້ຮັບການສະຫນັບສະຫນູນໂດຍ AT&T UNIX ksh93 ແມ່ນ: foo=(ກ b c); foo+=(ງ e)
-a | -o ຂາອອກ
ຕົວກໍານົດການໃຫມ່ທັງຫມົດແມ່ນຖືກສ້າງຂຶ້ນດ້ວຍຄຸນລັກສະນະການສົ່ງອອກ.
-b | -o ແຈ້ງ
ພິມຂໍ້ຄວາມແຈ້ງການວຽກ asynchronously, ແທນທີ່ຈະພຽງແຕ່ກ່ອນທີ່ຈະ
ດ່ວນ. ໃຊ້ພຽງແຕ່ຖ້າການຄວບຄຸມວຽກຖືກເປີດໃຊ້ງານ (-m).
-C | -o noclobber
ປ້ອງກັນ > ການປ່ຽນເສັ້ນທາງຈາກການຂຽນທັບໄຟລ໌ທີ່ມີຢູ່ແລ້ວ. ແທນທີ່ຈະ, >| ຕ້ອງໃຊ້
ເພື່ອບັງຄັບໃຫ້ຂຽນທັບ. ໃຫ້ສັງເກດວ່າອັນນີ້ບໍ່ປອດໄພທີ່ຈະໃຊ້ໃນການສ້າງ
ໄຟລ໌ຊົ່ວຄາວຫຼື lockfiles ເນື່ອງຈາກ TOCTOU ໃນການກວດສອບອະນຸຍາດໃຫ້ຫນຶ່ງເພື່ອປ່ຽນເສັ້ນທາງ
ຜົນຜະລິດເພື່ອ / dev / null ຫຼືໄຟລ໌ອຸປະກອນອື່ນໆເຖິງແມ່ນວ່າຢູ່ໃນ noclobber mode
-e | -o ຜິດພາດ
ອອກຈາກ (ຫຼັງຈາກປະຕິບັດ ERR ກັບດັກ) ທັນທີທີ່ເກີດຄວາມຜິດພາດຫຼືຄໍາສັ່ງ
ລົ້ມເຫລວ (ເຊັ່ນ: ອອກຈາກສະຖານະທີ່ບໍ່ແມ່ນສູນ). ນີ້ບໍ່ໄດ້ໃຊ້ກັບຄໍາສັ່ງ
ສະຖານະພາບທາງອອກຂອງພວກມັນຖືກທົດສອບຢ່າງຈະແຈ້ງໂດຍໂຄງສ້າງ shell ເຊັ່ນ if, ຈົນກ່ວາ,
ໃນຂະນະທີ່, ຫຼື ! ຖະແຫຼງການ. ສໍາລັບ && ຫຼື ||, ພຽງແຕ່ສະຖານະຂອງຄໍາສັ່ງສຸດທ້າຍແມ່ນ
ທົດສອບ.
-f | -o noglob
ຢ່າຂະຫຍາຍຮູບແບບຊື່ໄຟລ໌.
-h | -o ຕິດຕາມ
ສ້າງນາມແຝງທີ່ຖືກຕິດຕາມສໍາລັບຄໍາສັ່ງທີ່ຖືກປະຕິບັດທັງຫມົດ (ເບິ່ງ ນາມແຝງ ຂ້າງເທິງ). ເປີດໃຊ້ແລ້ວ
ໂດຍຄ່າເລີ່ມຕົ້ນສໍາລັບ shells ທີ່ບໍ່ມີການໂຕ້ຕອບ.
-i | -o ແບບໂຕ້ຕອບ
ຫອຍແມ່ນຫອຍທີ່ມີການໂຕ້ຕອບ. ທາງເລືອກນີ້ສາມາດໃຊ້ໄດ້ພຽງແຕ່ໃນເວລາທີ່ແກະ
ຖືກຮຽກຮ້ອງ. ເບິ່ງຂ້າງເທິງສໍາລັບລາຍລະອຽດຂອງສິ່ງທີ່ນີ້ຫມາຍຄວາມວ່າ.
-k | -o ຄໍາ
ການມອບຫມາຍພາລາມິເຕີຖືກຮັບຮູ້ທຸກບ່ອນໃນຄໍາສັ່ງ.
-l | -o ເຂົ້າສູ່ລະບົບ
ແກະແມ່ນແກະເຂົ້າສູ່ລະບົບ. ທາງເລືອກນີ້ສາມາດໃຊ້ໄດ້ພຽງແຕ່ໃນເວລາທີ່ແກະແມ່ນ
ຮຽກຮ້ອງ. ເບິ່ງຂ້າງເທິງສໍາລັບລາຍລະອຽດຂອງສິ່ງທີ່ນີ້ຫມາຍຄວາມວ່າ.
-m | -o ຕິດຕາມກວດກາ
ເປີດໃຊ້ການຄວບຄຸມວຽກ (ຄ່າເລີ່ມຕົ້ນສໍາລັບ shells ແບບໂຕ້ຕອບ).
-n | -o noexec
ຢ່າປະຕິບັດຄໍາສັ່ງໃດໆ. ເປັນປະໂຫຍດສໍາລັບການກວດສອບ syntax ຂອງ scripts (ບໍ່ສົນໃຈ
ຖ້າໂຕ້ຕອບ).
-p | -o ສິດທິພິເສດ
ແກະແມ່ນແກະທີ່ມີສິດທິພິເສດ. ມັນຖືກກໍານົດໂດຍອັດຕະໂນມັດຖ້າ, ເມື່ອແກະ
ເລີ່ມຕົ້ນ, UID ຫຼື GID ທີ່ແທ້ຈິງບໍ່ກົງກັບ UID (EUID) ຫຼື GID ທີ່ມີປະສິດທິພາບ
(EGID), ຕາມລໍາດັບ. ເບິ່ງຂ້າງເທິງສໍາລັບລາຍລະອຽດຂອງສິ່ງທີ່ນີ້ຫມາຍຄວາມວ່າ.
-r | -o ຖືກຈໍາກັດ
ຫອຍແມ່ນຫອຍທີ່ຈໍາກັດ. ທາງເລືອກນີ້ສາມາດໃຊ້ໄດ້ພຽງແຕ່ໃນເວລາທີ່ແກະແມ່ນ
ຮຽກຮ້ອງ. ເບິ່ງຂ້າງເທິງສໍາລັບລາຍລະອຽດຂອງສິ່ງທີ່ນີ້ຫມາຍຄວາມວ່າ.
-s | -o stdin
ຖ້າໃຊ້ໃນເວລາທີ່ແກະຖືກເອີ້ນ, ຄໍາສັ່ງຈະຖືກອ່ານຈາກວັດສະດຸປ້ອນມາດຕະຖານ. ຕັ້ງ
ອັດຕະໂນມັດຖ້າແກະຖືກເອີ້ນໂດຍບໍ່ມີການໂຕ້ຖຽງ.
ເມື່ອໃດ -s ຖືກນໍາໃຊ້ກັບ ທີ່ກໍານົດໄວ້ ຄໍາສັ່ງມັນເຮັດໃຫ້ການໂຕ້ຖຽງທີ່ລະບຸໄວ້ເປັນ
ຈັດຮຽງກ່ອນກຳນົດພວກມັນໃຫ້ກັບພາລາມິເຕີຕຳແໜ່ງ (ຫຼື array ຊື່, ຖ້າ
-A ຖືກນໍາໃຊ້).
-U | -o utf8-mode
ເປີດໃຊ້ການສະຫນັບສະຫນູນ UTF-8 ໃນ Emacs ການແກ້ໄຂ ຮູບແບບການ ແລະການຈັດການສາຍພາຍໃນ
ຫນ້າທີ່. ທຸງນີ້ຖືກປິດໃຊ້ງານໂດຍຄ່າເລີ່ມຕົ້ນ, ແຕ່ສາມາດເປີດໃຊ້ໄດ້ໂດຍການຕັ້ງຄ່າມັນ
ຢູ່ໃນເສັ້ນຄໍາສັ່ງ shell; ຖືກເປີດໃຊ້ອັດຕະໂນມັດສໍາລັບ shells ແບບໂຕ້ຕອບຖ້າ
ຮ້ອງຂໍໃນເວລາລວບລວມ, ລະບົບຂອງທ່ານສະຫນັບສະຫນູນ ຕັ້ງຖິ່ນຖານ(LC_CTYPE, "") ແລະ
ຕົວເລືອກ nl_langinfo(CODESET), ຫຼືສະພາບແວດລ້ອມ LC_ALL, LC_CTYPE, ຫຼື LANG
ຕົວແປ, ແລະຢ່າງຫນ້ອຍຫນຶ່ງໃນເຫຼົ່ານີ້ສົ່ງຄືນບາງສິ່ງບາງຢ່າງທີ່ກົງກັບ "UTF-8" ຫຼື
“utf8” case-insensitively; ສໍາລັບການໂທ buildin ໂດຍກົງຂຶ້ນກັບການ
ຕົວແປສະພາບແວດລ້ອມທີ່ໄດ້ກ່າວມາຂ້າງເທິງ; ຫຼືສໍາລັບ stdin ຫຼື scripts, ຖ້າການປ້ອນຂໍ້ມູນ
ເລີ່ມຕົ້ນດ້ວຍ UTF-8 Byte Order Mark.
ໃນອະນາຄົດອັນໃກ້ນີ້, ການຕິດຕາມທ້ອງຖິ່ນຈະຖືກປະຕິບັດ, ຊຶ່ງຫມາຍຄວາມວ່າ ທີ່ກໍານົດໄວ້ -+U is
ມີການປ່ຽນແປງທຸກຄັ້ງທີ່ຕົວແປສະພາບແວດລ້ອມທີ່ກ່ຽວຂ້ອງກັບທ້ອງຖິ່ນຂອງ POSIX ມີການປ່ຽນແປງ.
-u | -o ຄຳນາມ
ການອ້າງອິງພາລາມິເຕີທີ່ບໍ່ໄດ້ຕັ້ງ, ນອກເໜືອໄປຈາກ “$@” ຫຼື “$*”, ຖືກປະຕິບັດເປັນ
ຜິດພາດ, ເວັ້ນເສຍແຕ່ວ່າຫນຶ່ງໃນຕົວແກ້ໄຂ '-', '+', ຫຼື '=' ຖືກນໍາໃຊ້.
-v | -o ຄຳເວົ້າ
ຂຽນ Shell input ກັບຄວາມຜິດພາດມາດຕະຖານຍ້ອນວ່າມັນຖືກອ່ານ.
-X | -o ເຄື່ອງໝາຍ
ໝາຍລາຍຊື່ດ້ວຍ '/' ໃນຕອນທ້າຍໃນລະຫວ່າງການສ້າງຊື່ໄຟລ໌.
-x | -o xtrace
ພິມຕົ້ນໄມ້ຄໍາສັ່ງເມື່ອພວກມັນຖືກປະຕິບັດ, ກ່ອນຫນ້າດ້ວຍມູນຄ່າຂອງ PS4.
-o bgnice
ວຽກພື້ນຖານແມ່ນດໍາເນີນການໂດຍມີບູລິມະສິດຕ່ໍາກວ່າ.
-o ຂະຫຍາຍວົງເລັບ
ເປີດໃຊ້ການຂະຫຍາຍວົງເລັບ (aka alternation). ອັນນີ້ຖືກເປີດໃຊ້ໂດຍຄ່າເລີ່ມຕົ້ນ. ຖ້າ
ພິການ, ການຂະຫຍາຍຕົວ tilde ຫຼັງຈາກເຄື່ອງຫມາຍເທົ່າທຽມກັນຖືກປິດການໃຊ້ງານເປັນຜົນຂ້າງຄຽງ.
-o emacs
ເປີດໃຊ້ການດັດແກ້ແຖວຄໍາສັ່ງຄ້າຍຄື BRL emacs (interactive shells ເທົ່ານັ້ນ); ເບິ່ງ Emacs
ການແກ້ໄຂ ຮູບແບບການ.
-o gmacs
ເປີດໃຊ້ການແກ້ໄຂເສັ້ນຄໍາສັ່ງຄ້າຍຄື gmacs (ມີການໂຕ້ຕອບພຽງແຕ່ shells). ໃນປັດຈຸບັນ
ຄືກັນກັບການແກ້ໄຂ emacs ຍົກເວັ້ນວ່າ transpose-chars (^T) ປະຕິບັດເລັກນ້ອຍ
ແຕກຕ່າງ.
-o ບໍ່ສົນໃຈ
Shell ຈະບໍ່ (ໄດ້ຢ່າງງ່າຍດາຍ) ອອກໃນເວລາທີ່ສິ້ນສຸດຂອງໄຟລ໌ຖືກອ່ານ; ການທ່ອງທ່ຽວ ຕ້ອງໄດ້ຮັບການນໍາໃຊ້.
ເພື່ອຫຼີກເວັ້ນການ loops ທີ່ບໍ່ມີຂອບເຂດ, ແກະຈະອອກໄປຖ້າ EOF ຖືກອ່ານ 13 ເທື່ອຕິດຕໍ່ກັນ.
-o inherit-xtrace
ຢ່າຣີເຊັດ -o xtrace ເມື່ອເຂົ້າຟັງຊັນ. ອັນນີ້ຖືກເປີດໃຊ້ໂດຍຄ່າເລີ່ມຕົ້ນ.
-o ບໍ່ມີຫຍັງ
ຢ່າຂ້າວຽກທີ່ກຳລັງແລ່ນດ້ວຍສັນຍານ SIGHUP ເມື່ອລູກແກະເຂົ້າສູ່ລະບົບອອກ.
ໃນປັດຈຸບັນຖືກຕັ້ງເປັນຄ່າເລີ່ມຕົ້ນ, ແຕ່ອັນນີ້ອາດຈະປ່ຽນແປງໃນອະນາຄົດເພື່ອໃຫ້ເຂົ້າກັນໄດ້
ກັບ AT&T UNIX ksh, ເຊິ່ງບໍ່ມີທາງເລືອກນີ້, ແຕ່ສົ່ງ SIGHUP
signal
-o nolog
ບໍ່ມີຜົນກະທົບ. ໃນແກະ Korn ຕົ້ນສະບັບ, ນີ້ປ້ອງກັນບໍ່ໃຫ້ຄໍານິຍາມຂອງຫນ້າທີ່
ຖືກເກັບໄວ້ໃນເອກະສານປະຫວັດສາດ.
-o ທາງດ້ານຮ່າງກາຍ
ສາເຫດຂອງ cd ແລະ ນອນd ຄໍາສັ່ງທີ່ຈະໃຊ້ "ທາງດ້ານຮ່າງກາຍ" (ເຊັ່ນ: ລະບົບໄຟລ໌) '..'
ໄດເລກະທໍລີແທນທີ່ຈະເປັນ "ເຫດຜົນ" ໄດເລກະທໍລີ (ເຊັ່ນ: ແກະຈັບ '..', ເຊິ່ງ
ອະນຸຍາດໃຫ້ຜູ້ໃຊ້ທີ່ຈະບໍ່ລືມກ່ຽວກັບການເຊື່ອມຕໍ່ສັນຍາລັກກັບລາຍການ). ລ້າງໂດຍ
ຄ່າເລີ່ມຕົ້ນ. ໃຫ້ສັງເກດວ່າການຕັ້ງຄ່າຕົວເລືອກນີ້ບໍ່ມີຜົນຕໍ່ຄ່າປະຈຸບັນຂອງ
ພາລາມິເຕີ PWD; ພຽງແຕ່ cd ຄໍາສັ່ງປ່ຽນ PWD. ເບິ່ງ cd ແລະ ນອນd ຄໍາສັ່ງ
ຂ້າງເທິງສໍາລັບລາຍລະອຽດເພີ່ມເຕີມ.
-o pipefail
ເຮັດໃຫ້ສະຖານະການທາງອອກຂອງທໍ່ (ກ່ອນທີ່ຈະສົມເຫດສົມຜົນ) ໄດ້
ລະດັບຄວາມຜິດພາດທີ່ບໍ່ແມ່ນສູນ, ຫຼືສູນຖ້າຄຳສັ່ງທັງໝົດອອກດ້ວຍສູນ.
-o ບວກ
ປະຕິບັດຕົວໃກ້ຊິດກັບມາດຕະຖານ (ເບິ່ງ POSIX ຮູບແບບການ ສໍາລັບລາຍລະອຽດ). ອັດຕະໂນມັດ
ເປີດໃຊ້ຖ້າຊື່ພື້ນຖານຂອງການຮຽກຮ້ອງ shell ເລີ່ມຕົ້ນດ້ວຍ "sh" ແລະອັນນີ້
ຄຸນສົມບັດກວດຈັບອັດຕະໂນມັດຖືກລວບລວມຢູ່ໃນ (ບໍ່ແມ່ນຢູ່ໃນ MirBSD). ໃນຖານະເປັນຜົນຂ້າງຄຽງ, ການຕັ້ງຄ່າ
ທຸງນີ້ປິດ ຂະຫຍາຍວົງເລັບ ໂໝດ, ເຊິ່ງສາມາດເປີດຄືນໄດ້ດ້ວຍຕົນເອງ, ແລະ
sh ໂຫມດ (ເວັ້ນເສຍແຕ່ວ່າທັງສອງຈະຖືກເປີດໃຊ້ໃນເວລາດຽວກັນ).
-o sh
ເປີດນໍາໃຊ້ / ຖັງ / sh (kludge) ຮູບແບບ (ເບິ່ງ SH ຮູບແບບການ). ເປີດໃຊ້ງານອັດຕະໂນມັດຖ້າຫາກວ່າ
ຊື່ພື້ນຖານຂອງການຮຽກຮ້ອງ shell ເລີ່ມຕົ້ນດ້ວຍ "sh" ແລະຄຸນສົມບັດການກວດສອບອັດຕະໂນມັດນີ້
ຖືກລວບລວມຢູ່ໃນ (ບໍ່ແມ່ນຢູ່ໃນ MirBSD). ເປັນຜົນກະທົບຂ້າງຄຽງ, ການຕັ້ງຄ່າທຸງນີ້ຖືກປິດ
ຂະຫຍາຍວົງເລັບ ໂໝດ, ເຊິ່ງສາມາດເປີດຄືນໄດ້ດ້ວຍຕົນເອງ, ແລະ ບວກ ຮູບແບບ (ເວັ້ນເສຍແຕ່
ທັງສອງຖືກເປີດໃຊ້ໃນເວລາດຽວກັນ).
-o vi
ເປີດນໍາໃຊ້ vi(1) ຄ້າຍຄືການແກ້ໄຂບັນຊີຄໍາສັ່ງ (ການໂຕ້ຕອບ shells ເທົ່ານັ້ນ). ເບິ່ງ Vi
ການແກ້ໄຂ ຮູບແບບການ ສໍາລັບເອກະສານແລະຂໍ້ຈໍາກັດ.
-o vi-esccomplete
ໃນການແກ້ໄຂເສັ້ນຄໍາສັ່ງ vi, ເຮັດຄໍາສັ່ງແລະຊື່ໄຟລ໌ສໍາເລັດເມື່ອຫນີ (^[)
ຖືກໃສ່ໃນຮູບແບບຄໍາສັ່ງ.
-o vi-tabcomplete
ໃນການແກ້ໄຂເສັ້ນຄໍາສັ່ງ vi, ເຮັດຄໍາສັ່ງແລະຊື່ໄຟລ໌ສໍາເລັດເມື່ອແຖບ (^I) ແມ່ນ
ເຂົ້າໃນຮູບແບບແຊກ. ນີ້ແມ່ນຄ່າເລີ່ມຕົ້ນ.
-o viraw
ບໍ່ມີຜົນກະທົບ. ໃນແກະ Korn ຕົ້ນສະບັບ, ເວັ້ນເສຍແຕ່ viraw ໄດ້ຖືກຕັ້ງ, ຄໍາສັ່ງ vi-
ຮູບແບບເສັ້ນຈະປ່ອຍໃຫ້ tty(4) ຄົນຂັບເຮັດວຽກຈົນກ່ວາ ESC (^[) ເຂົ້າໄປໃນ.
mksh ຢູ່ໃນໂໝດ viraw ສະເໝີ.
ທາງເລືອກເຫຼົ່ານີ້ຍັງສາມາດຖືກນໍາໃຊ້ຕາມການຮຽກຮ້ອງຂອງ shell ໄດ້. ຊຸດປັດຈຸບັນຂອງ
ທາງເລືອກ (ທີ່ມີຊື່ຕົວອັກສອນດຽວ) ສາມາດພົບໄດ້ໃນພາລາມິເຕີ '$-'. ທີ່ກໍານົດໄວ້ -o ກັບ
ບໍ່ມີຊື່ທາງເລືອກທີ່ຈະລາຍຊື່ຕົວເລືອກທັງຫມົດແລະບໍ່ວ່າຈະເປີດຫຼືປິດ; ທີ່ກໍານົດໄວ້ +o ຈະ
ພິມຊື່ຍາວຂອງຕົວເລືອກທັງໝົດທີ່ເປີດຢູ່. ໃນສະບັບໃນອະນາຄົດ, ທີ່ກໍານົດໄວ້
+o ຈະປະຕິບັດຕາມຄໍາສັ່ງ POSIX ແລະພິມເພື່ອຟື້ນຟູທາງເລືອກໃນປະຈຸບັນ
ແທນທີ່ຈະເປັນ.
ການໂຕ້ຖຽງທີ່ຍັງເຫຼືອ, ຖ້າມີ, ແມ່ນຕົວກໍານົດການຕໍາແຫນ່ງແລະຖືກມອບຫມາຍ, ຕາມລໍາດັບ
ຕົວກໍານົດການຕໍາແຫນ່ງ (ເຊັ່ນ: $1, $2, ແລະອື່ນໆ). ຖ້າຕົວເລືອກລົງທ້າຍດ້ວຍ '--' ແລະຢູ່ທີ່ນັ້ນ
ບໍ່ມີການໂຕ້ຖຽງທີ່ຍັງເຫຼືອ, ຕົວກໍານົດການຕໍາແຫນ່ງທັງຫມົດຖືກລຶບລ້າງ. ຖ້າບໍ່ມີທາງເລືອກຫຼື
arguments ແມ່ນໃຫ້, ຄ່າຂອງຊື່ທັງຫມົດແມ່ນພິມອອກ. ສໍາລັບປະຫວັດສາດທີ່ບໍ່ຮູ້ຈັກ
ເຫດຜົນ, ທາງເລືອກ '-' ທີ່ໂດດດ່ຽວແມ່ນໄດ້ຮັບການປິ່ນປົວເປັນພິເສດ - ມັນເຮັດໃຫ້ທັງສອງ -v ແລະ -x
ຕົວເລືອກ
ປ່ຽນແປງ [ຈໍານວນ]
ຕົວກໍານົດການຕໍາແຫນ່ງ ຈໍານວນ+ 1, ຈໍານວນ+2, ແລະອື່ນໆ ຖືກປ່ຽນຊື່ເປັນ '1', '2', ແລະອື່ນໆ.
ຈໍານວນ ຄ່າເລີ່ມຕົ້ນເປັນ 1.
ນອນ ວິນາທີ
ໂຈະການດໍາເນີນການສໍາລັບຕໍາ່ສຸດທີ່ຂອງ ວິນາທີ ລະບຸເປັນຄ່າທົດສະນິຍົມບວກ
ມີສ່ວນເສດສ່ວນທີ່ເປັນທາງເລືອກ. ການສົ່ງສັນຍານອາດຈະສືບຕໍ່ປະຕິບັດກ່ອນຫນ້ານີ້.
ແຫຼ່ງ ເອກະສານ [arg ...]
ຄື . (“ຈຸດ”), ເວັ້ນເສຍແຕ່ວ່າໄດເລກະທໍລີທີ່ເຮັດວຽກໃນປະຈຸບັນຈະຖືກຕໍ່ທ້າຍກັບການຄົ້ນຫາ
ເສັ້ນທາງ (GNU bash ການຂະຫຍາຍ).
suspends
ຢຸດ Shell ຄືກັບວ່າມັນໄດ້ຮັບຕົວອັກສອນ suspend ຈາກ terminal. ມັນແມ່ນ
ບໍ່ສາມາດລະງັບ Shell ເຂົ້າສູ່ລະບົບໄດ້ ເວັ້ນເສຍແຕ່ວ່າຂະບວນການພໍ່ແມ່ເປັນສະມາຊິກຂອງ
ເຊດຊັນ terminal ດຽວກັນແຕ່ເປັນສະມາຊິກຂອງກຸ່ມຂະບວນການທີ່ແຕກຕ່າງກັນ. ໂດຍທົ່ວໄປ
ກົດລະບຽບ, ຖ້າແກະໄດ້ຖືກເລີ່ມຕົ້ນໂດຍແກະອື່ນຫຼືຜ່ານ su(1), ມັນສາມາດຖືກໂຈະ.
ການທົດສອບ ການສະແດງອອກ
[ ການສະແດງອອກ ]
ການທົດສອບ ການປະເມີນຜົນ ການສະແດງອອກ ແລະສົ່ງຄືນສະຖານະສູນຖ້າຖືກ, 1 ຖ້າຜິດ, ຫຼືຫຼາຍກວ່ານັ້ນ
ຫຼາຍກວ່າ 1 ຖ້າມີຂໍ້ຜິດພາດ. ມັນຖືກນໍາໃຊ້ເປັນປົກກະຕິເປັນຄໍາສັ່ງເງື່ອນໄຂຂອງ if ແລະ
ໃນຂະນະທີ່ ຖະແຫຼງການ. ການເຊື່ອມຕໍ່ສັນຍາລັກແມ່ນປະຕິບັດຕາມສໍາລັບທຸກຄົນ ເອກະສານ ການສະແດງອອກຍົກເວັ້ນ -h ແລະ
-L.
ການສະແດງອອກພື້ນຖານຕໍ່ໄປນີ້ແມ່ນມີຢູ່:
-a ເອກະສານ ເອກະສານ ລາຄາ:.
-b ເອກະສານ ເອກະສານ ເປັນອຸປະກອນພິເສດຕັນ.
-c ເອກະສານ ເອກະສານ ເປັນອຸປະກອນພິເສດລັກສະນະ.
-d ເອກະສານ ເອກະສານ ເປັນໄດເລກະທໍລີ.
-e ເອກະສານ ເອກະສານ ລາຄາ:.
-f ເອກະສານ ເອກະສານ ເປັນໄຟລ໌ປົກກະຕິ.
-G ເອກະສານ ເອກະສານກຸ່ມຂອງແມ່ນ ID ກຸ່ມທີ່ມີປະສິດທິພາບຂອງ shell.
-g ເອກະສານ ເອກະສານໂຫມດຂອງມີ setgid bit ທີ່ກໍານົດໄວ້.
-H ເອກະສານ ເອກະສານ ແມ່ນໄດເຣັກທໍຣີທີ່ຂຶ້ນກັບບໍລິບົດ (ມີປະໂຫຍດພຽງແຕ່ຢູ່ໃນ HP-UX).
-h ເອກະສານ ເອກະສານ ແມ່ນການເຊື່ອມຕໍ່ສັນຍາລັກ.
-k ເອກະສານ ເອກະສານຮູບແບບຂອງມີ ຫນຽວ(8) ບິດ.
-L ເອກະສານ ເອກະສານ ແມ່ນການເຊື່ອມຕໍ່ສັນຍາລັກ.
-O ເອກະສານ ເອກະສານເຈົ້າຂອງແມ່ນ ID ຜູ້ໃຊ້ທີ່ມີປະສິດທິພາບຂອງ Shell.
-o ທາງເລືອກ Shell ທາງເລືອກ ຖືກກໍານົດ (ເບິ່ງ ທີ່ກໍານົດໄວ້ ຄໍາສັ່ງຂ້າງເທິງສໍາລັບບັນຊີລາຍຊື່ຂອງ
ທາງເລືອກ). ເປັນການຂະຫຍາຍທີ່ບໍ່ແມ່ນມາດຕະຖານ, ຖ້າທາງເລືອກເລີ່ມຕົ້ນດ້ວຍ
a '!', ການທົດສອບແມ່ນ negated; ການທົດສອບສະເຫມີລົ້ມເຫລວຖ້າຫາກວ່າ ທາງເລືອກ
ບໍ່ມີຢູ່ (ສະນັ້ນ [ -o foo -o -o !foo ] ກັບຄືນຄວາມຈິງຖ້າ ແລະເທົ່ານັ້ນ
ຖ້າຫາກວ່າທາງເລືອກ ຟູ ມີ). ເຊັ່ນດຽວກັນນີ້ສາມາດເຮັດໄດ້ດ້ວຍ [ -o ?foo ]
ຄືກັບ AT&T UNIX ksh93. ທາງເລືອກ ຍັງສາມາດເປັນທຸງສັ້ນນໍາພາໂດຍ
ທັງ '-' ຫຼື '+' (ບໍ່ມີການປະຕິເສດຢ່າງມີເຫດຜົນ), ຕົວຢ່າງ '-x' ຫຼື '+x'
ແທນທີ່ 'xtrace'.
-p ເອກະສານ ເອກະສານ ແມ່ນທໍ່ທີ່ມີຊື່ວ່າ (FIFO).
-r ເອກະສານ ເອກະສານ ມີຢູ່ແລະສາມາດອ່ານໄດ້.
-S ເອກະສານ ເອກະສານ ເປັນ Unix(4)-ຊັອກເກັດໂດເມນ.
-s ເອກະສານ ເອກະສານ ບໍ່ແມ່ນຫວ່າງເປົ່າ.
-t fd ຕົວອະທິບາຍໄຟລ໌ fd ເປັນ tty(4) ອຸປະກອນ.
-u ເອກະສານ ເອກະສານໂຫມດຂອງມີ setuid bit ທີ່ກໍານົດໄວ້.
-w ເອກະສານ ເອກະສານ ມີຢູ່ແລະສາມາດຂຽນໄດ້.
-x ເອກະສານ ເອກະສານ ມີຢູ່ ແລະສາມາດປະຕິບັດໄດ້.
ແຟ້ມ 1 - ນ ແຟ້ມ 2 ແຟ້ມ 1 ແມ່ນໃຫມ່ກວ່າ ແຟ້ມ 2 or ແຟ້ມ 1 ມີຢູ່ແລະ ແຟ້ມ 2 ບໍ່.
ແຟ້ມ 1 -ບໍ່ ແຟ້ມ 2 ແຟ້ມ 1 ມີອາຍຸຫຼາຍກວ່າ ແຟ້ມ 2 or ແຟ້ມ 2 ມີຢູ່ແລະ ແຟ້ມ 1 ບໍ່.
ແຟ້ມ 1 -ຖ້າ ແຟ້ມ 2 ແຟ້ມ 1 ແມ່ນໄຟລ໌ດຽວກັນກັບ ແຟ້ມ 2.
string string ມີຄວາມຍາວທີ່ບໍ່ແມ່ນສູນ.
-n string string ບໍ່ແມ່ນຫວ່າງເປົ່າ.
-z string string ແມ່ນຫວ່າງເປົ່າ.
string = string Strings ແມ່ນເທົ່າທຽມກັນ.
string == string Strings ແມ່ນເທົ່າທຽມກັນ.
string > string ໂຕປະຕິບັດການສະຕຣິງທຳອິດແມ່ນໃຫຍ່ກວ່າຕົວປະຕິບັດການສະຕຣິງທີສອງ.
string < string ໂຕປະຕິບັດການສະຕຣິງທຳອິດແມ່ນໜ້ອຍກວ່າຕົວປະຕິບັດການສະຕຣິງທີສອງ.
string != string ສາຍບໍ່ເທົ່າກັນ.
ຈໍານວນ -eq ຈໍານວນ ຕົວເລກປຽບທຽບເທົ່າກັບ.
ຈໍານວນ - ບໍ່ ຈໍານວນ ຕົວເລກປຽບທຽບບໍ່ເທົ່າກັນ.
ຈໍານວນ -ຈີ ຈໍານວນ ຕົວເລກປຽບທຽບໃຫຍ່ກວ່າ ຫຼືເທົ່າກັບ.
ຈໍານວນ -gt ຈໍານວນ ຕົວເລກປຽບທຽບຫຼາຍກວ່າ.
ຈໍານວນ -ການ ຈໍານວນ ຕົວເລກປຽບທຽບຫນ້ອຍກວ່າຫຼືເທົ່າກັບ.
ຈໍານວນ -lt ຈໍານວນ ຕົວເລກປຽບທຽບຫນ້ອຍກວ່າ.
ການສະແດງອອກຂັ້ນພື້ນຖານຂ້າງເທິງ, ເຊິ່ງຕົວປະຕິບັດການ unary ມີຄວາມສຳຄັນກວ່າ binary
ຜູ້ປະກອບການ, ອາດຈະຖືກລວມເຂົ້າກັບຕົວປະຕິບັດການຕໍ່ໄປນີ້ (ລະບຸໄວ້ໃນລໍາດັບທີ່ເພີ່ມຂຶ້ນ
ອັນດັບຕົ້ນໆ):
expr -o expr Logical OR.
expr -a expr Logical AND.
! expr ເຫດຜົນບໍ່ແມ່ນ.
( expr ) ການຈັດກຸ່ມ.
ໃຫ້ສັງເກດວ່າຕົວເລກຕົວຈິງອາດຈະເປັນການສະແດງອອກທາງເລກຄະນິດ, ເຊັ່ນ: ຄະນິດສາດ
ຄຳສັບ ຫຼືຊື່ຂອງຕົວແປຈຳນວນເຕັມ:
x=1; [ "x" -eq 1] ປະເມີນເປັນຄວາມຈິງ
ໃຫ້ສັງເກດວ່າບາງກົດລະບຽບພິເສດແມ່ນຖືກນໍາໃຊ້ (ມາລະຍາດຂອງ POSIX) ຖ້າຈໍານວນຂອງ
ການໂຕ້ຖຽງກັບ ການທົດສອບ ຫຼືຢູ່ໃນວົງເລັບ [ ... ] ຫນ້ອຍກວ່າຫ້າ: ຖ້ານໍາ '!'
ການໂຕ້ຖຽງສາມາດຖືກຖອດອອກໄດ້ວ່າມີພຽງແຕ່ຫນຶ່ງຫາສາມການໂຕ້ຖຽງເທົ່ານັ້ນ, ຫຼັງຈາກນັ້ນ
ການປຽບທຽບທີ່ຫຼຸດລົງແມ່ນປະຕິບັດ; (ຂໍຂອບໃຈ XSI) ວົງເລັບ \( ... \) ຕ່ໍາສີ່- ແລະ
ຮູບແບບການໂຕ້ຖຽງສາມກັບຮູບແບບການໂຕ້ຖຽງສອງແລະຫນຶ່ງ, ຕາມລໍາດັບ; ການໂຕ້ຖຽງສາມ
ຮູບແບບສຸດທ້າຍມັກການດໍາເນີນການຄູ່, ຕິດຕາມມາດ້ວຍການປະຕິເສດ ແລະວົງເລັບ
ຫຼຸດລົງ; ຮູບແບບການໂຕ້ຖຽງສອງແລະສີ່ມັກການລົບລ້າງປະຕິບັດຕາມດ້ວຍວົງເລັບ; ໄດ້
ແບບຟອມການໂຕ້ຖຽງຫນຶ່ງສະເຫມີຫມາຍເຖິງ -n.
ຫມາຍເຫດ: ຄວາມຜິດພາດທົ່ວໄປແມ່ນການໃຊ້ “if [ $foo = bar ]” ເຊິ່ງລົ້ມເຫລວຖ້າພາລາມິເຕີ “foo”
ແມ່ນ NULL ຫຼືບໍ່ໄດ້ຕັ້ງ, ຖ້າມັນມີພື້ນທີ່ຝັງຕົວ (ເຊັ່ນ: IFS octets), ຫຼືຖ້າມັນເປັນ unary
ຜູ້ປະກອບການຄື '!' ຫຼື '-n'. ໃຊ້ການທົດສອບເຊັ່ນ "ຖ້າ [x"$foo" = x"bar" ]" ແທນ, ຫຼື
ຕົວປະຕິບັດການສອງວົງເລັບ “ຖ້າ [[ $foo = bar ]]” ຫຼື, ເພື່ອຫຼີກເວັ້ນການຈັບຄູ່ຮູບແບບ (ເບິ່ງ [[
ຂ້າງເທິງ): "ຖ້າ [[ $foo = "$bar" ]]”
ໄດ້ [[ ... ]] ການກໍ່ສ້າງບໍ່ພຽງແຕ່ມີຄວາມປອດໄພໃນການນໍາໃຊ້ຫຼາຍກວ່າ, ແຕ່ຍັງມັກຈະໄວຂຶ້ນ.
ທີ່ໃຊ້ເວລາ [-p] [ທໍ່]
ຖ້າຫາກວ່າເປັນ ທໍ່ ໄດ້ຖືກມອບໃຫ້, ເວລາທີ່ໃຊ້ເພື່ອປະຕິບັດທໍ່ໄດ້ຖືກລາຍງານ. ຖ້າບໍ່ມີ
ທໍ່ແມ່ນໃຫ້, ຫຼັງຈາກນັ້ນຜູ້ໃຊ້ແລະລະບົບທີ່ໃຊ້ເວລາທີ່ໃຊ້ໂດຍແກະຕົວມັນເອງ, ແລະທັງຫມົດ
ຄໍາສັ່ງທີ່ມັນໄດ້ດໍາເນີນການນັບຕັ້ງແຕ່ມັນໄດ້ເລີ່ມຕົ້ນ, ໄດ້ຖືກລາຍງານ. ເວລາລາຍງານແມ່ນ
ເວລາຈິງ (ເວລາຜ່ານໄປຕັ້ງແຕ່ຕົ້ນຈົນຈົບ), ເວລາ CPU ຂອງຜູ້ໃຊ້ (ເວລາໃຊ້
ແລ່ນຢູ່ໃນໂຫມດຜູ້ໃຊ້), ແລະເວລາ CPU ຂອງລະບົບ (ເວລາທີ່ໃຊ້ໃນໂຫມດ kernel).
ເວລາຖືກລາຍງານເຖິງຄວາມຜິດພາດມາດຕະຖານ; ຮູບແບບຂອງຜົນຜະລິດແມ່ນ:
0m0.00s ທີ່ແທ້ຈິງ 0m0.00s ຜູ້ໃຊ້ 0m0.00s ລະບົບ
ຖ້າ -p ທາງເລືອກແມ່ນໄດ້ຮັບຜົນຜະລິດແມ່ນຍາວເລັກນ້ອຍ:
ທີ່ແທ້ຈິງ 0.00
ຜູ້ໃຊ້ 0.00
sys 0.00
ມັນເປັນຄວາມຜິດພາດທີ່ຈະລະບຸ -p ທາງເລືອກເວັ້ນເສຍແຕ່ ທໍ່ ເປັນຄໍາສັ່ງທີ່ງ່າຍດາຍ.
ການປ່ຽນເສັ້ນທາງງ່າຍດາຍຂອງຄວາມຜິດພາດມາດຕະຖານບໍ່ມີຜົນກະທົບຕໍ່ຜົນຜະລິດຂອງ ທີ່ໃຊ້ເວລາ ຄໍາສັ່ງ:
$ ເວລານອນ 1 2>afile
$ { ເວລານອນ 1; } 2>ໄຟລ໌
ເວລາສໍາລັບຄໍາສັ່ງທໍາອິດບໍ່ໄດ້ໄປຫາ "afile", ແຕ່ວ່າຄໍາສັ່ງທີສອງເຮັດ.
ເວລາ ພິມເວລາທີ່ສະສົມຂອງຜູ້ໃຊ້ແລະລະບົບທີ່ໃຊ້ທັງໂດຍແກະແລະໂດຍຂະບວນການ
ວ່າແກະໄດ້ເລີ່ມຕົ້ນທີ່ໄດ້ອອກຈາກ. ຮູບແບບຂອງຜົນຜະລິດແມ່ນ:
0m0.00s 0m0.00s
0m0.00s 0m0.00s
ຈັ່ນຈັບ n [signal ...]
ຖ້າໂຕປະຕິບັດການທໍາອິດເປັນຈໍານວນທົດສະນິຍົມທີ່ບໍ່ໄດ້ເຊັນ, ອັນນີ້ຣີເຊັດສັນຍານທີ່ລະບຸໄວ້ທັງໝົດ
ກັບການປະຕິບັດໃນຕອນຕົ້ນ, ie ແມ່ນຄືກັນກັບການໂທ ຈັ່ນຈັບ ມີເຄື່ອງໝາຍລົບ ('-') ເປັນ
ຜູ້ຈັດການ, ຕິດຕາມດ້ວຍການໂຕ້ຖຽງ (n [signal ...]), ທັງຫມົດທີ່ຖືກປະຕິບັດເປັນ
ສັນຍານ.
ຈັ່ນຈັບ [ຜູ້ຈັດການ signal ...]
ກໍານົດຕົວຈັບຈັ່ນຈັບທີ່ຈະຖືກປະຕິບັດໃນເວລາທີ່ກໍານົດໃດໆ signals ແມ່ນ
ໄດ້ຮັບ. ຜູ້ຈັດການ ແມ່ນທັງ string ເປົ່າ, ຊີ້ບອກສັນຍານທີ່ຈະເປັນ
ບໍ່ສົນໃຈ, ເຄື່ອງຫມາຍລົບ ('-'), ຊີ້ບອກວ່າການດໍາເນີນການເລີ່ມຕົ້ນແມ່ນຈະດໍາເນີນການ
ສັນຍານ (ເບິ່ງ signal(3)), ຫຼືສະຕຣິງທີ່ມີຄຳສັ່ງ Shell ທີ່ຈະດຳເນີນການຢູ່
ໂອກາດທໍາອິດ (ເຊັ່ນເມື່ອຄໍາສັ່ງປະຈຸບັນສໍາເລັດ, ຫຼືກ່ອນທີ່ຈະພິມ
PS1 prompt ຕໍ່ໄປ) ຫຼັງຈາກໄດ້ຮັບສັນຍານຫນຶ່ງ. signal ແມ່ນຊື່ຂອງ a
ສັນຍານ (ເຊັ່ນ: PIPE ຫຼື ALRM) ຫຼືຈໍານວນຂອງສັນຍານ (ເບິ່ງ ຂ້າ -l ຄໍາສັ່ງ
ຂ້າງເທິງ).
ມີສອງສັນຍານພິເສດ: EXIT (ຍັງເອີ້ນວ່າ 0), ເຊິ່ງຖືກປະຕິບັດໃນເວລາທີ່
shell ກໍາລັງຈະອອກ, ແລະ ERR, ເຊິ່ງຖືກປະຕິບັດຫຼັງຈາກຂໍ້ຜິດພາດເກີດຂື້ນ; ຄວາມຜິດພາດແມ່ນ
ບາງສິ່ງບາງຢ່າງທີ່ຈະເຮັດໃຫ້ແກະອອກຖ້າຫາກວ່າ ທີ່ກໍານົດໄວ້ -e or ທີ່ກໍານົດໄວ້ -o ຜິດພາດ ທາງເລືອກ
ຖືກຕັ້ງ. EXIT handlers ຖືກປະຕິບັດໃນສະພາບແວດລ້ອມຂອງການປະຕິບັດຄັ້ງສຸດທ້າຍ
ຄໍາສັ່ງ.
ໃຫ້ສັງເກດວ່າ, ສໍາລັບແກະທີ່ບໍ່ມີການໂຕ້ຕອບ, ຕົວຈັບກັບດັກບໍ່ສາມາດປ່ຽນແປງໄດ້ສໍາລັບສັນຍານ
ທີ່ຖືກລະເລີຍໃນເວລາທີ່ແກະເລີ່ມຕົ້ນ.
ໂດຍບໍ່ມີການໂຕ້ຖຽງ, ສະຖານະການໃນປະຈຸບັນຂອງໃສ່ກັບດັກໄດ້ຖືກກໍານົດຕັ້ງແຕ່ແກະ
ເລີ່ມຕົ້ນແມ່ນສະແດງໃຫ້ເຫັນເປັນຊຸດຂອງ ຈັ່ນຈັບ ຄໍາສັ່ງ. ໃຫ້ສັງເກດວ່າຜົນຜະລິດຂອງ ຈັ່ນຈັບ ບໍ່ສາມາດເຮັດໄດ້
ຖືກທໍ່ທີ່ເປັນປະໂຫຍດກັບຂະບວນການອື່ນ (ສິ່ງປອມຂອງຄວາມຈິງທີ່ວ່າກັບດັກຖືກເກັບກູ້
ເມື່ອຂະບວນການຍ່ອຍຖືກສ້າງ).
ດັກ DEBUG ຂອງ Korn shell ຕົ້ນສະບັບ ແລະການຈັດການກັບດັກ ERR ແລະ EXIT ໃນ
ຫນ້າທີ່ຍັງບໍ່ທັນໄດ້ປະຕິບັດ.
ທີ່ແທ້ຈິງ ຄຳສັ່ງທີ່ອອກດ້ວຍຄ່າສູນ.
ທົ່ວໂລກ [[+-alpnrtUux] [-L[n]] [-R[n]] [-Z[n]] [-i[n]] | -f [- tux]] [ຊື່ [=ມູນຄ່າ] ...]
ປະເພດ [[+-alpnrtUux] [-LRZ[n]] [-i[n]] | -f [- tux]] [ຊື່ [=ມູນຄ່າ] ...]
ສະແດງຫຼືກໍານົດຄຸນລັກສະນະພາລາມິເຕີ. ກັບບໍ່ມີ ຊື່ ການໂຕ້ຖຽງ, ຄຸນລັກສະນະພາລາມິເຕີ
ຖືກສະແດງ; ຖ້າບໍ່ມີທາງເລືອກໃດໆຖືກນໍາໃຊ້, ຄຸນລັກສະນະປະຈຸບັນຂອງພາລາມິເຕີທັງຫມົດແມ່ນ
ພິມເປັນ ປະເພດ ຄໍາສັ່ງ; ຖ້າຫາກວ່າທາງເລືອກແມ່ນໄດ້ຮັບການໃຫ້ (ຫຼື '-' ບໍ່ມີຕົວອັກສອນທາງເລືອກ),
ຕົວກໍານົດການທັງຫມົດແລະຄ່າຂອງພວກມັນກັບຄຸນລັກສະນະທີ່ລະບຸແມ່ນຖືກພິມອອກ; ຖ້າຫາກວ່າທາງເລືອກ
ຖືກນໍາສະເຫນີດ້ວຍ '+', ຄ່າພາລາມິເຕີບໍ່ໄດ້ຖືກພິມອອກ.
If ຊື່ arguments ໄດ້ຖືກມອບໃຫ້, ຄຸນລັກສະນະຂອງພາລາມິເຕີທີ່ມີຊື່ແມ່ນຖືກກໍານົດ (-) ຫຼື
ລຶບລ້າງ (+). ຄ່າສໍາລັບພາລາມິເຕີອາດຈະເລືອກເປັນທາງເລືອກ. ສໍາລັບ ຊື່[*], ໄດ້
ການປ່ຽນແປງມີຜົນຕໍ່ອາເຣທັງໝົດ, ແລະບໍ່ມີການລະບຸຄ່າໃດໆ.
If ປະເພດ ຖືກໃຊ້ພາຍໃນຟັງຊັນ, ຕົວກໍານົດການໃດໆທີ່ລະບຸໄວ້ແມ່ນທ້ອງຖິ່ນ. ນີ້
ບໍ່ໄດ້ເຮັດໂດຍທີ່ຄືກັນ ທົ່ວໂລກ. ຫມາຍເຫດ: ນີ້ຫມາຍຄວາມວ່າ mksh 's ທົ່ວໂລກ
ຄໍາສັ່ງແມ່ນ ບໍ່ ທຽບເທົ່າກັບພາສາການຂຽນໂປລແກລມອື່ນໆ 'ຍ້ອນວ່າມັນບໍ່ອະນຸຍາດໃຫ້ a
ຟັງຊັນທີ່ເອີ້ນຈາກຟັງຊັນອື່ນເພື່ອເຂົ້າເຖິງພາລາມິເຕີໃນຂອບເຂດທົ່ວໂລກຢ່າງແທ້ຈິງ,
ແຕ່ພຽງແຕ່ປ້ອງກັນການວາງຫນຶ່ງທີ່ເຂົ້າເຖິງເຂົ້າໄປໃນຂອບເຂດທ້ອງຖິ່ນ.
ເມື່ອໃດ -f ຖືກນໍາໃຊ້, ປະເພດ ດໍາເນີນການກ່ຽວກັບຄຸນລັກສະນະຂອງຫນ້າທີ່. ເຊັ່ນດຽວກັບ
ຕົວກໍານົດການ, ຖ້າບໍ່ມີ ຊື່ ການໂຕ້ຖຽງໄດ້ຖືກມອບໃຫ້, ຫນ້າທີ່ຖືກລະບຸໄວ້ດ້ວຍຄຸນຄ່າຂອງມັນ
(ie ຄໍານິຍາມ) ເວັ້ນເສຍແຕ່ວ່າທາງເລືອກໄດ້ຖືກນໍາສະເຫນີດ້ວຍ '+', ໃນກໍລະນີນີ້ພຽງແຕ່ໄດ້
ຊື່ຟັງຊັນໄດ້ຖືກລາຍງານ.
-a ຄຸນສົມບັດ array ດັດສະນີ.
-f ໂໝດຟັງຊັນ. ສະແດງຫຼືກໍານົດຫນ້າທີ່ແລະຄຸນລັກສະນະຂອງເຂົາເຈົ້າ, ແທນທີ່ຈະ
ຕົວກໍານົດການ.
-i[n] ຄຸນສົມບັດຈຳນວນເຕັມ. n ລະບຸຖານທີ່ຈະໃຊ້ເມື່ອສະແດງຈຳນວນເຕັມ
(ຖ້າບໍ່ໄດ້ລະບຸ, ພື້ນຖານທີ່ໃຫ້ຢູ່ໃນການມອບຫມາຍທໍາອິດແມ່ນຖືກນໍາໃຊ້).
ພາລາມິເຕີທີ່ມີຄຸນລັກສະນະນີ້ອາດຈະຖືກມອບຫມາຍໃຫ້ມີມູນຄ່າທີ່ມີເລກເລກ
ສຳ ນວນ.
-L[n] ປະໄວ້ໃຫ້ເຫດຜົນ. n ລະບຸຄວາມກວ້າງຂອງຊ່ອງຂໍ້ມູນ. ຖ້າ n ບໍ່ໄດ້ລະບຸໄວ້,
ຄວາມກວ້າງປັດຈຸບັນຂອງພາລາມິເຕີ (ຫຼືຄວາມກວ້າງຂອງຄ່າທໍາອິດທີ່ໄດ້ມອບຫມາຍຂອງມັນ)
ຖືກນໍາໃຊ້. ຊ່ອງຫວ່າງຊັ້ນນໍາ (ແລະສູນ, ຖ້າໃຊ້ກັບ -Z ທາງເລືອກ) ແມ່ນ
ຖອດອອກ. ຖ້າຈໍາເປັນ, ຄ່າຈະຖືກຕັດອອກ ຫຼື ຊ່ອງຫວ່າງໃຫ້ພໍດີ
ຄວາມກວ້າງຂອງພາກສະຫນາມ.
-l ຄຸນສົມບັດຕົວພິມນ້ອຍ. ຕົວອັກສອນຕົວພິມໃຫຍ່ທັງໝົດໃນຄ່າຈະຖືກປ່ຽນເປັນ
ຕົວພິມນ້ອຍ. (ໃນຕົ້ນສະບັບ Korn, ພາລາມິເຕີນີ້ຫມາຍຄວາມວ່າ "ຈໍານວນເຕັມຍາວ"
ເມື່ອໃຊ້ກັບ -i ທາງເລືອກ.)
-n ສ້າງຕົວແປທີ່ຜູກມັດ (ຊື່ອ້າງອີງ): ການເຂົ້າເຖິງຕົວແປໃດໆ ຊື່
ຈະເຂົ້າເຖິງຕົວແປ ມູນຄ່າ ໃນຂອບເຂດປະຈຸບັນ (ອັນນີ້ແຕກຕ່າງຈາກ
AT&T UNIX ksh93!) ແທນ. ຍັງແຕກຕ່າງຈາກ AT&T UNIX ksh93 ແມ່ນວ່າ
ມູນຄ່າ ໄດ້ຖືກປະເມີນ lazily ໃນເວລານັ້ນ ຊື່ ແມ່ນເຂົ້າເຖິງ. ນີ້ສາມາດຖືກນໍາໃຊ້ໂດຍ
ຟັງຊັນເພື່ອເຂົ້າເຖິງຕົວແປທີ່ຊື່ຖືກສົ່ງຜ່ານເປັນພາລາມິເຕີ, ແທນ
ຂອງການນໍາໃຊ້ ການປະເມີນ.
-p ພິມສຳເລັດ ປະເພດ ຄໍາສັ່ງທີ່ສາມາດຖືກນໍາໃຊ້ເພື່ອສ້າງຄຸນລັກສະນະໃຫມ່
ແລະຄ່າຂອງພາລາມິເຕີ.
-R[n] ເຫດຜົນທີ່ຖືກຕ້ອງ. n ລະບຸຄວາມກວ້າງຂອງຊ່ອງຂໍ້ມູນ. ຖ້າ n ບໍ່ແມ່ນ
ລະບຸໄວ້, ຄວາມກວ້າງປັດຈຸບັນຂອງພາລາມິເຕີ (ຫຼືຄວາມກວ້າງຂອງຕົວທຳອິດຂອງມັນ
ມູນຄ່າມອບຫມາຍ) ຖືກນໍາໃຊ້. ຊ່ອງຫວ່າງທາງຫຼັງຖືກຖອດອອກ. ຖ້າຈໍາເປັນ,
ຄ່າຈະຖືກຖອດອອກຂອງຕົວອັກສອນຊັ້ນນໍາ ຫຼືຊ່ອງຫວ່າງເພື່ອເຮັດໃຫ້ພວກມັນ
ພໍດີກັບຄວາມກວ້າງຂອງຊ່ອງຂໍ້ມູນ.
-r ຄຸນສົມບັດອ່ານເທົ່ານັ້ນ. ພາລາມິເຕີທີ່ມີຄຸນລັກສະນະນີ້ອາດຈະບໍ່ຖືກມອບຫມາຍໃຫ້
ຫຼືບໍ່ໄດ້ຕັ້ງ. ເມື່ອຄຸນລັກສະນະນີ້ຖືກຕັ້ງ, ມັນບໍ່ສາມາດປິດໄດ້.
-t ຄຸນລັກສະນະແທັກ. ບໍ່ມີຄວາມຫມາຍກັບແກະ; ສະຫນອງໃຫ້ສໍາລັບການນໍາໃຊ້ຄໍາຮ້ອງສະຫມັກ.
ສໍາລັບຫນ້າທີ່, -t ແມ່ນຄຸນລັກສະນະການຕິດຕາມ. ເມື່ອປະຕິບັດຫນ້າທີ່ກັບການຕິດຕາມ
ຄຸນລັກສະນະແມ່ນປະຕິບັດ, ໄດ້ xtrace (-x) ທາງເລືອກ shell ແມ່ນຫັນຊົ່ວຄາວ
ກ່ຽວກັບການ.
-U ຄຸນສົມບັດຈຳນວນເຕັມທີ່ບໍ່ໄດ້ເຊັນ. ຈຳນວນເຕັມແມ່ນພິມອອກເປັນຄ່າທີ່ບໍ່ໄດ້ເຊັນ (ສົມທົບ
ກັບ -i ທາງເລືອກ). ທາງເລືອກນີ້ບໍ່ແມ່ນຢູ່ໃນແກະ Korn ຕົ້ນສະບັບ.
-u ຄຸນລັກສະນະຂອງຕົວພິມໃຫຍ່. ຕົວອັກສອນຕົວພິມນ້ອຍທັງໝົດໃນຄ່າຈະຖືກປ່ຽນເປັນ
ຕົວພິມໃຫຍ່. (ໃນຕົ້ນສະບັບ Korn, ຕົວກໍານົດການນີ້ຫມາຍຄວາມວ່າ "ບໍ່ໄດ້ເຊັນ
ຈຳນວນເຕັມ” ເມື່ອໃຊ້ກັບ -i ທາງເລືອກທີ່ຫມາຍເຖິງຕົວພິມໃຫຍ່ຈະ
ບໍ່ເຄີຍຖືກໃຊ້ສໍາລັບຖານທີ່ໃຫຍ່ກວ່າ 10. ເບິ່ງ -U ທາງເລືອກ.)
ສໍາລັບຫນ້າທີ່, -u ແມ່ນຄຸນລັກສະນະທີ່ບໍ່ໄດ້ກໍານົດ. ເບິ່ງ ຫນ້າທີ່ ຂ້າງເທິງສໍາລັບ
ຜົນສະທ້ອນຂອງເລື່ອງນີ້.
-x ສົ່ງອອກຄຸນລັກສະນະ. ພາລາມິເຕີ (ຫຼືຫນ້າທີ່) ແມ່ນຖືກຈັດໃສ່ໃນສະພາບແວດລ້ອມຂອງ
ຄໍາສັ່ງປະຕິບັດໃດໆ. ຫນ້າທີ່ສົ່ງອອກຍັງບໍ່ໄດ້ຖືກປະຕິບັດ.
-Z[n] ຄຸນສົມບັດການຕື່ມສູນ. ຖ້າບໍ່ລວມກັບ -L, ນີ້ແມ່ນຄືກັນກັບ -R, ຍົກເວັ້ນ
zero padding ຖືກນໍາໃຊ້ແທນ padding ຊ່ອງ. ສໍາລັບຈໍານວນເຕັມ, ຈໍານວນ
ແທນທີ່ຈະເປັນພື້ນຖານແມ່ນ padded.
ຖ້າມີຂອງ -i, -L, -l, -R, -U, -u, ຫຼື -Z ທາງເລືອກແມ່ນມີການປ່ຽນແປງ, ທັງຫມົດອື່ນໆຈາກນີ້
ການຕັ້ງຄ່າຖືກລຶບລ້າງ, ເວັ້ນເສຍແຕ່ວ່າພວກມັນຈະຖືກມອບໃຫ້ຢູ່ໃນເສັ້ນຄໍາສັ່ງດຽວກັນ.
ສູງສຸດ [-aBCcdefHilMmnOPpqrSsTtVvw] [ມູນຄ່າ]
ສະແດງຫຼືກໍານົດຂອບເຂດຈໍາກັດຂະບວນການ. ຖ້າຫາກວ່າບໍ່ມີທາງເລືອກທີ່ຖືກນໍາໃຊ້, ຈໍາກັດຂະຫນາດໄຟລ໌ (-f) ແມ່ນ
ຄາດ. ມູນຄ່າ, ຖ້າລະບຸ, ອາດຈະເປັນການສະແດງອອກທາງເລກຄະນິດຫຼືຄໍາ
"ບໍ່ຈໍາກັດ". ຂອບເຂດຈໍາກັດຜົນກະທົບຕໍ່ແກະແລະຂະບວນການໃດໆທີ່ສ້າງຂຶ້ນໂດຍແກະ
ຫຼັງຈາກກໍານົດຂອບເຂດຈໍາກັດ. ໃຫ້ສັງເກດວ່າບາງລະບົບອາດຈະບໍ່ອະນຸຍາດໃຫ້ມີຂອບເຂດຈໍາກັດ
ເພີ່ມຂຶ້ນເມື່ອພວກເຂົາຖືກກໍານົດ. ໃຫ້ສັງເກດວ່າປະເພດຂອງຂໍ້ຈໍາກັດທີ່ມີຢູ່ແມ່ນລະບົບ
ຂຶ້ນກັບ – ບາງລະບົບມີພຽງແຕ່ -f ຂີດ ຈຳ ກັດ.
-a ສະແດງຂອບເຂດຈໍາກັດທັງຫມົດ; ເວັ້ນເສຍແຕ່ -H ຖືກນໍາໃຊ້, ຂີດຈໍາກັດອ່ອນໆແມ່ນສະແດງ.
-B n ກໍານົດຂະຫນາດ socket buffer ເປັນ n kibibytes.
-C n ກໍານົດຈໍານວນຂອງກະທູ້ໃນຖານຄວາມຈໍາເປັນ n.
-c n ກໍານົດຂອບເຂດຈໍາກັດຂະຫນາດຂອງ n ຕັນກ່ຽວກັບຂະຫນາດຂອງ dumps ຫຼັກ.
-d n ກໍານົດຂອບເຂດຈໍາກັດຂະຫນາດຂອງ n kibibytes ກ່ຽວກັບຂະຫນາດຂອງພື້ນທີ່ຂໍ້ມູນ.
-e n ກໍານົດຄວາມງາມສູງສຸດທີ່ຈະ n.
-f n ກໍານົດຂອບເຂດຈໍາກັດຂະຫນາດຂອງ n ບລັອກໃນໄຟລ໌ທີ່ຂຽນໂດຍ shell ແລະລູກຂອງມັນ
ຂະບວນການ (ໄຟລ໌ຂອງຂະຫນາດໃດກໍ່ຕາມອາດຈະຖືກອ່ານ).
-H ກໍານົດຂອບເຂດຈໍາກັດຍາກເທົ່ານັ້ນ (ຄ່າເລີ່ມຕົ້ນແມ່ນກໍານົດຂອບເຂດຈໍາກັດທັງແຂງແລະອ່ອນ).
-i n ກໍານົດຈໍານວນຂອງສັນຍານທີ່ຍັງຄ້າງເປັນ n.
-l n ກໍານົດຂອບເຂດຈໍາກັດຂອງ n kibibytes ກ່ຽວກັບຈໍານວນ locked (wired) ຄວາມຊົງຈໍາທາງດ້ານຮ່າງກາຍ.
-M n ຕັ້ງຄວາມຊົງຈໍາທີ່ຖືກລັອກ AIO ເປັນ n kibibytes.
-m n ກໍານົດຂອບເຂດຈໍາກັດຂອງ n kibibytes ກ່ຽວກັບຈໍານວນຫນ່ວຍຄວາມຈໍາທາງດ້ານຮ່າງກາຍທີ່ໃຊ້.
-n n ກໍານົດຂອບເຂດຈໍາກັດຂອງ n ຕົວອະທິບາຍໄຟລ໌ທີ່ສາມາດເປີດໄດ້ໃນຄັ້ງດຽວ.
-O n ກໍານົດຈໍານວນຂອງການດໍາເນີນງານ AIO ເປັນ n.
-P n ຈໍາກັດຈໍານວນຂອງກະທູ້ຕໍ່ຂະບວນການເພື່ອ n.
-p n ກໍານົດຂອບເຂດຈໍາກັດຂອງ n ຂະບວນການທີ່ສາມາດດໍາເນີນການໄດ້ໂດຍຜູ້ໃຊ້ໄດ້ທຸກເວລາ.
-q n ຈໍາກັດຂະຫນາດຂອງແຖວຂໍ້ຄວາມ POSIX ເປັນ n ໄບ.
-r n ກໍານົດບູລິມະສິດສູງສຸດໃນເວລາທີ່ແທ້ຈິງເປັນ n.
-S ກໍານົດຂອບເຂດຈໍາກັດອ່ອນເທົ່ານັ້ນ (ຄ່າເລີ່ມຕົ້ນແມ່ນກໍານົດຂອບເຂດຈໍາກັດທັງແຂງແລະອ່ອນ).
-s n ກໍານົດຂອບເຂດຈໍາກັດຂະຫນາດຂອງ n kibibytes ກ່ຽວກັບຂະຫນາດຂອງພື້ນທີ່ stack ໄດ້.
-T n ກໍານົດຂອບເຂດເວລາຂອງ n ວິນາທີທີ່ແທ້ຈິງທີ່ຈະຖືກນໍາໃຊ້ໂດຍແຕ່ລະຂະບວນການ.
-t n ກໍານົດຂອບເຂດເວລາຂອງ n ວິນາທີ CPU ໃຊ້ໃນໂຫມດຜູ້ໃຊ້ເພື່ອໃຊ້ແຕ່ລະຄົນ
ຂະບວນການ.
-V n ກໍານົດຈໍານວນຂອງການຕິດຕາມ vnode ກ່ຽວກັບ Haiku ກັບ n.
-v n ກໍານົດຂອບເຂດຈໍາກັດຂອງ n kibibytes ກ່ຽວກັບຈໍານວນຂອງຫນ່ວຍຄວາມຈໍາ virtual (ຊ່ອງທີ່ຢູ່)
ໃຊ້ແລ້ວ.
-w n ກໍານົດຂອບເຂດຈໍາກັດຂອງ n kibibytes ກ່ຽວກັບຈໍານວນພື້ນທີ່ swap ທີ່ໃຊ້.
ເທົ່າກັບ ສູງສຸດ ມີຄວາມເປັນຫ່ວງ, ຕັນແມ່ນ 512 bytes.
ໜ້າ ກາກ [-S] [ຫນ້າກາກ]
ສະແດງຫຼືຕັ້ງຫນ້າກາກການສ້າງໄຟລ໌, ຫຼື umask (ເບິ່ງ ໜ້າ ກາກ(2)). ຖ້າ -S
ທາງເລືອກແມ່ນຖືກນໍາໃຊ້, ຫນ້າກາກທີ່ສະແດງຫຼືຊຸດແມ່ນສັນຍາລັກ; ຖ້າບໍ່ດັ່ງນັ້ນ, ມັນເປັນ octal
ຈໍານວນ
ຫນ້າກາກທີ່ເປັນສັນຍາລັກແມ່ນຄ້າຍຄືກັບທີ່ຖືກນໍາໃຊ້ໂດຍ chmod(1). ເມື່ອນໍາໃຊ້, ພວກເຂົາອະທິບາຍສິ່ງທີ່
ການອະນຸຍາດອາດຈະຖືກເຮັດໃຫ້ສາມາດໃຊ້ໄດ້ (ກົງກັນຂ້າມກັບຫນ້າກາກ octal ທີ່ກໍານົດເປັນ bit ຫມາຍຄວາມວ່າ
ບິດທີ່ສອດຄ້ອງກັນແມ່ນຈະຖືກລຶບລ້າງ). ຕົວຢ່າງ, "ug = rwx, o =" ກໍານົດຫນ້າກາກດັ່ງນັ້ນ
ໄຟລ໌ຈະບໍ່ສາມາດອ່ານໄດ້, ຂຽນໄດ້, ຫຼືສາມາດປະຕິບັດໄດ້ໂດຍ "ອື່ນໆ", ແລະທຽບເທົ່າ.
(ໃນລະບົບສ່ວນໃຫຍ່) ກັບຫນ້າກາກ octal "007".
ນາມແຝງ [-adt] [ຊື່ ...]
ນາມແຝງຂອງຊື່ທີ່ໃຫ້ຖືກເອົາອອກ. ຖ້າ -a ທາງເລືອກແມ່ນຖືກນໍາໃຊ້, ນາມແຝງທັງຫມົດ
ຖືກໂຍກຍ້າຍ. ຖ້າ -t or -d ທາງເລືອກທີ່ໄດ້ຖືກນໍາໃຊ້, ການດໍາເນີນງານທີ່ຊີ້ບອກແມ່ນປະຕິບັດ
ອອກໃນນາມແຝງທີ່ຕິດຕາມຫຼືໄດເລກະທໍລີ, ຕາມລໍາດັບ.
ກຳ ນົດ [-fv] ພາລາມິເຕີ ...
ຍົກເລີກການຕັ້ງຊື່ພາລາມິເຕີ (-v, ຄ່າເລີ່ມຕົ້ນ) ຫຼືຫນ້າທີ່ (-f). ກັບ ພາລາມິເຕີ[*],
ຄຸນລັກສະນະແມ່ນໄດ້ຖືກເກັບຮັກສາໄວ້, ພຽງແຕ່ຄ່າທີ່ບໍ່ໄດ້ຖືກຕັ້ງ.
ສະຖານະອອກບໍ່ແມ່ນສູນ ຖ້າພາລາມິເຕີໃດນຶ່ງມີຄຸນສົມບັດແບບອ່ານເທົ່ານັ້ນ
ຕັ້ງ, ເປັນສູນຖ້າບໍ່ດັ່ງນັ້ນ.
ລໍຖ້າ [ວຽກເຮັດງານທໍາ ...]
ລໍຖ້າໃຫ້ວຽກງານທີ່ກໍານົດໄວ້ສໍາເລັດ. ສະຖານະພາບທາງອອກຂອງ ລໍຖ້າ ແມ່ນອັນສຸດທ້າຍ
ວຽກທີ່ລະບຸ; ຖ້າວຽກສຸດທ້າຍຖືກຂ້າໂດຍສັນຍານ, ສະຖານະການອອກແມ່ນ 128 + the
ຈໍານວນສັນຍານ (ເບິ່ງ ຂ້າ -l ສະຖານະການອອກ ຂ້າງເທິງ); ຖ້າວຽກທີ່ລະບຸສຸດທ້າຍບໍ່ສາມາດ
ໄດ້ຖືກພົບເຫັນ (ເນື່ອງຈາກວ່າມັນບໍ່ເຄີຍມີ, ຫຼືໄດ້ສໍາເລັດແລ້ວ), ສະຖານະການອອກຂອງ ລໍຖ້າ
ແມ່ນ 127. ເບິ່ງ ວຽກເຮັດງານທໍາ ການຄວບຄຸມ ຂ້າງລຸ່ມນີ້ສໍາລັບຮູບແບບຂອງ ວຽກເຮັດງານທໍາ. ລໍຖ້າ ຈະກັບຄືນມາຖ້າສັນຍານ
ທີ່ໄດ້ຮັບການໃສ່ກັບດັກ, ຫຼືຖ້າຫາກວ່າ SIGHUP, SIGINT, ຫຼືສັນຍານ SIGQUIT
ແມ່ນໄດ້ຮັບ.
ຖ້າຫາກວ່າບໍ່ມີການກໍານົດວຽກເຮັດງານທໍາ, ລໍຖ້າ ລໍຖ້າສໍາລັບວຽກເຮັດງານທໍາທັງຫມົດໃນປັດຈຸບັນ (ຖ້າມີ) ກັບ
ຈົບແລ້ວອອກດ້ວຍສະຖານະສູນ. ຖ້າການກວດສອບວຽກຖືກເປີດໃຊ້, ການສໍາເລັດ
ສະຖານະພາບຂອງວຽກເຮັດງານທໍາໄດ້ຖືກພິມອອກ (ນີ້ບໍ່ແມ່ນກໍລະນີທີ່ວຽກເຮັດງານທໍາໄດ້ຖືກລະບຸຢ່າງຊັດເຈນ).
ມາຈາກໃສ [-pv] [ຊື່ ...]
ໂດຍບໍ່ມີການ -v ທາງເລືອກ, ມັນແມ່ນຄືກັນກັບ ຄໍາສັ່ງ -v, ຍົກເວັ້ນນາມແຝງບໍ່ໄດ້ຖືກພິມອອກ
ເປັນຄໍາສັ່ງນາມແຝງ. ກັບ -v ທາງເລືອກ, ມັນແມ່ນຄືກັນກັບ ຄໍາສັ່ງ -V. ໃນ
ໃນກໍລະນີໃດກໍ່ຕາມ, ໄດ້ -p ທາງເລືອກແຕກຕ່າງກັນ: ເສັ້ນທາງຄົ້ນຫາບໍ່ໄດ້ຮັບຜົນກະທົບໃນ ມາຈາກໃສ, ແຕ່
ການຄົ້ນຫາຖືກຈໍາກັດຢູ່ໃນເສັ້ນທາງ.
ວຽກເຮັດງານທໍາ ການຄວບຄຸມ
ການຄວບຄຸມວຽກຫມາຍເຖິງຄວາມສາມາດຂອງແກະໃນການຕິດຕາມແລະຄວບຄຸມວຽກທີ່ເປັນຂະບວນການຫຼື
ກຸ່ມຂະບວນການສ້າງສໍາລັບຄໍາສັ່ງຫຼືທໍ່. ຢ່າງຫນ້ອຍ, ຫອຍຮັກສາຕິດຕາມ
ສະຖານະຂອງພື້ນຫລັງ (ເຊັ່ນ: asynchronous) ວຽກທີ່ມີຢູ່ໃນປະຈຸບັນ; ນີ້
ຂໍ້ມູນສາມາດສະແດງໄດ້ໂດຍໃຊ້ ວຽກເຮັດງານທໍາ ຄໍາສັ່ງ. ຖ້າການຄວບຄຸມວຽກຖືກເປີດໃຊ້ຢ່າງສົມບູນ
(ການນໍາໃຊ້ ທີ່ກໍານົດໄວ້ -m or ທີ່ກໍານົດໄວ້ -o ຕິດຕາມກວດກາ), ຍ້ອນວ່າມັນແມ່ນສໍາລັບ shells ການໂຕ້ຕອບ, ຂະບວນການຂອງວຽກເຮັດງານທໍາ
ຖືກຈັດໃສ່ໃນກຸ່ມຂະບວນການຂອງຕົນເອງ. ວຽກຢູ່ເບື້ອງໜ້າສາມາດຢຸດໄດ້ໂດຍການພິມ suspend
ຕົວອັກສອນຈາກ terminal (ປົກກະຕິ ^Z), ວຽກງານສາມາດຖືກເລີ່ມຕົ້ນໃຫມ່ໃນດ້ານຫນ້າຫຼື.
ພື້ນຖານການນໍາໃຊ້ fg ແລະ bg ຄໍາສັ່ງ, ແລະສະຖານະຂອງ terminal ໄດ້ຖືກບັນທຶກໄວ້ຫຼືຟື້ນຟູ
ເມື່ອວຽກເບື້ອງໜ້າຖືກຢຸດ ຫຼືເລີ່ມໃໝ່, ຕາມລຳດັບ.
ໃຫ້ສັງເກດວ່າພຽງແຕ່ຄໍາສັ່ງທີ່ສ້າງຂະບວນການ (ເຊັ່ນ: ຄໍາສັ່ງ asynchronous, subshell
ຄໍາສັ່ງ, ແລະຄໍາສັ່ງທີ່ບໍ່ມີຢູ່ໃນຕົວ, ຄໍາສັ່ງທີ່ບໍ່ມີຫນ້າທີ່) ສາມາດຖືກຢຸດ; ຄໍາສັ່ງເຊັ່ນ ອ່ານ ບໍ່ສາມາດເຮັດໄດ້
be
ເມື່ອວຽກຖືກສ້າງ, ມັນຖືກມອບຫມາຍເລກວຽກ. ສໍາລັບ shells ແບບໂຕ້ຕອບ, ຕົວເລກນີ້ແມ່ນ
ພິມພາຍໃນ “[..]”, ຕິດຕາມດ້ວຍ ID ຂະບວນການຂອງຂະບວນການໃນວຽກເມື່ອ an
ຄຳສັ່ງ asynchronous ແມ່ນແລ່ນ. ວຽກເຮັດງານທໍາອາດຈະຖືກກ່າວເຖິງໃນ bg, fg, ວຽກເຮັດງານທໍາ, ຂ້າ, ແລະ ລໍຖ້າ
ຄໍາສັ່ງໂດຍ ID ຂະບວນການຂອງຂະບວນການສຸດທ້າຍໃນທໍ່ຄໍາສັ່ງ (ດັ່ງທີ່ເກັບໄວ້ໃນ
ໄດ້ $! ພາລາມິເຕີ) ຫຼືໂດຍການນໍາຫນ້າຕົວເລກວຽກທີ່ມີເຄື່ອງຫມາຍເປີເຊັນ ('%'). ສ່ວນຮ້ອຍອື່ນໆ
ລໍາດັບຍັງສາມາດຖືກນໍາໃຊ້ເພື່ອອ້າງອີງເຖິງວຽກ:
%+ | %% | % ວຽກທີ່ຢຸດບໍ່ດົນມານີ້ຫຼາຍທີ່ສຸດ, ຫຼື, ຖ້າບໍ່ມີວຽກທີ່ຢຸດເຊົາ, ແມ່ນວຽກເກົ່າແກ່ທີ່ສຸດ
ແລ່ນວຽກ.
%- ວຽກທີ່ຈະເປັນ %+ ວຽກເຮັດງານທໍາຖ້າຫາກວ່າສຸດທ້າຍບໍ່ມີ.
%n ວຽກເຮັດງານທໍາທີ່ມີຈໍານວນວຽກເຮັດງານທໍາ n.
%?string ວຽກທີ່ມີຄໍາສັ່ງຂອງມັນປະກອບດ້ວຍ string string (ມີຄວາມຜິດພາດເກີດຂຶ້ນຖ້າຫາກວ່າ
ຫຼາຍວຽກທີ່ຖືກຈັບຄູ່).
%string ວຽກທີ່ມີຄໍາສັ່ງຂອງມັນເລີ່ມຕົ້ນດ້ວຍ string string (ມີຄວາມຜິດພາດເກີດຂຶ້ນຖ້າຫາກວ່າ
ຫຼາຍວຽກທີ່ຖືກຈັບຄູ່).
ເມື່ອວຽກໃດນຶ່ງປ່ຽນສະຖານະ (ເຊັ່ນ: ວຽກພື້ນຫຼັງສຳເລັດ ຫຼືວຽກເບື້ອງໜ້າຖືກຢຸດ), the
shell ພິມຂໍ້ມູນສະຖານະຕໍ່ໄປນີ້:
[ຈໍານວນ] ທຸງ ສະຖານະພາບ ຄໍາສັ່ງ
ຢູ່ໃສ...
ຈໍານວນ ແມ່ນຕົວເລກຂອງວຽກ;
ທຸງ ແມ່ນຕົວອັກສອນ '+' ຫຼື '-' ຖ້າວຽກແມ່ນ %+ or %- ວຽກ, ຕາມລໍາດັບ, ຫຼືພື້ນທີ່
ຖ້າມັນບໍ່ແມ່ນທັງສອງ;
ສະຖານະພາບ ຊີ້ບອກສະຖານະປັດຈຸບັນຂອງວຽກ ແລະສາມາດເປັນ:
ສຳເລັດ [ຈໍານວນ]
ວຽກອອກ. ຈໍານວນ ແມ່ນສະຖານະການອອກຂອງວຽກທີ່ຖືກລະເວັ້ນ
ຖ້າສະຖານະເປັນສູນ.
ແລ່ນວຽກບໍ່ໄດ້ຢຸດ ຫຼືອອກ (ໝາຍເຫດວ່າແລ່ນບໍ່ໄດ້
ຈໍາເປັນຕ້ອງໄດ້ຫມາຍຄວາມວ່າໃຊ້ເວລາ CPU - ຂະບວນການສາມາດຖືກສະກັດ
ລໍຖ້າເຫດການບາງຢ່າງ).
ຢຸດ [signal]
ວຽກເຮັດງານທໍາໄດ້ຖືກຢຸດເຊົາໂດຍຊີ້ບອກ signal (ຖ້າບໍ່ມີສັນຍານໃຫ້, the
ວຽກຖືກຢຸດໂດຍ SIGTSTP).
ສັນຍານການອະທິບາຍ [“ຫຼັກຖືກຖິ້ມ”]
ວຽກເຮັດງານທໍາໄດ້ຖືກຂ້າຕາຍໂດຍສັນຍານ (ຕົວຢ່າງເຊັ່ນຄວາມຜິດຂອງຫນ່ວຍຄວາມຈໍາ, hangup); ໃຊ້ ຂ້າ -l
ສໍາລັບບັນຊີລາຍຊື່ຂອງຄໍາອະທິບາຍສັນຍານ. ຂໍ້ຄວາມ "core dumped" ຊີ້ໃຫ້ເຫັນ
ຂະບວນການສ້າງໄຟລ໌ຫຼັກ.
ຄໍາສັ່ງ ແມ່ນຄໍາສັ່ງທີ່ສ້າງຂະບວນການ. ຖ້າມີຫຼາຍຂະບວນການຢູ່ໃນ
ວຽກ, ແຕ່ລະຂະບວນການຈະມີເສັ້ນສະແດງຂອງມັນ ຄໍາສັ່ງ ແລະອາດຈະເປັນຂອງມັນ ສະຖານະພາບ, ຖ້າ
ມັນແຕກຕ່າງຈາກສະຖານະຂອງຂະບວນການທີ່ຜ່ານມາ.
ໃນເວລາທີ່ມີຄວາມພະຍາຍາມທີ່ຈະອອກຈາກແກະໃນຂະນະທີ່ມີວຽກຢູ່ໃນລັດຢຸດ, ໄດ້
shell ເຕືອນຜູ້ໃຊ້ວ່າມີວຽກທີ່ຢຸດເຊົາແລະບໍ່ອອກ. ຖ້າຫາກວ່າຄວາມພະຍາຍາມອື່ນແມ່ນ
ທັນທີທັນໃດເພື່ອອອກຈາກແກະ, ວຽກງານທີ່ຢຸດເຊົາຈະຖືກສົ່ງສັນຍານ SIGHUP ແລະແກະ
ອອກ. ເຊັ່ນດຽວກັນ, ຖ້າຫາກວ່າ ບໍ່ມີຫຍັງ ທາງເລືອກບໍ່ໄດ້ຖືກຕັ້ງໄວ້ແລະມີວຽກເຮັດງານທໍາໃນເວລາທີ່ຄວາມພະຍາຍາມ
ແມ່ນເຮັດໃຫ້ອອກຈາກ shell ເຂົ້າສູ່ລະບົບ, shell ເຕືອນຜູ້ໃຊ້ແລະບໍ່ໄດ້ອອກ. ຖ້າອື່ນ
ຄວາມພະຍາຍາມແມ່ນເຮັດໃຫ້ທັນທີທັນໃດທີ່ຈະອອກຈາກແກະ, ວຽກເຮັດງານທໍາໄດ້ຖືກສົ່ງສັນຍານ SIGHUP ແລະ
ແກະອອກຈາກ.
POSIX ຮູບແບບການ
ການປ້ອນ ທີ່ກໍານົດໄວ້ -o ບວກ ຮູບແບບຈະເຮັດໃຫ້ເກີດ mksh ເພື່ອປະຕິບັດຕົວໃຫ້ສອດຄ່ອງກັບ POSIX ໃນສະຖານທີ່ຕ່າງໆ
ບ່ອນທີ່ຄ່າເລີ່ມຕົ້ນຫຼືຄວາມຄິດເຫັນແຕກຕ່າງກັນ. ໃຫ້ສັງເກດວ່າ mksh ຈະຍັງດໍາເນີນການກັບ unsigned
ເລກເລກຄະນິດ 32-ບິດ; ໃຊ້ lksh ຖ້າເລກເລກຢູ່ໃນເຈົ້າພາບ ຍາວ ປະເພດຂໍ້ມູນ, ສົມບູນດ້ວຍ ISO C
ພຶດຕິກໍາທີ່ບໍ່ໄດ້ກໍານົດ, ແມ່ນຕ້ອງການ; ອ້າງເຖິງ lksh(1) ຫນ້າຄູ່ມືສໍາລັບລາຍລະອຽດ. ອື່ນໆທີ່ສຸດ
ປະຫວັດສາດ, AT&T UNIX ksh-compatible, ຫຼື ຄວາມແຕກຕ່າງຄວາມຄິດເຫັນສາມາດຖືກປິດການນໍາໃຊ້ນີ້
ໂຫມດ; ພວກນີ້ແມ່ນ:
· GNU bash ຕົວຊີ້ທິດທາງ I / O &>ເອກະສານ ບໍ່ຮອງຮັບອີກຕໍ່ໄປ.
· ຕົວອະທິບາຍໄຟລ໌ທີ່ສ້າງຂຶ້ນໂດຍການປ່ຽນເສັ້ນທາງ I/O ແມ່ນສືບທອດໂດຍຂະບວນການເດັກນ້ອຍ.
· ຕົວເລກທີ່ມີເລກສູນນຳໜ້າຖືກຕີຄວາມໝາຍເປັນເລກແປດ.
· ໄດ້ echo buildin ບໍ່ໄດ້ຕີຄວາມຫມາຍ backslashes ແລະພຽງແຕ່ສະຫນັບສະຫນູນທາງເລືອກທີ່ແນ່ນອນ "-n".
· ... (ບັນຊີລາຍຊື່ບໍ່ຄົບຖ້ວນແລະອາດຈະມີການປ່ຽນແປງສໍາລັບ R53)
SH ຮູບແບບການ
ຮູບແບບຄວາມເຂົ້າກັນໄດ້; ມີຈຸດປະສົງເພື່ອໃຊ້ກັບສະຄຣິບເກົ່າທີ່ບໍ່ສາມາດແກ້ໄຂໄດ້ງ່າຍ; ໄດ້
ການປ່ຽນແປງມີດັ່ງນີ້:
· GNU bash ຕົວຊີ້ທິດທາງ I / O &>ເອກະສານ ບໍ່ຮອງຮັບອີກຕໍ່ໄປ.
· ຕົວອະທິບາຍໄຟລ໌ທີ່ສ້າງຂຶ້ນໂດຍການປ່ຽນເສັ້ນທາງ I/O ແມ່ນສືບທອດໂດຍຂະບວນການເດັກນ້ອຍ.
· ໄດ້ echo buildin ບໍ່ໄດ້ຕີຄວາມຫມາຍ backslashes ແລະພຽງແຕ່ສະຫນັບສະຫນູນທາງເລືອກທີ່ແນ່ນອນ "-n".
· ... (ບັນຊີລາຍຊື່ບໍ່ຄົບຖ້ວນແລະອາດຈະມີການປ່ຽນແປງສໍາລັບ R53)
Interactive ການປ້ອນຂໍ້ມູນ ອອນໄລນ໌ ການແກ້ໄຂ
Shell ສະຫນັບສະຫນູນສາມໂຫມດຂອງການອ່ານຄໍາສັ່ງຈາກ a tty(4) ໃນການໂຕ້ຕອບ
ກອງປະຊຸມ, ຄວບຄຸມໂດຍ emacs, gmacs, ແລະ vi ທາງເລືອກ (ໃນຫຼາຍທີ່ສຸດຫນຶ່ງໃນເຫຼົ່ານີ້ສາມາດໄດ້ຮັບການຕັ້ງຢູ່ທີ່
ຄັ້ງດຽວ). ຄ່າເລີ່ມຕົ້ນແມ່ນ emacs. ຮູບແບບການແກ້ໄຂສາມາດຖືກຕັ້ງຄ່າຢ່າງຊັດເຈນໂດຍໃຊ້ ທີ່ກໍານົດໄວ້ ການກໍ່ສ້າງໃນ.
ຖ້າບໍ່ມີທາງເລືອກເຫຼົ່ານີ້ຖືກເປີດໃຊ້, shell ພຽງແຕ່ອ່ານເສັ້ນໂດຍໃຊ້ປົກກະຕິ tty(4)
ຄົນຂັບ. ຖ້າ emacs or gmacs ທາງເລືອກແມ່ນໄດ້ຖືກຕັ້ງໄວ້, ແກະອະນຸຍາດໃຫ້ການແກ້ໄຂທີ່ຄ້າຍຄື emacs ຂອງ
ຄໍາສັ່ງ; ເຊັ່ນດຽວກັນ, ຖ້າຫາກວ່າ vi ທາງເລືອກທີ່ກໍານົດໄວ້, ແກະອະນຸຍາດໃຫ້ການແກ້ໄຂ viຄ້າຍຄືຂອງ
ຄໍາສັ່ງ. ຮູບແບບເຫຼົ່ານີ້ແມ່ນໄດ້ອະທິບາຍໂດຍລະອຽດໃນພາກສ່ວນຕໍ່ໄປນີ້.
ໃນຮູບແບບການແກ້ໄຂເຫຼົ່ານີ້, ຖ້າຫາກວ່າເສັ້ນທີ່ຍາວກວ່າຄວາມກວ້າງຂອງຫນ້າຈໍ (ເບິ່ງ COLUMNS
ພາລາມິເຕີ), a '>', '+', ຫຼື '<' ມີລັກສະນະສະແດງຢູ່ໃນຖັນສຸດທ້າຍທີ່ຊີ້ບອກວ່າ
ມີຕົວອັກສອນເພີ່ມເຕີມຫຼັງຈາກ, ກ່ອນແລະຫຼັງ, ຫຼືກ່ອນຕໍາແຫນ່ງປະຈຸບັນ,
ຕາມລໍາດັບ. ເສັ້ນຖືກເລື່ອນຕາມແນວນອນຕາມຄວາມຈໍາເປັນ.
ເສັ້ນທີ່ສໍາເລັດແລ້ວຈະຖືກຍູ້ເຂົ້າໄປໃນປະຫວັດສາດ, ເວັ້ນເສຍແຕ່ວ່າພວກເຂົາເລີ່ມຕົ້ນດ້ວຍ IFS octet ຫຼື IFS
ພື້ນທີ່ສີຂາວ, ຫຼືຄືກັນກັບແຖວທີ່ຜ່ານມາ.
Emacs ການແກ້ໄຂ ຮູບແບບການ
ໃນເວລາທີ່ emacs ທາງເລືອກຖືກຕັ້ງໄວ້, ການແກ້ໄຂເສັ້ນການປ້ອນຂໍ້ມູນແບບໂຕ້ຕອບແມ່ນເປີດໃຊ້ງານ. ຄຳເຕືອນ: ໂໝດນີ້
ແມ່ນແຕກຕ່າງກັນເລັກນ້ອຍຈາກໂຫມດ emacs ໃນແກະ Korn ຕົ້ນສະບັບ. ໃນຮູບແບບນີ້, ຕ່າງໆ
ການແກ້ໄຂຄໍາສັ່ງ (ໂດຍປົກກະຕິຖືກຜູກມັດກັບຫນຶ່ງຫຼືຫຼາຍຕົວອັກສອນຄວບຄຸມ) ເຮັດໃຫ້ເກີດການປະຕິບັດທັນທີ
ໂດຍບໍ່ຕ້ອງລໍຖ້າສາຍໃໝ່. ຄໍາສັ່ງດັດແກ້ຫຼາຍແມ່ນຜູກມັດກັບການຄວບຄຸມໂດຍສະເພາະ
ຕົວອັກສອນເມື່ອແກະຖືກເອີ້ນ; ການຜູກມັດເຫຼົ່ານີ້ສາມາດປ່ຽນແປງໄດ້ໂດຍໃຊ້ ຜູກ ຄໍາສັ່ງ.
ຕໍ່ໄປນີ້ແມ່ນບັນຊີລາຍຊື່ຂອງຄໍາສັ່ງການແກ້ໄຂທີ່ມີຢູ່. ແຕ່ລະຄໍາອະທິບາຍເລີ່ມຕົ້ນດ້ວຍ
ຊື່ຂອງຄໍາສັ່ງ, suffixed ກັບຈໍ້າສອງເມັດ; ເປັນ [n] (ຖ້າຄໍາສັ່ງສາມາດຖືກນໍາຫນ້າດ້ວຍ a
ນັບ); ແລະປຸ່ມໃດໆທີ່ຄໍາສັ່ງຖືກຜູກມັດໂດຍຄ່າເລີ່ມຕົ້ນ, ຂຽນໂດຍໃຊ້ cart notation eg
ຕົວອັກສອນ ASCII ESC ຖືກຂຽນເປັນ ^[. ລຳດັບການຄວບຄຸມເຫຼົ່ານີ້ບໍ່ແມ່ນຕົວພິມນ້ອຍໃຫຍ່.
ຄໍານໍາຫນ້າການນັບສໍາລັບຄໍາສັ່ງຖືກໃສ່ໂດຍໃຊ້ລໍາດັບ ^[n, ບ່ອນທີ່ n ແມ່ນລໍາດັບຂອງ 1
ຫຼືຫຼາຍຕົວເລກ. ເວັ້ນເສຍແຕ່ໄດ້ລະບຸໄວ້ເປັນຢ່າງອື່ນ, ຖ້າການນັບຖືກລະເວັ້ນ, ມັນຈະເປັນຄ່າເລີ່ມຕົ້ນເປັນ 1.
ໃຫ້ສັງເກດວ່າການແກ້ໄຂຊື່ຄໍາສັ່ງແມ່ນໃຊ້ກັບ ຜູກ ຄໍາສັ່ງ. ນອກຈາກນັ້ນ, ຈໍານວນຫຼາຍ
ຄໍາສັ່ງການແກ້ໄຂແມ່ນເປັນປະໂຫຍດພຽງແຕ່ຢູ່ໃນ terminals ທີ່ມີຕົວກະພິບທີ່ເບິ່ງເຫັນ. ການຜູກມັດເລີ່ມຕົ້ນ
ໄດ້ຖືກເລືອກໃຫ້ຄ້າຍຄືກັບການຜູກມັດກະແຈ Emacs ທີ່ສອດຄ້ອງກັນ. ຂອງຜູ້ໃຊ້ tty(4) ຕົວອັກສອນ
(ເຊັ່ນ: ERASE) ຖືກຜູກມັດກັບການທົດແທນທີ່ສົມເຫດສົມຜົນ ແລະລົບລ້າງການຜູກມັດເລີ່ມຕົ້ນ.
ເອົາລູກອອກ: ^C, ^G
ຍົກເລີກຄໍາສັ່ງໃນປັດຈຸບັນ, ຫວ່າງບັນຟແວເສັ້ນແລະກໍານົດສະຖານະການອອກເປັນ
ຂັດຂວາງ.
ໃສ່ອັດຕະໂນມັດ: [n]
ພຽງແຕ່ເຮັດໃຫ້ຕົວລະຄອນປາກົດເປັນການປ້ອນຂໍ້ມູນຕົວໜັງສື. ລັກສະນະ ທຳ ມະດາ
ຖືກຜູກມັດກັບເລື່ອງນີ້.
backward-char: [n] ^B, ^XD, ANSI-CurLeft, PC-CurLeft
ຍ້າຍຕົວກະພິບໄປທາງຫຼັງ n ລັກສະນະ.
ຄໍາກັບຄືນໄປບ່ອນ: [n] ^[b, ANSI-Ctrl-CurLeft, ANSI-Alt-CurLeft
ຍ້າຍຕົວກະພິບໄປທາງຫຼັງໄປຫາຈຸດເລີ່ມຕົ້ນຂອງຄໍາ; ຄໍາສັບຕ່າງໆປະກອບດ້ວຍ
ຕົວເລກແລະຕົວເລກ, ຂີດກ້ອງ ('_'), ແລະເຄື່ອງໝາຍເງິນໂດລາ ('$').
ປະຫວັດການເລີ່ມຕົ້ນ: ^[
ຍ້າຍໄປຈຸດເລີ່ມຕົ້ນຂອງປະຫວັດສາດ.
ເລີ່ມຕົ້ນສາຍ: ^A, ANSI-Home, PC-Home
ຍ້າຍຕົວກະພິບໄປທີ່ຈຸດເລີ່ມຕົ້ນຂອງແຖວປ້ອນຂໍ້ມູນທີ່ຖືກດັດແກ້.
ຄຳສັບຕົວພິມໃຫຍ່: [n] ^[C, ^[ຄ
ຕົວພິມໃຫຍ່ຕົວອັກສອນທຳອິດໃນຕົວຕໍ່ໄປ n ຄໍາສັບຕ່າງໆ, ປ່ອຍໃຫ້ຕົວກະພິບຜ່ານໄປໃນຕອນທ້າຍ
ຂອງຄໍາສຸດທ້າຍ.
ໜ້າຈໍຈະແຈ້ງ: ^[^L
ພິມລຳດັບການຕັ້ງຄ່າທີ່ສັງລວມເວລາເພື່ອລຶບໜ້າຈໍ ແລະຕັ້ງຕົວກະພິບ,
ແຕ້ມຄືນການເຕືອນທັງໝົດ ແລະແຖວການປ້ອນຂໍ້ມູນທີ່ຖືກແກ້ໄຂໃນປັດຈຸບັນ. ລຳດັບເລີ່ມຕົ້ນ
ເຮັດວຽກສໍາລັບເກືອບທຸກ terminals ມາດຕະຖານ.
ຄໍາເຫັນ: ^[#
ຖ້າເສັ້ນປະຈຸບັນບໍ່ເລີ່ມຕົ້ນດ້ວຍຕົວສະແດງຄໍາຄິດເຫັນ, ຫນຶ່ງຈະຖືກເພີ່ມໃສ່
ການເລີ່ມຕົ້ນຂອງເສັ້ນແລະເສັ້ນຖືກໃສ່ (ຄືກັບວ່າກັບຄືນໄດ້ຖືກກົດດັນ);
ຖ້າບໍ່ດັ່ງນັ້ນ, ຕົວອັກສອນຄໍາຄິດຄໍາເຫັນທີ່ມີຢູ່ຈະຖືກໂຍກຍ້າຍອອກແລະຕົວກະພິບຖືກວາງໄວ້
ການເລີ່ມຕົ້ນຂອງເສັ້ນ.
ສົມບູນ: ^[^[
ສໍາເລັດອັດຕະໂນມັດຫຼາຍເທົ່າທີ່ເປັນເອກະລັກຂອງຊື່ຄໍາສັ່ງຫຼືຊື່ໄຟລ໌
ປະກອບດ້ວຍຕົວກະພິບ. ຖ້າຄໍາສັ່ງຫຼືຊື່ໄຟລ໌ທີ່ຍັງເຫຼືອທັງຫມົດແມ່ນເປັນເອກະລັກ, a
space ແມ່ນພິມອອກຫຼັງຈາກສໍາເລັດຂອງມັນ, ເວັ້ນເສຍແຕ່ວ່າມັນເປັນຊື່ໄດເລກະທໍລີໃນກໍລະນີນີ້
'/' ຖືກຕໍ່ທ້າຍ. ຖ້າບໍ່ມີຄໍາສັ່ງຫຼືຊື່ໄຟລ໌ທີ່ມີຄໍາບາງສ່ວນໃນປະຈຸບັນ
ຕາມຄໍານໍາຫນ້າຂອງມັນ, ລັກສະນະລະຄັງແມ່ນຜົນຜະລິດ (ປົກກະຕິແລ້ວເຮັດໃຫ້ສຽງບີບເປັນສຽງ).
ຄໍາສັ່ງສໍາເລັດ: ^X^[
ອັດຕະໂນມັດສໍາເລັດຫຼາຍເທົ່າທີ່ເປັນເອກະລັກຂອງຊື່ຄໍາສັ່ງທີ່ມີບາງສ່ວນ
ຄໍາທີ່ຂຶ້ນກັບຕົວກະພິບເປັນຄໍານໍາຫນ້າຂອງມັນ, ເຊັ່ນດຽວກັບໃນ ສົມບູນ ຄໍາສັ່ງຂ້າງເທິງ.
ໄຟລ໌ທີ່ສົມບູນ: ^[^X
ສໍາເລັດອັດຕະໂນມັດຫຼາຍເທົ່າທີ່ເປັນເອກະລັກຂອງຊື່ໄຟລ໌ທີ່ມີບາງສ່ວນ
ຄໍາທີ່ຂຶ້ນກັບຕົວກະພິບເປັນຄໍານໍາຫນ້າຂອງມັນ, ເຊັ່ນດຽວກັບໃນ ສົມບູນ ຄໍາສັ່ງອະທິບາຍຂ້າງເທິງ.
ບັນຊີລາຍຊື່ເຕັມ: ^I, ^[=
ຕື່ມຂໍ້ມູນໃສ່ຫຼາຍເທົ່າທີ່ເປັນໄປໄດ້ຂອງຄໍາປະຈຸບັນ, ແລະບອກລາຍການທີ່ເປັນໄປໄດ້
ສໍາເລັດສໍາລັບມັນ. ຖ້າຫາກວ່າພຽງແຕ່ຫນຶ່ງສໍາເລັດແມ່ນເປັນໄປໄດ້, ໃຫ້ກົງກັບໃນ ສົມບູນ
ຄໍາສັ່ງຂ້າງເທິງ. ໃຫ້ສັງເກດວ່າ ^I ປົກກະຕິແລ້ວແມ່ນສ້າງຂຶ້ນໂດຍປຸ່ມ TAB (tabulator).
delete-char-backward: [n] ລົບ, ^?, ^H
ລຶບຖິ້ມ n ຕົວອັກສອນກ່ອນຕົວກະພິບ.
delete-char-forward: [n] ANSI-Del, PC-Del
ລຶບຖິ້ມ n ຕົວອັກສອນຫຼັງຈາກຕົວກະພິບ.
ລຶບຄໍາກັບຄືນໄປບ່ອນ: [n] WERASE, ^[^?, ^[^H, ^[h
ລຶບຖິ້ມ n ຄໍາກ່ອນຕົວກະພິບ.
ລົບ-word-forward: [n] ^[ງ
ລຶບຕົວອັກສອນຫຼັງຈາກຕົວກະພິບເຖິງຈຸດສິ້ນສຸດຂອງ n ຄໍາເວົ້າ.
ປະຫວັດຫຍໍ້: [n] ^N, ^XB, ANSI-CurDown, PC-CurDown
ເລື່ອນການປ້ອງກັນປະຫວັດສາດໄປຂ້າງຫນ້າ n ສາຍ (ຕໍ່ມາ). ແຕ່ລະແຖວການປ້ອນຂໍ້ມູນເບື້ອງຕົ້ນ
ເລີ່ມຕົ້ນພຽງແຕ່ຫຼັງຈາກການເຂົ້າສຸດທ້າຍໃນ buffer ປະຫວັດສາດ, ດັ່ງນັ້ນ ປະຫວັດຫຍໍ້ ບໍ່ແມ່ນ
ທີ່ເປັນປະໂຫຍດຈົນກ່ວາ ປະຫວັດການຄົ້ນຫາ, ປະຫວັດການຄົ້ນຫາ or ປະຫວັດສາດ ໄດ້
ປະຕິບັດ.
ຄໍາຫຍໍ້: [n] ^[L, ^[l
ພິມຕົວພິມນ້ອຍຕໍ່ໄປ n ຄໍາເວົ້າ.
ເສັ້ນແກ້ໄຂ: [n] ^ເຊ
ແກ້ໄຂແຖວ n ຫຼືເສັ້ນປະຈຸບັນ, ຖ້າບໍ່ໄດ້ລະບຸ, ໂຕ້ຕອບ. ຕົວຈິງ
ຄໍາສັ່ງປະຕິບັດແມ່ນ fc -e ${VISUAL:-${Editor:-vi}} n.
ປະຫວັດສຸດທ້າຍ: ^[>
ຍ້າຍໄປໃນຕອນທ້າຍຂອງປະຫວັດສາດ.
end-of-line: ^E, ANSI-End, PC-End
ຍ້າຍຕົວກະພິບໄປໃນຕອນທ້າຍຂອງແຖວປ້ອນຂໍ້ມູນ.
ເອີ້: ^_
ເຮັດຫນ້າທີ່ເປັນເອກະສານສິ້ນສຸດ; ອັນນີ້ເປັນປະໂຫຍດເພາະວ່າການປ້ອນຂໍ້ມູນແບບແກ້ໄຂປິດໃຊ້ງານປົກກະຕິ
terminal input canonicalization.
eot-or-delete: [n] ^D
ປະຕິບັດເປັນ ເອີ ຖ້າຢູ່ຄົນດຽວໃນເສັ້ນ; ຖ້າບໍ່ດັ່ງນັ້ນເຮັດເປັນ ລຶບ-char-forward.
ຄວາມຜິດພາດ: (ບໍ່ໄດ້ຜູກມັດ)
ຜິດພາດ (ສຽງລະຄັງ).
ຈຸດແລກປ່ຽນ ແລະເຄື່ອງໝາຍ: ^X^X
ວາງຕົວກະພິບບ່ອນທີ່ເຄື່ອງໝາຍຢູ່ ແລະຕັ້ງເຄື່ອງໝາຍໃສ່ບ່ອນທີ່ຕົວກະພິບຢູ່.
ຂະຫຍາຍໄຟລ໌: ^[*
ຕື່ມໃສ່ '*' ກັບຄຳປັດຈຸບັນ ແລະປ່ຽນແທນຄຳດ້ວຍຜົນຂອງ
ປະຕິບັດໄຟລ໌ globbing ກ່ຽວກັບຄໍາ. ຖ້າບໍ່ມີໄຟລ໌ກົງກັບຮູບແບບ, ກະດິ່ງແມ່ນ
ຮຸ່ງ.
forward-char: [n] ^F, ^XC, ANSI-CurRight, PC-CurRight
ເລື່ອນຕົວກະພິບໄປຂ້າງຫນ້າ n ລັກສະນະ.
ຄໍາຕໍ່ໄປ: [n] ^[f, ANSI-Ctrl-CurRight, ANSI-Alt-CurRight
ຍ້າຍຕົວກະພິບໄປຂ້າງຫນ້າໄປຫາຈຸດສິ້ນສຸດຂອງ nth ຄໍາ.
goto-ປະຫວັດສາດ: [n] ^[ກ
ໄປຫາໝາຍເລກປະຫວັດສາດ n.
kill-line: ຂ້າ
ລຶບແຖວການປ້ອນຂໍ້ມູນທັງໝົດ.
ພາກພື້ນຂ້າ: ^W
ລຶບການປ້ອນຂໍ້ມູນລະຫວ່າງຕົວກະພິບ ແລະເຄື່ອງໝາຍ.
kill-to-eol: [n] ^ ກ
ລຶບການປ້ອນຂໍ້ມູນຈາກຕົວກະພິບໄປຫາທ້າຍແຖວ if n ບໍ່ໄດ້ລະບຸ;
ຖ້າບໍ່ດັ່ງນັ້ນຈະລຶບຕົວອັກສອນລະຫວ່າງຕົວກະພິບ ແລະຖັນ n.
ບັນຊີລາຍຊື່: ^[?
ພິມລາຍການຈັດຮຽງ, ຖັນຂອງຊື່ຄໍາສັ່ງ ຫຼືຊື່ໄຟລ໌ (ຖ້າມີ) ທີ່ສາມາດ
ຕື່ມຂໍ້ມູນໃສ່ບາງສ່ວນທີ່ມີຕົວກະພິບ. ຊື່ໄດເລກະທໍລີມີ '/' ຕໍ່ທ້າຍ
ໃຫ້ເຂົາເຈົ້າ.
list-command: ^X?
ພິມລາຍການທີ່ຈັດຮຽງຕາມຖັນຂອງຊື່ຄໍາສັ່ງ (ຖ້າມີ) ທີ່ສາມາດເຮັດສໍາເລັດ
ຄໍາບາງສ່ວນທີ່ມີຕົວກະພິບ.
list-file: ^X^Y
ພິມລາຍການຈັດຮຽງ, ຖັນຂອງຊື່ໄຟລ໌ (ຖ້າມີ) ທີ່ສາມາດເຮັດສໍາເລັດ
ຄໍາບາງສ່ວນທີ່ມີຕົວກະພິບ. ຕົວຊີ້ບອກປະເພດໄຟລ໌ຖືກຕໍ່ທ້າຍຕາມທີ່ອະທິບາຍໄວ້
ພາຍໃຕ້ການ ບັນຊີລາຍຊື່ ຂ້າງເທິງ.
ແຖວໃໝ່: ^J, ^M
ເຮັດໃຫ້ເສັ້ນປ້ອນຂໍ້ມູນປະຈຸບັນຖືກປະມວນຜົນໂດຍແກະ. ຕົວກະພິບປັດຈຸບັນ
ຕຳແໜ່ງອາດຈະຢູ່ບ່ອນໃດກໍໄດ້ໃນແຖວ.
ແຖວໃໝ່ ແລະ ຕໍ່ໄປ: ^O
ເຮັດໃຫ້ສາຍການປ້ອນຂໍ້ມູນປະຈຸບັນຖືກປະມວນຜົນໂດຍແກະ, ແລະແຖວຕໍ່ໄປຈາກ
ປະຫວັດສາດກາຍເປັນເສັ້ນປະຈຸບັນ. ນີ້ແມ່ນເປັນປະໂຫຍດພຽງແຕ່ຫຼັງຈາກ ປະຫວັດສາດ,
ປະຫວັດການຄົ້ນຫາ or ປະຫວັດການຄົ້ນຫາ.
no-op: ອອກຈາກ
ອັນນີ້ບໍ່ເຮັດຫຍັງເລີຍ.
ຄຳນຳໜ້າ-1: ^[
ແນະນຳລຳດັບຄຳສັ່ງ 2 ຕົວອັກສອນ.
prefix-2: ^X, ^[[, ^[O
ແນະນຳລຳດັບຄຳສັ່ງ 2 ຕົວອັກສອນ.
prev-hist-word: [n] ^[., ^[_
ຄໍາສຸດທ້າຍ, ຫຼື, ຖ້າໃຫ້, the nth ຄໍາ (ສູນ) ຂອງທີ່ຜ່ານມາ (ກ່ຽວກັບຊ້ໍາ
ການປະຕິບັດ, ທີສອງ, ສຸດທ້າຍ, ທີສາມ, ແລະອື່ນໆ) ຄໍາສັ່ງຖືກໃສ່ຢູ່ຕົວກະພິບ. ການນໍາໃຊ້
ຄໍາສັ່ງດັດແກ້ນີ້ຖິ້ມເຄື່ອງຫມາຍ.
quote: ^^, ^V
ລັກສະນະຕໍ່ໄປນີ້ຖືກປະຕິບັດຕົວຈິງແທນທີ່ຈະເປັນຄໍາສັ່ງດັດແກ້.
ແຕ້ມໃໝ່: ^L
Reprints ແຖວສຸດທ້າຍຂອງສະຕຣິງ prompt ແລະເສັ້ນ input ໃນປັດຈຸບັນຢູ່ໃນໃຫມ່
ເສັ້ນ.
search-character-backward: [n] ^[^]
ຄົ້ນຫາກັບຄືນໄປບ່ອນໃນແຖວປະຈຸບັນສໍາລັບ nth ການປະກົດຕົວຂອງລັກສະນະຕໍ່ໄປ
ພິມ.
search-character-forward: [n] ^]
ຄົ້ນຫາໄປຂ້າງຫນ້າໃນເສັ້ນປະຈຸບັນສໍາລັບການ nth ການປະກົດຕົວຂອງລັກສະນະຕໍ່ໄປ
ພິມ.
ປະຫວັດການຄົ້ນຫາ: ^R
ເຂົ້າສູ່ໂໝດຊອກຫາແບບເພີ່ມ. ບັນຊີລາຍຊື່ປະຫວັດສາດພາຍໃນແມ່ນຊອກຫາກັບຄືນໄປບ່ອນ
ຄໍາສັ່ງທີ່ກົງກັບວັດສະດຸປ້ອນ. ໃນເບື້ອງຕົ້ນ '^' ໃນສະຕຣິງຄົ້ນຫາ anchors the
ຄົ້ນຫາ. ປຸ່ມ Escape ຈະອອກຈາກໂໝດຄົ້ນຫາ. ຄໍາສັ່ງອື່ນໆ, ລວມທັງລໍາດັບ
ຂອງ escape ເປັນ ຄຳນຳໜ້າ-1 ຕາມດ້ວຍ ຄຳນຳໜ້າ-1 or ຄຳນຳໜ້າ-2 ຄີຈະຖືກປະຕິບັດຫຼັງຈາກ
ອອກຈາກຮູບແບບການຊອກຫາ. ໄດ້ ເອົາລູກອອກ (^G) ຄໍາສັ່ງຈະຟື້ນຟູເສັ້ນປ້ອນເຂົ້າກ່ອນ
ການຄົ້ນຫາໄດ້ເລີ່ມຕົ້ນ. ສໍາເລັດ ປະຫວັດການຄົ້ນຫາ ຄໍາສັ່ງສືບຕໍ່ຊອກຫາກັບຄືນໄປບ່ອນ
ການປະກົດຕົວຕໍ່ໄປຂອງຮູບແບບທີ່ຜ່ານມາ. buffer ປະຫວັດສາດເກັບຮັກສາໄວ້ພຽງແຕ່ a
ຈໍານວນຈໍາກັດຂອງສາຍ; ເກົ່າແກ່ທີ່ສຸດຖືກຍົກເລີກຕາມຄວາມຈໍາເປັນ.
search-history-up: ANSI-PgUp, PC-PgUp
ຄົ້ນຫາກັບຄືນໄປບ່ອນໂດຍຜ່ານ buffer ປະຫວັດສາດສໍາລັບຄໍາສັ່ງທີ່ມີຈຸດເລີ່ມຕົ້ນທີ່ກົງກັບ
ສ່ວນຂອງແຖວປ້ອນຂໍ້ມູນກ່ອນຕົວກະພິບ. ໃນເວລາທີ່ນໍາໃຊ້ໃນເສັ້ນຫວ່າງເປົ່າ, ນີ້ມີ
ຜົນກະທົບດຽວກັນກັບ ປະຫວັດສາດ.
search-history-down: ANSI-PgDn, PC-PgDn
ຄົ້ນຫາຕໍ່ໄປໂດຍຜ່ານ buffer ປະຫວັດສາດສໍາລັບຄໍາສັ່ງທີ່ມີຈຸດເລີ່ມຕົ້ນທີ່ກົງກັບ
ສ່ວນຂອງແຖວປ້ອນຂໍ້ມູນກ່ອນຕົວກະພິບ. ໃນເວລາທີ່ນໍາໃຊ້ໃນເສັ້ນຫວ່າງເປົ່າ, ນີ້ມີ
ຜົນກະທົບດຽວກັນກັບ ປະຫວັດຫຍໍ້. ນີ້ແມ່ນເປັນປະໂຫຍດພຽງແຕ່ຫຼັງຈາກ ປະຫວັດສາດ,
ປະຫວັດການຄົ້ນຫາ or ປະຫວັດການຄົ້ນຫາ.
set-mark-command: ^[
ຕັ້ງເຄື່ອງໝາຍຢູ່ຕຳແໜ່ງຕົວກະພິບ.
transpose-chars: ^T
ຖ້າຢູ່ໃນຕອນທ້າຍຂອງເສັ້ນ, ຫຼືຖ້າ gmacs ທາງເລືອກທີ່ກໍານົດໄວ້, ນີ້ການແລກປ່ຽນທັງສອງ
ຕົວອັກສອນທີ່ຜ່ານມາ; ຖ້າບໍ່ດັ່ງນັ້ນ, ມັນແລກປ່ຽນລັກສະນະທີ່ຜ່ານມາແລະປະຈຸບັນແລະ
ຍ້າຍຕົວກະພິບໜຶ່ງຕົວໄປທາງຂວາ.
ປະຫວັດສາດ: [n] ^P, ^XA, ANSI-CurUp, PC-CurUp
ເລື່ອນປະຫວັດກັນກັບຫຼັງ n ສາຍ (ກ່ອນຫນ້ານີ້).
ຄໍາທີ່ຕົວພິມໃຫຍ່: [n] ^[U, ^[u
ຕົວພິມໃຫຍ່ຕໍ່ໄປ n ຄໍາເວົ້າ.
ສະບັບ: ^[^V
ສະແດງສະບັບຂອງ mksh. ບັຟເຟີການແກ້ໄຂປະຈຸບັນຖືກຟື້ນຟູຄືນມາທັນທີທີ່ກະແຈ
ຖືກກົດດັນ. ການກົດປຸ່ມຟື້ນຟູແມ່ນດໍາເນີນການ, ເວັ້ນເສຍແຕ່ວ່າມັນເປັນຊ່ອງຫວ່າງ.
ຢັງ: ^Y
ແຊກສະຕຣິງຂໍ້ຄວາມທີ່ຖືກຂ້າຕາຍຫຼ້າສຸດຢູ່ຕຳແໜ່ງເຄີເຊີປັດຈຸບັນ.
yank-pop: ^[y
ທັນທີຫຼັງຈາກ ກ yank, ປ່ຽນແທນສະຕຣິງຂໍ້ຄວາມທີ່ໃສ່ດ້ວຍອັນຕໍ່ໄປກ່ອນໜ້ານີ້
ຂໍ້ຄວາມຖືກຂ້າຕາຍ.
Vi ການແກ້ໄຂ ຮູບແບບການ
ຫມາຍເຫດ: ຮູບແບບການແກ້ໄຂເສັ້ນຄໍາສັ່ງ vi ແມ່ນເດັກກໍາພ້າ, ແຕ່ຍັງເຮັດວຽກໄດ້. ມັນສະອາດ 8-bit
ແຕ່ໂດຍສະເພາະບໍ່ສະຫນັບສະຫນູນ UTF-8 ຫຼື MBCS.
ບັນນາທິການເສັ້ນຄໍາສັ່ງ vi ໃນ mksh ໂດຍພື້ນຖານແລ້ວມີຄໍາສັ່ງດຽວກັນກັບ vi(1) ບັນນາທິການກັບ
ຂໍ້ຍົກເວັ້ນຕໍ່ໄປນີ້:
· ທ່ານເລີ່ມຕົ້ນໃນໂຫມດໃສ່.
· ມີຊື່ໄຟລ໌ແລະຄໍາສັ່ງສໍາເລັດຄໍາສັ່ງ: =, \, *, ^X, ^E, ^F, ແລະ,
ທາງເລືອກ, ແລະ .
· ໄດ້ _ ຄໍາສັ່ງແມ່ນແຕກຕ່າງກັນ (ໃນ mksh, ມັນແມ່ນຄໍາສັ່ງໂຕ້ຖຽງສຸດທ້າຍ; ໃນ vi(1) ມັນໄປ
ກັບຈຸດເລີ່ມຕົ້ນຂອງເສັ້ນປະຈຸບັນ).
· ໄດ້ / ແລະ G ຄໍາສັ່ງຍ້າຍໃນທິດທາງກົງກັນຂ້າມກັບ j ຄໍາສັ່ງ.
· ຄໍາສັ່ງທີ່ບໍ່ມີຄວາມຫມາຍໃນຕົວແກ້ໄຂແຖວດຽວແມ່ນບໍ່ສາມາດໃຊ້ໄດ້ (ເຊັ່ນ: ຫນ້າຈໍ
ຄໍາສັ່ງການເຄື່ອນໄຫວແລະ ex(1) ແບບຈໍ້າສອງເມັດ (:) ຄໍາສັ່ງ).
ຄື vi(1), ມີສອງໂຫມດ: ໂຫມດ "ໃສ່" ແລະ "ຄໍາສັ່ງ". ໃນໂຫມດແຊກ, ຫຼາຍທີ່ສຸດ
ຕົວອັກສອນຖືກໃສ່ໃນ buffer ຢູ່ທີ່ຕໍາແຫນ່ງຕົວກະພິບໃນປະຈຸບັນຍ້ອນວ່າພວກເຂົາຖືກພິມ;
ແນວໃດກໍ່ຕາມ, ບາງລັກສະນະຖືກປະຕິບັດເປັນພິເສດ. ໂດຍສະເພາະ, ລັກສະນະຕໍ່ໄປນີ້ແມ່ນ
ເອົາມາຈາກປະຈຸບັນ tty(4) ການຕັ້ງຄ່າ (ເບິ່ງ stty(1)) ແລະມີຄວາມຫມາຍປົກກະຕິຂອງພວກເຂົາ (ຄ່າປົກກະຕິ
ຢູ່ໃນວົງເລັບ): ຂ້າ (^U), ລົບ (^?), ລົບ (^W), eof (^D), intr (^C), ແລະເຊົາ (^\).
ນອກເຫນືອໄປຈາກຂ້າງເທິງນີ້, ລັກສະນະດັ່ງຕໍ່ໄປນີ້ຍັງໄດ້ຮັບການພິເສດໃນການໃສ່
ໂຫມດ:
^E ການນັບບັນທຶກຄໍາສັ່ງແລະຊື່ໄຟລ໌ (ເບິ່ງຂ້າງລຸ່ມນີ້).
^F ຄໍາສັ່ງແລະຊື່ໄຟລ໌ສໍາເລັດ (ເບິ່ງຂ້າງລຸ່ມນີ້). ຖ້າໃຊ້ສອງຄັ້ງຕິດຕໍ່ກັນ, ບັນຊີລາຍຊື່ຂອງ
ການສໍາເລັດທີ່ເປັນໄປໄດ້ແມ່ນສະແດງ; ຖ້າໃຊ້ເປັນຄັ້ງທີສາມ, ການສໍາເລັດຈະຍົກເລີກ.
^H ລຶບຕົວອັກສອນກ່ອນໜ້າ.
^J | ^M ທ້າຍແຖວ. ເສັ້ນປະຈຸບັນແມ່ນອ່ານ, ວິເຄາະ, ແລະປະຕິບັດໂດຍ shell.
^V ຕົວໜັງສືຕໍ່ໄປ. ຕົວອັກສອນຕໍ່ໄປທີ່ພິມບໍ່ໄດ້ຖືກປະຕິບັດເປັນພິເສດ (ສາມາດຖືກນໍາໃຊ້ເພື່ອ
ໃສ່ຕົວອັກສອນທີ່ຖືກອະທິບາຍຢູ່ທີ່ນີ້).
^ X ຄໍາສັ່ງແລະການຂະຫຍາຍຊື່ໄຟລ໌ (ເບິ່ງຂ້າງລຸ່ມນີ້).
ວາງຕົວແກ້ໄຂໃນຮູບແບບຄໍາສັ່ງ (ເບິ່ງຂ້າງລຸ່ມນີ້).
ຊື່ໄຟລ໌ທາງເລືອກແລະການສໍາເລັດຄໍາສັ່ງ (ເບິ່ງ ^F ຂ້າງເທິງ), ເປີດໃຊ້ດ້ວຍ ທີ່ກໍານົດໄວ້ -o
vi-tabcomplete.
ໃນໂຫມດຄໍາສັ່ງ, ແຕ່ລະລັກສະນະຖືກຕີຄວາມຫມາຍເປັນຄໍາສັ່ງ. ລັກສະນະທີ່ບໍ່ມີ
ສອດຄ້ອງກັບຄໍາສັ່ງ, ແມ່ນການປະສົມປະສານທີ່ຜິດກົດຫມາຍຂອງຄໍາສັ່ງ, ຫຼືເປັນຄໍາສັ່ງທີ່ບໍ່ສາມາດເປັນ
ດໍາເນີນການ, ທັງຫມົດເຮັດໃຫ້ເກີດ beeps. ໃນຄໍາອະທິບາຍຄໍາສັ່ງຕໍ່ໄປນີ້, [n] ສະແດງໃຫ້ເຫັນ
ຄໍາສັ່ງອາດຈະຖືກນໍາຫນ້າດ້ວຍຕົວເລກ (ຕົວຢ່າງ 10l ຍ້າຍຂວາ 10 ຕົວອັກສອນ); ຖ້າບໍ່ມີຕົວເລກ
ຄໍານໍາຫນ້າຖືກນໍາໃຊ້, n ຖືວ່າແມ່ນ 1 ເວັ້ນເສຍແຕ່ໄດ້ລະບຸໄວ້ເປັນຢ່າງອື່ນ. ຄໍາວ່າ "ປະຈຸບັນ
ຕຳແໜ່ງ” ໝາຍເຖິງຕຳແໜ່ງລະຫວ່າງຕົວກະພິບ ແລະ ຕົວອັກສອນທີ່ຢູ່ຂ້າງໜ້າຕົວກະພິບ.
“ຄຳ” ແມ່ນລຳດັບຂອງຕົວອັກສອນ, ຕົວເລກ, ແລະ ຕົວອັກສອນຂີດກ້ອງ ຫຼື ລຳດັບຂອງຕົວໜັງສືທີ່ບໍ່ແມ່ນຕົວໜັງສື.
ຕົວອັກສອນ, ບໍ່ແມ່ນຕົວເລກ, ບໍ່ແມ່ນຕົວຂີດກ້ອງ, ແລະຕົວອັກສອນທີ່ບໍ່ແມ່ນຊ່ອງຫວ່າງ (ເຊັ່ນ: “ab2*&^” ມີສອງອັນ.
ຄໍາ) ແລະ "ຄໍາໃຫຍ່" ແມ່ນລໍາດັບຂອງຕົວອັກສອນທີ່ບໍ່ແມ່ນຊ່ອງຫວ່າງ.
ພິເສດ mksh vi ຄໍາສັ່ງ:
ຄໍາສັ່ງຕໍ່ໄປນີ້ບໍ່ໄດ້ຢູ່ໃນ, ຫຼືແຕກຕ່າງຈາກຕົວແກ້ໄຂໄຟລ໌ vi ປົກກະຕິ:
[n]_ ໃສ່ຍະຫວ່າງຕາມດ້ວຍ nth big-word ຈາກຄໍາສັ່ງສຸດທ້າຍໃນປະຫວັດສາດ
ຢູ່ທີ່ຕໍາແຫນ່ງປະຈຸບັນແລະເຂົ້າຮູບແບບການໃສ່; ຖ້າ n ບໍ່ໄດ້ລະບຸ, ສຸດທ້າຍ
ຄໍາຖືກໃສ່.
# ໃສ່ຕົວອັກສອນຄໍາຄິດເຫັນ ('#') ຢູ່ຈຸດເລີ່ມຕົ້ນຂອງແຖວປະຈຸບັນແລະກັບຄືນ
ເສັ້ນກັບແກະ (ເທົ່າກັບ I#^J).
[n]g ມັກ G, ຍົກເວັ້ນຖ້າ n ບໍ່ໄດ້ລະບຸໄວ້, ມັນໄປຫາການຈື່ຈໍາຫຼ້າສຸດ
ເສັ້ນ.
[n]v ແກ້ໄຂແຖວ n ການນໍາໃຊ້ vi(1) ບັນນາທິການ; ຖ້າ n ບໍ່ໄດ້ລະບຸ, ເສັ້ນປະຈຸບັນແມ່ນ
ດັດແກ້. ຄໍາສັ່ງປະຕິບັດຕົວຈິງແມ່ນ fc -e ${VISUAL:-${Editor:-vi}} n.
* ແລະ ^X ຄໍາສັ່ງຫຼືການຂະຫຍາຍຊື່ໄຟລ໌ແມ່ນໄດ້ນໍາໃຊ້ກັບຄໍາທີ່ໃຫຍ່ໃນປັດຈຸບັນ (ມີ
ຕື່ມໃສ່ '*' ຖ້າຄຳນັ້ນບໍ່ມີຕົວໜັງສື globbing) – ຄໍາໃຫຍ່ແມ່ນ
ແທນທີ່ດ້ວຍຄໍາທີ່ຜົນໄດ້ຮັບ. ຖ້າຄໍາໃຫຍ່ໃນປະຈຸບັນແມ່ນຄໍາທໍາອິດໃນ
ແຖວ ຫຼື ຕິດຕາມຕົວລະຄອນໃດໜຶ່ງ ';', '|', '&', '(', ຫຼື ')', ແລະບໍ່.
ມີ slash ('/'), ຫຼັງຈາກນັ້ນການຂະຫຍາຍຄໍາສັ່ງແມ່ນເຮັດ; ຖ້າບໍ່ດັ່ງນັ້ນຊື່ໄຟລ໌
ການຂະຫຍາຍແມ່ນເຮັດແລ້ວ. ການຂະຫຍາຍຄໍາສັ່ງຈະກົງກັບຄໍາໃຫຍ່ຕໍ່ກັບທັງຫມົດ
ນາມແຝງ, ຟັງຊັນ, ແລະຄໍາສັ່ງໃນຕົວເຊັ່ນດຽວກັນກັບໄຟລ໌ທີ່ສາມາດປະຕິບັດໄດ້ທີ່ພົບເຫັນ
ໂດຍການຄົ້ນຫາໄດເລກະທໍລີໃນພາລາມິເຕີ PATH. ການຂະຫຍາຍຊື່ໄຟລ໌ກົງກັນ
ຄໍາໃຫຍ່ຕໍ່ກັບໄຟລ໌ທີ່ຢູ່ໃນໄດເລກະທໍລີປະຈຸບັນ. ຫຼັງຈາກການຂະຫຍາຍຕົວ, ໄດ້
ຕົວກະພິບຖືກວາງໄວ້ຜ່ານຄໍາສຸດທ້າຍແລະຕົວແກ້ໄຂແມ່ນຢູ່ໃນໂຫມດແຊກ.
[n]\, [n]^F, [n] , ແລະ [n]
ຄໍາສັ່ງ / ຊື່ໄຟລ໌ສໍາເລັດ. ປ່ຽນແທນຄຳໃຫຍ່ປັດຈຸບັນດ້ວຍຄຳທີ່ຍາວທີ່ສຸດ
ການຈັບຄູ່ທີ່ເປັນເອກະລັກທີ່ໄດ້ຮັບຫຼັງຈາກປະຕິບັດຄໍາສັ່ງແລະການຂະຫຍາຍຊື່ໄຟລ໌.
ຖືກຮັບຮູ້ພຽງແຕ່ຖ້າຫາກວ່າ vi-tabcomplete ທາງເລືອກແມ່ນຖືກກໍານົດ, ໃນຂະນະທີ່ ແມ່ນພຽງແຕ່
ຮັບຮູ້ຖ້າຫາກວ່າ vi-esccomplete ທາງເລືອກແມ່ນໄດ້ຖືກກໍານົດ (ເບິ່ງ ທີ່ກໍານົດໄວ້ -o) ຖ້າຫາກວ່າ n ແມ່ນລະບຸໄວ້,
ໄດ້ nການສໍາເລັດທີ່ເປັນໄປໄດ້ແມ່ນເລືອກ (ຕາມການລາຍງານໂດຍຄໍາສັ່ງ / ຊື່ໄຟລ໌
ຄໍາສັ່ງ enumeration).
= ແລະ ^E ຄໍາສັ່ງ/ການນັບຊື່ໄຟລ໌. ບອກຄໍາສັ່ງຫຼືໄຟລ໌ທັງຫມົດທີ່ກົງກັບ
ຄໍາສັບໃຫຍ່ໃນປະຈຸບັນ.
^V ສະແດງສະບັບຂອງ mksh. ບັຟເຟີການແກ້ໄຂປະຈຸບັນຖືກຟື້ນຟູຄືນມາທັນທີທີ່ a
ປຸ່ມກົດ. ການກົດປຸ່ມຟື້ນຟູແມ່ນຖືກລະເລີຍ.
@c ການຂະຫຍາຍມະຫາພາກ. ປະຕິບັດຄໍາສັ່ງທີ່ພົບເຫັນຢູ່ໃນນາມແຝງ c.
ຄໍາສັ່ງການເຄື່ອນໄຫວພາຍໃນເສັ້ນ:
[n]ຊ ແລະ [n]^ຮ
ຍ້າຍອອກໄປ n ລັກສະນະ.
[n]l ແລະ [n]
ຍ້າຍຂວາ n ລັກສະນະ.
0 ຍ້າຍໄປຖັນ 0.
^ ຍ້າຍໄປທີ່ຕົວອັກສອນທີ່ບໍ່ແມ່ນຊ່ອງຂາວທຳອິດ.
[n]| ຍ້າຍໄປຖັນ n.
$ ຍ້າຍໄປຕົວອັກສອນສຸດທ້າຍ.
[n]b ຍ້າຍກັບຄືນໄປບ່ອນ n ຄໍາເວົ້າ.
[n]B ຍ້າຍກັບຄືນ n ຄໍາໃຫຍ່.
[n]e ກ້າວໄປຂ້າງຫນ້າເພື່ອສິ້ນສຸດຂອງຄໍາສັບ, n ເວລາ.
[n]E ກ້າວໄປຂ້າງຫນ້າເພື່ອສິ້ນສຸດຂອງຄໍາໃຫຍ່, n ເວລາ.
[n]w ກ້າວໄປຂ້າງຫນ້າ n ຄໍາເວົ້າ.
[n]W ກ້າວໄປຂ້າງຫນ້າ n ຄໍາໃຫຍ່.
% ຊອກຫາທີ່ກົງກັນ. ບັນນາທິການເບິ່ງໄປຂ້າງຫນ້າສໍາລັບວົງເລັບ, ວົງເລັບ, ຫຼືວົງເລັບທີ່ໃກ້ທີ່ສຸດ
ແລະຫຼັງຈາກນັ້ນຍ້າຍຕົວກະພິບໄປຫາວົງເລັບ, ວົງເລັບ, ຫຼືວົງເລັບທີ່ກົງກັນ.
[n]fc ກ້າວໄປຂ້າງຫນ້າ nth ການປະກົດຕົວຂອງລັກສະນະ c.
[n]Fc ຍ້າຍກັບຄືນໄປບ່ອນ nth ການປະກົດຕົວຂອງລັກສະນະ c.
[n]tc ກ້າວໄປຂ້າງຫນ້າພຽງແຕ່ກ່ອນທີ່ຈະໄດ້ nth ການປະກົດຕົວຂອງລັກສະນະ c.
[n]Tc ຍ້າຍກັບຄືນໄປຫາພຽງແຕ່ກ່ອນ nth ການປະກົດຕົວຂອງລັກສະນະ c.
[n]; ເຮັດຊ້ຳຄັ້ງສຸດທ້າຍ f, F, t, ຫຼື T ຄໍາສັ່ງ.
[n], ເຮັດຊ້ໍາອີກຄັ້ງ f, F, t, ຫຼື T ຄໍາສັ່ງ, ແຕ່ຍ້າຍໃນທິດທາງກົງກັນຂ້າມ.
ຄໍາສັ່ງການເຄື່ອນໄຫວລະຫວ່າງສາຍ:
[n]j, [n]+, ແລະ [n]^ ນ
ຍ້າຍໄປ nແຖວຕໍ່ໄປໃນປະຫວັດສາດ.
[n]k, [n]-, ແລະ [n]^ປ
ຍ້າຍໄປ nແຖວທີ່ຜ່ານມາໃນປະຫວັດສາດ.
[n]G ຍ້າຍໄປແຖວ n ໃນປະຫວັດສາດ; ຖ້າ n ບໍ່ໄດ້ລະບຸ, ຈໍານວນທໍາອິດ
ເສັ້ນທີ່ຈື່ໄດ້ຖືກນໍາໃຊ້.
[n]g ມັກ G, ຍົກເວັ້ນຖ້າ n ບໍ່ໄດ້ລະບຸໄວ້, ມັນໄປຫາແຖວທີ່ຈື່ໄດ້ຫຼ້າສຸດ.
[n]/string
ຄົ້ນຫາກັບຄືນໄປບ່ອນໂດຍຜ່ານປະຫວັດສາດສໍາລັບການ nເສັ້ນທີປະກອບດ້ວຍ string; ຖ້າ string
ເລີ່ມຕົ້ນດ້ວຍ '^', ສ່ວນທີ່ເຫຼືອຂອງສະຕຣິງຈະຕ້ອງປາກົດໃນຕອນເລີ່ມຕົ້ນຂອງປະຫວັດສາດ
ເສັ້ນເພື່ອໃຫ້ມັນກົງກັນ.
[n]?string
ຄືກັນກັບ /, ຍົກເວັ້ນແຕ່ມັນຊອກຫາຕໍ່ໄປໂດຍຜ່ານປະຫວັດສາດ.
[n]n ຄົ້ນຫາສໍາລັບ nth ການປະກົດຕົວຂອງສາຍຄົ້ນຫາສຸດທ້າຍ; ທິດທາງຂອງການຄົ້ນຫາ
ແມ່ນຄືກັນກັບການຄົ້ນຫາຄັ້ງສຸດທ້າຍ.
[n]N ຄົ້ນຫາສໍາລັບ nth ການປະກົດຕົວຂອງສາຍຄົ້ນຫາສຸດທ້າຍ; ທິດທາງຂອງການຄົ້ນຫາ
ແມ່ນກົງກັນຂ້າມກັບການຄົ້ນຫາຄັ້ງສຸດທ້າຍ.
ANSI-CurUp, PC-PgUp
ເອົາຕົວອັກສອນຈາກຈຸດເລີ່ມຕົ້ນຂອງເສັ້ນໄປຫາຕໍາແຫນ່ງຕົວກະພິບປະຈຸບັນເປັນ
ຄົ້ນຫາສະຕຣິງແລະເຮັດປະຫວັດສາດກັບຄືນໄປບ່ອນຄົ້ນຫາສໍາລັບແຖວທີ່ເລີ່ມຕົ້ນດ້ວຍອັນນີ້
ຊ່ອຍແນ່; ຮັກສາຕໍາແຫນ່ງຕົວກະພິບ. ອັນນີ້ເຮັດວຽກພຽງແຕ່ຢູ່ໃນໂໝດແຊກ ແລະຮັກສາມັນໄວ້
enabled
ແກ້ໄຂຄໍາສັ່ງ
[n]a ຕື່ມຂໍ້ຄວາມ n ເວລາ; ເຂົ້າໄປໃນໂຫມດແຊກຫຼັງຈາກຕໍາແຫນ່ງປະຈຸບັນ. ໄດ້
append ແມ່ນ replicated ພຽງ ແຕ່ ຖ້າ ຫາກ ວ່າ ຮູບ ແບບ ຄໍາ ສັ່ງ ແມ່ນ re : ເຂົ້າ ie ຖືກນໍາໃຊ້.
[n]ຄືກັນກັບ a, ຍົກເວັ້ນແຕ່ມັນຕໍ່ທ້າຍຂອງເສັ້ນ.
[n]ຂ້ອຍໃສ່ຂໍ້ຄວາມ n ເວລາ; ເຂົ້າໄປໃນໂຫມດໃສ່ໃນຕໍາແຫນ່ງປະຈຸບັນ. ການແຊກ
ແມ່ນ replicated ພຽງ ແຕ່ ຖ້າ ຫາກ ວ່າ ຮູບ ແບບ ຄໍາ ສັ່ງ ແມ່ນ re : ເຂົ້າ ie ຖືກນໍາໃຊ້.
[n]ຂ້ອຍຄືກັນ i, ຍົກເວັ້ນການແຊກແມ່ນເຮັດກ່ອນຕົວອັກສອນທີ່ບໍ່ແມ່ນເປົ່າຫວ່າງທໍາອິດ.
[n]s ແທນອັນຕໍ່ໄປ n ລັກສະນະ (ເຊັ່ນ: ລຶບຕົວອັກສອນແລະເຂົ້າໄປໃນການໃສ່
mode)
S ແທນທັງແຖວ. ຕົວອັກສອນທັງໝົດຕັ້ງແຕ່ຕົວທຳອິດທີ່ບໍ່ແມ່ນຕົວເປົ່າຫວ່າງຈົນຮອດທ້າຍ
ຂອງເສັ້ນຖືກລຶບແລະໃສ່ໂຫມດໃສ່.
[n]cຍ້າຍ-cmd
ປ່ຽນຈາກຕໍາແຫນ່ງປະຈຸບັນໄປຫາຕໍາແຫນ່ງທີ່ເກີດຈາກ n ຍ້າຍ-cmds (ເຊັ່ນ
ລົບພາກພື້ນທີ່ລະບຸໄວ້ແລະເຂົ້າໄປໃນຮູບແບບການແຊກ); ຖ້າ ຍ້າຍ-cmd is c, ເສັ້ນ
ເລີ່ມຕົ້ນຈາກຕົວອັກສອນທີ່ບໍ່ແມ່ນເປົ່າຫວ່າງທໍາອິດແມ່ນມີການປ່ຽນແປງ.
C ປ່ຽນຈາກຕໍາແຫນ່ງປະຈຸບັນໄປໃນຕອນທ້າຍຂອງເສັ້ນ (ie ລົບໄປໃນຕອນທ້າຍຂອງ
ເສັ້ນແລະເຂົ້າໄປໃນຮູບແບບການໃສ່).
[n]x ລຶບອັນຕໍ່ໄປ n ລັກສະນະ.
[n]X ລຶບທີ່ຜ່ານມາ n ລັກສະນະ.
D ລົບໄປໃນຕອນທ້າຍຂອງແຖວ.
[n]dຍ້າຍ-cmd
ລົບຈາກຕໍາແຫນ່ງປະຈຸບັນໄປຫາຕໍາແຫນ່ງທີ່ເປັນຜົນມາຈາກ n ຍ້າຍ-cmds;
ຍ້າຍ-cmd ແມ່ນຄໍາສັ່ງການເຄື່ອນໄຫວ (ເບິ່ງຂ້າງເທິງ) ຫຼື d, ໃນກໍລະນີນີ້ເສັ້ນປະຈຸບັນແມ່ນ
ລຶບແລ້ວ.
[n]rc ແທນທີ່ຕໍ່ໄປ n ລັກສະນະທີ່ມີຕົວລະຄອນ c.
[n]R ແທນ. ເຂົ້າສູ່ໂໝດແຊກ ແຕ່ຂຽນທັບຕົວອັກສອນທີ່ມີຢູ່ແລ້ວແທນການໃສ່
ກ່ອນຕົວອັກສອນທີ່ມີຢູ່. ການທົດແທນແມ່ນຊ້ໍາ n ເວລາ.
[n]~ ປ່ຽນກໍລະນີຂອງຕໍ່ໄປ n ລັກສະນະ.
[n]yຍ້າຍ-cmd
Yank ຈາກ ຕໍາ ແຫນ່ງ ໃນ ປະ ຈຸ ບັນ ກັບ ຕໍາ ແຫນ່ງ ເປັນ ຜົນ ມາ ຈາກ n ຍ້າຍ-cmds ເຂົ້າໄປໃນ
yank buffer; ຖ້າ ຍ້າຍ-cmd is y, ເສັ້ນທັງຫມົດແມ່ນ yanked.
Y Yank ຈາກຕໍາແຫນ່ງປະຈຸບັນໄປໃນຕອນທ້າຍຂອງເສັ້ນ.
[n]p ວາງເນື້ອໃນຂອງ yank buffer ຫຼັງຈາກຕໍາແຫນ່ງປະຈຸບັນ, n ເວລາ.
[n]P ຄືກັນກັບ p, ຍົກເວັ້ນ buffer ແມ່ນ pasted ຢູ່ຕໍາແຫນ່ງປະຈຸບັນ.
ຄໍາສັ່ງ vi ອື່ນ
^J ແລະ ^M
ເສັ້ນປະຈຸບັນແມ່ນອ່ານ, ວິເຄາະ, ແລະປະຕິບັດໂດຍ shell.
^L ແລະ ^R
ແຕ້ມເສັ້ນປະຈຸບັນຄືນໃໝ່.
[n]. ເຮັດຄືນຄໍາສັ່ງດັດແກ້ຫຼ້າສຸດ n ເວລາ.
u ຍົກເລີກຄໍາສັ່ງດັດແກ້ຫຼ້າສຸດ.
U ຍົກເລີກການປ່ຽນແປງທັງຫມົດທີ່ໄດ້ເຮັດກັບແຖວປະຈຸບັນ.
PC Home, End, Del, ແລະກະແຈຕົວກະພິບ
ພວກມັນເຄື່ອນທີ່ຕາມທີ່ຄາດໄວ້, ທັງຢູ່ໃນໂໝດແຊກ ແລະ ໂໝດຄຳສັ່ງ.
ພາຍໃນ ແລະ ເຊົາ
ຕົວອັກສອນ interrupt ແລະ quit terminal ເຮັດໃຫ້ເສັ້ນປະຈຸບັນຖືກລຶບແລະ
ການກະຕຸ້ນເຕືອນໃຫມ່ທີ່ຈະພິມ.
ໃຊ້ mksh-static ອອນໄລນ໌ໂດຍໃຊ້ບໍລິການ onworks.net
