awkposix - ອອນລາຍໃນຄລາວ

ໂຄງການ:

NAME

awk — ການສະແກນຮູບແບບ ແລະພາສາປະມວນຜົນ

ສະຫຼຸບສັງລວມ

ງຸ່ມ [−F sepstring] [−v ການມອບຫມາຍ]... ໂຄງການ [ການໂຕ້ຖຽງ...]

ງຸ່ມ [−F sepstring] -f ໂປຣແກມ [-f ໂປຣແກມ]... [−v ການມອບຫມາຍ]...
[ການໂຕ້ຖຽງ...]

ລາຍລະອຽດ

ໄດ້ ງຸ່ມ ຜົນປະໂຫຍດຈະຕ້ອງປະຕິບັດໂຄງການທີ່ຂຽນໄວ້ໃນ ງຸ່ມ ພາສາການຂຽນໂປລແກລມ, ເຊິ່ງແມ່ນ
ຊ່ຽວຊານສໍາລັບການຈັດການຂໍ້ມູນຂໍ້ຄວາມ. ອັນ ງຸ່ມ ໂຄງ​ການ​ແມ່ນ​ລໍາ​ດັບ​ຂອງ​ຮູບ​ແບບ​ແລະ​
ການ​ປະ​ຕິ​ບັດ​ທີ່​ສອດ​ຄ້ອງ​ກັນ​. ເມື່ອການປ້ອນຂໍ້ມູນຖືກອ່ານທີ່ກົງກັບຮູບແບບ, ການປະຕິບັດທີ່ກ່ຽວຂ້ອງ
ກັບຮູບແບບທີ່ໄດ້ຖືກປະຕິບັດ.

ການປ້ອນຂໍ້ມູນຈະຖືກຕີຄວາມໝາຍເປັນລຳດັບຂອງບັນທຶກ. ໂດຍຄ່າເລີ່ມຕົ້ນ, ບັນທຶກເປັນແຖວ, ຫນ້ອຍລົງ
ການ​ສິ້ນ​ສຸດ​ລົງ​ຂອງ​ຕົນ​ , ແຕ່ນີ້ສາມາດປ່ຽນແປງໄດ້ໂດຍການໃຊ້ RS ຕົວແປໃນຕົວ. ແຕ່ລະ
ບັນທຶກການປ້ອນຂໍ້ມູນຈະຖືກຈັບຄູ່ກັນກັບແຕ່ລະຮູບແບບໃນໂປຣແກຣມ. ສໍາລັບແຕ່ລະຄົນ
ຮູບແບບທີ່ກົງກັນ, ການປະຕິບັດທີ່ກ່ຽວຂ້ອງຈະຖືກປະຕິບັດ.

ໄດ້ ງຸ່ມ ຜົນປະໂຫຍດຈະຕ້ອງຕີຄວາມຫມາຍບັນທຶກການປ້ອນຂໍ້ມູນແຕ່ລະອັນເປັນລໍາດັບຂອງຂົງເຂດທີ່, ໂດຍ
ຄ່າເລີ່ມຕົ້ນ, ຊ່ອງຂໍ້ມູນແມ່ນສະຕຣິງຂອງທີ່ບໍ່ແມ່ນ. ບໍ່ແມ່ນ ຕົວລະຄອນ. ຄ່າເລີ່ມຕົ້ນນີ້
ແລະ ຕົວຂັ້ນພາກສະຫນາມສາມາດປ່ຽນແປງໄດ້ໂດຍການໃຊ້ FS ຕົວແປທີ່ສ້າງຂຶ້ນໃນຕົວແປຫຼື −F
sepstring ທາງເລືອກ. ທ ງຸ່ມ ຜົນປະໂຫຍດຈະຕ້ອງລະບຸພາກສະຫນາມທໍາອິດໃນບັນທຶກ $1, ທີສອງ
$2, ແລະອື່ນໆ. ສັນຍາລັກ $0 ຈະອ້າງອີງໃສ່ບັນທຶກທັງໝົດ; ການ​ຕັ້ງ​ຄ່າ​ພາກ​ສະ​ຫນາມ​ອື່ນໆ​
ເຮັດໃຫ້ການປະເມີນຄືນໃຫມ່ຂອງ $0. ການມອບໝາຍໃຫ້ $0 ຈະຣີເຊັດຄ່າຂອງຊ່ອງຂໍ້ມູນອື່ນທັງໝົດ
ແລະ NF ຕົວແປໃນຕົວ.

OPTIONS

ໄດ້ ງຸ່ມ ຜົນປະໂຫຍດຈະຕ້ອງສອດຄ່ອງກັບປະລິມານຄໍານິຍາມພື້ນຖານຂອງ POSIX.1-2008, ສ່ວນ
12.2, ຜົນປະໂຫຍດ syntax ຄູ່ມືແນະນໍາ.

ທາງເລືອກຕໍ່ໄປນີ້ຈະໄດ້ຮັບການສະຫນັບສະຫນູນ:

−F sepstring
ກໍານົດຕົວແຍກຊ່ອງໃສ່ຂໍ້ມູນ. ຕົວເລືອກນີ້ຈະທຽບເທົ່າກັບ:

-v FS =sepstring

ຍົກເວັ້ນວ່າຖ້າ −F sepstring ແລະ −v FS =sepstring ທັງສອງຖືກນໍາໃຊ້, ມັນບໍ່ໄດ້ຖືກລະບຸ
ບໍ່ວ່າຈະເປັນ FS ການມອບຫມາຍຜົນມາຈາກ −F sepstring ຖືກປະມວນຜົນໃນຄໍາສັ່ງ
ຄໍາສັ່ງແຖວຫຼືຖືກປຸງແຕ່ງຫຼັງຈາກສຸດທ້າຍ −v FS =sepstring. ເບິ່ງຄໍາອະທິບາຍ
ຂອງ FS ຕົວແປໃນຕົວ, ແລະວິທີທີ່ມັນຖືກນໍາໃຊ້, ໃນຄໍາອະທິບາຍຂະຫຍາຍ
ສ່ວນ.

-f ໂປຣແກມ
ລະບຸຊື່ເສັ້ນທາງຂອງໄຟລ໌ ໂປຣແກມ ບັນຈຸເປັນ ງຸ່ມ ໂຄງການ. ຊື່ເສັ້ນທາງ
of '−' ຈະໝາຍເຖິງການປ້ອນຂໍ້ມູນມາດຕະຖານ. ຖ້າຫຼາຍຕົວຢ່າງຂອງທາງເລືອກນີ້ແມ່ນ
ລະບຸໄວ້, concatenation ຂອງໄຟລ໌ທີ່ລະບຸໄວ້ເປັນ ໂປຣແກມ ໃນຄໍາສັ່ງ
ກໍານົດຈະເປັນ ງຸ່ມ ໂຄງການ. ໄດ້ ງຸ່ມ ໂຄງ​ການ​ສາ​ມາດ​ເປັນ​ທາງ​ເລືອກ​
ລະບຸໄວ້ໃນເສັ້ນຄໍາສັ່ງເປັນການໂຕ້ຖຽງດຽວ.

−v ການມອບຫມາຍ
ຄໍາຮ້ອງສະຫມັກຈະຕ້ອງຮັບປະກັນວ່າ ການມອບຫມາຍ ການໂຕ້ຖຽງແມ່ນຢູ່ໃນຮູບແບບດຽວກັນກັບ
an ການມອບຫມາຍ ປະຕິບັດການ. ການມອບໝາຍຕົວແປທີ່ລະບຸໄວ້ຈະຕ້ອງເກີດຂຶ້ນກ່ອນ
ການ​ປະ​ຕິ​ບັດ​ ງຸ່ມ ໂຄງການ, ລວມທັງການປະຕິບັດທີ່ກ່ຽວຂ້ອງກັບ ເລີ່ມຕົ້ນ ຮູບແບບການ
(ຖ້າ​ມີ). ສາມາດລະບຸການປະກົດຕົວຫຼາຍຢ່າງຂອງຕົວເລືອກນີ້ໄດ້.

ດໍາເນີນງານ

ໂຕປະຕິບັດການຕໍ່ໄປນີ້ຈະໄດ້ຮັບການສະຫນັບສະຫນູນ:

ໂຄງການ ຖ້າບໍ່ -f ທາງ​ເລືອກ​ແມ່ນ​ລະ​ບຸ​ໄວ້​, ຕົວ​ປະ​ຕິ​ບັດ​ທໍາ​ອິດ​ທີ່​ຈະ​ ງຸ່ມ ຈະເປັນຂໍ້ຄວາມຂອງ
ງຸ່ມ ໂຄງການ. ຄໍາຮ້ອງສະຫມັກຈະຕ້ອງສະຫນອງ ໂຄງການ ດໍາເນີນການເປັນອັນດຽວ
ການໂຕ້ຖຽງກັບ ງຸ່ມ. ຖ້າຂໍ້ຄວາມບໍ່ສິ້ນສຸດໃນ a , ງຸ່ມ ຈະຕີຄວາມໝາຍ
ຂໍ້ຄວາມຄືກັບວ່າມັນໄດ້ເຮັດ.

ການໂຕ້ຖຽງ ທັງສອງປະເພດຕໍ່ໄປນີ້ ການໂຕ້ຖຽງ ສາ​ມາດ​ໄດ້​ຮັບ​ການ​ປະ​ສົມ​:

ເອກະສານ ຊື່ເສັ້ນທາງຂອງໄຟລ໌ທີ່ປະກອບດ້ວຍການປ້ອນຂໍ້ມູນທີ່ຈະອ່ານ, ເຊິ່ງແມ່ນ
ຈັບຄູ່ກັບຊຸດຂອງຮູບແບບໃນໂຄງການ. ຖ້າບໍ່ມີ ເອກະສານ
operands ຖືກກໍານົດ, ຫຼືຖ້າຫາກວ່າ a ເອກະສານ operand ແມ່ນ '−', ມາດຕະຖານ
ວັດສະດຸປ້ອນຈະຖືກໃຊ້.

ການມອບຫມາຍ
operand ທີ່ເລີ່ມຕົ້ນດ້ວຍ an ຫຼືຕົວອັກສອນ
ຈາກຊຸດຕົວອັກສອນແບບພົກພາ (ເບິ່ງຕາຕະລາງໃນຄໍານິຍາມພື້ນຖານ
ປະລິມານຂອງ POSIX.1-2008, ສ່ວນ 6.1, Portable ລັກສະນະ ທີ່ກໍານົດໄວ້), ປະຕິບັດຕາມ
ໂດຍລໍາດັບຂອງເຄື່ອງຂຽນ, ຕົວເລກ, ແລະຕົວອັກສອນຈາກ
ຊຸດຕົວອັກສອນແບບພົກພາ, ຕິດຕາມດ້ວຍ '=' ລັກສະນະ, ຈະຕ້ອງລະບຸ a
ການມອບໝາຍຕົວແປແທນທີ່ຈະເປັນຊື່ເສັ້ນທາງ. ລັກສະນະກ່ອນ
'=' ເປັນຕົວແທນຂອງຊື່ຂອງ ງຸ່ມ ຕົວແປ; ຖ້າຊື່ນັ້ນເປັນ ງຸ່ມ
ຄໍາສະຫງວນ (ເບິ່ງ Grammar) ພຶດຕິກໍາແມ່ນບໍ່ໄດ້ກໍານົດ. ລັກສະນະ
ປະຕິບັດຕາມ ຈະຖືກຕີຄວາມວ່າພວກເຂົາປາກົດ
ໃນ ງຸ່ມ ໂຄງ​ການ​ນໍາ​ຫນ້າ​ແລະ​ປະ​ຕິ​ບັດ​ຕາມ​ດ້ວຍ​ວົງ​ຢືມ​ສອງ ('"')
ລັກສະນະ, ເປັນ ຄັກ token (ເບິ່ງ Grammar), ຍົກເວັ້ນວ່າຖ້າສຸດທ້າຍ
ລັກ​ສະ​ນະ​ແມ່ນ​ເປັນ unescaped ໄດ້​ , ມັນຈະຖືກຕີຄວາມວ່າເປັນ
ຕົວໜັງສື ແທນທີ່ຈະເປັນລັກສະນະທໍາອິດຂອງລໍາດັບ
"\"". ຕົວແປຈະຖືກມອບໝາຍມູນຄ່າຂອງສິ່ງນັ້ນ ຄັກ token
ແລະ, ຖ້າເຫມາະສົມ, ຈະຖືກພິຈາລະນາ a numeric string (ເບິ່ງ
ສຳ ນວນ in ງຸ່ມ), ຕົວແປຍັງຈະຖືກມອບຫມາຍຕົວເລກຂອງມັນ
ຄ່າ. ແຕ່​ລະ​ການ​ມອບ​ຫມາຍ​ຕົວ​ປ່ຽນ​ແປງ​ດັ່ງ​ກ່າວ​ຈະ​ເກີດ​ຂຶ້ນ​ກ່ອນ​ທີ່​ຈະ​
ການ​ປຸງ​ແຕ່ງ​ດັ່ງ​ຕໍ່​ໄປ​ນີ້​ ເອກະສານ, ຖ້າ​ມີ. ດັ່ງນັ້ນ, ການມອບຫມາຍກ່ອນ
ທໍາອິດ ເອກະສານ ການໂຕ້ຖຽງຈະຖືກປະຕິບັດຫຼັງຈາກ ເລີ່ມຕົ້ນ ການປະຕິບັດ (ຖ້າ
any), ໃນຂະນະທີ່ການມອບຫມາຍຫຼັງຈາກສຸດທ້າຍ ເອກະສານ ການໂຕ້ຖຽງຈະເກີດຂຶ້ນ
ກ່ອນທີ່ຈະໄດ້ END ການປະຕິບັດ (ຖ້າມີ). ຖ້າບໍ່ມີ ເອກະສານ ການໂຕ້ຖຽງ,
ການມອບໝາຍຈະຕ້ອງຖືກປະຕິບັດກ່ອນທີ່ຈະປະມວນຜົນວັດສະດຸປ້ອນມາດຕະຖານ.

STDIN

ການປ້ອນຂໍ້ມູນມາດຕະຖານຈະຖືກໃຊ້ພຽງແຕ່ຖ້າບໍ່ມີ ເອກະສານ operands ຖືກກໍານົດ, ຫຼືຖ້າຫາກວ່າ a ເອກະສານ
operand ແມ່ນ '−', ຫຼືຖ້າ ກ ໂປຣແກມ option-argument ແມ່ນ '−'; ເບິ່ງພາກສ່ວນ INPUT FILES. ຖ້າ
ໄດ້ ງຸ່ມ ໂປລແກລມບໍ່ມີການປະຕິບັດແລະບໍ່ມີຮູບແບບ, ແຕ່ມີຄວາມຖືກຕ້ອງ ງຸ່ມ program,
ການປ້ອນຂໍ້ມູນມາດຕະຖານ ແລະອັນໃດ ເອກະສານ operands ຈະບໍ່ຖືກອ່ານແລະ ງຸ່ມ ຈະ​ອອກ​ດ້ວຍ​ຜົນ​ຕອບ​ແທນ
ສະຖານະຂອງສູນ.

ປັດໄຈນໍາເຂົ້າ ເອກະສານ

ໄຟລ​໌​ເຂົ້າ​ໄປ​ທີ່​ ງຸ່ມ ໂຄງ​ການ​ຈາກ​ແຫຼ່ງ​ໃດ​ຫນຶ່ງ​ດັ່ງ​ຕໍ່​ໄປ​ນີ້​ຈະ​ເປັນ​ໄຟລ​໌​ຂໍ້​ຄວາມ​:

* ໃດໆ ເອກະສານ operands ຫຼືການທຽບເທົ່າຂອງເຂົາເຈົ້າ, ບັນລຸໄດ້ໂດຍການດັດແກ້ ງຸ່ມ ຕົວແປ ARGV
ແລະ ARGC

* ວັດສະດຸປ້ອນມາດຕະຖານໃນກໍລະນີທີ່ບໍ່ມີ ເອກະສານ ໂຕປະຕິບັດການ

* ການໂຕ້ຖຽງກັບ ສາຍ ຫນ້າທີ່

ບໍ່ວ່າຈະເປັນຕົວແປ RS ຖືກຕັ້ງເປັນຄ່າອື່ນທີ່ບໍ່ແມ່ນ a ຫຼືບໍ່, ສໍາລັບໄຟລ໌ເຫຼົ່ານີ້,
ການ​ປະ​ຕິ​ບັດ​ຈະ​ສະ​ຫນັບ​ສະ​ຫນູນ​ການ​ບັນ​ທຶກ​ການ​ສິ້ນ​ສຸດ​ລົງ​ດ້ວຍ​ຕົວ​ແຍກ​ທີ່​ກໍາ​ນົດ​ໄວ້​ເຖິງ
{LINE_MAX} ໄບຕ໌ ແລະອາດຈະຮອງຮັບການບັນທຶກທີ່ຍາວກວ່າ.

If -f ໂປຣແກມ ໄດ້ຖືກລະບຸໄວ້, ຄໍາຮ້ອງສະຫມັກຈະຕ້ອງຮັບປະກັນວ່າໄຟລ໌ທີ່ມີຊື່ໂດຍແຕ່ລະຄົນ
ໄດ້ ໂປຣແກມ option-arguments ແມ່ນໄຟລ໌ຂໍ້ຄວາມແລະການສົມທົບຂອງພວກເຂົາ, ໃນຄໍາສັ່ງດຽວກັນກັບ
ພວກເຂົາເຈົ້າປະກົດຢູ່ໃນການໂຕ້ຖຽງ, ແມ່ນ ງຸ່ມ ໂຄງການ.

ENVIRONMENT ຄວາມຮັບຜິດຊອບ

ຕົວແປສະພາບແວດລ້ອມຕໍ່ໄປນີ້ຈະສົ່ງຜົນກະທົບຕໍ່ການປະຕິບັດ ງຸ່ມ:

ພາສາ ໃຫ້ຄ່າເລີ່ມຕົ້ນສໍາລັບຕົວແປສາກົນທີ່ບໍ່ໄດ້ຕັ້ງ ຫຼື
null. (ເບິ່ງປະລິມານຄໍານິຍາມພື້ນຖານຂອງ POSIX.1-2008, ສ່ວນ 8.2,
Internationalization Variables ​ເພື່ອ​ຄວາມ​ກ້າວໜ້າ​ຂອງ​ການ​ຫັນ​ເປັນ​ສາກົນ
ຕົວແປທີ່ໃຊ້ເພື່ອກໍານົດຄ່າຂອງປະເພດທ້ອງຖິ່ນ.)

LC_ALL ຖ້າຕັ້ງເປັນຄ່າສະຕຣິງທີ່ບໍ່ຫວ່າງເປົ່າ, ລົບລ້າງຄ່າຂອງອັນອື່ນທັງໝົດ
ຕົວແປສາກົນ.

LC_COLLATE
ກໍານົດສະຖານທີ່ສໍາລັບພຶດຕິກໍາຂອງໄລຍະ, ຫ້ອງຮຽນທຽບເທົ່າ, ແລະ multi-
ອົງປະກອບການລວບລວມຕົວອັກສອນພາຍໃນສໍານວນປົກກະຕິແລະການປຽບທຽບຂອງ
ຄ່າສະຕຣິງ.

LC_CTYPE ກໍານົດທ້ອງຖິ່ນສໍາລັບການຕີຄວາມລໍາດັບຂອງ bytes ຂອງຂໍ້ມູນຂໍ້ຄວາມ
ເປັນຕົວອັກສອນ (ຕົວຢ່າງ, single-byte ກົງກັນຂ້າມກັບ multi-byte ຕົວອັກສອນໃນ
arguments ແລະ input ໄຟລ໌), ພຶດຕິກໍາຂອງຫ້ອງຮຽນລັກສະນະພາຍໃນປົກກະຕິ
ການສະແດງອອກ, ການກໍານົດຕົວອັກສອນເປັນຕົວອັກສອນ, ແລະການສ້າງແຜນທີ່
ຕົວພິມໃຫຍ່ແລະຕົວພິມນ້ອຍສໍາລັບ topper ແລະ ລຸ່ມ ປະຕິບັດຫນ້າ.

LC_MESSAGES
ກໍານົດທ້ອງຖິ່ນທີ່ຄວນຈະຖືກນໍາໃຊ້ເພື່ອຜົນກະທົບຕໍ່ຮູບແບບແລະເນື້ອໃນຂອງ
ຂໍ້ຄວາມການວິນິໄສທີ່ຂຽນເປັນຄວາມຜິດພາດມາດຕະຖານ.

LC_NUMERIC
ກໍານົດຕົວອັກສອນ radix ທີ່ໃຊ້ໃນເວລາທີ່ຕີຄວາມຫມາຍການປ້ອນຂໍ້ມູນຕົວເລກ, ປະຕິບັດ
ການປ່ຽນແປງລະຫວ່າງຄ່າຕົວເລກ ແລະສະຕຣິງ, ແລະການຈັດຮູບແບບຜົນຜະລິດຕົວເລກ.
ໂດຍບໍ່ຄໍານຶງເຖິງທ້ອງຖິ່ນ, ໄດ້ ຕົວອັກສອນ (ຕົວອັກສອນຈຸດທົດສະນິຍົມຂອງ
POSIX locale) ແມ່ນຕົວອັກສອນຈຸດທົດສະນິຍົມທີ່ຮັບຮູ້ໃນການປະມວນຜົນ ງຸ່ມ
ໂປລແກລມ (ລວມທັງການມອບຫມາຍໃນການໂຕ້ຖຽງແຖວຄໍາສັ່ງ).

NLSPATH ກໍານົດສະຖານທີ່ຂອງລາຍການຂໍ້ຄວາມສໍາລັບການປະມວນຜົນຂອງ LC_MESSAGES.

PATH ກໍານົດເສັ້ນທາງຄົ້ນຫາໃນເວລາທີ່ຊອກຫາຄໍາສັ່ງປະຕິບັດໂດຍ ລະບົບ(ຕົວຢ່າງ), ຫຼື
ທໍ່ປ້ອນຂໍ້ມູນແລະຜົນຜະລິດ; ເບິ່ງປະລິມານຄໍານິຍາມພື້ນຖານຂອງ POSIX.1-2008, ບົດ
8, ສະພາບແວດລ້ອມ Variables.

ນອກ​ຈາກ​ນັ້ນ​, ຕົວ​ປ່ຽນ​ສະ​ພາບ​ແວດ​ລ້ອມ​ທັງ​ຫມົດ​ຈະ​ໄດ້​ຮັບ​ການ​ສັງ​ເກດ​ເຫັນ​ໂດຍ​ຜ່ານ​ການ​ ງຸ່ມ ຕົວແປ ສະພາບແວດລ້ອມ.

ASYNCHRONOUS ເຫດການ

ເລີ່ມຕົ້ນ.

STDOUT

ລັກສະນະຂອງໄຟລ໌ຜົນຜະລິດແມ່ນຂຶ້ນກັບ ງຸ່ມ ໂຄງການ.

ສະດຸດ

ຄວາມຜິດພາດມາດຕະຖານຈະຖືກນໍາໃຊ້ສໍາລັບຂໍ້ຄວາມວິນິດໄສເທົ່ານັ້ນ.

OUTPUT ເອກະສານ

ລັກສະນະຂອງໄຟລ໌ຜົນຜະລິດແມ່ນຂຶ້ນກັບ ງຸ່ມ ໂຄງການ.

ອະທິບາຍ ລາຍລະອຽດ

ໂດຍລວມ ໂຄງການ ໂຄງສ້າງ
An ງຸ່ມ ໂຄງ​ການ​ແມ່ນ​ປະ​ກອບ​ດ້ວຍ​ຄູ່​ຂອງ​ຮູບ​ແບບ​:

ຮູບແບບ { ການປະຕິບັດ }

ບໍ່ວ່າຈະເປັນຮູບແບບຫຼືການປະຕິບັດ (ລວມທັງຕົວອັກສອນວົງເລັບ) ສາມາດເປັນ
ຖືກລະເວັ້ນ.

ຮູບ​ແບບ​ທີ່​ຂາດ​ຫາຍ​ໄປ​ຈະ​ກົງ​ກັບ​ການ​ບັນ​ທຶກ​ການ​ປ້ອນ​ຂໍ້​ມູນ​ໃດໆ​, ແລະ​ການ​ປະ​ຕິ​ບັດ​ທີ່​ຂາດ​ຫາຍ​ໄປ​ຈະ​ເປັນ​
ເທົ່າກັບ:

{ ພິມ }

ການ​ປະ​ຕິ​ບັດ​ຂອງ​ ງຸ່ມ ໂຄງ​ການ​ຈະ​ເລີ່ມ​ຕົ້ນ​ໂດຍ​ທໍາ​ອິດ​ປະ​ຕິ​ບັດ​ການ​ປະ​ຕິ​ບັດ​ທີ່​ກ່ຽວ​ຂ້ອງ​ກັບ​
ທັງຫມົດ ເລີ່ມຕົ້ນ ຮູບແບບໃນຄໍາສັ່ງທີ່ເຂົາເຈົ້າເກີດຂຶ້ນໃນໂຄງການ. ຫຼັງຈາກນັ້ນແຕ່ລະຄົນ ເອກະສານ operand (ຫຼື
ການ​ປ້ອນ​ຂໍ້​ມູນ​ມາດ​ຕະ​ຖານ​ຖ້າ​ຫາກ​ວ່າ​ບໍ່​ມີ​ໄຟລ​໌​ໄດ້​ຖືກ​ລະ​ບຸ​ໄວ້​) ຈະ​ໄດ້​ຮັບ​ການ​ປຸງ​ແຕ່ງ​ໂດຍ​ການ​ອ່ານ​ຂໍ້​ມູນ​ຈາກ​
ໄຟລ໌ຈົນກວ່າຈະເຫັນຕົວແຍກບັນທຶກ ( ໂດຍຄ່າເລີ່ມຕົ້ນ). ກ່ອນທີ່ຈະທໍາອິດ
ການ​ອ້າງ​ອີງ​ເຖິງ​ພາກ​ສະ​ຫນາມ​ໃນ​ການ​ບັນ​ທຶກ​ໄດ້​ຖືກ​ປະ​ເມີນ​ຜົນ​, ການ​ບັນ​ທຶກ​ຈະ​ຖືກ​ແບ່ງ​ອອກ​ເປັນ​ພາກ​ສະ​ຫນາມ​,
ຕາມກົດລະບຽບໃນ ເປັນປົກກະຕິ ສຳ ນວນ, ການນໍາໃຊ້ມູນຄ່າຂອງ FS ນັ້ນຄືປັດຈຸບັນຢູ່ທີ່
ເວລາທີ່ບັນທຶກໄດ້ຖືກອ່ານ. ແຕ່ລະຮູບແບບໃນໂຄງການຫຼັງຈາກນັ້ນຈະໄດ້ຮັບການປະເມີນຢູ່ໃນ
ຄໍາສັ່ງຂອງການປະກົດຕົວ, ແລະການປະຕິບັດທີ່ກ່ຽວຂ້ອງກັບແຕ່ລະຮູບແບບທີ່ກົງກັບປະຈຸບັນ
ບັນ​ທຶກ​ການ​ປະ​ຕິ​ບັດ​. ການປະຕິບັດສໍາລັບຮູບແບບທີ່ກົງກັນຈະຕ້ອງຖືກປະຕິບັດກ່ອນທີ່ຈະປະເມີນ
ຮູບ​ແບບ​ຕໍ່​ມາ​. ສຸດທ້າຍ, ການກະທໍາທີ່ກ່ຽວຂ້ອງກັບທັງຫມົດ END ຮູບ​ແບບ​ຈະ​ເປັນ​
ປະຕິບັດໃນຄໍາສັ່ງທີ່ເຂົາເຈົ້າເກີດຂຶ້ນໃນໂຄງການ.

ສຳ ນວນ in ງຸ່ມ
ການສະແດງອອກອະທິບາຍການຄິດໄລ່ທີ່ໃຊ້ໃນ ຮູບແບບການ ແລະ ຫຸ້ນ. ໃນຕາຕະລາງຕໍ່ໄປນີ້,
ການປະຕິບັດການສະແດງອອກທີ່ຖືກຕ້ອງແມ່ນໃຫ້ຢູ່ໃນກຸ່ມຈາກລໍາດັບສູງສຸດກ່ອນໄປຫາຕໍ່າສຸດ
ກ່ອນໜ້າສຸດທ້າຍ, ໂດຍມີຕົວປະຕິບັດການກ່ອນໜ້າເທົ່າກັນຈັດກຸ່ມລະຫວ່າງເສັ້ນແນວນອນ. ໃນ
ການ​ປະ​ເມີນ​ຜົນ​ການ​ສະ​ແດງ​ອອກ​, ບ່ອນ​ທີ່​ໄວ​ຍະ​ກອນ​ແມ່ນ​ບໍ່​ຊັດ​ເຈນ​ຢ່າງ​ເປັນ​ທາງ​ການ​, ມີ​ລໍາ​ດັບ​ສູງ​ກວ່າ​
ຜູ້ປະຕິບັດການຈະຖືກປະເມີນກ່ອນຜູ້ປະຕິບັດການທີ່ມີລໍາດັບຕ່ໍາກວ່າ. ໃນຕາຕະລາງນີ້ ຕົວຢ່າງ, expr1,
expr2, ແລະ expr3 ເປັນຕົວແທນຂອງການສະແດງອອກໃດໆ, ໃນຂະນະທີ່ lvalue ເປັນຕົວແທນຂອງຫນ່ວຍງານໃດໆທີ່ສາມາດເປັນ
ມອບຫມາຍໃຫ້ (ນັ້ນແມ່ນ, ຢູ່ເບື້ອງຊ້າຍຂອງຜູ້ປະຕິບັດການມອບຫມາຍ). syntax ທີ່ຊັດເຈນຂອງ
ການສະແດງອອກແມ່ນໃຫ້ຢູ່ໃນ Grammar.

ຕາຕະລາງ 4-1: ສຳ ນວນ in ຫຼຸດລົງ ຄວາມ ສຳ ຄັນກ່ອນ in ງຸ່ມ

┌─────────────────────── ┬──────────────────────── ────────────────── ┬──────────────
│ syntax │ ຊື່ │ ປະເພດ of ຜົນ │ສະມາຄົມ │
├────────────────────── ┼──────────────────── ────────────────────────────────────────┤
│( ຕົວຢ່າງ ) │ ການຈັດກຸ່ມ │ ປະເພດຂອງ ຕົວຢ່າງ │N/A │
├────────────────────── ┼──────────────────── ────────────────────────────────────────┤
│$ຕົວຢ່າງ │ການອ້າງອີງພາກສະຫນາມ │String │N/A │
├────────────────────── ┼──────────────────── ────────────────────────────────────────┤
│lvalue ++ │ Post-increment │ຕົວເລກ │N/A │
│lvalue −− │ Post-decrement │ຕົວເລກ │N/A │
├────────────────────── ┼──────────────────── ────────────────────────────────────────┤
│++ ມູນຄ່າ │ ການເພີ່ມກ່ອນ │ ຕົວເລກ │N/A │
│−− lvalue │ Pre-decrement │ຕົວເລກ │N/A │
├────────────────────── ┼──────────────────── ────────────────────────────────────────┤
│ຕົວຢ່າງ ^ ຕົວຢ່າງ │Exponentiation │ຕົວເລກ │ຂວາ │
├────────────────────── ┼──────────────────── ────────────────────────────────────────┤
│! ຕົວຢ່າງ │ໂລຈິກບໍ່ແມ່ນ │ຕົວເລກ │N/A │
│+ ຕົວຢ່າງ │Unary ບວກ │ຕົວເລກ │N/A │
│− ຕົວຢ່າງ │Unary ລົບ │ຕົວເລກ │N/A │
├────────────────────── ┼──────────────────── ────────────────────────────────────────┤
│ຕົວຢ່າງ * ຕົວຢ່າງ │ການຄູນ │ຕົວເລກ │ຊ້າຍ │
│ຕົວຢ່າງ / ຕົວຢ່າງ │ ການແບ່ງ │ ຕົວເລກ │ ຊ້າຍ │
│ຕົວຢ່າງ % ຕົວຢ່າງ │ໂມດູລ │ຕົວເລກ │ຊ້າຍ │
├────────────────────── ┼──────────────────── ────────────────────────────────────────┤
│ຕົວຢ່າງ + ຕົວຢ່າງ │ການເພີ່ມ │ຕົວເລກ │ຊ້າຍ │
│ຕົວຢ່າງ - ຕົວຢ່າງ │ການລົບ │ຕົວເລກ │ຊ້າຍ │
├────────────────────── ┼──────────────────── ────────────────────────────────────────┤
│ຕົວຢ່າງ ຕົວຢ່າງ │ String concatenation │String │ຊ້າຍ │
├────────────────────── ┼──────────────────── ────────────────────────────────────────┤
│ຕົວຢ່າງ < ຕົວຢ່າງ │ນ້ອຍກວ່າ │ຕົວເລກ │None │
│ຕົວຢ່າງ <= ຕົວຢ່າງ │ນ້ອຍກວ່າ ຫຼືເທົ່າກັບ │ຕົວເລກ │ບໍ່ມີ │
│ຕົວຢ່າງ != ຕົວຢ່າງ │ບໍ່ເທົ່າກັບ │ຕົວເລກ │None │
│ຕົວຢ່າງ == ຕົວຢ່າງ │ເທົ່າກັບ │ຕົວເລກ │None │
│ຕົວຢ່າງ > ຕົວຢ່າງ │ໃຫຍ່ກວ່າ │ຕົວເລກ │None │
│ຕົວຢ່າງ >= ຕົວຢ່າງ │ໃຫຍ່ກວ່າ ຫຼືເທົ່າກັບ │ຕົວເລກ │ບໍ່ມີ │
├────────────────────── ┼──────────────────── ────────────────────────────────────────┤
│ຕົວຢ່າງ ~ ຕົວຢ່າງ │ERE ກົງກັນ │ຕົວເລກ │None │
│ຕົວຢ່າງ !~ ຕົວຢ່າງ │ERE ບໍ່ກົງກັນ │ຕົວເລກ │ບໍ່ມີ │
├────────────────────── ┼──────────────────── ────────────────────────────────────────┤
│ຕົວຢ່າງ ໃນອາເຣ │ສະມາຊິກອາເຣ │ຕົວເລກ │ຊ້າຍ │
│( ດັດຊະນີ in array │ອະເຣຫຼາຍມິຕິ │ຕົວເລກ │ຊ້າຍ │
│ │ ສະມາຊິກ │ │ │
├────────────────────── ┼──────────────────── ────────────────────────────────────────┤
│ຕົວຢ່າງ && ຕົວຢ່າງ │ໂລຈິກ ແລະ │ຕົວເລກ │ຊ້າຍ │
├────────────────────── ┼──────────────────── ────────────────────────────────────────┤
│ຕົວຢ່າງ || ຕົວຢ່າງ │ໂລຈິກ ຫຼື │ຕົວເລກ │ຊ້າຍ │
├────────────────────── ┼──────────────────── ────────────────────────────────────────┤
│expr1 ? expr2 : expr3│ການສະແດງອອກຕາມເງື່ອນໄຂ │ປະເພດຂອງການເລືອກ│ຂວາ │
│ │ │expr2 or expr3 ││
├────────────────────── ┼──────────────────── ────────────────────────────────────────┤
│lvalue ^= ຕົວຢ່າງ │ ການມອບໝາຍເລກກຳລັງ │ ຕົວເລກ │ ຂວາ │
│lvalue %= ຕົວຢ່າງ │ ການກຳນົດໂມດູລ │ ຕົວເລກ │ ຂວາ │
│lvalue *= ຕົວຢ່າງ │ການມອບໝາຍການຄູນ│ຕົວເລກ │ຂວາ │
│lvalue /= ຕົວຢ່າງ │ ການມອບໝາຍການແບ່ງ │ ຕົວເລກ │ ຂວາ │
│lvalue += ຕົວຢ່າງ │ການມອບໝາຍເພີ່ມເຕີມ │ຕົວເລກ │ຂວາ │
│lvalue −= ຕົວຢ່າງ │ ການມອບໝາຍການລົບ │ ຕົວເລກ │ ຂວາ │
│lvalue = ຕົວຢ່າງ │ການມອບໝາຍ │ປະເພດຂອງ ຕົວຢ່າງ │ຂວາ│
└────────────────────── ┴──────────────────────── ────────────────────────────────────────┘
ແຕ່ລະສະແດງອອກຈະຕ້ອງມີຄ່າສະຕຣິງ, ຄ່າຕົວເລກ, ຫຼືທັງສອງ. ຍົກເວັ້ນເປັນ
ລະບຸໄວ້ສໍາລັບສະພາບການສະເພາະ, ມູນຄ່າຂອງການສະແດງຜົນຈະຖືກປ່ຽນເປັນ implicitly
ປະເພດທີ່ຈໍາເປັນສໍາລັບສະພາບການທີ່ມັນຖືກນໍາໃຊ້. ຄ່າສະຕຣິງຈະຖືກປ່ຽນເປັນ
ຄ່າທີ່ເປັນຕົວເລກເທົ່າກັບການເອີ້ນຕໍ່ໄປນີ້ໄປຫາຫນ້າທີ່ກໍານົດໂດຍ
ມາດຕະຖານ ISO C:

setlocale(LC_NUMERIC, "");
numeric_value = atof(string_value);

ຫຼືໂດຍການປ່ຽນສ່ວນເບື້ອງຕົ້ນຂອງສະຕຣິງເປັນປະເພດ double ການເປັນຕົວແທນ
ຕໍ່ໄປນີ້:

ສາຍປ້ອນຂໍ້ມູນຖືກແຍກອອກເປັນສອງສ່ວນ: ເບື້ອງຕົ້ນ, ອາດຈະຫວ່າງເປົ່າ, ລໍາດັບ
ຂອງຕົວອັກສອນຊ່ອງຫວ່າງ (ຕາມທີ່ລະບຸໄວ້ໂດຍ ພື້ນທີ່ຫວ່າງ()) ແລະລໍາດັບວິຊາ
ແປເປັນຄ່າຄົງທີ່ຈຸດທີ່ລອຍຕົວ.

ຮູບແບບທີ່ຄາດໄວ້ຂອງລຳດັບວິຊາແມ່ນເປັນທາງເລືອກ '+' or '−' ເຊັນ, ຈາກນັ້ນ ກ
ລໍາດັບບໍ່ຫວ່າງເປົ່າຂອງຕົວເລກທາງເລືອກທີ່ມີ a , ຫຼັງຈາກນັ້ນເປັນທາງເລືອກ
ສ່ວນ exponent. ພາກສ່ວນເລກກຳລັງປະກອບດ້ວຍ 'ອີ' or 'ອີ', ຕາມດ້ວຍທາງເລືອກ
ເຄື່ອງໝາຍ, ຕາມດ້ວຍຕົວເລກທົດສະນິຍົມໜຶ່ງ ຫຼື ຫຼາຍໂຕ.

ລໍາດັບທີ່ເລີ່ມຕົ້ນດ້ວຍຕົວເລກທໍາອິດຫຼືຕົວເລກ (ອັນໃດເກີດຂຶ້ນກ່ອນ)
ຖືກຕີຄວາມໝາຍວ່າເປັນຄ່າຄົງທີ່ທີ່ເລື່ອນໄດ້ຂອງພາສາ C, ແລະຖ້າບໍ່ແມ່ນຕົວຊີ້ບອກ
ສ່ວນ ຫຼື ກ ປະກົດວ່າ, ກ ສົມມຸດວ່າປະຕິບັດຕາມຕົວເລກສຸດທ້າຍໃນ
ສາຍ. ຖ້າລໍາດັບຫົວຂໍ້ເລີ່ມຕົ້ນດ້ວຍເຄື່ອງຫມາຍລົບ, ຄ່າທີ່ມາຈາກ
ການ​ປ່ຽນ​ແປງ​ແມ່ນ​ລົບ​ກວນ​.

ຄ່າຕົວເລກທີ່ເທົ່າກັບຄ່າຂອງຈຳນວນເຕັມ (ເບິ່ງ ສ່ວນ 1.1.2,
ແນວຄິດ ມາຈາກ ຈາກ ໄດ້ ISO C ມາດຕະຖານ) ຈະຖືກປ່ຽນເປັນສະຕຣິງໂດຍຄ່າທຽບເທົ່າ
ຂອງການໂທຫາ ແລ່ນ ຫນ້າທີ່ (ເບິ່ງ string ຫນ້າທີ່) ກັບຊ່ອຍແນ່ "%d" ເປັນ fmt
argument ແລະຄ່າຕົວເລກທີ່ຖືກແປງເປັນຄັ້ງທໍາອິດແລະດຽວ ຕົວຢ່າງ ການໂຕ້ຖຽງ. ໃດ
ຄ່າຕົວເລກອື່ນຈະຖືກປ່ຽນເປັນສະຕຣິງໂດຍທຽບເທົ່າກັບການໂທຫາ
ແລ່ນ function ກັບຄ່າຂອງຕົວແປ CONVFMT ເປັນ fmt ການໂຕ້ຖຽງແລະ
ຄ່າຕົວເລກຖືກປ່ຽນເປັນຄ່າທຳອິດ ແລະອັນດຽວ ຕົວຢ່າງ ການໂຕ້ຖຽງ. ຜົນໄດ້ຮັບຂອງ
ການປ່ຽນໃຈເຫລື້ອມໃສແມ່ນບໍ່ໄດ້ກໍານົດຖ້າຫາກວ່າມູນຄ່າຂອງ CONVFMT ບໍ່ແມ່ນຮູບແບບຈຸດລອຍ
ສະເພາະ. ປະລິມານນີ້ຂອງ POSIX.1-2008 ກໍານົດບໍ່ມີການແປງຢ່າງຊັດເຈນລະຫວ່າງ
ຕົວເລກ ແລະສາຍ. ແອັບພລິເຄຊັນສາມາດບັງຄັບການສະແດງອອກທີ່ຈະຖືກປະຕິບັດເປັນຕົວເລກໂດຍ
ເພີ່ມສູນໃສ່ມັນ, ຫຼືສາມາດບັງຄັບໃຫ້ມັນຖືກປະຕິບັດເປັນ string ໂດຍການ concatenating null
ສະຕຣິງ ("") ກັບ​ມັນ​.

ຄ່າສະຕຣິງຈະຖືກພິຈາລະນາເປັນ numeric string ຖ້າມັນມາຈາກຫນຶ່ງໃນຕໍ່ໄປນີ້:

1. ຕົວແປພາກສະຫນາມ

2. ການປ້ອນຂໍ້ມູນຈາກ ສາຍ() ໜ້າ ທີ່

3. ຊື່​ເອ​ກະ​ສານ

4. ARGV ອົງປະກອບຂບວນ

5. ສະພາບແວດລ້ອມ ອົງປະກອບຂບວນ

6. ອົງປະກອບ Array ສ້າງໂດຍ ແບ່ງປັນ() ໜ້າ ທີ່

7. ການມອບໝາຍຕົວແປຂອງແຖວຄຳສັ່ງ

8. ການມອບໝາຍຕົວແປຈາກຕົວແປສະຕຣິງຕົວເລກອື່ນ

ແລະເງື່ອນໄຂການຈັດຕັ້ງປະຕິບັດທີ່ສອດຄ່ອງກັບກໍລະນີ (a) ຫຼື (b) ຂ້າງລຸ່ມນີ້ແມ່ນ
ໄດ້ພົບ.

ກ. ຫຼັງ​ຈາກ​ການ​ທຽບ​ເທົ່າ​ຂອງ​ການ​ເອີ້ນ​ຕໍ່​ໄປ​ນີ້​ເພື່ອ​ທໍາ​ງານ​ທີ່​ກໍາ​ນົດ​ໂດຍ ISO C​
ມາດຕະຖານ, string_value_end ຈະແຕກຕ່າງຈາກ string_value, ແລະຕົວອັກສອນໃດໆກ່ອນ
ຕົວອັກສອນ null ສິ້ນສຸດໃນ string_value_end ຈະເປັນ ຕົວອັກສອນ:

char *string_value_end;
setlocale(LC_NUMERIC, "");
numeric_value = strtod (string_value, &string_value_end);

ຂ. ຫຼັງ​ຈາກ​ການ​ປ່ຽນ​ແປງ​ທັງ​ຫມົດ​ດັ່ງ​ຕໍ່​ໄປ​ນີ້​ໄດ້​ຖືກ​ນໍາ​ໃຊ້​, ສະ​ຕ​ຣິງ​ຜົນ​ໄດ້​ຮັບ​ຈະ​
lexically ໄດ້ຮັບການຍອມຮັບວ່າເປັນ NUMBER token ດັ່ງທີ່ອະທິບາຍໂດຍສົນທິສັນຍາ lexical ໃນ
Grammar:

-- ທັງ​ຫມົດ​ນໍາ​ຫນ້າ​ແລະ​ຕິດ​ຕາມ​ ຕົວອັກສອນຖືກຍົກເລີກ.

-- ຖ້າ​ຫາກ​ວ່າ​ທໍາ​ອິດ​ທີ່​ບໍ່​ແມ່ນ ແມ່ນ '+' or '−', ມັນໄດ້ຖືກຍົກເລີກ.

-- ແຕ່ລະການປະກົດຕົວຂອງຕົວອັກສອນຈຸດທົດສະນິຍົມຈາກທ້ອງຖິ່ນປະຈຸບັນມີການປ່ຽນແປງ
ເປັນ .
ໃນກໍລະນີ (a) ຄ່າຕົວເລກຂອງ numeric string ຈະເປັນມູນຄ່າທີ່ຈະເປັນ
ກັບຄືນໂດຍ strtod() ໂທ. ໃນ​ກໍ​ລະ​ນີ (b​) ຖ້າ​ຫາກ​ວ່າ​ຄັ້ງ​ທໍາ​ອິດ​ບໍ່​ແມ່ນ ແມ່ນ '−', ຕົວເລກ
ມູນຄ່າຂອງ numeric string ຈະຕ້ອງເປັນການປະຕິເສດຂອງມູນຄ່າຕົວເລກຂອງການຮັບຮູ້
NUMBER ໂທເຄັນ; ຖ້າບໍ່ດັ່ງນັ້ນ, ຄ່າຕົວເລກຂອງ numeric string ຈະເປັນຕົວເລກ
ມູນ​ຄ່າ​ຂອງ​ການ​ຮັບ​ຮູ້​ NUMBER ໂທເຄັນ. ບໍ່ວ່າຈະເປັນ string a numeric string ຈະເປັນ
ທີ່ກ່ຽວຂ້ອງພຽງແຕ່ໃນສະພາບການທີ່ຄໍາທີ່ໃຊ້ໃນພາກນີ້.

ເມື່ອການສະແດງອອກຖືກໃຊ້ໃນບໍລິບົດ Boolean, ຖ້າມັນມີມູນຄ່າຕົວເລກ, ຄ່າຂອງ
ສູນຈະຖືກຖືວ່າບໍ່ຖືກຕ້ອງ ແລະຄ່າອື່ນໆຈະຖືກຖືວ່າເປັນຄວາມຈິງ. ຖ້າບໍ່ດັ່ງນັ້ນ, ກ
ຄ່າສະຕຣິງຂອງສະຕຣິງ null ຈະຖືກຖືວ່າເປັນ false ແລະຄ່າອື່ນໆຈະເປັນ
ຖືວ່າເປັນຄວາມຈິງ. ບໍລິບົດ Boolean ຈະຕ້ອງເປັນຫນຶ່ງໃນຕໍ່ໄປນີ້:

* ການສະແດງອອກທຳອິດຂອງການສະແດງອອກຕາມເງື່ອນໄຂ

* ການສະແດງອອກທີ່ດໍາເນີນການໂດຍບໍ່ມີເຫດຜົນ, ມີເຫດຜົນ AND, ຫຼືເຫດຜົນ OR

* ການສະແດງອອກທີສອງຂອງ a ສໍາລັບການ ຄໍາຖະແຫຼງທີ່

* ການສະແດງອອກຂອງ an if ຄໍາຖະແຫຼງທີ່

* ການສະແດງອອກຂອງ ໃນຂະນະທີ່ ຂໍ້​ຄວາມ​ໃນ​ທັງ a ໃນຂະນະທີ່ or do...ໃນຂະນະທີ່ ຄໍາຖະແຫຼງທີ່

* ສະ​ແດງ​ອອກ​ທີ່​ນໍາ​ໃຊ້​ເປັນ​ຮູບ​ແບບ (ເຊັ່ນ​ດຽວ​ກັນ​ກັບ​ໂຄງ​ສ້າງ​ໂຄງ​ການ​ລວມ​)

ເລກເລກທັງໝົດຕ້ອງປະຕິບັດຕາມທາງເລກໝາຍຂອງເລກເລກທີ່ລອຍຕົວຕາມທີ່ກຳນົດໄວ້
ມາດຕະຖານ ISO C (ເບິ່ງ ສ່ວນ 1.1.2, ແນວຄິດ ມາຈາກ ຈາກ ໄດ້ ISO C ມາດຕະຖານ).

ຄ່າຂອງການສະແດງຜົນ:

expr1 ^ expr2

ຈະເທົ່າກັບຄ່າທີ່ສົ່ງຄືນໂດຍການເອີ້ນຟັງຊັນມາດຕະຖານ ISO C:

pow(expr1, expr2)

ການສະແດງອອກ:

ມູນຄ່າ ^= ຕົວຢ່າງ

ຈະທຽບເທົ່າກັບການສະແດງອອກມາດຕະຖານ ISO C:

ມູນຄ່າ = pow(ມູນຄ່າ, ຕົວຢ່າງ)

ຍົກເວັ້ນມູນຄ່ານັ້ນຈະຖືກປະເມີນພຽງແຕ່ຄັ້ງດຽວ. ຄ່າຂອງການສະແດງຜົນ:

expr1 % expr2

ຈະເທົ່າກັບຄ່າທີ່ສົ່ງຄືນໂດຍການເອີ້ນຟັງຊັນມາດຕະຖານ ISO C:

fmod(expr1, expr2)

ການສະແດງອອກ:

ມູນຄ່າ %= ຕົວຢ່າງ

ຈະທຽບເທົ່າກັບການສະແດງອອກມາດຕະຖານ ISO C:

ມູນຄ່າ = fmod(ມູນຄ່າ, ຕົວຢ່າງ)

ຍົກເວັ້ນມູນຄ່ານັ້ນຈະຖືກປະເມີນພຽງແຕ່ຄັ້ງດຽວ.

ຕົວແປ ແລະຊ່ອງຂໍ້ມູນຈະຖືກກຳນົດໂດຍຄຳຖະແຫຼງການມອບໝາຍ:

ມູນຄ່າ = ການສະແດງອອກ

ແລະປະເພດຂອງ ການສະແດງອອກ ຈະຕ້ອງກໍານົດປະເພດຕົວແປຜົນໄດ້ຮັບ. ການມອບຫມາຍ
ລວມເຖິງການມອບໝາຍເລກເລກ ("+=", "−=", "*=", "/=", "%=", "^=", "++", "−−") ທັງ​ຫມົດ​
ຊຶ່ງໃນນັ້ນຈະສ້າງຜົນໄດ້ຮັບເປັນຕົວເລກ. ດ້ານຊ້າຍມືຂອງການມອບຫມາຍແລະ
ເປົ້າໝາຍຂອງຕົວປະຕິບັດການເພີ່ມຂຶ້ນ ແລະການຫຼຸດລົງສາມາດເປັນຕົວແປອັນໜຶ່ງ, ອາເຣທີ່ມີດັດຊະນີ,
ຫຼືຕົວເລືອກພາກສະຫນາມ.

ໄດ້ ງຸ່ມ arrays ສະຫນອງພາສາທີ່ໃຊ້ສໍາລັບການເກັບຮັກສາຕົວເລກຫຼືສາຍ. ອາເຣ
ບໍ່​ຈໍາ​ເປັນ​ຕ້ອງ​ໄດ້​ຮັບ​ການ​ປະ​ກາດ​. ໃນເບື້ອງຕົ້ນພວກມັນຈະຫວ່າງເປົ່າ, ແລະຂະຫນາດຂອງພວກມັນຈະປ່ຽນແປງ
ແບບເຄື່ອນໄຫວ. subscripts, ຫຼືຕົວລະບຸອົງປະກອບ, ແມ່ນ strings, ສະຫນອງປະເພດຂອງ
ຄວາມ​ສາ​ມາດ array ການ​ຮ່ວມ​ມື​. ຊື່ array ຕິດຕາມດ້ວຍ subscript ພາຍໃນວົງເລັບສີ່ຫຼ່ຽມ
ສາມາດຖືກນໍາໃຊ້ເປັນມູນຄ່າແລະດັ່ງນັ້ນຈຶ່ງເປັນການສະແດງອອກ, ດັ່ງທີ່ໄດ້ອະທິບາຍໄວ້ໃນໄວຍະກອນ; ເບິ່ງ
Grammar. ຊື່ array unsubscripted ສາມາດນໍາໃຊ້ໄດ້ພຽງແຕ່ໃນສະພາບການດັ່ງຕໍ່ໄປນີ້:

* ພາລາມິເຕີໃນຄໍານິຍາມຟັງຊັນຫຼືການເອີ້ນຟັງຊັນ

* The NAME token ປະຕິບັດຕາມການນໍາໃຊ້ຄໍາສໍາຄັນໃດໆ in ຕາມທີ່ລະບຸໄວ້ໃນໄວຍະກອນ (ເບິ່ງ
Grammar); ຖ້າຊື່ທີ່ໃຊ້ໃນບໍລິບົດນີ້ບໍ່ແມ່ນຊື່ array, ພຶດຕິກໍາແມ່ນ
undefined

array ທີ່ຖືກຕ້ອງ ດັດຊະນີ ຈະປະກອບດ້ວຍຫນຶ່ງຫຼືຫຼາຍກວ່ານັ້ນ - ການ​ສະ​ແດງ​ອອກ​ທີ່​ແຍກ​ອອກ​, ຄ້າຍ​ຄື​ກັນ​ກັບ​
ວິທີການທີ່ arrays ຫຼາຍມິຕິລະດັບຖືກດັດສະນີໃນບາງພາສາການຂຽນໂປຼແກຼມ.
ເນື່ອງຈາກວ່າ ງຸ່ມ arrays ແມ່ນແທ້ຫນຶ່ງມິຕິລະດັບ, ເຊັ່ນ: - ບັນ​ຊີ​ລາຍ​ຊື່​ແຍກ​ອອກ​ຈະ​ເປັນ​
ປ່ຽນເປັນສະຕຣິງດຽວໂດຍການລວມຄ່າສະຕຣິງຂອງຕົວແຍກ
ການສະແດງອອກ, ແຕ່ລະຄົນແຍກອອກຈາກອື່ນໆໂດຍມູນຄ່າຂອງ SUBSEP ຕົວແປ. ດັ່ງນັ້ນ, ໄດ້
ການປະຕິບັດດັດຊະນີສອງອັນຕໍ່ໄປນີ້ຈະທຽບເທົ່າ:

var[expr1, expr2, ... exprn]

var[expr1 SUBSEP expr2 SUBSEP ... SUBSEP exprn]

ຄໍາຮ້ອງສະຫມັກຈະຕ້ອງຮັບປະກັນວ່າມີຫຼາຍມິຕິລະດັບ ດັດຊະນີ ໃຊ້ກັບ in ຜູ້ປະກອບການແມ່ນ
ວົງເລັບ. ໄດ້ in operator, ເຊິ່ງທົດສອບການມີຢູ່ຂອງ array ໂດຍສະເພາະ
ອົງປະກອບ, ຈະບໍ່ເຮັດໃຫ້ອົງປະກອບນັ້ນມີ. ການອ້າງອີງອື່ນໆຕໍ່ກັບອາເຣທີ່ບໍ່ມີຢູ່
ອົງປະກອບຈະສ້າງມັນໂດຍອັດຕະໂນມັດ.

ການປຽບທຽບ (ກັບ '<', "<=", "!=", "==", '>', ແລະ ">=" ຜູ້ປະກອບການ) ຈະຖືກເຮັດ
ຕົວເລກຖ້າຕົວປະຕິບັດທັງສອງເປັນຕົວເລກ, ຖ້າອັນໃດອັນໜຶ່ງເປັນຕົວເລກ ແລະອີກອັນໜຶ່ງມີສະຕຣິງ
ຄ່າທີ່ເປັນຕົວເລກເປັນສະຕຣິງ, ຫຼືຖ້າອັນໜຶ່ງເປັນຕົວເລກ ແລະອີກອັນໜຶ່ງມີ uninitialized
ຄ່າ. ຖ້າບໍ່ດັ່ງນັ້ນ, operands ຈະຖືກປ່ຽນເປັນ strings ຕາມຄວາມຕ້ອງການ ແລະ string
ການປຽບທຽບຈະຕ້ອງຖືກເຮັດໂດຍໃຊ້ລຳດັບການລວມກັນສະເພາະທ້ອງຖິ່ນ. ມູນຄ່າຂອງ
ການສະແດງຜົນການປຽບທຽບຈະຕ້ອງເປັນ 1 ຖ້າຄວາມສຳພັນເປັນຈິງ, ຫຼື 0 ຖ້າຄວາມສຳພັນເປັນຜິດ.

Variables ແລະ ພິເສດ Variables
ຕົວແປສາມາດຖືກນໍາໃຊ້ໃນ ງຸ່ມ ໂຄງ​ການ​ໂດຍ​ການ​ອ້າງ​ອີງ​ໃຫ້​ເຂົາ​ເຈົ້າ​. ມີຂໍ້ຍົກເວັ້ນຂອງ
ຕົວກໍານົດການທໍາງານ (ເບິ່ງ ຜູ້ໃຊ້ກໍານົດ ຫນ້າທີ່), ພວກເຂົາບໍ່ໄດ້ຖືກປະກາດຢ່າງຈະແຈ້ງ.
ຊື່ພາລາມິເຕີການທໍາງານຈະຕ້ອງຢູ່ໃນທ້ອງຖິ່ນຂອງຫນ້າທີ່; ຊື່ຕົວແປອື່ນໆທັງໝົດຈະຕ້ອງເປັນ
ທົ່ວໂລກ. ຊື່ດຽວກັນຈະບໍ່ຖືກໃຊ້ເປັນທັງຊື່ພາລາມິເຕີຟັງຊັນ ແລະເປັນຊື່
ຂອງຫນ້າທີ່ຫຼືພິເສດ ງຸ່ມ ຕົວແປ. ຊື່ດຽວກັນຈະບໍ່ຖືກນໍາໃຊ້ທັງສອງເປັນ
ຊື່ຕົວແປທີ່ມີຂອບເຂດທົ່ວໂລກ ແລະເປັນຊື່ຂອງຟັງຊັນ. ຊື່ດຽວກັນຈະບໍ່ເປັນ
ໃຊ້ພາຍໃນຂອບເຂດດຽວກັນທັງເປັນຕົວແປ scalar ແລະເປັນ array. ບໍ່ໄດ້ຕັ້ງຕົ້ນ
ຕົວແປ, ລວມທັງຕົວແປ scalar, ອົງປະກອບອາເຣ, ແລະຕົວແປພາກສະຫນາມ, ຕ້ອງມີ
ມູນ​ຄ່າ unitialized. ຄ່າ uninitialized ຕ້ອງມີທັງຄ່າຕົວເລກຂອງສູນ ແລະ a
ຄ່າສະຕຣິງຂອງສະຕຣິງຫວ່າງເປົ່າ. ການ​ປະ​ເມີນ​ຜົນ​ຂອງ​ຕົວ​ແປ​ທີ່​ມີ​ມູນ​ຄ່າ uninitialized​, ກັບ​
ບໍ່ວ່າຈະເປັນສະຕຣິງ ຫຼືຕົວເລກ, ຈະຕ້ອງຖືກກໍານົດໂດຍບໍລິບົດທີ່ພວກມັນຖືກນໍາໃຊ້.

ຕົວແປພາກສະຫນາມຈະຕ້ອງຖືກກໍານົດໂດຍ a '$' ຕິດຕາມດ້ວຍຕົວເລກ ຫຼື ຕົວເລກ.
ຜົນກະທົບຂອງຕົວເລກພາກສະຫນາມ ການສະແດງອອກ ການ​ປະ​ເມີນ​ຜົນ​ກັບ​ສິ່ງ​ອື່ນ​ນອກ​ຈາກ​ບໍ່​ແມ່ນ​ທາງ​ລົບ​
ຈຳນວນເຕັມແມ່ນບໍ່ໄດ້ລະບຸ; ຕົວແປ uninitialized ຫຼືຄ່າ string ບໍ່ຈໍາເປັນຕ້ອງຖືກປ່ຽນເປັນ
ຄ່າຕົວເລກໃນສະພາບການນີ້. ຕົວແປພາກສະຫນາມໃຫມ່ສາມາດຖືກສ້າງຂື້ນໂດຍການກໍາຫນົດຄ່າໃຫ້
ເຂົາເຈົ້າ. ການອ້າງອິງໃສ່ຊ່ອງຂໍ້ມູນທີ່ບໍ່ມີຢູ່ (ນັ້ນແມ່ນ, ຊ່ອງຂໍ້ມູນຫຼັງຈາກ $NF), ຈະ​ປະ​ເມີນ​ຜົນ​
ມູນ​ຄ່າ unitialized. ການອ້າງອີງດັ່ງກ່າວຈະບໍ່ສ້າງຊ່ອງຂໍ້ມູນໃຫມ່. ຢ່າງໃດກໍ່ຕາມ, ການມອບຫມາຍໃຫ້ ກ
ຊ່ອງຂໍ້ມູນທີ່ບໍ່ມີຢູ່ (ຕົວຢ່າງ, $(NF+2)=5) ຈະເພີ່ມມູນຄ່າຂອງ NF; ສ້າງໃດໆ
intervening ທົ່ງນາທີ່ມີມູນຄ່າ uninitialized; ແລະເຮັດໃຫ້ມູນຄ່າຂອງ $0 ເປັນ
recomputed, ກັບພາກສະຫນາມຈະຖືກແຍກອອກໂດຍມູນຄ່າຂອງ FSO. ຕົວແປແຕ່ລະຊ່ອງຂໍ້ມູນ
ຈະມີຄ່າສະຕຣິງ ຫຼືຄ່າທີ່ຍັງບໍ່ທັນໄດ້ສ້າງຂຶ້ນເມື່ອສ້າງ. ຕົວແປພາກສະຫນາມຈະຕ້ອງ
ມີມູນຄ່າ uninitialized ເມື່ອສ້າງຈາກ $0 ໂດຍໃຊ້ FS ແລະຕົວແປບໍ່ໄດ້
ມີຕົວອັກສອນໃດນຶ່ງ. ຖ້າເຫມາະສົມ, ຕົວແປພາກສະຫນາມຈະຖືກພິຈາລະນາເປັນຕົວເລກ
string (ເບິ່ງ ສຳ ນວນ in ງຸ່ມ).

ການຈັດຕັ້ງປະຕິບັດຈະຕ້ອງສະຫນັບສະຫນູນຕົວແປພິເສດອື່ນໆທີ່ຖືກກໍານົດໂດຍ ງຸ່ມ:

ARGC ຈໍານວນຂອງອົງປະກອບໃນ ARGV ຂບວນ.

ARGV array ຂອງ arguments ເສັ້ນຄໍາສັ່ງ, ບໍ່ລວມທາງເລືອກແລະ ໂຄງການ ການໂຕ້ຖຽງ,
ເລກຈາກສູນຫາ ARGC-1

ການໂຕ້ຖຽງໃນ ARGV ສາມາດດັດແກ້ຫຼືເພີ່ມໃສ່; ARGC ສາມາດປ່ຽນແປງໄດ້. ເປັນແຕ່ລະຄົນ
ໄຟລ໌ປ້ອນຂໍ້ມູນສິ້ນສຸດ, ງຸ່ມ ຈະປະຕິບັດຕໍ່ອົງປະກອບທີ່ບໍ່ແມ່ນ null ຂອງ ARGV, ເຖິງ
ມູນຄ່າປັດຈຸບັນຂອງ ARGC−1, ຮວມ, ເປັນຊື່ຂອງໄຟລ໌ປ້ອນຂໍ້ມູນຕໍ່ໄປ. ດັ່ງນັ້ນ,
ການ​ຕັ້ງ​ຄ່າ​ອົງ​ປະ​ກອບ​ຂອງ​ ARGV to null ຫມາຍຄວາມວ່າມັນຈະບໍ່ຖືກປະຕິບັດເປັນ
ໄຟລ໌ປ້ອນຂໍ້ມູນ. ຊື່ '−' ຊີ້ບອກການປ້ອນຂໍ້ມູນມາດຕະຖານ. ຖ້າການໂຕ້ຖຽງກົງກັນ
ຮູບ​ແບບ​ຂອງ​ການ​ ການມອບຫມາຍ operand, ການໂຕ້ຖຽງນີ້ຈະຖືກປະຕິບັດເປັນ
ການມອບຫມາຍ ແທນທີ່ຈະກ ເອກະສານ ການໂຕ້ຖຽງ.

CONVFMT ໄດ້ printf ຮູບ​ແບບ​ສໍາ​ລັບ​ການ​ປ່ຽນ​ຕົວ​ເລກ​ເປັນ​ສະ​ຕ​ຣິງ (ຍົກ​ເວັ້ນ​ສໍາ​ລັບ​ການ​ຜະ​ລິດ​ຕະ​ພັນ​
ຖະແຫຼງການ, ບ່ອນທີ່ OFMT ຖືກນໍາໃຊ້); "%.6g" ໂດຍຄ່າເລີ່ມຕົ້ນ

ສະພາບແວດລ້ອມ array ທີ່ເປັນຕົວແທນຂອງມູນຄ່າຂອງສະພາບແວດລ້ອມ, ດັ່ງທີ່ອະທິບາຍໄວ້ໃນ exec
ຟັງຊັນທີ່ກຳນົດໄວ້ໃນປະລິມານສ່ວນຕິດຕໍ່ລະບົບຂອງ POSIX.1-2008. ດັດຊະນີ
ຂອງອາເຣຈະຕ້ອງເປັນສາຍທີ່ປະກອບດ້ວຍຊື່ຂອງສະພາບແວດລ້ອມ
ຕົວແປ, ແລະຄ່າຂອງແຕ່ລະອົງປະກອບ array ຈະເປັນ string ປະກອບດ້ວຍ
ຄ່າຂອງຕົວແປນັ້ນ. ຖ້າເຫມາະສົມ, ສະພາບແວດລ້ອມຈະມີການປ່ຽນແປງ
ພິຈາລະນາເປັນ numeric string (ເບິ່ງ ສຳ ນວນ in ງຸ່ມ); ອົງປະກອບ array ຈະ
ຍັງມີມູນຄ່າຕົວເລກຂອງມັນ.

ໃນທຸກກໍລະນີທີ່ພຶດຕິກໍາຂອງ ງຸ່ມ ໄດ້ຮັບຜົນກະທົບຈາກຕົວແປສະພາບແວດລ້ອມ
(ລວມທັງສະພາບແວດລ້ອມຂອງຄໍາສັ່ງໃດໆ ງຸ່ມ ປະຕິບັດໂດຍຜ່ານ ລະບົບ
ການທໍາງານຫຼືໂດຍຜ່ານທໍ່ redirections ກັບ ພິມ ຖະແຫຼງການ, printf
ຖະແຫຼງການ, ຫຼື ສາຍ function), ສະພາບແວດລ້ອມທີ່ໃຊ້ຈະຕ້ອງເປັນ
ສະພາບແວດລ້ອມໃນເວລານັ້ນ ງຸ່ມ ເລີ່ມປະຕິບັດ; ມັນ​ແມ່ນ​ການ​ປະ​ຕິ​ບັດ​ກໍາ​ນົດ​
ບໍ່ວ່າຈະເປັນການປ່ຽນແປງໃດໆຂອງ ສະພາບແວດລ້ອມ ຜົນກະທົບຕໍ່ສະພາບແວດລ້ອມນີ້.

ຊື່​ເອ​ກະ​ສານ ຊື່ເສັ້ນທາງຂອງໄຟລ໌ປ້ອນຂໍ້ມູນປັດຈຸບັນ. ພາຍໃນ ກ ເລີ່ມຕົ້ນ ການປະຕິບັດມູນຄ່າແມ່ນ
ບໍ່ໄດ້ກໍານົດ. ພາຍໃນ END ການປະຕິບັດຄ່າຈະຕ້ອງເປັນຊື່ຂອງການປ້ອນຂໍ້ມູນສຸດທ້າຍ
ປະມວນຜົນໄຟລ໌ແລ້ວ.

FNR ຈໍານວນຄໍາສັ່ງຂອງບັນທຶກປະຈຸບັນໃນໄຟລ໌ປະຈຸບັນ. ພາຍໃນ ກ ເລີ່ມຕົ້ນ
ການປະຕິບັດມູນຄ່າຈະເປັນສູນ. ພາຍໃນ END ການປະຕິບັດມູນຄ່າຈະຕ້ອງເປັນ
ຈໍານວນບັນທຶກສຸດທ້າຍທີ່ດໍາເນີນການໃນໄຟລ໌ສຸດທ້າຍທີ່ດໍາເນີນການ.

FS ການ​ປ້ອນ​ຂໍ້​ມູນ​ຕົວ​ແຍກ​ສະ​ແດງ​ອອກ​ປົກ​ກະ​ຕິ​; ກ ໂດຍຄ່າເລີ່ມຕົ້ນ.

NF ຈຳນວນຊ່ອງຂໍ້ມູນໃນບັນທຶກປັດຈຸບັນ. ພາຍໃນ ກ ເລີ່ມຕົ້ນ ການ​ປະ​ຕິ​ບັດ​, ການ​ນໍາ​ໃຊ້​ NF
ແມ່ນບໍ່ໄດ້ກໍານົດເວັ້ນເສຍແຕ່ a ສາຍ ຟັງຊັ່ນທີ່ບໍ່ມີ a var ການໂຕ້ຖຽງຖືກປະຕິບັດ
ກ່ອນຫນ້ານີ້. ພາຍໃນ END ການປະຕິບັດ, NF ຈະຕ້ອງຮັກສາມູນຄ່າທີ່ມັນມີໄວ້ເປັນຄັ້ງສຸດທ້າຍ
ບັນທຶກການອ່ານ, ເວັ້ນເສຍແຕ່ວ່າຕໍ່ມາ, ການປ່ຽນເສັ້ນທາງ, ສາຍ ຟັງຊັ່ນທີ່ບໍ່ມີ a var
ການໂຕ້ຖຽງແມ່ນປະຕິບັດກ່ອນທີ່ຈະເຂົ້າໄປໃນ END ການປະຕິບັດ.

NR ຕົວເລກຕາມລໍາດັບຂອງບັນທຶກປັດຈຸບັນຈາກການເລີ່ມຕົ້ນຂອງການປ້ອນຂໍ້ມູນ. ພາຍໃນ ກ
ເລີ່ມຕົ້ນ ການປະຕິບັດມູນຄ່າຈະເປັນສູນ. ພາຍໃນ END ການ​ປະ​ຕິ​ບັດ​ມູນ​ຄ່າ​ຈະ​ເປັນ​
ຈໍານວນບັນທຶກສຸດທ້າຍທີ່ດໍາເນີນການ.

OFMT ໄດ້ printf ຮູບ​ແບບ​ສໍາ​ລັບ​ການ​ແປງ​ຕົວ​ເລກ​ເປັນ​ສະ​ຕ​ຣິງ​ໃນ​ຄໍາ​ບັນ​ຍາຍ​ຜົນ​ຜະ​ລິດ (ເບິ່ງ​
ຜົນຜະລິດ ບົດລາຍງານ); "%.6g" ໂດຍຄ່າເລີ່ມຕົ້ນ. ຜົນໄດ້ຮັບຂອງການປ່ຽນໃຈເຫລື້ອມໃສແມ່ນ
ບໍ່ໄດ້ລະບຸວ່າຄ່າຂອງ OFMT ບໍ່ແມ່ນການກຳນົດຮູບແບບຈຸດລອຍ.

FSO ໄດ້ ພິມ ຕົວແຍກພາກສະຫນາມຜົນຜະລິດຖະແຫຼງການ; ໂດຍຄ່າເລີ່ມຕົ້ນ.

ORS ໄດ້ ພິມ ຕົວ​ແຍກ​ການ​ບັນ​ທຶກ​ຜົນ​ຜະ​ລິດ​ຖະ​ແຫຼງ​ການ​; ກ ໂດຍຄ່າເລີ່ມຕົ້ນ.

RLENGTH ຄວາມ​ຍາວ​ຂອງ​ສາຍ​ທີ່​ຖືກ​ຈັບ​ຄູ່​ໂດຍ​ ການແຂ່ງຂັນ function

RS ຕົວອັກສອນທຳອິດຂອງຄ່າສະຕຣິງຂອງ RS ຈະເປັນການບັນທຶກການປ້ອນຂໍ້ມູນ
ຕົວແຍກ; ກ ໂດຍຄ່າເລີ່ມຕົ້ນ. ຖ້າ RS ມີຫຼາຍກວ່າຫນຶ່ງລັກສະນະ, the
ຜົນໄດ້ຮັບແມ່ນບໍ່ໄດ້ລະບຸ. ຖ້າ RS ແມ່ນ null, ຫຼັງຈາກນັ້ນບັນທຶກຖືກແຍກອອກໂດຍລໍາດັບ
ປະ​ກອບ​ດ້ວຍ a ບວກໜຶ່ງ ຫຼືຫຼາຍເສັ້ນຫວ່າງ, ແຖວໜ້າ ຫຼືຈາກຫຼັງ
ເສັ້ນເປົ່າຈະບໍ່ສົ່ງຜົນໃຫ້ບັນທຶກຫວ່າງເປົ່າໃນຕອນຕົ້ນ ຫຼືຕອນທ້າຍຂອງ
ວັດສະດຸປ້ອນ, ແລະ ກ ສະເຫມີຈະເປັນຕົວແຍກພາກສະຫນາມ, ບໍ່ວ່າສິ່ງທີ່
ມູນຄ່າຂອງ FS ແມ່ນ.

RSTART ຕໍາ​ແຫນ່ງ​ເລີ່ມ​ຕົ້ນ​ຂອງ​ສະ​ຕ​ຣິງ​ຈັບ​ຄູ່​ໂດຍ​ ການແຂ່ງຂັນ ການ​ທໍາ​ງານ​, ການ​ຈໍາ​ນວນ​
ຈາກ 1. ອັນນີ້ຈະຕ້ອງເທົ່າກັບຄ່າກັບຄືນຂອງຄ່າສະເໝີ ການແຂ່ງຂັນ
function

SUBSEP ສະຕຣິງຕົວແຍກ subscript ສໍາລັບອາເຣຫຼາຍມິຕິ; ຄ່າເລີ່ມຕົ້ນ
ແມ່ນ​ການ​ປະ​ຕິ​ບັດ​ກໍາ​ນົດ​.

ເປັນປົກກະຕິ ສຳ ນວນ
ໄດ້ ງຸ່ມ ຜົນປະໂຫຍດຈະຕ້ອງໃຊ້ການຂະຫຍາຍການສະແດງອອກເປັນປົກກະຕິ (ເບິ່ງພື້ນຖານ
ປະລິມານຄໍານິຍາມຂອງ POSIX.1-2008, ສ່ວນ 9.4, ການຂະຫຍາຍ ເປັນປົກກະຕິ ສຳ ນວນ) ຍົກ​ເວັ້ນ​ແຕ່​ວ່າ​
ມັນຈະອະນຸຍາດໃຫ້ນໍາໃຊ້ສົນທິສັນຍາພາສາ C ສໍາລັບ escaping ຕົວອັກສອນພິເສດພາຍໃນ
EREs, ຕາມທີ່ລະບຸໄວ້ໃນຕາຕະລາງໃນປະລິມານຄໍານິຍາມພື້ນຖານຂອງ POSIX.1-2008,
ບົດ 5, ເອກະສານ ຮູບແບບ notation ('\\', '\a', '\b', '\f', '\n', '\r', '\t', '\v') ແລະໄດ້
ຕາຕະລາງຕໍ່ໄປນີ້; ລໍາດັບການຫລົບຫນີເຫຼົ່ານີ້ຈະຖືກຮັບຮູ້ທັງພາຍໃນແລະພາຍນອກ
ການສະແດງອອກວົງເລັບ. ໃຫ້ສັງເກດວ່າບັນທຶກບໍ່ຈໍາເປັນຕ້ອງຖືກແຍກອອກໂດຍ ລັກ​ສະ​ນະ​ແລະ​
ຄົງສະຕຣິງສາມາດບັນຈຸໄດ້ ລັກສະນະ, ສະນັ້ນເຖິງແມ່ນວ່າ "\n" ລໍາດັບແມ່ນຖືກຕ້ອງໃນ
ງຸ່ມ EREs. ການນໍາໃຊ້ ກ ລັກສະນະພາຍໃນ ERE ຮຽກຮ້ອງໃຫ້ມີການຫລົບຫນີທີ່ສະແດງຢູ່ໃນ
ຕາຕະລາງຕໍ່ໄປນີ້.

ຕາຕະລາງ 4-2: Escape ລໍາດັບ in ງຸ່ມ

┌────────────────────────────────────────────── ─────────────────────────────────── ┐
│ Escape │ │ │
│ລໍາດັບ │ ລາຍລະອຽດ │ ຊຶ່ງຫມາຍຄວາມວ່າ │
├───────────────────────────────────────── ──────────────────────────────────────
│\" │ │ ລັກສະນະ │
├───────────────────────────────────────── ──────────────────────────────────────
│\/ │ │ ລັກສະນະ │
├───────────────────────────────────────── ──────────────────────────────────────
│\ddd │ A ຕົວອັກສອນປະຕິບັດຕາມ │ ຕົວອັກສອນທີ່ມີການເຂົ້າລະຫັດແມ່ນ │
│ │ ໂດຍລຳດັບທີ່ຍາວທີ່ສຸດຂອງອັນໜຶ່ງ, │ ສະແດງໂດຍໜຶ່ງ, ສອງ, ຫຼື │
│ │ ສອງ, ຫຼືສາມໂຕເລກແປດ │ ເລກແປດເລກສາມໂຕ. ຫຼາຍ- │
│ │ ຕົວອັກສອນ (01234567). ຖ້າຕົວອັກສອນ │ byte ທັງໝົດຕ້ອງການຫຼາຍຕົວ, │
│ │ ຕົວເລກແມ່ນ 0 (ນັ້ນຄື │ ລຳດັບການຫລົບຫນີທີ່ປະສົມປະສານຂອງ │
│ │ ການເປັນຕົວແທນຂອງ NUL │ ປະເພດນີ້, ລວມທັງ │ ຊັ້ນນໍາ.
│ │ ລັກສະນະ), ພຶດຕິກໍາແມ່ນ │ ສໍາລັບແຕ່ລະ byte. │
│ │ ບໍ່ໄດ້ກຳນົດ. │ │
├───────────────────────────────────────── ──────────────────────────────────────
│\c │ A ຕົວອັກສອນຕາມ │ Undefined │
│ │ ໂດຍຕົວລະຄອນໃດນຶ່ງທີ່ບໍ່ໄດ້ອະທິບາຍໄວ້ໃນ │ │
│ │ ຕາຕະລາງນີ້ ຫຼື ຕາຕະລາງໃນ │ │
│ │ Base Definitions volume of │ │
│ │ POSIX.1-2008, ບົດ 5, ເອກະສານ ││
││ ຮູບແບບ notation ('\\', '\a', '\b', │ │
││ '\f', '\n', '\r', '\t', '\v'). │ │
└─────────────────────────────────────────────── ─────────────────────────────────────
ການສະແດງຜົນປົກກະຕິສາມາດຖືກຈັບຄູ່ກັບຊ່ອງຂໍ້ມູນ ຫຼືສະຕຣິງໃດໜຶ່ງໄດ້ໂດຍການໃຊ້ອັນໃດນຶ່ງ
ສອງຕົວປະຕິບັດການຈັບຄູ່ການສະແດງອອກປົກກະຕິ, '~' ແລະ "!~". ຜູ້ປະກອບການເຫຼົ່ານີ້ຈະຕ້ອງຕີຄວາມໝາຍ
operand ຂວາມືຂອງເຂົາເຈົ້າເປັນການສະແດງອອກປົກກະຕິແລະ operand ຊ້າຍມືຂອງເຂົາເຈົ້າເປັນ string.
ຖ້າການສະແດງອອກປົກກະຕິກົງກັບສະຕຣິງ, the '~' ການສະແດງອອກຈະຕ້ອງປະເມີນເປັນມູນຄ່າ
ຂອງ 1, ແລະ "!~" expression ຈະຕ້ອງປະເມີນເປັນຄ່າຂອງ 0. (ການສະແດງອອກປົກກະຕິ
ການ​ດໍາ​ເນີນ​ງານ​ການ​ຈັບ​ຄູ່​ແມ່ນ​ໄດ້​ກໍາ​ນົດ​ໂດຍ​ຄໍາ​ສັບ​ທີ່​ກົງ​ກັນ​ໃນ​ປະ​ລິ​ມານ​ຄໍາ​ນິ​ຍາມ​ຖານ​ຂອງ​
POSIX.1-2008, ສ່ວນ 9.1, ເປັນປົກກະຕິ ການສະແດງອອກ ຄໍານິຍາມ, ບ່ອນທີ່ມີການແຂ່ງຂັນເກີດຂຶ້ນໃນທຸກ
ສ່ວນໜຶ່ງຂອງສະຕຣິງ ເວັ້ນເສຍແຕ່ວ່າການສະແດງຜົນປົກກະຕິຈະຖືກຈຳກັດດ້ວຍ ຫຼື
ຕົວອັກສອນພິເສດ.) ຖ້າການສະແດງອອກປົກກະຕິບໍ່ກົງກັບສະຕຣິງ,
ໄດ້ '~' ການສະແດງຜົນຈະຕ້ອງປະເມີນເປັນຄ່າຂອງ 0, ແລະ "!~" ການສະແດງອອກຈະຕ້ອງປະເມີນ
ເປັນຄ່າຂອງ 1. ຖ້າຕົວປະຕິບັດການຂວາມືແມ່ນສະແດງອອກໃດໆນອກຈາກ token lexical
TIME, ຄ່າສະຕຣິງຂອງການສະແດງຜົນຈະຖືກຕີຄວາມໝາຍເປັນການຂະຫຍາຍປົກກະຕິ
ການສະແດງອອກ, ລວມທັງສົນທິສັນຍາການຫລົບຫນີທີ່ໄດ້ອະທິບາຍຂ້າງເທິງ. ໃຫ້ສັງເກດວ່າການຫລົບຫນີດຽວກັນນີ້
ສົນທິສັນຍາຍັງຈະຖືກນໍາໃຊ້ໃນການກໍານົດມູນຄ່າຂອງຕົວຫນັງສື (the
token lexical ຄັກ), ແລະດັ່ງນັ້ນຈຶ່ງຈະຖືກນໍາໃຊ້ເປັນຄັ້ງທີສອງໃນເວລາທີ່ຕົວຫນັງສືເປັນ
ໃຊ້ໃນສະພາບການນີ້.

ໃນເວລາທີ່ຫນຶ່ງ TIME token ປະ​ກົດ​ວ່າ​ເປັນ​ການ​ສະ​ແດງ​ອອກ​ໃນ​ສະ​ພາບ​ການ​ໃດ​ຫນຶ່ງ​ນອກ​ເຫນືອ​ໄປ​ຈາກ​ທາງ​ຂວາ​ມື​ຂອງ​
ໄດ້ '~' or "!~" operator ຫຼືເປັນຫນຶ່ງໃນຕົວໂຕ້ແຍ້ງຟັງຊັນທີ່ອະທິບາຍຂ້າງລຸ່ມນີ້, the
ຄ່າຂອງການສະແດງຜົນຈະເທົ່າກັບ:

$0 " " /ere/

ໄດ້ ere ການໂຕ້ຖຽງກັບ gsub, ການແຂ່ງຂັນ, ການຍ່ອຍ ຫນ້າທີ່, ແລະ fs ການໂຕ້ຖຽງກັບ ແບ່ງປັນ
ຫນ້າທີ່ (ເບິ່ງ string ຫນ້າທີ່) ຈະ​ຖືກ​ຕີ​ລາ​ຄາ​ເປັນ​ສໍາ​ນວນ​ປົກ​ກະ​ຕິ​ຂະ​ຫຍາຍ​.
ເຫຼົ່ານີ້ສາມາດເປັນ TIME tokens ຫຼືການສະແດງອອກ arbitrary, ແລະຈະຖືກຕີຄວາມຫມາຍໃນ
ລັກສະນະດຽວກັນກັບດ້ານຂວາມືຂອງ '~' or "!~" ຜູ້ປະກອບການ.

ການສະແດງຜົນປົກກະຕິທີ່ຂະຫຍາຍອອກສາມາດຖືກໃຊ້ເພື່ອແຍກຊ່ອງຂໍ້ມູນໂດຍການກຳນົດສາຍສະຕຣິງ
ປະກອບດ້ວຍການສະແດງອອກຕໍ່ກັບຕົວແປທີ່ສ້າງຂຶ້ນ FS, ໂດຍກົງຫຼືເປັນຜົນສະທ້ອນ
ຂອງການນໍາໃຊ້ −F sepstring ທາງເລືອກ. ຄ່າເລີ່ມຕົ້ນຂອງ FS ຕົວແປຈະຕ້ອງເປັນອັນດຽວ
. ຕໍ່ໄປນີ້ອະທິບາຍ FS ພຶດຕິ ກຳ:

1 If FS ເປັນສະຕຣິງ null, ພຶດຕິກໍາແມ່ນບໍ່ໄດ້ລະບຸ.

2 If FS ເປັນ​ຕົວ​ອັກ​ສອນ​ດຽວ​:

ກ. ຖ້າ FS ແມ່ນ , ຂ້າມການນໍາແລະຕິດຕາມ ແລະ ລັກສະນະ;
ຊ່ອງຂໍ້ມູນຈະຖືກຈຳກັດໂດຍຊຸດໜຶ່ງ ຫຼືຫຼາຍກວ່ານັ້ນ ຫຼື ຕົວລະຄອນ.

ຂ. ຖ້າບໍ່ດັ່ງນັ້ນ, ຖ້າ FS ແມ່ນລັກສະນະອື່ນໆ c, ຊ່ອງຂໍ້ມູນຈະຖືກ delimited ໂດຍແຕ່ລະຄົນ
ການປະກົດຕົວດຽວຂອງ c.

3. ຖ້າບໍ່ດັ່ງນັ້ນ, ຄ່າ string ຂອງ FS ຈະຖືກພິຈາລະນາເປັນໄລຍະເວລາປົກກະຕິ
ການສະແດງອອກ. ແຕ່ລະການປະກົດຕົວຂອງລໍາດັບທີ່ກົງກັບການສະແດງຜົນປົກກະຕິທີ່ຂະຫຍາຍອອກ
ຈະກໍານົດຂອບເຂດ.

ຍົກເວັ້ນສໍາລັບການ '~' ແລະ "!~" ຜູ້ປະກອບການ, ແລະໃນ gsub, ການແຂ່ງຂັນ, ແບ່ງປັນ, ແລະ ການຍ່ອຍ ສ້າງຂຶ້ນໃນ
ຫນ້າທີ່, ການຈັບຄູ່ ERE ຈະຕ້ອງອີງໃສ່ບັນທຶກການປ້ອນຂໍ້ມູນ; ນັ້ນແມ່ນ, ຕົວແຍກບັນທຶກ
ຕົວອັກສອນ (ລັກສະນະທໍາອິດຂອງມູນຄ່າຂອງຕົວແປ RS, ໂດຍຄ່າເລີ່ມຕົ້ນ)
ບໍ່​ສາ​ມາດ​ໄດ້​ຮັບ​ການ​ຝັງ​ຢູ່​ໃນ​ສະ​ແດງ​ອອກ​, ແລະ​ບໍ່​ມີ​ການ​ສະ​ແດງ​ອອກ​ທີ່​ຈະ​ກົງ​ກັບ​ຕົວ​ແຍກ​ບັນ​ທຶກ​
ລັກສະນະ. ຖ້າຕົວແຍກບັນທຶກບໍ່ແມ່ນ , ຕົວອັກສອນທີ່ຝັງຢູ່ໃນ
ການສະແດງອອກສາມາດຖືກຈັບຄູ່. ສໍາ​ລັບ '~' ແລະ "!~" ຜູ້ປະກອບການ, ແລະໃນສີ່ກໍ່ສ້າງໃນນັ້ນ
ຫນ້າທີ່, ການຈັບຄູ່ ERE ຈະຕ້ອງອີງໃສ່ສາຍຂໍ້ຄວາມ; ນັ້ນແມ່ນ, ລັກສະນະໃດກໍ່ຕາມ (ລວມທັງ
ແລະຕົວແຍກບັນທຶກ) ສາມາດຖືກຝັງຢູ່ໃນຮູບແບບ, ແລະເຫມາະສົມ
ຮູບແບບຈະກົງກັບລັກສະນະໃດນຶ່ງ. ຢ່າງໃດກໍຕາມ, ໃນທັງຫມົດ ງຸ່ມ ການຈັບຄູ່ ERE, ການນໍາໃຊ້ຫນຶ່ງຫຼື
ຕົວອັກສອນ NUL ເພີ່ມເຕີມຢູ່ໃນຮູບແບບ, ການບັນທຶກການປ້ອນຂໍ້ມູນ, ຫຼືສະຕຣິງຂໍ້ຄວາມເຮັດໃຫ້ບໍ່ໄດ້ກໍານົດ
ຜົນໄດ້ຮັບ.

ຮູບແບບການ
A ຮູບແບບ ແມ່ນຖືກຕ້ອງ ການສະແດງອອກ, ໄລຍະທີ່ກຳນົດໂດຍສອງສຳນວນທີ່ແຍກອອກໂດຍ a
comma, ຫຼືຫນຶ່ງໃນສອງຮູບແບບພິເສດ ເລີ່ມຕົ້ນ or END.

ພິເສດ ຮູບແບບການ
ໄດ້ ງຸ່ມ ຜົນປະໂຫຍດຈະຮັບຮູ້ສອງຮູບແບບພິເສດ, ເລີ່ມຕົ້ນ ແລະ ENDທີ່ຢູ່ ແຕ່ລະຄົນ ເລີ່ມຕົ້ນ ຮູບແບບ
ຈະຖືກຈັບຄູ່ຄັ້ງດຽວ ແລະການປະຕິບັດທີ່ກ່ຽວຂ້ອງຂອງມັນຖືກປະຕິບັດກ່ອນການບັນທຶກການປ້ອນຂໍ້ມູນທຳອິດ
ແມ່ນອ່ານ - ຍົກເວັ້ນເປັນໄປໄດ້ໂດຍການໃຊ້ ສາຍ ຫນ້າທີ່ (ເບິ່ງ Input / Output ແລະ ໂດຍ​ທົ່ວ​ໄປ
ຫນ້າທີ່) ໃນ​ກ່ອນ​ຫນ້າ​ນີ້​ ເລີ່ມຕົ້ນ ການປະຕິບັດ - ແລະກ່ອນທີ່ຈະມອບຫມາຍແຖວຄໍາສັ່ງຈະສໍາເລັດ. ແຕ່ລະ END
ຮູບ​ແບບ​ຈະ​ຖືກ​ຈັບ​ຄູ່​ຫນຶ່ງ​ຄັ້ງ​ແລະ​ການ​ປະ​ຕິ​ບັດ​ທີ່​ກ່ຽວ​ຂ້ອງ​ຂອງ​ຕົນ​ປະ​ຕິ​ບັດ​ຫຼັງ​ຈາກ​ການ​ບັນ​ທຶກ​ສຸດ​ທ້າຍ​ຂອງ
ການປ້ອນຂໍ້ມູນໄດ້ຖືກອ່ານແລ້ວ. ທັງສອງຮູບແບບນີ້ຈະມີການກະທຳທີ່ກ່ຽວຂ້ອງ.

ເລີ່ມຕົ້ນ ແລະ END ບໍ່ຄວນສົມທົບກັບຮູບແບບອື່ນໆ. ຫຼາຍ ເລີ່ມຕົ້ນ ແລະ END ຮູບແບບຈະ
ອະນຸຍາດ. ການ​ກະ​ທໍາ​ທີ່​ກ່ຽວ​ຂ້ອງ​ກັບ​ ເລີ່ມຕົ້ນ ຮູບ​ແບບ​ຈະ​ໄດ້​ຮັບ​ການ​ປະ​ຕິ​ບັດ​ໃນ​ຄໍາ​ສັ່ງ​
ທີ່ລະບຸໄວ້ໃນໂຄງການ, ເຊັ່ນດຽວກັນກັບ END ການກະທໍາ. ອັນ END ຮູບ​ແບບ​ສາ​ມາດ​ນໍາ​ຫນ້າ a ເລີ່ມຕົ້ນ
ຮູບ​ແບບ​ໃນ​ໂຄງ​ການ​.

ຖ້າເປັນ ງຸ່ມ ໂຄງ​ການ​ປະ​ກອບ​ດ້ວຍ​ພຽງ​ແຕ່​ການ​ປະ​ຕິ​ບັດ​ທີ່​ມີ​ຮູບ​ແບບ​ ເລີ່ມຕົ້ນ, ແລະ ເລີ່ມຕົ້ນ ການປະຕິບັດ
ບັນຈຸບໍ່ມີ ສາຍ ໜ້າ ທີ່, ງຸ່ມ ຈະຕ້ອງອອກໂດຍບໍ່ມີການອ່ານວັດສະດຸປ້ອນຂອງມັນເມື່ອສຸດທ້າຍ
ຖະແຫຼງການໃນຄັ້ງສຸດທ້າຍ ເລີ່ມຕົ້ນ ການ​ປະ​ຕິ​ບັດ​ແມ່ນ​ປະ​ຕິ​ບັດ​. ຖ້າເປັນ ງຸ່ມ ໂຄງ​ການ​ປະ​ກອບ​ດ້ວຍ​ການ​ປະ​ຕິ​ບັດ​ພຽງ​ແຕ່​
ມີຮູບແບບ END ຫຼືພຽງແຕ່ປະຕິບັດກັບຮູບແບບ ເລີ່ມຕົ້ນ ແລະ END, ວັດສະດຸປ້ອນຈະຕ້ອງເປັນ
ອ່ານກ່ອນຄໍາຖະແຫຼງການໃນ END ການ​ປະ​ຕິ​ບັດ​ແມ່ນ​ປະ​ຕິ​ບັດ​.

ການສະແດງອອກ ຮູບແບບການ
ຮູບແບບການສະແດງອອກຈະຖືກປະເມີນຄືກັບວ່າມັນເປັນການສະແດງອອກໃນບໍລິບົດ Boolean.
ຖ້າຜົນໄດ້ຮັບແມ່ນຄວາມຈິງ, ຮູບແບບຈະຖືກພິຈາລະນາວ່າກົງກັນ, ແລະການປະຕິບັດທີ່ກ່ຽວຂ້ອງ
(ຖ້າມີ) ຈະຖືກປະຕິບັດ. ຖ້າຜົນໄດ້ຮັບແມ່ນບໍ່ຖືກຕ້ອງ, ການປະຕິບັດຈະບໍ່ຖືກປະຕິບັດ.

ຮູບແບບ ຊ່ວງ
ຊ່ວງຮູບແບບປະກອບດ້ວຍສອງການສະແດງຜົນທີ່ແຍກດ້ວຍເຄື່ອງໝາຍຈຸດ; ໃນກໍລະນີດັ່ງກ່າວນີ້, ການປະຕິບັດ
ຈະຖືກປະຕິບັດສໍາລັບບັນທຶກທັງຫມົດລະຫວ່າງການຈັບຄູ່ຂອງການສະແດງຜົນທໍາອິດແລະ
ດັ່ງຕໍ່ໄປນີ້ການຈັບຄູ່ຂອງສໍານວນທີສອງ, ລວມ. ໃນຈຸດນີ້, ລະດັບຮູບແບບສາມາດ
ຈະຖືກຊ້ໍາໂດຍເລີ່ມຕົ້ນຈາກການບັນທຶກການປ້ອນຂໍ້ມູນຕໍ່ມາຈົນຮອດທ້າຍຂອງຊ່ວງທີ່ຈັບຄູ່ກັນ.

ການກະທໍາ
ການປະຕິບັດແມ່ນລໍາດັບຂອງຄໍາຖະແຫຼງທີ່ສະແດງຢູ່ໃນໄວຍາກອນໃນ Grammar. ດຽວ
ຖະແຫຼງການສາມາດຖືກແທນທີ່ດ້ວຍລາຍຊື່ຄໍາຖະແຫຼງທີ່ປິດຢູ່ໃນວົງເລັບ curly. ຄໍາຮ້ອງສະຫມັກ
ຈະຕ້ອງຮັບປະກັນວ່າຄໍາຖະແຫຼງທີ່ຢູ່ໃນບັນຊີລາຍຊື່ຄໍາຖະແຫຼງທີ່ແຍກອອກໂດຍ ຫຼື
ຕົວລະຄອນ. ຖະແຫຼງການໃນລາຍການຖະແຫຼງການຈະຕ້ອງຖືກປະຕິບັດຕາມລໍາດັບຕາມລໍາດັບ
ວ່າພວກເຂົາເຈົ້າປະກົດວ່າ.

ໄດ້ ການສະແດງອອກ ເຮັດຫນ້າທີ່ເປັນເງື່ອນໄຂໃນ if ຖະແຫຼງການຈະຖືກປະເມີນ ແລະຖ້າມັນ
ບໍ່ແມ່ນສູນ ຫຼືບໍ່ແມ່ນ null, ຂໍ້ຄວາມຕໍ່ໄປນີ້ຈະຖືກປະຕິບັດ; ຖ້າບໍ່ດັ່ງນັ້ນ, ຖ້າ ອື່ນ is
ປະຈຸບັນ, ຖະແຫຼງການດັ່ງຕໍ່ໄປນີ້ ອື່ນ ຈະຖືກປະຕິບັດ.

ໄດ້ if, ໃນຂະນະທີ່, do...ໃນຂະນະທີ່, ສໍາລັບການ, ພັກຜ່ອນ, ແລະ ດໍາເນີນການຕໍ່ ຖະແຫຼງການແມ່ນອີງໃສ່ ISO C
ມາດຕະຖານ (ເບິ່ງ ສ່ວນ 1.1.2, ແນວຄິດ ມາຈາກ ຈາກ ໄດ້ ISO C ມາດຕະຖານ), ຍົກເວັ້ນວ່າ
ການສະແດງອອກຂອງ Boolean ຈະຖືກປະຕິບັດຕາມທີ່ໄດ້ອະທິບາຍໄວ້ໃນ ສຳ ນວນ in ງຸ່ມ, ແລະຍົກເວັ້ນໃນ
ກໍ​ລະ​ນີ​ຂອງ​:

ສໍາລັບການ (ຕົວແປ in array)

ເຊິ່ງຈະ iterate, ມອບຫມາຍແຕ່ລະຄົນ ດັດຊະນີ of array to ຕົວແປ ໃນຄໍາສັ່ງທີ່ບໍ່ລະບຸ.
ຜົນໄດ້ຮັບຂອງການເພີ່ມອົງປະກອບໃຫມ່ array ພາຍໃນດັ່ງກ່າວ ສໍາລັບການ loop ແມ່ນບໍ່ໄດ້ກໍານົດ. ຖ້າ ກ
ພັກຜ່ອນ or ດໍາເນີນການຕໍ່ ຄໍາຖະແຫຼງທີ່ເກີດຂື້ນຢູ່ນອກວົງແຫວນ, ພຶດຕິກໍາແມ່ນບໍ່ໄດ້ກໍານົດ.

ໄດ້ ລຶບ ຄໍາຖະແຫຼງທີ່ຈະເອົາອົງປະກອບ array ສ່ວນບຸກຄົນ. ດັ່ງນັ້ນ, ລະຫັດຕໍ່ໄປນີ້
ລຶບອາເຣທັງໝົດ:

ສໍາລັບການ (ດັດຊະນີ in array)
ລຶບ array[index]

ໄດ້ ຕໍ່ໄປ ຖະແຫຼງການຈະເຮັດໃຫ້ເກີດການປະມວນຜົນເພີ່ມເຕີມຂອງບັນທຶກການປ້ອນຂໍ້ມູນໃນປະຈຸບັນ
ປະຖິ້ມໄວ້. ພຶດຕິກໍາແມ່ນບໍ່ໄດ້ກໍານົດຖ້າຫາກວ່າ a ຕໍ່ໄປ ຄໍາຖະແຫຼງທີ່ປະກົດຂຶ້ນຫຼືຖືກເອີ້ນໃນ a ເລີ່ມຕົ້ນ
or END ການປະຕິບັດ.

ໄດ້ ການທ່ອງທ່ຽວ ຖະແຫຼງການຈະຮຽກຮ້ອງທັງໝົດ END ການປະຕິບັດໃນຄໍາສັ່ງທີ່ພວກເຂົາເກີດຂຶ້ນໃນ
ແຫຼ່ງຂອງໂປລແກລມ ແລະຫຼັງຈາກນັ້ນຢຸດໂຄງການໂດຍບໍ່ໄດ້ອ່ານຂໍ້ມູນເພີ່ມຕື່ມ. ອັນ ການທ່ອງທ່ຽວ
ຖະແຫຼງການພາຍໃນ END ການ​ປະ​ຕິ​ບັດ​ຈະ​ຢຸດ​ເຊົາ​ໂຄງ​ການ​ໂດຍ​ບໍ່​ມີ​ການ​ປະ​ຕິ​ບັດ​ເພີ່ມ​ເຕີມ​ຂອງ​
END ການກະທໍາ. ຖ້າການສະແດງອອກແມ່ນລະບຸໄວ້ໃນ an ການທ່ອງທ່ຽວ ຖະແຫຼງການ, ມູນຄ່າຕົວເລກຂອງມັນຈະຕ້ອງ
ເປັນສະຖານະພາບທາງອອກຂອງ ງຸ່ມ, ເວັ້ນເສຍແຕ່ຈະພົບຄວາມຜິດພາດຕໍ່ມາຫຼືຕໍ່ມາ ການທ່ອງທ່ຽວ
ຖະແຫຼງການທີ່ມີການສະແດງຜົນຖືກປະຕິບັດ.

ຜົນຜະລິດ ບົດລາຍງານ
ທັງສອງ ພິມ ແລະ printf ຖະແຫຼງການຈະຕ້ອງຂຽນໃສ່ຜົນໄດ້ຮັບມາດຕະຖານໂດຍຄ່າເລີ່ມຕົ້ນ. ຜົນຜະລິດ
ຈະຖືກຂຽນໃສ່ສະຖານທີ່ທີ່ລະບຸໄວ້ໂດຍ output_redirection ຖ້າຫາກວ່າຫນຶ່ງແມ່ນສະຫນອງໃຫ້, ເປັນ
ຕໍ່ໄປນີ້:

> ການສະແດງອອກ
>> ການສະແດງອອກ
| ການສະແດງອອກ

ໃນກໍລະນີທັງຫມົດ, ໄດ້ ການສະແດງອອກ ຈະຖືກປະເມີນເພື່ອຜະລິດ string ທີ່ຖືກນໍາໃຊ້ເປັນ
ຊື່ເສັ້ນທາງທີ່ຈະຂຽນ (ສໍາລັບ '>' or ">>") ຫຼືເປັນຄໍາສັ່ງທີ່ຈະປະຕິບັດ (ສໍາລັບ '|').
ການນໍາໃຊ້ສອງຮູບແບບທໍາອິດ, ຖ້າໄຟລ໌ຂອງຊື່ນັ້ນບໍ່ໄດ້ເປີດໃນປັດຈຸບັນ, ມັນຈະເປັນ
ເປີດ, ສ້າງມັນຖ້າຈໍາເປັນແລະນໍາໃຊ້ແບບຟອມທໍາອິດ, ຕັດໄຟລ໌. ຜົນຜະລິດ
ຫຼັງ​ຈາກ​ນັ້ນ​ຈະ​ໄດ້​ຮັບ​ການ​ຕໍ່​ທ້າຍ​ໄຟລ​໌​. ຕາບໃດທີ່ໄຟລ໌ຍັງເປີດຢູ່, ຕໍ່ມາການໂທເຂົ້າ
ທີ່ ການສະແດງອອກ ການປະເມີນຄ່າຂອງສະຕຣິງດຽວກັນພຽງແຕ່ຈະເພີ່ມຜົນຜະລິດເຂົ້າໃສ່
ໄຟລ໌. ໄຟລ໌ຍັງຄົງເປີດຈົນກ່ວາ ໃກ້ ຫນ້າທີ່ (ເບິ່ງ Input / Output ແລະ ໂດຍ​ທົ່ວ​ໄປ
ຫນ້າທີ່) ຖືກເອີ້ນດ້ວຍການສະແດງຜົນທີ່ປະເມີນເປັນຄ່າສະຕຣິງດຽວກັນ.

ຮູບແບບທີ XNUMX ຈະຕ້ອງຂຽນຜົນອອກມາໃສ່ກະແສທີ່ທໍ່ໃສ່ກັບອິນພຸດຂອງຄຳສັ່ງ. ໄດ້
stream ຈະຖືກສ້າງຂື້ນຖ້າບໍ່ມີກະແສເປີດໃນປະຈຸບັນດ້ວຍຄ່າຂອງ ການສະແດງອອກ ເປັນຂອງຕົນ
ຊື່ຄໍາສັ່ງ. ກະແສທີ່ສ້າງຂຶ້ນຈະທຽບເທົ່າກັບອັນໜຶ່ງທີ່ສ້າງຂຶ້ນໂດຍການໂທຫາ
popen() ຟັງຊັນທີ່ກຳນົດໄວ້ໃນ System Interfaces volume ຂອງ POSIX.1-2008 ດ້ວຍຄ່າຂອງ
ການສະແດງອອກ ເປັນ ຄໍາສັ່ງ argument ແລະມູນຄ່າຂອງ w ເປັນ ຮູບແບບການ ການໂຕ້ຖຽງ. ຕາບໃດທີ່
ການຖ່າຍທອດຍັງຄົງເປີດຢູ່, ການໂທຕໍ່ມາໃນນັ້ນ ການສະແດງອອກ ປະເມີນເປັນສາຍດຽວກັນ
ຄ່າຈະຕ້ອງຂຽນຜົນອອກໄປຫາກະແສທີ່ມີຢູ່. ນ້ໍາຈະຍັງຄົງເປີດຈົນກ່ວາ
ໃກ້ ຫນ້າທີ່ (ເບິ່ງ Input / Output ແລະ ໂດຍ​ທົ່ວ​ໄປ ຫນ້າທີ່) ຖືກເອີ້ນດ້ວຍການສະແດງອອກວ່າ
ປະເມີນເປັນຄ່າສະຕຣິງດຽວກັນ. ໃນ​ເວ​ລາ​ນັ້ນ, ສາຍ​ນ​້​ໍ​ຈະ​ຖືກ​ປິດ​ເປັນ​ຖ້າ​ຫາກ​ວ່າ​ໂດຍ a
ໂທຫາໄດ້ ປິດ() ຟັງຊັນທີ່ກຳນົດໄວ້ໃນປະລິມານສ່ວນຕິດຕໍ່ລະບົບຂອງ POSIX.1-2008.

ດັ່ງທີ່ໄດ້ອະທິບາຍລາຍລະອຽດໂດຍໄວຍາກອນໃນ Grammar, ບົດລາຍງານຜົນໄດ້ຮັບເຫຼົ່ານີ້ຈະຕ້ອງໃຊ້ເວລາ a
- ບັນ​ຊີ​ລາຍ​ຊື່​ແຍກ​ອອກ​ຂອງ​ ການສະແດງອອກs ອ້າງເຖິງໃນໄວຍາກອນໂດຍ non-terminal
ສັນຍາລັກ expr_list, print_expr_list, ຫຼື print_expr_list_opt. ບັນຊີລາຍຊື່ນີ້ແມ່ນອ້າງອີງເຖິງທີ່ນີ້
ເປັນ ການສະແດງອອກ ບັນຊີລາຍຊື່, ແລະສະມາຊິກແຕ່ລະຄົນຖືກເອີ້ນວ່າເປັນ ການສະແດງອອກ ການໂຕ້ຖຽງ.

ໄດ້ ພິມ ຖະແຫຼງການຈະຂຽນມູນຄ່າຂອງແຕ່ລະການໂຕ້ຖຽງການສະແດງອອກໃສ່ທີ່ລະບຸໄວ້
ກະແສຜົນຜະລິດທີ່ແຍກໂດຍຕົວແຍກພາກສະຫນາມຜົນຜະລິດໃນປະຈຸບັນ (ເບິ່ງຕົວແປ FSO ຂ້າງເທິງ),
ແລະສິ້ນສຸດໂດຍຕົວແຍກບັນທຶກຜົນຜະລິດ (ເບິ່ງຕົວແປ ORS ຂ້າງເທິງ). ການສະແດງອອກທັງຫມົດ
ການໂຕ້ຖຽງຈະຖືກປະຕິບັດເປັນສາຍ, ຖືກແປງຖ້າຈໍາເປັນ; ການປ່ຽນແປງນີ້ຈະ
ຈະ​ເປັນ​ດັ່ງ​ທີ່​ອະ​ທິ​ບາຍ​ໃນ​ ສຳ ນວນ in ງຸ່ມ, ມີຂໍ້ຍົກເວັ້ນທີ່ printf ຮູບແບບໃນ OFMT
ຈະຖືກໃຊ້ແທນຄ່າໃນ CONVFMT. ບັນຊີລາຍຊື່ການສະແດງອອກທີ່ຫວ່າງເປົ່າຈະຕ້ອງຢືນຢູ່
ບັນທຶກການປ້ອນຂໍ້ມູນທັງໝົດ ($0).

ໄດ້ printf ຄໍາຖະແຫຼງທີ່ຈະຜະລິດຜົນໄດ້ຮັບໂດຍອີງໃສ່ notation ທີ່ຄ້າຍຄືກັນກັບຮູບແບບເອກະສານ
ຫມາຍເຫດທີ່ໃຊ້ເພື່ອອະທິບາຍຮູບແບບໄຟລ໌ໃນປະລິມານຂອງ POSIX.1-2008 ນີ້ (ເບິ່ງ Base
ປະລິມານຄໍານິຍາມຂອງ POSIX.1-2008, ບົດ 5, ເອກະສານ ຮູບແບບ notation). ຜົນຜະລິດຈະ
ຜະລິດຕາມທີ່ລະບຸໄວ້ກັບຄັ້ງທໍາອິດ ການສະແດງອອກ argument ເປັນ string ໄດ້ ຮູບແບບ ແລະ
ຕໍ່ມາ ການສະແດງອອກ ການໂຕ້ຖຽງເປັນສາຍ arg1 to Argn, ລວມ, ມີດັ່ງຕໍ່ໄປນີ້
ຂໍ້ຍົກເວັ້ນ:

1. ໄດ້ ຮູບແບບ ຈະເປັນສະຕຣິງຕົວອັກສອນຕົວຈິງ ແທນທີ່ຈະເປັນຕົວແທນກຣາຟິກ.
ດັ່ງນັ້ນ, ມັນບໍ່ສາມາດມີຕໍາແຫນ່ງຕົວອັກສອນເປົ່າ. ໄດ້ ໃນ ຮູບແບບ
string, ໃນສະພາບການໃດນຶ່ງນອກເໜືອໄປຈາກ a ທຸງ ຂອງຂໍ້ກໍານົດການແປງ, ຈະເປັນ
ຖືວ່າເປັນຕົວລະຄອນທຳມະດາທີ່ຖືກຄັດລອກໄປຫາຜົນຜະລິດ.

2. ຖ້າຊຸດຕົວອັກສອນປະກອບດ້ວຍ a '' ລັກສະນະແລະລັກສະນະນັ້ນປາກົດຢູ່ໃນ ຮູບແບບ
string, ມັນຈະຖືກປະຕິບັດເປັນລັກສະນະທໍາມະດາທີ່ຖືກຄັດລອກໄປຫາຜົນຜະລິດ.

3. ໄດ້ escape ລໍາດັບ ເລີ່ມຕົ້ນດ້ວຍ a ລັກສະນະຕ້ອງໄດ້ຮັບການປະຕິບັດເປັນ
ລໍາດັບຂອງຕົວອັກສອນທໍາມະດາທີ່ຖືກຄັດລອກໄປຫາຜົນໄດ້ຮັບ. ໃຫ້ສັງເກດວ່າສິ່ງເຫຼົ່ານີ້ຄືກັນ
ລໍາດັບຕ້ອງໄດ້ຮັບການຕີຄວາມຫມາຍ lexically ໂດຍ ງຸ່ມ ເມື່ອພວກມັນປາກົດຢູ່ໃນສາຍອັກສອນ,
ແຕ່​ພວກ​ເຂົາ​ເຈົ້າ​ຈະ​ບໍ່​ໄດ້​ຮັບ​ການ​ປິ່ນ​ປົວ​ໂດຍ​ສະ​ເພາະ​ printf ຄໍາຖະແຫຼງທີ່.

4 A ພາກສະຫນາມ width or ຄວາມຖືກຕ້ອງ ສາມາດໄດ້ຮັບການລະບຸວ່າເປັນ '*' ຕົວອັກສອນແທນຕົວເລກ
ສາຍ. ໃນ​ກໍ​ລະ​ນີ​ນີ້​ການ​ໂຕ້​ຖຽງ​ຕໍ່​ໄປ​ຈາກ​ບັນ​ຊີ​ລາຍ​ການ​ສະ​ແດງ​ອອກ​ຈະ​ໄດ້​ຮັບ​ການ​ດຶງ​ເອົາ​ແລະ​
ຄ່າຕົວເລກຂອງມັນແມ່ນຄວາມກວ້າງຂອງຊ່ອງຂໍ້ມູນ ຫຼືຄວາມຊັດເຈນ.

5. ການຈັດຕັ້ງປະຕິບັດຈະຕ້ອງບໍ່ນຳໜ້າ ຫຼື ປະຕິບັດຕາມຜົນໄດ້ຮັບຈາກ d or u ການປ່ຽນແປງ
ຕົວລະບຸຕົວຕົນທີ່ມີ ຕົວ​ອັກ​ສອນ​ທີ່​ບໍ່​ໄດ້​ລະ​ບຸ​ໄວ້​ໂດຍ​ ຮູບແບບ string

6. ການປະຕິບັດຈະຕ້ອງບໍ່ນໍາຫນ້າຜົນໄດ້ຮັບຈາກ o ຕົວກໍານົດການແປງ
ກັບສູນນໍາຫນ້າບໍ່ໄດ້ລະບຸໄວ້ໂດຍ ຮູບແບບ string

7. ສຳ ລັບ c ຕົວກໍານົດການແປງ: ຖ້າ argument ມີມູນຄ່າຕົວເລກ, the
ຕົວອັກສອນທີ່ເຂົ້າລະຫັດເປັນຄ່ານັ້ນຈະຖືກສົ່ງອອກ. ຖ້າຄ່າແມ່ນສູນຫຼືບໍ່
ການ​ເຂົ້າ​ລະ​ຫັດ​ຂອງ​ຕົວ​ອັກ​ສອນ​ໃດ​ຫນຶ່ງ​ໃນ​ຊຸດ​ຕົວ​ອັກ​ສອນ​, ພຶດ​ຕິ​ກໍາ​ແມ່ນ​ບໍ່​ໄດ້​ກໍາ​ນົດ​. ຖ້າ
ອາກິວເມັນບໍ່ມີຄ່າຕົວເລກ, ຕົວອັກສອນທຳອິດຂອງຄ່າສະຕຣິງຈະຕ້ອງ
ເປັນຜົນຜະລິດ; ຖ້າສະຕຣິງບໍ່ມີຕົວອັກສອນໃດໆ, ພຶດຕິກຳຈະບໍ່ຖືກກຳນົດ.

8. ສໍາລັບແຕ່ລະຕົວກໍານົດການແປງທີ່ບໍລິໂພກການໂຕ້ຖຽງ, ສະແດງອອກຕໍ່ໄປ
ການໂຕ້ຖຽງຈະຖືກປະເມີນ. ມີຂໍ້ຍົກເວັ້ນຂອງ c ຕົວລະບຸການແປງ
ລັກສະນະ, ມູນຄ່າຈະຖືກປ່ຽນ (ອີງຕາມກົດລະບຽບທີ່ລະບຸໄວ້ໃນ
ສຳ ນວນ in ງຸ່ມ) ກັບປະເພດທີ່ເຫມາະສົມສໍາລັບຂໍ້ກໍານົດການແປງ.

9. ຖ້າມີການໂຕ້ຖຽງການສະແດງອອກບໍ່ພຽງພໍເພື່ອຕອບສະຫນອງການແປງທັງຫມົດ
ສະ​ເພາະ​ໃນ​ ຮູບແບບ string, ພຶດຕິກໍາແມ່ນບໍ່ໄດ້ກໍານົດ.

10. ຖ້າ​ຫາກ​ວ່າ​ລໍາ​ດັບ​ຕົວ​ອັກ​ສອນ​ໃດ​ຫນຶ່ງ​ໃນ​ ຮູບແບບ string ເລີ່ມຕົ້ນດ້ວຍ a '%' ລັກ​ສະ​ນະ​, ແຕ່​ວ່າ​
ບໍ່ແມ່ນການກຳນົດການແປງທີ່ຖືກຕ້ອງ, ພຶດຕິກຳບໍ່ໄດ້ລະບຸ.

ທັງສອງ ພິມ ແລະ printf ສາມາດອອກໄດ້ຢ່າງໜ້ອຍ {LINE_MAX} ໄບຕ໌.

ຫນ້າທີ່
ໄດ້ ງຸ່ມ ພາ​ສາ​ມີ​ຄວາມ​ຫຼາກ​ຫຼາຍ​ຂອງ​ຫນ້າ​ທີ່​ໃນ​ຕົວ​: ເລກ​ຄະ​ນິດ​ສາດ​, string​, input / output​,
ແລະທົ່ວໄປ.

ເລກຄະນິດສາດ ຫນ້າທີ່
ຟັງຊັນເລກຄະນິດ, ຍົກເວັ້ນ int, ຈະຕ້ອງອີງໃສ່ມາດຕະຖານ ISO C (ເບິ່ງ
ສ່ວນ 1.1.2, ແນວຄິດ ມາຈາກ ຈາກ ໄດ້ ISO C ມາດຕະຖານ). ພຶດຕິກໍາແມ່ນບໍ່ໄດ້ກໍານົດຢູ່ໃນ
ກໍ​ລະ​ນີ​ທີ່​ມາດ​ຕະ​ຖານ ISO C ລະ​ບຸ​ວ່າ​ຄວາມ​ຜິດ​ພາດ​ໄດ້​ຮັບ​ການ​ກັບ​ຄືນ​ມາ​ຫຼື​ວ່າ​ພຶດ​ຕິ​ກໍາ​ແມ່ນ​
ບໍ່ໄດ້ກໍານົດ. ເຖິງແມ່ນວ່າໄວຍາກອນ (ເບິ່ງ Grammar) ອະ​ນຸ​ຍາດ​ໃຫ້​ການ​ສ້າງ​ໃນ​ຫນ້າ​ທີ່​ທີ່​ຈະ​ປາ​ກົດ​ທີ່​ບໍ່​ມີ​
arguments ຫຼືວົງເລັບ, ເວັ້ນເສຍແຕ່ວ່າ argument ຫຼືວົງເລັບຖືກລະບຸວ່າເປັນທາງເລືອກໃນ
ບັນ​ຊີ​ລາຍ​ຊື່​ດັ່ງ​ຕໍ່​ໄປ​ນີ້ (ໂດຍ​ການ​ສະ​ແດງ​ໃຫ້​ເຂົາ​ເຈົ້າ​ຢູ່​ໃນ​ "[]" ວົງເລັບ), ການນໍາໃຊ້ດັ່ງກ່າວແມ່ນບໍ່ໄດ້ກໍານົດ.

atan2(y,x)
ກັບຄືນ arctangent ຂອງ y/x ໃນເຣດຽນໃນໄລຍະ [−π,π].

cos(x) ກັບຄືນ cosine ຂອງ x, ບ່ອນທີ່ x ຢູ່ໃນເຣດຽນ.

sin(x) ກັບຄືນ sine ຂອງ x, ບ່ອນທີ່ x ຢູ່ໃນເຣດຽນ.

exp(x) ສົ່ງຄືນຟັງຊັນ exponential ຂອງ x.

log(x) ກັບຄືນ logarithm ທໍາມະຊາດຂອງ x.

sqrt(x) ກັບຄືນຮາກທີ່ສອງຂອງ x.

int(x) ສົ່ງຄືນອາກິວເມັນທີ່ຖືກຕັດອອກເປັນຈຳນວນເຕັມ. ການຕັດຕ້ອງເປັນ 0 ເມື່ອ
x> 0.

ໄຕ້() ສົ່ງຄືນຕົວເລກສຸ່ມ n, ເຊັ່ນວ່າ 0≤n

ໄສ້([ຕົວຢ່າງ])
ກໍານົດມູນຄ່າແກ່ນສໍາລັບ ໄຕ້ to ຕົວຢ່າງ ຫຼືໃຊ້ເວລາຂອງມື້ຖ້າ ຕົວຢ່າງ ຖືກລະເວັ້ນ.
ມູນຄ່າເມັດກ່ອນຫນ້າຈະຖືກສົ່ງຄືນ.

string ຫນ້າທີ່
ຟັງຊັນສະຕຣິງໃນລາຍການຕໍ່ໄປນີ້ຈະຖືກຮອງຮັບ. ເຖິງແມ່ນວ່າໄວຍາກອນ (ເບິ່ງ
Grammar) ອະ​ນຸ​ຍາດ​ໃຫ້​ປະ​ຕິ​ບັດ​ຫນ້າ​ທີ່​ສ້າງ​ໃນ​ປະ​ກົດ​ວ່າ​ບໍ່​ມີ​ການ​ໂຕ້​ຖຽງ​ຫຼື​ວົງ​ເລັບ​, ເວັ້ນ​ເສຍ​ແຕ່​ໄດ້​
argument ຫຼືວົງເລັບຖືກຊີ້ບອກເປັນທາງເລືອກໃນບັນຊີລາຍຊື່ຕໍ່ໄປນີ້ (ໂດຍການສະແດງ
ເຂົາເຈົ້າພາຍໃນ "[]" ວົງເລັບ), ການນໍາໃຊ້ດັ່ງກ່າວແມ່ນບໍ່ໄດ້ກໍານົດ.

gsub(ere, ແທນ[, in])
ປະຕິບັດຕົວຄືກັບ ການຍ່ອຍ (ເບິ່ງຂ້າງລຸ່ມນີ້), ຍົກເວັ້ນວ່າມັນຈະທົດແທນການປະກົດຕົວທັງຫມົດຂອງ
ການສະແດງອອກປົກກະຕິ (ເຊັ່ນ: ed utility global substitute) ໃນ $0 ຫຼື​ໃນ in
ການໂຕ້ຖຽງ, ໃນເວລາທີ່ກໍານົດ.

ດັດຊະນີ(s, t)
ກັບຄືນຕໍາແຫນ່ງ, ໃນຕົວອັກສອນ, ຕົວເລກຈາກ 1, ໃນສະຕຣິງ s ບ່ອນທີ່ string t
ທໍາອິດເກີດຂຶ້ນ, ຫຼືສູນຖ້າຫາກວ່າມັນບໍ່ໄດ້ເກີດຂຶ້ນທັງຫມົດ.

ຄວາມຍາວ[([s])]
ຕອບຄວາມຍາວ, ໃນຕົວອັກສອນ, ຂອງການໂຕ້ແຍ້ງຂອງມັນທີ່ເອົາເປັນສະຕຣິງ, ຫຼືຂອງ
ບັນທຶກທັງຫມົດ, $0, ຖ້າບໍ່ມີການໂຕ້ຖຽງ.

ການແຂ່ງຂັນ(s, ere)
ກັບຄືນຕໍາແຫນ່ງ, ໃນຕົວອັກສອນ, ຕົວເລກຈາກ 1, ໃນສະຕຣິງ s ບ່ອນທີ່
ຂະຫຍາຍການສະແດງອອກປົກກະຕິ ere ເກີດຂຶ້ນ, ຫຼືສູນຖ້າຫາກວ່າມັນບໍ່ໄດ້ເກີດຂຶ້ນທັງຫມົດ.
RSTART ຈະຖືກຕັ້ງເປັນຕໍາແຫນ່ງເລີ່ມຕົ້ນ (ເຊິ່ງຄືກັນກັບຜົນຕອບແທນ
value), ສູນຖ້າບໍ່ພົບການຈັບຄູ່; RLENGTH ຈະຖືກຕັ້ງເປັນຄວາມຍາວຂອງ
ສະຕຣິງທີ່ກົງກັນ, −1 ຖ້າບໍ່ພົບການຈັບຄູ່.

ແບ່ງປັນ(s, a[, fs ])
ແຍກສາຍ s ເຂົ້າໄປໃນອົງປະກອບ array a[1], a[2] , ... , a[n], ແລະກັບຄືນ nທີ່ຢູ່ ທັງຫມົດ
ອົງປະກອບຂອງ array ຈະຖືກລຶບລ້າງກ່ອນທີ່ການແບ່ງປັນຈະຖືກປະຕິບັດ. ໄດ້
ການແຍກຕົວຈະຕ້ອງເຮັດດ້ວຍ ERE fs ຫຼືກັບຕົວແຍກພາກສະຫນາມ FS if fs is
ບໍ່ໄດ້ໃຫ້. ແຕ່ລະອົງປະກອບ array ຈະມີມູນຄ່າສະຕຣິງເມື່ອສ້າງແລະ, if
ເຫມາະສົມ, ອົງປະກອບ array ຈະຖືກພິຈາລະນາເປັນຕົວເລກ (ເບິ່ງ
ສຳ ນວນ in ງຸ່ມ). ຜົນກະທົບຂອງສະຕຣິງ null ເປັນຄ່າຂອງ fs is
ບໍ່ໄດ້ລະບຸ.

ແລ່ນ(fmt, ຕົວຢ່າງ, ຕົວຢ່າງ, ... )
ຈັດຮູບແບບການສະແດງອອກຕາມ printf ຮູບແບບທີ່ມອບໃຫ້ໂດຍ fmt ແລະກັບຄືນ
ຊ່ອຍແນ່ຜົນໄດ້ຮັບ.

ຍ່ອຍ(ere, ແທນ[, in ])
ປ່ຽນສະຕຣິງ ແທນ ແທນທີ່ຈະເປັນຕົວຢ່າງທໍາອິດຂອງການຂະຫຍາຍ
ການສະແດງອອກເປັນປະ ຈຳ TIME ໃນ string in ແລະສົ່ງຄືນຈໍານວນການທົດແທນ. ອັນ
('&') ປາກົດຢູ່ໃນສາຍ ແທນ ຈະຖືກແທນທີ່ດ້ວຍສາຍ
ຈາກ in ທີ່ກົງກັບ ERE. ອັນ ນຳໜ້າດ້ວຍ ກ ຈະ
ຖືກຕີຄວາມໝາຍເປັນຕົວໜັງສື ລັກສະນະ. ການປະກົດຕົວຂອງສອງ
ຕິດຕໍ່ກັນ ຕົວອັກສອນຈະຖືກຕີຄວາມວ່າເປັນພຽງຕົວໜັງສືອັນດຽວ
ລັກສະນະ. ການປະກົດຕົວອື່ນໆຂອງ ກ (ຍົກ​ຕົວ​ຢ່າງ,
ກ່ອນລັກສະນະອື່ນໆ) ຈະຖືກປະຕິບັດເປັນຕົວຫນັງສື
ລັກສະນະ. ໃຫ້ສັງເກດວ່າຖ້າ ແທນ ແມ່ນຕົວໜັງສືສະຕຣິງ (the lexical token ຄັກ1 ເບິ່ງ
Grammar), ການຈັດການຂອງ ລັກສະນະເກີດຂຶ້ນຫຼັງຈາກ lexical ໃດ
ການປຸງແຕ່ງ, ລວມທັງ lexical ໃດ -escape ການ​ປຸງ​ແຕ່ງ​ລໍາ​ດັບ​. ຖ້າ in
ຖືກກໍານົດແລະມັນບໍ່ແມ່ນມູນຄ່າ (ເບິ່ງ ສຳ ນວນ in ງຸ່ມ), ພຶດຕິກໍາແມ່ນ
ບໍ່ໄດ້ກໍານົດ. ຖ້າ in ຖືກລະເວັ້ນ, ງຸ່ມ ຈະຕ້ອງໃຊ້ບັນທຶກປັດຈຸບັນ ($0) ໃນສະຖານທີ່ຂອງມັນ.

ຍ່ອຍ(s, m[, n ])
ກັບຄືນສູງສຸດ n- ຕົວອັກສອນຍ່ອຍຂອງ s ທີ່ເລີ່ມຕົ້ນຢູ່ໃນຕໍາແຫນ່ງ m,
ຕົວເລກຈາກ 1. ຖ້າ n ຖືກລະເວັ້ນ, ຫຼືຖ້າ n ລະບຸຕົວລະຄອນຫຼາຍກວ່າ
ປະໄວ້ຢູ່ໃນສະຕຣິງ, ຄວາມຍາວຂອງສາຍຍ່ອຍຈະຖືກຈໍາກັດໂດຍຄວາມຍາວ
ຂອງຊ່ອຍແນ່ s.

ລຸ່ມ(s)
ຕອບສະຕຣິງຕາມສະຕຣິງ s. ແຕ່ລະລັກສະນະໃນ s ນັ້ນແມ່ນຕົວພິມໃຫຍ່
ຈົດໝາຍທີ່ລະບຸວ່າມີ ກ ລຸ່ມ ແຜນທີ່ໂດຍ LC_CTYPE ປະ​ເພດ​ຂອງ​
ທ້ອງຖິ່ນປະຈຸບັນຈະຖືກແທນທີ່ດ້ວຍຕົວພິມນ້ອຍ
ກໍານົດໂດຍແຜນທີ່. ລັກສະນະອື່ນໆໃນ s ຈະ​ບໍ່​ມີ​ການ​ປ່ຽນ​ແປງ​ໃນ​
ສະຕຣິງກັບຄືນ.

topper(s)
ຕອບສະຕຣິງຕາມສະຕຣິງ s. ແຕ່ລະລັກສະນະໃນ s ນັ້ນແມ່ນຕົວພິມນ້ອຍ
ຈົດໝາຍທີ່ລະບຸວ່າມີ ກ topper ແຜນທີ່ໂດຍ LC_CTYPE ປະ​ເພດ​ຂອງ​
ທ້ອງຖິ່ນປະຈຸບັນຖືກແທນທີ່ໃນສະຕຣິງທີ່ສົ່ງຄືນດ້ວຍຕົວພິມໃຫຍ່
ກໍານົດໂດຍແຜນທີ່. ລັກສະນະອື່ນໆໃນ s ບໍ່ມີການປ່ຽນແປງໃນຜົນຕອບແທນ
string

ຫນ້າທີ່ກ່ອນຫນ້າທັງຫມົດທີ່ໃຊ້ TIME ເປັນພາລາມິເຕີຄາດຫວັງວ່າຮູບແບບຫຼືສາຍ
ການສະແດງອອກທີ່ມີຄຸນຄ່າທີ່ເປັນການສະແດງອອກປົກກະຕິຕາມທີ່ໄດ້ກໍານົດໄວ້ໃນ ເປັນປົກກະຕິ ສຳ ນວນ.

Input / Output ແລະ ໂດຍ​ທົ່ວ​ໄປ ຫນ້າທີ່
ການ​ປ້ອນ​ຂໍ້​ມູນ / ຜົນ​ຜະ​ລິດ​ແລະ​ຫນ້າ​ທີ່​ທົ່ວ​ໄປ​ແມ່ນ​:

ໃກ້(ການສະແດງອອກ)
ປິດໄຟລ໌ຫຼືທໍ່ທີ່ເປີດໂດຍ ກ ພິມ or printf ຖະແຫຼງການຫຼືໂທຫາ
ສາຍ ດ້ວຍ string-value ດຽວກັນ ການສະແດງອອກ. ຂອບເຂດຈໍາກັດກ່ຽວກັບຈໍານວນການເປີດ
ການສະແດງອອກ ການໂຕ້ຖຽງແມ່ນການປະຕິບັດທີ່ຖືກກໍານົດ. ຖ້າປິດສົບຜົນສໍາເລັດ, ໄດ້
ຟັງຊັນຈະກັບຄືນສູນ; ຖ້າບໍ່ດັ່ງນັ້ນ, ມັນຈະກັບຄືນມາບໍ່ແມ່ນສູນ.

ການສະແດງອອກ | ສາຍ [var]
ອ່ານບັນທຶກການປ້ອນຂໍ້ມູນຈາກກະແສທີ່ທໍ່ຈາກຜົນຜະລິດຂອງຄໍາສັ່ງ. ໄດ້
stream ຈະຖືກສ້າງຂື້ນຖ້າບໍ່ມີກະແສເປີດໃນປະຈຸບັນດ້ວຍຄ່າຂອງ
ການສະແດງອອກ ເປັນຊື່ຄໍາສັ່ງຂອງມັນ. ກະແສທີ່ສ້າງຂຶ້ນຈະຕ້ອງເທົ່າກັບໜຶ່ງ
ສ້າງໂດຍການໂທຫາ popen() ຟັງຊັ່ນທີ່ມີຄ່າຂອງ ການສະແດງອອກ ເປັນ
ຄໍາສັ່ງ argument ແລະມູນຄ່າຂອງ r ເປັນ ຮູບແບບການ ການໂຕ້ຖຽງ. ຕາບໃດທີ່ກະແສ
ຍັງເປີດຢູ່, ການໂທຕໍ່ມາໃນນັ້ນ ການສະແດງອອກ ປະເມີນເປັນສາຍດຽວກັນ
ຄ່າຈະຕ້ອງອ່ານບັນທຶກຕໍ່ໄປຈາກກະແສ. ກະແສຈະຍັງຄົງຢູ່
ເປີດຈົນກ່ວາ ໃກ້ ຟັງຊັນແມ່ນເອີ້ນວ່າດ້ວຍການສະແດງອອກທີ່ປະເມີນກັບ
ຄ່າສະຕຣິງດຽວກັນ. ໃນ​ເວ​ລາ​ນັ້ນ, ສາຍ​ນ​້​ໍ​ຈະ​ຖືກ​ປິດ​ເປັນ​ຖ້າ​ຫາກ​ວ່າ​ໂດຍ​ການ​ໂທ​ຫາ
ໄດ້ ປິດ() ຫນ້າທີ່. ຖ້າ var ຖືກລະເວັ້ນ, $0 ແລະ NF ຈະຖືກຕັ້ງ; ຖ້າບໍ່ດັ່ງນັ້ນ, var
ຈະຖືກຕັ້ງແລະ, ຖ້າເຫມາະສົມ, ມັນຈະຖືກພິຈາລະນາເປັນຕົວເລກ (ເບິ່ງ
ສຳ ນວນ in ງຸ່ມ).

ໄດ້ ສາຍ ຜູ້ປະກອບການສາມາດສ້າງໂຄງສ້າງທີ່ບໍ່ຊັດເຈນເມື່ອມີ
ຕົວປະຕິບັດການ unparenthesized (ລວມທັງ concatenate) ໄປທາງຊ້າຍຂອງ '|' (ເຖິງ
ການເລີ່ມຕົ້ນຂອງການສະແດງອອກທີ່ມີ ສາຍ). ໃນສະພາບການຂອງ '$'
ຜູ້ປະຕິບັດການ, '|' ຈະ​ປະ​ຕິ​ບັດ​ຕົວ​ເປັນ​ຖ້າ​ຫາກ​ວ່າ​ມັນ​ມີ​ຄວາມ​ສໍາ​ຄັນ​ຕ​່​ໍ​າ​ກ​່​ວາ​ '$'. ຜົນ
ການ​ປະ​ເມີນ​ຜົນ​ການ​ປະ​ຕິ​ບັດ​ການ​ອື່ນໆ​ແມ່ນ​ບໍ່​ໄດ້​ລະ​ບຸ​ໄວ້​, ແລະ​ຄໍາ​ຮ້ອງ​ສະ​ຫມັກ​ທີ່​ສອດ​ຄ້ອງ​ກັນ​ຈະ​
ກຳນົດວົງເລັບໃຫ້ຖືກຕ້ອງທຸກການນຳໃຊ້ດັ່ງກ່າວ.

ສາຍ ຕັ້ງ $0 ໃສ່ບັນທຶກການປ້ອນຂໍ້ມູນຕໍ່ໄປຈາກໄຟລ໌ປ້ອນຂໍ້ມູນປັດຈຸບັນ. ຮູບແບບນີ້
ສາຍ ຈະ​ກໍາ​ນົດ NF, NR, ແລະ FNR ຕົວແປ

ສາຍ var
ກໍານົດຕົວແປ var ໄປຫາບັນທຶກການປ້ອນຂໍ້ມູນຕໍ່ໄປຈາກໄຟລ໌ປ້ອນຂໍ້ມູນປະຈຸບັນ ແລະ, ຖ້າ
ທີ່​ເຫມາະ​ສົມ​, var ຈະຖືກພິຈາລະນາເປັນຕົວເລກ (ເບິ່ງ ສຳ ນວນ in ງຸ່ມ).
ແບບຟອມຂອງ ສາຍ ຈະ​ກໍາ​ນົດ FNR ແລະ NR ຕົວແປ

ສາຍ [var] < ການສະແດງອອກ
ອ່ານບັນທຶກຕໍ່ໄປຂອງການປ້ອນຂໍ້ມູນຈາກໄຟລ໌ທີ່ມີຊື່. ໄດ້ ການສະແດງອອກ ຈະເປັນ
ປະເມີນເພື່ອຜະລິດສະຕຣິງທີ່ໃຊ້ເປັນຊື່ເສັ້ນທາງ. ຖ້າໄຟລ໌ຂອງນັ້ນ
ຊື່ບໍ່ໄດ້ເປີດໃນປັດຈຸບັນ, ມັນຈະຖືກເປີດ. ຕາບໃດທີ່ກະແສຍັງຄົງຢູ່
ເປີດ, ໂທຕໍ່ມາໃນທີ່ ການສະແດງອອກ ປະເມີນເປັນຄ່າສະຕຣິງດຽວກັນ
ຈະອ່ານບັນທຶກຕໍ່ໄປຈາກໄຟລ໌. ໄຟລ໌ຈະຍັງຄົງເປີດຈົນກ່ວາ
ໄດ້ ໃກ້ ຟັງຊັນແມ່ນເອີ້ນວ່າດ້ວຍການສະແດງອອກທີ່ປະເມີນຄືກັນ
ຄ່າສະຕຣິງ. ຖ້າ var ຖືກລະເວັ້ນ, $0 ແລະ NF ຈະຖືກຕັ້ງ; ຖ້າບໍ່ດັ່ງນັ້ນ, var ຈະເປັນ
ກໍານົດແລະ, ຖ້າເຫມາະສົມ, ມັນຈະຖືກພິຈາລະນາເປັນຕົວເລກ (ເບິ່ງ
ສຳ ນວນ in ງຸ່ມ).

ໄດ້ ສາຍ ຜູ້ປະກອບການສາມາດສ້າງໂຄງສ້າງທີ່ບໍ່ຊັດເຈນເມື່ອມີ
unparenthesized binary operators (ລວມທັງ concatenate) ໄປທາງຂວາຂອງ '<'
(ເຖິງຕອນທ້າຍຂອງສຳນວນທີ່ປະກອບດ້ວຍ ສາຍ). ຜົນໄດ້ຮັບຂອງ
ການ​ປະ​ເມີນ​ການ​ກໍ່​ສ້າງ​ດັ່ງ​ກ່າວ​ແມ່ນ​ບໍ່​ໄດ້​ລະ​ບຸ​ໄວ້​, ແລະ​ຄໍາ​ຮ້ອງ​ສະ​ຫມັກ​ທີ່​ສອດ​ຄ້ອງ​ກັນ​ຈະ​
ກຳນົດວົງເລັບໃຫ້ຖືກຕ້ອງທຸກການນຳໃຊ້ດັ່ງກ່າວ.

ລະບົບ(ການສະແດງອອກ)
ປະຕິບັດຄໍາສັ່ງທີ່ໃຫ້ໂດຍ ການສະແດງອອກ ໃນລັກສະນະທີ່ທຽບເທົ່າກັບ ລະບົບ()
ຟັງຊັນທີ່ກຳນົດໄວ້ໃນ System Interfaces volume ຂອງ POSIX.1-2008 ແລະສົ່ງຄືນ
ອອກຈາກສະຖານະຂອງຄໍາສັ່ງ.

ທຸກ​ຮູບ​ແບບ​ຂອງ​ ສາຍ ຈະສົ່ງຄືນ 1 ສຳລັບການປ້ອນຂໍ້ມູນສຳເລັດ, ສູນສຳລັບສິ້ນສຸດຂອງໄຟລ໌, ແລະ −1 ສຳລັບ
ຄວາມ​ຜິດ​ພາດ​.

ບ່ອນທີ່ສະຕຣິງຖືກໃຊ້ເປັນຊື່ຂອງໄຟລ໌ຫຼືທໍ່, ຄໍາຮ້ອງສະຫມັກຈະຕ້ອງຮັບປະກັນ
ວ່າ strings ແມ່ນ textually ຄືກັນ. ຄຳສັບທີ່ວ່າ ``ຄ່າສະຕຣິງດຽວກັນ'' ໝາຍເຖິງ
ວ່າ `` ສາຍທຽບເທົ່າ ' , ເຖິງແມ່ນວ່າມັນແຕກຕ່າງກັນພຽງແຕ່ ຕົວອັກສອນ, ເປັນຕົວແທນ
ໄຟລ​໌​ທີ່​ແຕກ​ຕ່າງ​ກັນ​.

ຜູ້ໃຊ້ກໍານົດ ຫນ້າທີ່
ໄດ້ ງຸ່ມ ພາສາຍັງໃຫ້ຟັງຊັນທີ່ຜູ້ໃຊ້ກຳນົດເອງ. ຫນ້າທີ່ດັ່ງກ່າວສາມາດຖືກກໍານົດເປັນ:

ຫນ້າທີ່ ຊື່([ພາລາມິເຕີ, ...]) { ບົດລາຍງານ }

ຟັງຊັນສາມາດຖືກອ້າງເຖິງທຸກບ່ອນໃນ ງຸ່ມ ໂຄງການ; ໂດຍສະເພາະ, ການນໍາໃຊ້ຂອງມັນສາມາດເຮັດໄດ້
ນຳໜ້າຄຳນິຍາມຂອງມັນ. ຂອບເຂດຂອງຫນ້າທີ່ແມ່ນທົ່ວໂລກ.

ພາລາມິເຕີການທໍາງານ, ຖ້າມີ, ສາມາດເປັນ scalar ຫຼື arrays; ພຶດຕິກໍາແມ່ນ
undefined ຖ້າຊື່ array ຖືກສົ່ງຜ່ານເປັນພາລາມິເຕີທີ່ຟັງຊັນໃຊ້ເປັນ scalar, ຫຼື
ຖ້າການສະແດງອອກ scalar ຖືກສົ່ງຜ່ານເປັນພາລາມິເຕີທີ່ຟັງຊັນໃຊ້ເປັນອາເຣ.
ພາລາມິເຕີຟັງຊັນຈະຖືກສົ່ງຜ່ານໂດຍຄ່າຖ້າ scalar ແລະໂດຍອ້າງອີງຖ້າຊື່ array.

ຈໍານວນຂອງຕົວກໍານົດການໃນຄໍານິຍາມຟັງຊັນຈໍາເປັນຕ້ອງບໍ່ກົງກັບຈໍານວນຂອງ
ຕົວກໍານົດການໃນການໂທຟັງຊັນ. ຕົວກໍານົດການຢ່າງເປັນທາງການເກີນສາມາດຖືກນໍາໃຊ້ເປັນຕົວແປທ້ອງຖິ່ນ.
ຖ້າມີການສະຫນອງການໂຕ້ຖຽງຫນ້ອຍລົງໃນການເອີ້ນຟັງຊັນຫຼາຍກ່ວາຢູ່ໃນຄໍານິຍາມຂອງຟັງຊັນ,
ຕົວກໍານົດການພິເສດທີ່ຖືກນໍາໃຊ້ຢູ່ໃນຮ່າງກາຍຂອງຫນ້າທີ່ເປັນ scalar ຈະຕ້ອງປະເມີນ
ຄ່າ uninitialized ຈົນກ່ວາພວກເຂົາເຈົ້າໄດ້ຖືກເລີ່ມຕົ້ນຖ້າບໍ່ດັ່ງນັ້ນ, ແລະຕົວກໍານົດການພິເສດທີ່
ຖືກນໍາໃຊ້ຢູ່ໃນຮ່າງກາຍຂອງຫນ້າທີ່ເປັນ arrays ຈະຖືກປະຕິບັດເປັນ array uninitialized ບ່ອນທີ່
ແຕ່​ລະ​ອົງ​ປະ​ກອບ​ການ​ປະ​ເມີນ​ເປັນ​ມູນ​ຄ່າ​ທີ່​ບໍ່​ໄດ້​ເລີ່ມ​ຕົ້ນ​ຈົນ​ກ​່​ວາ​ບໍ່​ດັ່ງ​ນັ້ນ​ຈະ​ເລີ່ມ​ຕົ້ນ​.

ເມື່ອເອີ້ນຟັງຊັນໃດໜຶ່ງ, ບໍ່ມີພື້ນທີ່ສີຂາວສາມາດຖືກວາງໄວ້ລະຫວ່າງຊື່ຟັງຊັນ ແລະ
ເປີດວົງເລັບ. ການໂທຟັງຊັນສາມາດຖືກວາງໄວ້ໄດ້ ແລະການໂທຊ້ຳໆສາມາດໂທອອກໄດ້
ຫນ້າທີ່. ເມື່ອກັບຄືນຈາກການເອີ້ນຟັງຊັນທີ່ຕັ້ງ ຫຼື recursive ໃດ, ຄ່າຂອງທັງໝົດ
ຕົວກໍານົດການຂອງຟັງຊັນການໂທຈະບໍ່ປ່ຽນແປງ, ຍົກເວັ້ນພາລາມິເຕີ array ຜ່ານ
ໂດຍອ້າງອີງ. ໄດ້ ການກັບຄືນມາ ຄຳຖະແຫຼງທີ່ສາມາດໃຊ້ເພື່ອສົ່ງຄືນຄ່າ. ຖ້າ ກ ການກັບຄືນມາ ຄໍາຖະແຫຼງທີ່
ປາກົດຢູ່ນອກນິຍາມຟັງຊັນ, ພຶດຕິກໍາແມ່ນບໍ່ໄດ້ກໍານົດ.

ໃນ​ຄໍາ​ນິ​ຍາມ​ຫນ້າ​ທີ່​, ຕົວອັກສອນຈະຕ້ອງເປັນທາງເລືອກກ່ອນທີ່ຈະເປີດ
brace ແລະຫຼັງຈາກວົງເລັບປິດ. ຄໍານິຍາມຟັງຊັນສາມາດປາກົດຢູ່ທຸກບ່ອນໃນໂຄງການ
ຢູ່​ໃສ ຮູບ​ແບບ​ການ​ປະ​ຕິ​ບັດ​ ຄູ່ແມ່ນອະນຸຍາດ.

Grammar
ໄວຍາກອນໃນພາກນີ້ແລະສົນທິສັນຍາ lexical ໃນພາກຕໍ່ໄປນີ້ຈະຕ້ອງ
ຮ່ວມກັນອະທິບາຍ syntax ສໍາລັບ ງຸ່ມ ໂຄງການ. ສົນທິສັນຍາທົ່ວໄປສໍາລັບການແບບນີ້ຂອງ
ໄວຍາກອນໄດ້ຖືກອະທິບາຍຢູ່ໃນ ສ່ວນ 1.3, Grammar ອະນຸສັນຍາ. ໂຄງການທີ່ຖືກຕ້ອງສາມາດເປັນ
ເປັນຕົວແທນເປັນສັນຍາລັກທີ່ບໍ່ແມ່ນຢູ່ປາຍຍອດ ໂຄງການ ໃນໄວຍາກອນ. syntax ຢ່າງເປັນທາງການນີ້ຈະ
ມີຄວາມສຳຄັນກວ່າຄຳອະທິບາຍໄວຍະກອນຂໍ້ຄວາມກ່ອນໜ້າ.

%ໂທເຄັນ NAME NUMBER ຄັກ TIME
%ໂທເຄັນ FUNC_NAME /* ຊື່ ປະຕິບັດຕາມ by '(' ໂດຍບໍ່ມີການ ສີຂາວ space */

/* ຄໍາສໍາຄັນ */
%token ເລີ່ມຕົ້ນສິ້ນສຸດ
/* 'BEGIN' 'END' */

%token Break ສືບຕໍ່ລຶບເຮັດອັນອື່ນ
/* 'ຢຸດ' 'ສືບຕໍ່' 'ລຶບ' 'ເຮັດ' 'ອື່ນ' */

% token Exit ສໍາລັບຟັງຊັນຖ້າຢູ່ໃນ
/* 'ອອກ' 'ສຳລັບ' 'ຟັງຊັນ' 'ຖ້າ' 'ໃນ' */

%token Next Print Printf Return while
/* 'ຕໍ່ໄປ' 'ພິມ' 'printf' 'ກັບຄືນ' 'ໃນຂະນະທີ່' */

/* ຊື່​ຫນ້າ​ທີ່​ສະ​ຫງວນ */
%token BUILTIN_FUNC_NAME
/* ຫນຶ່ງ token ສໍາລັບດັ່ງຕໍ່ໄປນີ້:
* atan2 cos sin exp log sqrt int rand srand
* ຄວາມຍາວດັດຊະນີ gsub ກົງກັບການແບ່ງປັນຍ່ອຍ sprintf
* substr tolower ລະບົບປິດ topper
*/
%token GETLINE
/* Syntactically ແຕກຕ່າງຈາກການກໍ່ສ້າງອື່ນໆ. */

/* ໂທເຄັນສອງຕົວອັກສອນ. */
%token ADD_ASSIGN SUB_ASSIGN MUL_ASSIGN DIV_ASSIGN MOD_ASSIGN POW_ASSIGN
/* '+=' '−=' '*=' '/=' '%=' '^=' */

%token ຫຼື AND NO_MATCH EQ LE GE NE INCR DECR APPEND
/* '||' '&&' '!~' '==' '<=' '>=' '!=' '++' '−−' '>>' */

/* ໂທເຄັນໜຶ່ງຕົວອັກສອນ. */
%token '{' '}' '(' ')' '[' ']' ',' ';' NEWLINE
%token '+' '−' '*' '%' '^' '!' '>' '<' '|' '?' ' : ' ' " " ' $ ' ' = '

% ເລີ່ມ​ຕົ້ນ​ໂຄງ​ການ
%%

ໂປຣແກຣມ : item_list
| actionless_item_list
;

item_list : newline_opt
| actionless_item_list terminator ລາຍການ
| item_list terminator ລາຍການ
| item_list ຕົວສິ້ນສຸດການປະຕິບັດ
;

actionless_item_list : item_list ຮູບແບບຕົວສິ້ນສຸດ
| actionless_item_list ຕົວສິ້ນສຸດຮູບແບບ
;

ລາຍການ : ຮູບແບບການປະຕິບັດ
| ຟັງຊັນ NAME '(' param_list_opt ')'
newline_opt action
| ຟັງຊັນ FUNC_NAME '(' param_list_opt ')'
newline_opt action
;

param_list_opt : /* ຫວ່າງ */
| param_list
;

param_list : NAME
| param_list ',' NAME
;

ຮູບ​ແບບ​: ເລີ່ມ​ຕົ້ນ​
| ຈົບ
| expr
| expr ',' newline_opt expr
;

ຄຳສັ່ງ : '{' newline_opt '}'
| '{' newline_opt terminated_statement_list '}'
| '{' newline_opt unterminated_statement_list '}'
;

terminator : terminator ';'
| terminator NEWLINE
| ';'
| NEWLINE
;

terminated_statement_list : terminated_statement
| terminated_statement_list terminated_statement
;

unterminated_statement_list : unterminated_statement
| terminated_statement_list unterminated_statement
;

terminated_statement : action newline_opt
| ຖ້າ '(' expr ')' newline_opt terminated_statement
| ຖ້າ '(' expr ')' newline_opt terminated_statement
newline_opt terminated_statement ອື່ນ
| ໃນຂະນະທີ່ '(' expr ')' newline_opt terminated_statement
| ສໍາລັບ '('simple_statement_opt ';'
expr_opt ';' simple_statement_opt ')' newline_opt
terminated_statement
| ສໍາລັບ '(' NAME In NAME ')' newline_opt
terminated_statement
| ';' newline_opt
| terminatable_statement NEWLINE newline_opt
| terminatable_statement ';' newline_opt
;

unterminated_statement : terminatable_statement
| ຖ້າ '(' expr ')' newline_opt unterminated_statement
| ຖ້າ '(' expr ')' newline_opt terminated_statement
ອື່ນ newline_opt unterminated_statement
| ໃນຂະນະທີ່ '(' expr ')' newline_opt unterminated_statement
| ສໍາລັບ '('simple_statement_opt ';'
expr_opt ';' simple_statement_opt ')' newline_opt
unterminated_statement
| ສໍາລັບ '(' NAME In NAME ')' newline_opt
unterminated_statement
;

terminatable_statement : simple_statement
| ພັກຜ່ອນ
| ສືບຕໍ່
| ຕໍ່ໄປ
| ອອກຈາກ expr_opt
| ກັບຄືນ expr_opt
| ເຮັດ newline_opt terminated_statement ໃນຂະນະທີ່ '(' expr ')'
;

simple_statement_opt : /* ຫວ່າງ */
| simple_statement
;

simple_statement : ລຶບ NAME '[' expr_list ']'
| expr
| print_ຖະແຫຼງການ
;

print_statement : simple_print_statement
| simple_print_statement output_redirection
;

simple_print_statement : ພິມ print_expr_list_opt
| ພິມ '(' multiple_expr_list ')'
| Printf print_expr_list
| Printf '(' multiple_expr_list ')'
;

output_redirection : '>' expr
| APPEND expr
| '|' expr
;

expr_list_opt : /* ຫວ່າງ */
| expr_list
;

expr_list : expr
| multiple_expr_list
;

multiple_expr_list : expr ',' newline_opt expr
| multiple_expr_list ',' newline_opt expr
;

expr_opt : /* ຫວ່າງ */
| expr
;

expr : unary_expr
| non_unary_expr
;

unary_expr : '+' expr
| '−' expr
| unary_expr '^' expr
| unary_expr '*' expr
| unary_expr '/' expr
| unary_expr '%' expr
| unary_expr '+' expr
| unary_expr '−' expr
| unary_expr non_unary_expr
| unary_expr '<' expr
| unary_expr LE expr
| unary_expr NE expr
| unary_expr EQ expr
| unary_expr '>' expr
| unary_expr GE expr
| unary_expr '~' expr
| unary_expr NO_MATCH expr
| unary_expr ໃນ NAME
| unary_expr ແລະ newline_opt expr
| unary_expr ຫຼື newline_opt expr
| unary_expr '?' expr ':' expr
| unary_input_function
;

non_unary_expr : '(' expr ')'
| '!' expr
| non_unary_expr '^' expr
| non_unary_expr '*' expr
| non_unary_expr '/' expr
| non_unary_expr '%' expr
| non_unary_expr '+' expr
| non_unary_expr '−' expr
| non_unary_expr non_unary_expr
| non_unary_expr '<' expr
| non_unary_expr LE expr
| non_unary_expr NE expr
| non_unary_expr EQ expr
| non_unary_expr '>' expr
| non_unary_expr GE expr
| non_unary_expr '~' expr
| non_unary_expr NO_MATCH expr
| non_unary_expr ໃນ NAME
| '(' multiple_expr_list ')' ໃນ NAME
| non_unary_expr ແລະ newline_opt expr
| non_unary_expr ຫຼື newline_opt expr
| non_unary_expr '?' expr ':' expr
| NUMBER
| STRING
| ມູນຄ່າ
| ERE
| ມູນຄ່າ INCR
| ມູນຄ່າ DECR
| ມູນຄ່າ INCR
| ມູນຄ່າ DECR
| lvalue POW_ASSIGN expr
| ມູນຄ່າ MOD_ASSIGN expr
| lvalue MUL_ASSIGN expr
| lvalue DIV_ASSIGN expr
| lvalue ADD_ASSIGN expr
| lvalue SUB_ASSIGN expr
| lvalue '=' expr
| FUNC_NAME '(' expr_list_opt ')'
/* ບໍ່ອະນຸຍາດໃຫ້ມີພື້ນທີ່ສີຂາວກ່ອນ '(' */
| BUILTIN_FUNC_NAME '(' expr_list_opt ')'
| BUILTIN_FUNC_NAME
| non_unary_input_function
;

print_expr_list_opt : /* ຫວ່າງ */
| print_expr_list
;

print_expr_list : print_expr
| print_expr_list ',' newline_opt print_expr
;

print_expr : unary_print_expr
| non_unary_print_expr
;

unary_print_expr : '+' print_expr
| '−' print_expr
| unary_print_expr '^' print_expr
| unary_print_expr '*' print_expr
| unary_print_expr '/' print_expr
| unary_print_expr '%' print_expr
| unary_print_expr '+' print_expr
| unary_print_expr '−' print_expr
| unary_print_expr non_unary_print_expr
| unary_print_expr '~' print_expr
| unary_print_expr NO_MATCH print_expr
| unary_print_expr ໃນ NAME
| unary_print_expr ແລະ newline_opt print_expr
| unary_print_expr ຫຼື newline_opt print_expr
| unary_print_expr '?' print_expr ':' print_expr
;

non_unary_print_expr : '(' expr ')'
| '!' print_expr
| non_unary_print_expr '^' print_expr
| non_unary_print_expr '*' print_expr
| non_unary_print_expr '/' print_expr
| non_unary_print_expr '%' print_expr
| non_unary_print_expr '+' print_expr
| non_unary_print_expr '−' print_expr
| non_unary_print_expr non_unary_print_expr
| non_unary_print_expr '~' print_expr
| non_unary_print_expr NO_MATCH print_expr
| non_unary_print_expr ໃນ NAME
| '(' multiple_expr_list ')' ໃນ NAME
| non_unary_print_expr ແລະ newline_opt print_expr
| non_unary_print_expr OR newline_opt print_expr
| non_unary_print_expr '?' print_expr ':' print_expr
| NUMBER
| STRING
| ມູນຄ່າ
| ERE
| ມູນຄ່າ INCR
| ມູນຄ່າ DECR
| ມູນຄ່າ INCR
| ມູນຄ່າ DECR
| ມູນຄ່າ POW_ASSIGN print_expr
| ມູນຄ່າ MOD_ASSIGN print_expr
| ມູນຄ່າ MUL_ASSIGN print_expr
| ມູນຄ່າ DIV_ASSIGN print_expr
| ມູນຄ່າ ADD_ASSIGN print_expr
| lvalue SUB_ASSIGN print_expr
| lvalue '=' print_expr
| FUNC_NAME '(' expr_list_opt ')'
/* ບໍ່ອະນຸຍາດໃຫ້ມີພື້ນທີ່ສີຂາວກ່ອນ '(' */
| BUILTIN_FUNC_NAME '(' expr_list_opt ')'
| BUILTIN_FUNC_NAME
;

ຄ່າ : NAME
| NAME '[' expr_list ']'
| '$' expr
;

non_unary_input_function : simple_get
| simple_get '<' expr
| non_unary_expr '|' simple_get
;

unary_input_function : unary_expr '|' simple_get
;

simple_get : GETLINE
| ຄ່າ GETLINE
;

newline_opt : /* ຫວ່າງ */
| newline_opt NEWLINE
;

ໄວຍາກອນນີ້ມີຄວາມບໍ່ແນ່ນອນຫຼາຍອັນທີ່ຕ້ອງໄດ້ຮັບການແກ້ໄຂດັ່ງຕໍ່ໄປນີ້:

* ຄວາມສຳຄັນຂອງຜູ້ດຳເນີນງານ ແລະ ສະມາຄົມຈະຕ້ອງເປັນໄປຕາມທີ່ອະທິບາຍໄວ້ໃນ ຕາຕະລາງ 4-1, ສຳ ນວນ
in ຫຼຸດລົງ ຄວາມ ສຳ ຄັນກ່ອນ in ງຸ່ມ.

* ໃນກໍລະນີຂອງຄວາມບໍ່ແນ່ນອນ, ເປັນ ອື່ນ ຈະຕ້ອງກ່ຽວຂ້ອງກັບອັນກ່ອນໜ້າທີ່ສຸດທັນທີ
if ທີ່ຈະຕອບສະຫນອງໄວຍາກອນ.

* ໃນບາງສະພາບການ, ກ ('/') ທີ່ຖືກນໍາໃຊ້ເພື່ອລ້ອມຮອບ ERE ຍັງສາມາດເປັນ
ປະຕິບັດການພະແນກ. ອັນນີ້ຈະຖືກແກ້ໄຂໃນແບບທີ່ບ່ອນໃດກໍໄດ້ແບ່ງອອກ
ຜູ້ປະກອບການສາມາດປາກົດ, a ຖືວ່າເປັນຜູ້ປະຕິບັດການພະແນກ. (ບໍ່​ມີ
ຜູ້ປະຕິບັດການພະແນກ unary.)

ແຕ່ລະສະແດງອອກໃນ an ງຸ່ມ ໂຄງ​ການ​ຈະ​ສອດ​ຄ່ອງ​ກັບ​ແບບ​ກ່ອນ​ແລະ​ກົດ​ລະ​ບຽບ​ການ​ຮ່ວມ​ມື​,
ເຖິງແມ່ນວ່າມັນບໍ່ຈໍາເປັນເພື່ອແກ້ໄຂຄວາມບໍ່ແນ່ນອນ. ສໍາລັບຕົວຢ່າງ, ເນື່ອງຈາກວ່າ '$' ມີສູງກວ່າ
ເໜືອກວ່າ '++', ຊ່ອຍແນ່ "$x++−−" ບໍ່ຖືກຕ້ອງ ງຸ່ມ ການສະແດງອອກ, ເຖິງແມ່ນວ່າມັນເປັນ
parsed unambiguously ໂດຍໄວຍາກອນເປັນ "$(x++)−−".

ສົນທິສັນຍາຫນຶ່ງທີ່ອາດຈະບໍ່ເຫັນໄດ້ຊັດເຈນຈາກໄວຍາກອນທີ່ເປັນທາງການແມ່ນບ່ອນທີ່
ຕົວອັກສອນທີ່ຍອມຮັບໄດ້. ມີການຈັດວາງທີ່ຊັດເຈນຫຼາຍເຊັ່ນການຢຸດ a
ຖະແຫຼງການ, ແລະ ກ ສາມາດໃຊ້ເພື່ອຫລົບຫນີ ຕົວອັກສອນລະຫວ່າງໃດໆ
tokens lexical. ເພີ່ມ​ເຕີມ, ຕົວອັກສອນທີ່ບໍ່ມີ ລັກສະນະສາມາດ
ປະ​ຕິ​ບັດ​ຕາມ​ເຄື່ອງ​ຫມາຍ​ຈຸດ​, ເປັນ​ວົງ​ເລັບ​ເປີດ​, ມີ​ເຫດ​ຜົນ AND operator ("&&"), ໂຕປະຕິບັດການຕາມເຫດຜົນ OR ("||"),
ໄດ້ do ຄໍາສໍາຄັນ, ໄດ້ ອື່ນ ຄໍາສໍາຄັນ, ແລະວົງເລັບປິດຂອງ an if, ສໍາລັບການ, ຫຼື ໃນຂະນະທີ່
ຖະແຫຼງການ. ຍົກ​ຕົວ​ຢ່າງ:

{ ພິມ $ 1,
$2 }

ໃບລານ ອະນຸສັນຍາ
ສົນທິສັນຍາ lexical ສໍາລັບ ງຸ່ມ ໂຄງການ, ກ່ຽວກັບໄວຍາກອນກ່ອນຫນ້າ, ຈະເປັນ
ດັ່ງຕໍ່ໄປນີ້:

1. ຍົກເວັ້ນດັ່ງທີ່ບັນທຶກໄວ້, ງຸ່ມ ຈະຮັບຮູ້ token ທີ່ຍາວທີ່ສຸດທີ່ເປັນໄປໄດ້ ຫຼືຈຸດເລີ່ມຕົ້ນ
ໃນຈຸດໃດຫນຶ່ງ.

2. ຄໍາຄິດເຫັນຈະຕ້ອງປະກອບດ້ວຍຕົວອັກສອນທີ່ເລີ່ມຕົ້ນດ້ວຍ ລັກສະນະ
ແລະສິ້ນສຸດໂດຍ, ແຕ່ບໍ່ລວມການປະກົດຕົວຕໍ່ໄປຂອງ, a . ຄໍາເຫັນຈະ
ບໍ່ມີຜົນ, ຍົກເວັ້ນການຈຳກັດ tokens lexical.

3. ທ ຈະຖືກຮັບຮູ້ວ່າເປັນສັນຍາລັກ NEWLINE.

4. ກ ລັກສະນະທັນທີທັນໃດຕິດຕາມດ້ວຍ a ຈະບໍ່ມີຜົນກະທົບ.

5. ເຄື່ອງໝາຍ ຄັກ ຈະເປັນຕົວແທນຂອງສະຕຣິງຄົງທີ່. ສະຕຣິງຄົງທີ່ຈະຕ້ອງເລີ່ມຕົ້ນດ້ວຍ
ລັກສະນະ '"'. ພາຍໃນສະຕຣິງຄົງທີ່, a ລັກ​ສະ​ນະ​ຈະ​ເປັນ​
ພິຈາລະນາທີ່ຈະເລີ່ມຕົ້ນລໍາດັບການຫລົບຫນີຕາມທີ່ລະບຸໄວ້ໃນຕາຕະລາງໃນ Base
ປະລິມານຄໍານິຍາມຂອງ POSIX.1-2008, ບົດ 5, ເອກະສານ ຮູບແບບ notation ('\\', '\a', '\b',
'\f', '\n', '\r', '\t', '\v'). ນອກຈາກນັ້ນ, ລໍາດັບການຫລົບຫນີໃນ ຕາຕະລາງ 4-2, Escape
ລໍາດັບ in ງຸ່ມ ຈະຖືກຮັບຮູ້. ກ ຈະບໍ່ເກີດຂຶ້ນພາຍໃນ string ເປັນ
ຄົງທີ່. ຄົງສະຕຣິງໃດໜຶ່ງຈະຖືກຢຸດໂດຍການປະກົດຕົວທີ່ບໍ່ໄດ້ຫຼົບຫຼີກທຳອິດ
ລັກສະນະ '"' ຫຼັງ​ຈາກ​ຫນຶ່ງ​ທີ່​ເລີ່ມ​ຕົ້ນ​ສະ​ຕ​ຣິງ​ຄົງ​ທີ່​. ມູນຄ່າຂອງ
string ຈະເປັນລໍາດັບຂອງຕົວອັກສອນທີ່ບໍ່ໄດ້ຫຼົບຫຼີກທັງໝົດ ແລະຄ່າຂອງການຫລົບໜີ
ລໍາດັບລະຫວ່າງ, ແຕ່ບໍ່ລວມເອົາ, ທັງສອງ delimiting '"' ລັກສະນະ.

6. ເຄື່ອງໝາຍ TIME ເປັນຕົວແທນຂອງຄ່າຄົງທີ່ສະແດງອອກເປັນປົກກະຕິ. ERE ຄົງທີ່
ຈະເລີ່ມຕົ້ນດ້ວຍ ລັກສະນະ. ພາຍໃນ ERE ຄົງທີ່, a
ລັກ​ສະ​ນະ​ຈະ​ໄດ້​ຮັບ​ການ​ພິ​ຈາ​ລະ​ນາ​ເພື່ອ​ເລີ່ມ​ຕົ້ນ​ການ​ລໍາ​ດັບ​ການ​ຫນີ​ທີ່​ລະ​ບຸ​ໄວ້​ໃນ​ຕາ​ຕະ​ລາງ​ໃນ​
ປະລິມານນິຍາມພື້ນຖານຂອງ POSIX.1-2008, ບົດ 5, ເອກະສານ ຮູບແບບ notation. ໃນ
ນອກຈາກນັ້ນ, ລໍາດັບການຫລົບຫນີໃນ ຕາຕະລາງ 4-2, Escape ລໍາດັບ in ງຸ່ມ ຈະເປັນ
ຮັບຮູ້. ຄໍາຮ້ອງສະຫມັກຈະຕ້ອງຮັບປະກັນວ່າ a ບໍ່ໄດ້ເກີດຂຶ້ນພາຍໃນ ERE
ຄົງທີ່. ຄົງທີ່ ERE ຈະຖືກຢຸດໂດຍການປະກົດຕົວທີ່ບໍ່ໄດ້ຫຼົບຫຼີກຄັ້ງທຳອິດ
ລັກສະນະຫຼັງຈາກຫນຶ່ງທີ່ເລີ່ມຕົ້ນ ERE ຄົງທີ່. ຂະຫຍາຍປົກກະຕິ
ການສະແດງອອກທີ່ສະແດງໂດຍຄ່າຄົງທີ່ ERE ຈະເປັນລໍາດັບຂອງ unescaped ທັງຫມົດ
ລັກສະນະແລະຄ່າຂອງລໍາດັບ escape ລະຫວ່າງ, ແຕ່ບໍ່ລວມ, ສອງ
ຂີດຈຳກັດ ຕົວລະຄອນ.

7. ກ ຈະບໍ່ມີຜົນກະທົບ, ຍົກເວັ້ນການກໍານົດ tokens lexical ຫຼືພາຍໃນ ຄັກ or
TIME ໂທເຄນ.

8. ເຄື່ອງໝາຍ NUMBER ຈະສະແດງຄ່າຄົງທີ່ຂອງຕົວເລກ. ຮູບແບບ ແລະຄ່າຕົວເລກຂອງມັນຈະຕ້ອງ
ບໍ່ວ່າຈະທຽບເທົ່າກັບ decimal-floating-ຄົງທີ່ token ຕາມທີ່ ISO C
ມາດຕະຖານ, ຫຼືມັນຈະເປັນລໍາດັບຂອງຕົວເລກທົດສະນິຍົມແລະຈະຖືກປະເມີນເປັນ
ຈຳນວນຄົງທີ່ໃນອັດຕາທົດສະນິຍົມ. ນອກຈາກນັ້ນ, ການປະຕິບັດອາດຈະຍອມຮັບຄ່າຄົງທີ່ຂອງຕົວເລກ
ດ້ວຍຮູບແບບ ແລະຄ່າຕົວເລກເທົ່າກັບ hexadecimal-ຄົງທີ່ ແລະ
hexadecimal-floating-constant tokens ຕາມທີ່ກໍານົດໂດຍມາດຕະຖານ ISO C.

ຖ້າຄ່າໃຫຍ່ເກີນໄປ ຫຼືນ້ອຍເກີນໄປທີ່ຈະເປັນຕົວແທນໄດ້ (ເບິ່ງ ສ່ວນ 1.1.2,
ແນວຄິດ ມາຈາກ ຈາກ ໄດ້ ISO C ມາດຕະຖານ), ພຶດຕິກໍາແມ່ນບໍ່ໄດ້ກໍານົດ.

9. ລຳດັບຂອງເຄື່ອງໝາຍຂີດກ້ອງ, ຕົວເລກ, ແລະຕົວອັກສອນຈາກຊຸດຕົວອັກສອນແບບເຄື່ອນທີ່.
(ເບິ່ງປະລິມານຄໍານິຍາມພື້ນຖານຂອງ POSIX.1-2008, ສ່ວນ 6.1, Portable ລັກສະນະ
ທີ່ກໍານົດໄວ້), ເລີ່ມຕົ້ນດ້ວຍ ຫຼືຕົວອັກສອນ, ຈະຖືກພິຈາລະນາເປັນ
ຄຳ.

10. ຄໍາຕໍ່ໄປນີ້ແມ່ນຄໍາສໍາຄັນທີ່ຕ້ອງໄດ້ຮັບການຮັບຮູ້ເປັນ tokens ສ່ວນບຸກຄົນ; ໄດ້
ຊື່ຂອງ token ແມ່ນຄືກັນກັບຄໍາສໍາຄັນ:

ເລີ່ມຕົ້ນ ລຶບ END ຫນ້າທີ່ in printf
ພັກຜ່ອນ do ການທ່ອງທ່ຽວ ສາຍ ຕໍ່ໄປ ການກັບຄືນມາ
ດໍາເນີນການຕໍ່ ອື່ນ ສໍາລັບການ if ພິມ ໃນຂະນະທີ່

11. ຄໍາຕໍ່ໄປນີ້ແມ່ນຊື່ຂອງຫນ້າທີ່ສ້າງໃນແລະຕ້ອງໄດ້ຮັບການຮັບຮູ້ເປັນ
token BUILTIN_FUNC_NAME:

atan2 gsub log ແບ່ງປັນ ການຍ່ອຍ topper
ໃກ້ ດັດຊະນີ ການແຂ່ງຂັນ ແລ່ນ ຍ່ອຍ
cos int ໄຕ້ sqrt ລະບົບ
exp ຄວາມຍາວ sin ໄສ້ ລຸ່ມ

ຄໍາສໍາຄັນທີ່ໄດ້ກ່າວມາຂ້າງເທິງແລະຊື່ຂອງຫນ້າທີ່ສ້າງຢູ່ໃນແມ່ນຖືວ່າສະຫງວນໄວ້
ຄໍາເວົ້າ.

12. ເຄື່ອງໝາຍ NAME ຈະປະກອບດ້ວຍຄໍາທີ່ບໍ່ແມ່ນຄໍາສໍາຄັນຫຼືຊື່ຂອງຕົວຕົນ
function ແລະບໍ່ໄດ້ປະຕິບັດຕາມທັນທີ (ໂດຍບໍ່ມີການ delimiters) ໂດຍ '('
ລັກສະນະ.

13. ເຄື່ອງໝາຍ FUNC_NAME ຈະປະກອບດ້ວຍຄໍາທີ່ບໍ່ແມ່ນຄໍາສໍາຄັນຫຼືຊື່ຂອງ a
ການທໍາງານຂອງການກໍ່ສ້າງໃນ, ປະຕິບັດຕາມທັນທີ (ໂດຍບໍ່ມີການ delimiters ໃດ) ໂດຍ '(' ລັກສະນະ.
ໄດ້ '(' ຕົວອັກສອນຈະບໍ່ຖືກລວມເຂົ້າເປັນສ່ວນໜຶ່ງຂອງໂທເຄັນ.

14. ລຳດັບສອງລັກສະນະຕໍ່ໄປນີ້ຈະຖືກຮັບຮູ້ວ່າເປັນໂທເຄັນທີ່ມີຊື່:

┌────────────────────────────────┬─────────────────┬────────────┐
│token ຊື່ │ ລໍາດັບ │ token ຊື່ │ ລໍາດັບ │
├─────────────────────────────┼────────────────────────────────┤
│ADD_ASSIGN │ += │ NO_MATCH │ !~ │
│SUB_ASSIGN │ −= │ EQ │ == │
│MUL_ASSIGN │ *= │ LE │ <= │
│DIV_ASSIGN │ /= │ GE │ >= │
│MOD_ASSIGN │ %= │ NE │ != │
│POW_ASSIGN │ ^= │ INCR │ ++│
│OR │ || │ ເດືອນທັນວາ │ −− │
│ແລະ │ && │ ສະ ເໜີ │ >> │
└───────────────────────────────────┴─────────────────────────────┘
15. ຕົວອັກສອນດຽວຕໍ່ໄປນີ້ຈະຖືກຮັບຮູ້ເປັນໂທເຄັນທີ່ມີຊື່
ລັກສະນະ:

{ } ( ) [ ] , ; + - * % ^ ! > < | ? : " " $ =

ມີຄວາມບໍ່ຊັດເຈນ lexical ລະຫວ່າງ token TIME ແລະໂທເຄັນ '/' ແລະ DIV_ASSIGN.
ເມື່ອລໍາດັບການປ້ອນຂໍ້ມູນເລີ່ມຕົ້ນດ້ວຍ a ລັກສະນະໃນສະພາບການ syntactic ໃດໆທີ່
token '/' or DIV_ASSIGN ສາມາດປາກົດເປັນ token ຕໍ່ໄປໃນໂຄງການທີ່ຖືກຕ້ອງ, ຍາວກວ່າ
ທັງສອງ tokens ທີ່ສາມາດຮັບຮູ້ໄດ້ຈະໄດ້ຮັບການຮັບຮູ້. ໃນ syntactic ອື່ນໆ
ສະພາບການທີ່ token TIME ສາມາດປາກົດເປັນ token ຕໍ່ໄປໃນໂຄງການທີ່ຖືກຕ້ອງ, token
TIME ຈະຖືກຮັບຮູ້.

ອອກ STATUS

ຄ່າທາງອອກຕໍ່ໄປນີ້ຈະຖືກສົ່ງຄືນ:

0 ໄຟລ໌ປ້ອນຂໍ້ມູນທັງໝົດໄດ້ຖືກປະມວນຜົນສຳເລັດແລ້ວ.

>0 ເກີດຄວາມຜິດພາດຂຶ້ນ.

ສະ​ຖາ​ນະ​ການ​ອອກ​ສາ​ມາດ​ໄດ້​ຮັບ​ການ​ປ່ຽນ​ແປງ​ພາຍ​ໃນ​ໂຄງ​ການ​ໂດຍ​ການ​ນໍາ​ໃຊ້​ ການທ່ອງທ່ຽວ ການສະແດງອອກ.

ຂໍ້ສັງເກດ OF ຄວາມຜິດພາດ

ຖ້າ​ມີ ເອກະສານ operand ຖືກ​ລະ​ບຸ​ໄວ້​ແລະ​ໄຟລ​໌​ທີ່​ມີ​ຊື່​ບໍ່​ສາ​ມາດ​ເຂົ້າ​ເຖິງ​, ງຸ່ມ ຈະ​ຂຽນ a
ຂໍ້​ຄວາມ​ວິ​ນິດ​ໄສ​ກັບ​ຄວາມ​ຜິດ​ພາດ​ມາດ​ຕະ​ຖານ​ແລະ​ຢຸດ​ເຊົາ​ການ​ໂດຍ​ບໍ່​ມີ​ການ​ດໍາ​ເນີນ​ການ​ໃດໆ​.

ຖ້າ​ຫາກ​ວ່າ​ໂຄງ​ການ​ທີ່​ກໍາ​ນົດ​ໄວ້​ໂດຍ​ທັງ​ຫມົດ​ ໂຄງການ ຄຳສັ່ງ ຫຼື ກ ໂປຣແກມ operand ບໍ່ແມ່ນ
ຖືກຕ້ອງ ງຸ່ມ ໂຄງ​ການ (ຕາມ​ທີ່​ລະ​ບຸ​ໄວ້​ໃນ​ພາກ​ສ່ວນ​ການ​ອະ​ທິ​ບາຍ​ການ​ຂະ​ຫຍາຍ​)​, ພຶດ​ຕິ​ກໍາ​ແມ່ນ​
ບໍ່ໄດ້ກໍານົດ.

ໄດ້ ດັ່ງຕໍ່ໄປນີ້ ພາກສ່ວນ ມີ ຂໍ້ມູນ.

ຄໍາຮ້ອງສະຫມັກ ການນໍາໃຊ້

ໄດ້ ດັດຊະນີ, ຄວາມຍາວ, ການແຂ່ງຂັນ, ແລະ ຍ່ອຍ ຫນ້າທີ່ບໍ່ຄວນສັບສົນກັບຄ້າຍຄືກັນ
ຫນ້າທີ່ຢູ່ໃນມາດຕະຖານ ISO C; ໄດ້ ງຸ່ມ ສະບັບຕ່າງໆຈັດການກັບຕົວອັກສອນ, ໃນຂະນະທີ່ ISO C
ມາດຕະຖານ deals ກັບ bytes.

ເນື່ອງຈາກວ່າການດໍາເນີນງານ concatenation ແມ່ນເປັນຕົວແທນໂດຍການສະແດງອອກທີ່ຢູ່ໃກ້ຄຽງແທນທີ່ຈະເປັນ
ຕົວປະຕິບັດການຢ່າງຊັດເຈນ, ມັນມັກຈະຈໍາເປັນຕ້ອງໃຊ້ວົງເລັບເພື່ອບັງຄັບໃຊ້ທີ່ເຫມາະສົມ
ລຳດັບການປະເມີນຜົນ.

ຕົວຢ່າງ

ໄດ້ ງຸ່ມ ໂຄງ​ການ​ທີ່​ລະ​ບຸ​ໄວ້​ໃນ​ບັນ​ຊີ​ຄໍາ​ສັ່ງ​ແມ່ນ​ໄດ້​ລະ​ບຸ​ງ່າຍ​ທີ່​ສຸດ​ໃນ​ການ​ດຽວ​.
ວົງຢືມ (ຕົວຢ່າງ, 'ໂຄງການ') ສໍາລັບຄໍາຮ້ອງສະຫມັກການນໍາໃຊ້ sh, ເພາະວ່າ ງຸ່ມ ໂຄງການທົ່ວໄປ
ປະກອບມີຕົວອັກສອນທີ່ພິເສດຕໍ່ກັບແກະ, ລວມທັງການອ້າງອີງສອງເທົ່າ. ໃນກໍລະນີ
ບ່ອນທີ່ເປັນ ງຸ່ມ ໂຄງ​ການ​ປະ​ກອບ​ດ້ວຍ​ຕົວ​ອັກ​ສອນ​ວົງ​ຢືມ​ດຽວ​, ໂດຍ​ປົກ​ກະ​ຕິ​ແມ່ນ​ງ່າຍ​ທີ່​ສຸດ​ທີ່​ຈະ​ລະ​ບຸ​
ສ່ວນໃຫຍ່ຂອງໂຄງການເປັນສາຍພາຍໃນວົງຢືມດຽວ concatenated ໂດຍ shell ກັບວົງຢືມ
ຕົວອັກສອນຫຍໍ້ໜ້າດຽວ. ຍົກ​ຕົວ​ຢ່າງ:

ງຸ່ມ '/'\'/ { ພິມ "ອ້າງອີງ:", $0 }'

ພິມທຸກແຖວຈາກການປ້ອນຂໍ້ມູນມາດຕະຖານທີ່ມີຕົວອັກສອນຄຳເວົ້າອັນດຽວ, ຖືກນຳໜ້າ
ກັບ quote:.

ຕໍ່ໄປນີ້ແມ່ນຕົວຢ່າງຂອງງ່າຍດາຍ ງຸ່ມ ໂຄງການ:

1. ຂຽນໃສ່ເສັ້ນ input ມາດຕະຖານທັງໝົດທີ່ຊ່ອງ 3 ໃຫຍ່ກວ່າ 5:

$3 > 5

2. ຂຽນທຸກໆແຖວທີສິບ:

(ຄຄຊ % 10) == 0

3. ຂຽນແຖວໃດນຶ່ງທີ່ມີ substring ກົງກັບ expression ປົກກະຕິ:

/(G|D)(2[0−9][[:alpha:]]*)/

4. ພິມເສັ້ນໃດນຶ່ງທີ່ມີ substring ທີ່ມີ a 'G' or 'D', ຕາມດ້ວຍລໍາດັບຂອງ
ຕົວ​ເລກ​ແລະ​ຕົວ​ອັກ​ສອນ​. ຕົວຢ່າງນີ້ໃຊ້ຫ້ອງຮຽນຕົວອັກສອນ ຫລັກ ແລະ alpha ກົງກັນ
ຕົວເລກທີ່ເປັນເອກະລາດຂອງພາສາ ແລະຕົວອັກສອນຕາມລໍາດັບ:

/(G|D)([[:digit:][:alpha:]]*)/

5. ຂຽນແຖວໃດນຶ່ງທີ່ສະໜາມທີສອງກົງກັບສຳນວນປົກກະຕິ ແລະຂໍ້ທີສີ່
ພາກສະຫນາມບໍ່ໄດ້:

$2 " " /xyz/ && $4 ! " " /xyz/

6. ຂຽນແຖວໃດນຶ່ງທີ່ຊ່ອງຂໍ້ມູນທີສອງມີ a :

$2 " " /\\/

7. ຂຽນແຖວໃດນຶ່ງທີ່ຊ່ອງຂໍ້ມູນທີສອງມີ a . ໃຫ້ສັງເກດວ່າ
-escapes ຖືກຕີຄວາມຫມາຍສອງຄັ້ງ; ຄັ້ງດຽວໃນການປະມວນຜົນ lexical ຂອງຊ່ອຍແນ່
ແລະເມື່ອປະມວນຜົນການສະແດງອອກປົກກະຕິ:

$2 " " "\\\\"

8. ຂຽນຂໍ້ທີສອງໄປຫາບ່ອນສຸດທ້າຍແລະສຸດທ້າຍໃນແຕ່ລະແຖວ. ແຍກທົ່ງນາໂດຍ ກ
:

{OFS=":";ພິມ $(NF−1), $NF}

9. ຂຽນເລກແຖວ ແລະຈໍານວນຊ່ອງໃສ່ແຕ່ລະແຖວ. ສາມສາຍ
ຕົວ​ແທນ​ຈໍາ​ນວນ​ເສັ້ນ​, ໄດ້​ , ແລະຈໍານວນຂອງພາກສະຫນາມແມ່ນ concatenated
ແລະສະຕຣິງນັ້ນຖືກຂຽນເປັນຜົນຜະລິດມາດຕະຖານ:

{ພິມ NR ":" NF}

10. ຂຽນເສັ້ນຍາວກວ່າ 72 ຕົວອັກສອນ:

ຄວາມຍາວ($0) > 72

11. ຂຽນສອງຊ່ອງທໍາອິດໃນລໍາດັບກົງກັນຂ້າມທີ່ແຍກດ້ວຍ FSO:

{ ພິມ $ 2, $1 }

12. ຄືກັນ, ມີຊ່ອງປ້ອນຂໍ້ມູນແຍກດ້ວຍ ກ ຫຼື ແລະ ຕົວອັກສອນ, ຫຼື
ທັງສອງ:

ເລີ່ມຕົ້ນ { FS = ",[ \t]*|[ \t]+" }
{ ພິມ $ 2, $1 }

13. ເພີ່ມຖັນທຳອິດ, ພິມລວມ, ແລະສະເລ່ຍ:

{s += $1 }
END {ພິມ "ລວມ is ", s, " ໂດຍສະເລ່ຍ ແມ່ນ", s/NR}

14. ຂຽນຊ່ອງຂໍ້ມູນໃນລໍາດັບປີ້ນກັບກັນ, ຫນຶ່ງຕໍ່ແຖວ (ຫຼາຍເສັ້ນອອກສໍາລັບແຕ່ລະແຖວ):

{ ສໍາລັບການ (i = NF; i > 0; −−i) ພິມ $i }

15. ຂຽນເສັ້ນທັງໝົດລະຫວ່າງການປະກົດຕົວຂອງສາຍ ການເລີ່ມຕົ້ນ ແລະ ຢຸດ:

/start/, /ຢຸດ/

16. ຂຽນທຸກແຖວທີ່ຊ່ອງທໍາອິດແຕກຕ່າງຈາກເສັ້ນກ່ອນ:

$1 != prev { ພິມ; prev = $1 }

17. ຈໍາລອງ echo:

ເລີ່ມຕົ້ນ {
ສໍາລັບການ (i = 1; i < ARGC; ++i)
printf("%s%s", ARGV[i], i==ARGC−1?"\n":" ")
}

18. ຂຽນຄຳນຳໜ້າເສັ້ນທາງທີ່ບັນຈຸຢູ່ໃນ PATH ສະພາບແວດລ້ອມປ່ຽນແປງໄດ້, ຫນຶ່ງຕໍ່ແຖວ:

ເລີ່ມຕົ້ນ {
n = ແບ່ງປັນ (ສະພາບແວດລ້ອມ["ເສັ້ນທາງ"], ເສັ້ນທາງ, ":")
ສໍາລັບການ (i = 1; i <= n; ++i)
ພິມ ເສັ້ນທາງ[i]
}

19. ຖ້າມີໄຟລ໌ທີ່ມີຊື່ ການປ້ອນຂໍ້ມູນ ປະກອບມີສ່ວນຫົວຂອງແບບຟອມ: Page #.

ແລະໄຟລ໌ທີ່ມີຊື່ ໂຄງການ ເຊິ່ງປະກອບດ້ວຍ:

/ຫນ້າ/ { $2 = n++; }
{ ພິມ }

ຫຼັງຈາກນັ້ນ, ເສັ້ນຄໍາສັ່ງ:

ງຸ່ມ -f ໂຄງການ n = 5 ການປ້ອນຂໍ້ມູນ

ພິມໄຟລ໌ ການປ້ອນຂໍ້ມູນ, ຕື່ມຂໍ້ມູນໃສ່ໃນຈໍານວນຫນ້າເລີ່ມຕົ້ນທີ່ 5.

ສະຖານທີ່

ຄໍາອະທິບາຍນີ້ແມ່ນອີງໃສ່ໃຫມ່ ງຸ່ມ, ``nawk'', (ເບິ່ງທີ່ອ້າງອີງ ໄດ້ AWK
ດໍາເນີນໂຄງການ ພາສາ), ເຊິ່ງໄດ້ນໍາສະເຫນີລັກສະນະໃຫມ່ຈໍານວນຫນຶ່ງຕໍ່ກັບປະຫວັດສາດ ງຸ່ມ:

1. ຄໍາສໍາຄັນໃຫມ່: ລຶບ, do, ຫນ້າທີ່, ການກັບຄືນມາ

2. ຟັງຊັນໃນຕົວໃຫມ່: atan2, ໃກ້, cos, gsub, ການແຂ່ງຂັນ, ໄຕ້, sin, ໄສ້, ການຍ່ອຍ, ລະບົບ

3. ຕົວແປທີ່ກຳນົດໄວ້ລ່ວງໜ້າໃໝ່: FNR, ARGC, ARGV, RSTART, RLENGTH, SUBSEP

4. ຕົວປະຕິບັດການສະແດງອອກໃໝ່: ?, :, ,, ^

5. ໄດ້ FS ຕົວແປແລະການໂຕ້ຖຽງທີສາມກັບ ແບ່ງປັນ, ໃນປັດຈຸບັນໄດ້ຮັບການປິ່ນປົວເປັນປົກກະຕິຂະຫຍາຍ
ສຳ ນວນ.

6. ຕົວປະຕິບັດການກ່ອນໜ້າ, ປ່ຽນເປັນພາສາ C ຢ່າງໃກ້ຊິດ. ສອງຕົວຢ່າງ
ລະຫັດທີ່ເຮັດວຽກແຕກຕ່າງກັນຄື:

ໃນຂະນະທີ່ ( n /= 10 > 1) ...
if (!"wk" ~ /bwk/) ...

ຄຸນນະສົມບັດຈໍານວນຫນຶ່ງໄດ້ຖືກເພີ່ມໂດຍອີງໃສ່ການປະຕິບັດໃຫມ່ຂອງ ງຸ່ມ:

* ຫຼາຍ​ຕົວ​ຢ່າງ​ຂອງ​ -f ໂປຣແກມ ອະນຸຍາດ.

* ທາງ​ເລືອກ​ໃຫມ່​ −v ການແຕ່ງຕັ້ງ.

* ຕົວແປທີ່ກຳນົດໄວ້ລ່ວງໜ້າໃໝ່ ສະພາບແວດລ້ອມ.

* ຟັງຊັນໃນຕົວໃຫມ່ topper ແລະ ລຸ່ມ.

* ຄວາມ​ສາ​ມາດ​ຮູບ​ແບບ​ເພີ່ມ​ເຕີມ​ແມ່ນ​ໄດ້​ຮັບ​ການ​ເພີ່ມ​ printf ເພື່ອໃຫ້ກົງກັບມາດຕະຖານ ISO C.

ໂດຍລວມ ງຸ່ມ syntax ໄດ້ສະເຫມີໂດຍອີງໃສ່ພາສາ C, ມີລັກສະນະບໍ່ຫຼາຍປານໃດຈາກ
ພາສາຄໍາສັ່ງ shell ແລະແຫຼ່ງອື່ນໆ. ເນື່ອງຈາກວ່ານີ້, ມັນບໍ່ສົມບູນ
ເຂົ້າກັນໄດ້ກັບພາສາອື່ນ, ເຊິ່ງເຮັດໃຫ້ເກີດຄວາມສັບສົນສໍາລັບຜູ້ໃຊ້ບາງຄົນ. ມັນ​ບໍ່​ແມ່ນ
ຄວາມຕັ້ງໃຈຂອງຜູ້ພັດທະນາມາດຕະຖານເພື່ອແກ້ໄຂບັນຫາດັ່ງກ່າວ. ຂ້ອນຂ້າງຂ້ອນຂ້າງເລັກນ້ອຍ
ມີການປ່ຽນແປງໄປສູ່ການເຮັດໃຫ້ພາສາເຂົ້າກັນໄດ້ກັບມາດຕະຖານ ISO C ຫຼາຍຂຶ້ນ; ທີ່ສຸດ
ການປ່ຽນແປງເຫຼົ່ານີ້ແມ່ນອີງໃສ່ການປ່ຽນແປງທີ່ຄ້າຍຄືກັນໃນການປະຕິບັດທີ່ຜ່ານມາ, ດັ່ງທີ່ໄດ້ອະທິບາຍ
ຂ້າງເທິງ. ຍັງມີຫຼາຍສົນທິສັນຍາພາສາ C ທີ່ບໍ່ໄດ້ຢູ່ໃນ ງຸ່ມ. ຫນຶ່ງ​ໃນ
ອັນທີ່ໂດດເດັ່ນແມ່ນ operator, ເຊິ່ງຖືກນໍາໃຊ້ທົ່ວໄປເພື່ອກໍານົດຫຼາຍ
ການສະແດງອອກໃນພາສາ C ສໍາລັບການ ຖະແຫຼງການ. ນອກຈາກນີ້, ມີສະຖານທີ່ຕ່າງໆ ງຸ່ມ is
ຈໍາກັດຫຼາຍກ່ວາພາສາ C ກ່ຽວກັບປະເພດຂອງການສະແດງອອກທີ່ສາມາດຖືກນໍາໃຊ້ໃນ
ບໍລິບົດທີ່ໃຫ້. ຂໍ້ຈໍາກັດເຫຼົ່ານີ້ແມ່ນເນື່ອງມາຈາກລັກສະນະທີ່ແຕກຕ່າງກັນທີ່ ງຸ່ມ ພາສາ
ບໍ່ສະຫນອງ.

ການສະແດງອອກປົກກະຕິໃນ ງຸ່ມ ໄດ້​ຮັບ​ການ​ຂະ​ຫຍາຍ​ບາງ​ສ່ວນ​ຈາກ​ການ​ປະ​ຕິ​ບັດ​ປະ​ຫວັດ​ສາດ​
ເຮັດໃຫ້ເຂົາເຈົ້າເປັນ superset ບໍລິສຸດຂອງການສະແດງປົກກະຕິຂະຫຍາຍ, ຕາມທີ່ກໍານົດໂດຍ POSIX.1-2008 (ເບິ່ງ.
ປະລິມານນິຍາມພື້ນຖານຂອງ POSIX.1-2008, ສ່ວນ 9.4, ການຂະຫຍາຍ ເປັນປົກກະຕິ ສຳ ນວນ).
ການຂະຫຍາຍຕົ້ນຕໍແມ່ນລັກສະນະສາກົນແລະການສະແດງອອກໃນໄລຍະຫ່າງ. ປະຫວັດສາດ
ການ​ປະ​ຕິ​ບັດ​ຂອງ​ ງຸ່ມ ໄດ້​ສະ​ຫນັບ​ສະ​ຫນູນ​ດົນ​ນານ​ -escape ລໍາດັບເປັນການຂະຫຍາຍໄປ
ຂະຫຍາຍການສະແດງອອກເປັນປົກກະຕິ, ແລະສ່ວນຂະຫຍາຍນີ້ໄດ້ຖືກເກັບຮັກສາໄວ້ເຖິງວ່າຈະມີຄວາມບໍ່ສອດຄ່ອງກັນ
ກັບ​ອຸ​ປະ​ກອນ​ອື່ນໆ​. ຈໍາ​ນວນ​ຂອງ​ລໍາ​ດັບ​ການ​ຫນີ​ຮັບ​ຮູ້​ທັງ​ສອງ​ຂະ​ຫຍາຍ​ເປັນ​ປົກ​ກະ​ຕິ​
ການສະແດງອອກແລະສາຍຕ່າງໆມີຄວາມແຕກຕ່າງກັນ (ໂດຍທົ່ວໄປແລ້ວເພີ່ມຂຶ້ນຕາມເວລາ) ໃນບັນດາການປະຕິບັດ.
ຊຸດທີ່ລະບຸໄວ້ໂດຍ POSIX.1-2008 ປະກອບມີລໍາດັບສ່ວນໃຫຍ່ທີ່ຮູ້ວ່າໄດ້ຮັບການສະຫນັບສະຫນູນຈາກຄວາມນິຍົມ
ການປະຕິບັດແລະໂດຍມາດຕະຖານ ISO C. ລໍາດັບຫນຶ່ງທີ່ບໍ່ໄດ້ຮັບການສະຫນັບສະຫນູນແມ່ນ
ຄ່າເລກຖານສິບຫົກຫລົບຫນີເລີ່ມຕົ້ນດ້ວຍ '\x'. ນີ້ຈະອະນຸຍາດໃຫ້ມີຄ່າທີ່ສະແດງອອກໃນຫຼາຍ
ຫຼາຍກ່ວາ 9 ບິດທີ່ຈະໃຊ້ພາຍໃນ ງຸ່ມ ເຊັ່ນດຽວກັບມາດຕະຖານ ISO C. ຢ່າງໃດກໍຕາມ, ເນື່ອງຈາກວ່າ syntax ນີ້
ມີຄວາມຍາວທີ່ບໍ່ແມ່ນຕົວກໍານົດ, ມັນບໍ່ໄດ້ອະນຸຍາດໃຫ້ລັກສະນະຕໍ່ມາເປັນ a
ເລກຖານສິບຫົກ. ຂໍ້ຈໍາກັດນີ້ສາມາດຈັດການກັບພາສາ C ໂດຍການນໍາໃຊ້
ການເຊື່ອມສານສະຕຣິງ lexical. ໃນ ງຸ່ມ ພາສາ, concatenation ຍັງສາມາດເປັນການແກ້ໄຂ
ສໍາ​ລັບ​ການ​ສະ​ຕ​ຣິ​ງ, ແຕ່​ບໍ່​ແມ່ນ​ສໍາ​ລັບ​ການ​ຂະ​ຫຍາຍ​ຕົວ​ສະ​ແດງ​ອອກ​ປົກ​ກະ​ຕິ (ທັງ lexical ERE tokens ຫຼື
ສະຕຣິງທີ່ໃຊ້ແບບໄດນາມິກເປັນການສະແດງອອກປົກກະຕິ). ເນື່ອງຈາກວ່າຂໍ້ຈໍາກັດນີ້, ຄຸນນະສົມບັດ
ຍັງບໍ່ໄດ້ຖືກເພີ່ມໃສ່ POSIX.1-2008.

ເມື່ອຕົວແປສະຕຣິງຖືກໃຊ້ໃນບໍລິບົດທີ່ມີການຂະຫຍາຍການສະແດງອອກຕາມປົກກະຕິ
ປາກົດ (ບ່ອນທີ່ token lexical ERE ຖືກນໍາໃຊ້ໃນໄວຍະກອນ) string ບໍ່ມີ
ຕົວຫນັງສື ຕົວລະຄອນ.

ບາງຮຸ່ນຂອງ ງຸ່ມ ອະ​ນຸ​ຍາດ​ໃຫ້​ຮູບ​ແບບ​:

ມ່ວນ ຊື່(args, ... ) { ບົດລາຍງານ }

ນີ້ໄດ້ຖືກປະຕິເສດໂດຍຜູ້ຂຽນພາສາ, ຜູ້ທີ່ຖາມວ່າມັນບໍ່ແມ່ນ
ລະບຸ.

ການປະຕິບັດປະຫວັດສາດຂອງ ງຸ່ມ ຜະລິດຄວາມຜິດພາດຖ້າຫາກວ່າ a ຕໍ່ໄປ ຄໍາ​ຖະ​ແຫຼງ​ການ​ແມ່ນ​ປະ​ຕິ​ບັດ​ໃນ a
ເລີ່ມຕົ້ນ ການກະທໍາ, ແລະສາເຫດ ງຸ່ມ ຢຸດເຊົາຖ້າ ກ ຕໍ່ໄປ ຄໍາ​ຖະ​ແຫຼງ​ການ​ແມ່ນ​ປະ​ຕິ​ບັດ​ໃນ​ END ການປະຕິບັດ.
ພຶດຕິກໍານີ້ບໍ່ໄດ້ຖືກບັນທຶກໄວ້, ແລະມັນບໍ່ໄດ້ຖືກເຊື່ອວ່າມັນເປັນສິ່ງຈໍາເປັນ
ມາດຕະຖານມັນ.

ສະເພາະຂອງການປ່ຽນແປງລະຫວ່າງສະຕຣິງ ແລະຄ່າຕົວເລກແມ່ນລະອຽດກວ່າຫຼາຍ
ກ​່​ວາ​ໃນ​ເອ​ກະ​ສານ​ຂອງ​ການ​ປະ​ຕິ​ບັດ​ປະ​ຫວັດ​ສາດ​ຫຼື​ໃນ​ການ​ອ້າງ​ອີງ ໄດ້ AWK
ດໍາເນີນໂຄງການ ພາສາ. ເຖິງແມ່ນວ່າສ່ວນໃຫຍ່ຂອງພຶດຕິກໍາໄດ້ຖືກອອກແບບເພື່ອໃຫ້ intuitive, ໄດ້
ລາຍລະອຽດແມ່ນມີຄວາມຈໍາເປັນເພື່ອຮັບປະກັນພຶດຕິກໍາທີ່ເຂົ້າກັນໄດ້ຈາກການປະຕິບັດທີ່ແຕກຕ່າງກັນ. ນີ້
ມີຄວາມສໍາຄັນໂດຍສະເພາະໃນການສະແດງອອກທີ່ກ່ຽວຂ້ອງນັບຕັ້ງແຕ່ປະເພດຂອງຕົວປະຕິບັດການ
ກຳນົດວ່າມີການປຽບທຽບສະຕຣິງ ຫຼືຕົວເລກ. ຈາກທັດສະນະຂອງ an
ນັກພັດທະນາແອັບພລິເຄຊັນ, ປົກກະຕິແລ້ວມັນພຽງພໍທີ່ຈະຄາດຫວັງວ່າພຶດຕິກໍາ intuitive ແລະບັງຄັບ
ການປ່ຽນໃຈເຫລື້ອມໃສ (ໂດຍການເພີ່ມສູນຫຼື concatenating a null string) ເມື່ອປະເພດຂອງການສະແດງອອກ
ບໍ່ແນ່ນອນກົງກັບສິ່ງທີ່ຕ້ອງການ. ຈຸດປະສົງແມ່ນເພື່ອກໍານົດປະຫວັດສາດ
ການປະຕິບັດໃນເກືອບທຸກກໍລະນີ. ຂໍ້ຍົກເວັ້ນຫນຶ່ງແມ່ນວ່າ, ໃນການປະຕິບັດປະຫວັດສາດ,
ຕົວແປ ແລະຄ່າຄົງທີ່ຮັກສາທັງຄ່າສະຕຣິງ ແລະຕົວເລກຫຼັງຈາກຄ່າເດີມຂອງພວກມັນ
ຖືກແປງໂດຍການນໍາໃຊ້ໃດໆ. ນີ້ຫມາຍຄວາມວ່າການອ້າງອີງຕົວແປຫຼືຄົງທີ່ສາມາດມີ
ຜົນຂ້າງຄຽງທີ່ບໍ່ຄາດຄິດ. ຕົວຢ່າງ, ດ້ວຍການຈັດຕັ້ງປະຕິບັດປະຫວັດສາດຕໍ່ໄປນີ້
ໂຄງການ:

{
a = "+2"
b = 2
if (ຄຄຊ % 2)
c = a + b
if (a == b)
ພິມ "ຕົວເລກ ການ​ປຽບ​ທຽບ
ອື່ນ
ພິມ "ສາຍ ການ​ປຽບ​ທຽບ
}

ຈະປະຕິບັດການປຽບທຽບຕົວເລກ (ແລະຜົນຜະລິດການປຽບທຽບຕົວເລກ) ສໍາລັບແຕ່ລະຕົວເລກຄີກ
ເສັ້ນ, ແຕ່ປະຕິບັດການປຽບທຽບສະຕຣິງ (ແລະການປຽບທຽບສະຕຣິງຜົນຜະລິດ) ສໍາລັບແຕ່ລະຄູ່.
ເສັ້ນເລກ. POSIX.1-2008 ຮັບປະກັນວ່າການປຽບທຽບຈະເປັນຕົວເລກຖ້າຈໍາເປັນ. ກັບ
ການ​ປະ​ຕິ​ບັດ​ປະ​ຫວັດ​ສາດ​, ໂຄງ​ການ​ດັ່ງ​ຕໍ່​ໄປ​ນີ້​:

ເລີ່ມຕົ້ນ {
OFMT = "%e"
ພິມ 3.14
OFMT = "%f"
ພິມ 3.14
}

ຈະອອກ "3.140000e+00" ສອງຄັ້ງ, ເພາະວ່າໃນຄັ້ງທີສອງ ພິມ ຖະແຫຼງການຄົງທີ່
"3.14" ຈະມີມູນຄ່າສະຕຣິງຈາກການແປງກ່ອນໜ້າ. POSIX.1-2008 ຕ້ອງການນັ້ນ
ຜົນ​ຜະ​ລິດ​ຂອງ​ຄັ້ງ​ທີ​ສອງ​ ພິມ ຖະແຫຼງການຈະ "3.140000". ພຶດຕິກໍາຂອງປະຫວັດສາດ
ການ​ປະ​ຕິ​ບັດ​ໄດ້​ຖືກ​ເຫັນ​ວ່າ​ເປັນ unintuitive ເກີນ​ໄປ​ແລະ​ຄາດ​ຄະ​ເນ​ບໍ່​ໄດ້​.

ມັນໄດ້ຖືກຊີ້ໃຫ້ເຫັນວ່າມີກົດລະບຽບທີ່ມີຢູ່ໃນຮ່າງຕົ້ນ, script ຕໍ່ໄປນີ້
ຈະບໍ່ພິມຫຍັງ:

ເລີ່ມຕົ້ນ {
y[1.5] = 1
OFMT = "%e"
ພິມ y[1.5]
}

ດັ່ງນັ້ນ, ການປ່ຽນແປງໃຫມ່, CONVFMT, ໄດ້ນໍາສະເຫນີ. ໄດ້ OFMT ຕົວປ່ຽນແປງໄດ້ຖືກຈໍາກັດໃນປັດຈຸບັນ
ຜົນ​ກະ​ທົບ​ການ​ປ່ຽນ​ແປງ​ຂອງ​ຕົວ​ເລກ​ເປັນ​ສະ​ຕ​ຣິງ​ແລະ​ CONVFMT ຖືກນໍາໃຊ້ສໍາລັບພາຍໃນ
ການປ່ຽນແປງ, ເຊັ່ນ: ການປຽບທຽບ ຫຼືການຈັດດັດສະນີອາເຣ. ຄ່າເລີ່ມຕົ້ນແມ່ນຄືກັນກັບທີ່
ສໍາລັບການ OFMT, ສະນັ້ນເວັ້ນເສຍແຕ່ວ່າໂຄງການມີການປ່ຽນແປງ CONVFMT (ຊຶ່ງບໍ່ມີໂຄງການປະຫວັດສາດຈະເຮັດ), ມັນ
ຈະໄດ້ຮັບພຶດຕິກໍາປະຫວັດສາດທີ່ກ່ຽວຂ້ອງກັບການແປງສະຕຣິງພາຍໃນ.

POSIX ງຸ່ມ ສົນທິສັນຍາ lexical ແລະ syntactic ແມ່ນໄດ້ລະບຸຢ່າງເປັນທາງການຫຼາຍກ່ວາໃນອື່ນໆ
ແຫຼ່ງຂໍ້ມູນ. ອີກເທື່ອ ໜຶ່ງ, ຄວາມຕັ້ງໃຈແມ່ນເພື່ອ ກຳ ນົດການປະຕິບັດປະຫວັດສາດ. ສົນທິສັນຍາໜຶ່ງທີ່ອາດຈະ
ບໍ່ໄດ້ເຫັນໄດ້ຊັດເຈນຈາກໄວຍາກອນທີ່ເປັນທາງການຄືກັບການອະທິບາຍຄໍາເວົ້າອື່ນໆແມ່ນບ່ອນທີ່
ຕົວອັກສອນທີ່ຍອມຮັບໄດ້. ມີການຈັດວາງທີ່ຊັດເຈນຫຼາຍເຊັ່ນການຢຸດ a
ຖະແຫຼງການ, ແລະ ກ ສາມາດໃຊ້ເພື່ອຫລົບຫນີ ຕົວອັກສອນລະຫວ່າງໃດໆ
tokens lexical. ເພີ່ມ​ເຕີມ, ຕົວອັກສອນທີ່ບໍ່ມີ ລັກສະນະສາມາດ
ປະ​ຕິ​ບັດ​ຕາມ​ເຄື່ອງ​ຫມາຍ​ຈຸດ​, ເປັນ​ວົງ​ເລັບ​ເປີດ​, ເປັນ​ເຫດ​ຜົນ AND operator ("&&"), ໂຕປະຕິບັດການ OR ຕາມເຫດຜົນ
("||"), the do ຄໍາສໍາຄັນ, ໄດ້ ອື່ນ ຄໍາສໍາຄັນ, ແລະວົງເລັບປິດຂອງ an if, ສໍາລັບການ, ຫຼື
ໃນຂະນະທີ່ ຖະແຫຼງການ. ຍົກ​ຕົວ​ຢ່າງ:

{ ພິມ $ 1,
$2 }

ຄວາມ​ຕ້ອງ​ການ​ທີ່​ ງຸ່ມ ຕື່ມ​ການ​ຕິດ​ຕາມ​ ຂໍ້ຄວາມໂຕ້ແຍ້ງຂອງໂປຣແກຣມແມ່ນເພື່ອ
ງ່າຍໄວຍະກອນ, ເຮັດໃຫ້ມັນກົງກັບໄຟລ໌ຂໍ້ຄວາມໃນຮູບແບບ. ບໍ່ມີທາງສໍາລັບການເປັນ
ຄໍາຮ້ອງສະຫມັກຫຼືຊຸດການທົດສອບເພື່ອກໍານົດວ່າຕົວຫນັງສື ແມ່ນເພີ່ມຫຼືວ່າ ງຸ່ມ
ພຽງແຕ່ເຮັດຄືກັບວ່າມັນໄດ້ເຮັດ.

POSIX.1-2008 ຮຽກຮ້ອງໃຫ້ມີການປ່ຽນແປງຫຼາຍຢ່າງຈາກການປະຕິບັດປະຫວັດສາດເພື່ອສະຫນັບສະຫນູນ
ຄວາມເປັນສາກົນ. ອາດຈະເປັນສິ່ງທີ່ລະອຽດອ່ອນທີ່ສຸດແມ່ນການໃຊ້ຈຸດທົດສະນິຍົມ
ລັກສະນະ, ກໍານົດໂດຍ LC_NUMERIC ປະເພດຂອງທ້ອງຖິ່ນ, ໃນການເປັນຕົວແທນຂອງ
ຕົວເລກຈຸດລອຍ. ຕົວອັກສອນສະເພາະທ້ອງຖິ່ນນີ້ຖືກໃຊ້ໃນການຮັບຮູ້ຕົວເລກ
ວັດສະດຸປ້ອນ, ໃນການແປງລະຫວ່າງສະຕຣິງແລະຄ່າຕົວເລກ, ແລະໃນຮູບແບບຜົນຜະລິດ.
ຢ່າງໃດກໍຕາມ, ໂດຍບໍ່ຄໍານຶງເຖິງທ້ອງຖິ່ນ, ໄດ້ ຕົວອັກສອນ (ຕົວອັກສອນຈຸດທົດສະນິຍົມຂອງ
POSIX locale) ແມ່ນຕົວອັກສອນຈຸດທົດສະນິຍົມທີ່ຮັບຮູ້ໃນການປະມວນຜົນ ງຸ່ມ ໂຄງການ
(ລວມທັງການມອບໝາຍໃນການໂຕ້ຖຽງແຖວຄໍາສັ່ງ). ນີ້​ແມ່ນ​ເປັນ​ການ​ສໍາ​ຄັນ​ສົນ​ທິ​ສັນ​ຍາ​ດຽວ​ກັນ​
ເປັນອັນນຶ່ງທີ່ໃຊ້ໃນມາດຕະຖານ ISO C. ຄວາມແຕກຕ່າງແມ່ນວ່າພາສາ C ປະກອບມີ
ຕັ້ງຖິ່ນຖານ() ຟັງຊັນ, ເຊິ່ງອະນຸຍາດໃຫ້ແອັບພລິເຄຊັນແກ້ໄຂທ້ອງຖິ່ນຂອງມັນ. ເນື່ອງຈາກວ່ານີ້
ຄວາມສາມາດ, ຄໍາຮ້ອງສະຫມັກ C ເລີ່ມຕົ້ນປະຕິບັດກັບທ້ອງຖິ່ນຂອງຕົນຕັ້ງເປັນ C locale, ແລະພຽງແຕ່
ປະຕິບັດຢູ່ໃນສະຖານທີ່ສະພາບແວດລ້ອມທີ່ລະບຸໄວ້ຫຼັງຈາກການໂທຫາຢ່າງຊັດເຈນ ຕັ້ງຖິ່ນຖານ,
ຢ່າງໃດກໍຕາມ, ການເພີ່ມລັກສະນະໃຫມ່ທີ່ລະອຽດອ່ອນກັບ ງຸ່ມ ພາ​ສາ​ໄດ້​ຖືກ​ເຫັນ​ເປັນ​
ບໍ່ເໝາະສົມກັບ POSIX.1-2008. ມັນເປັນໄປໄດ້ທີ່ຈະປະຕິບັດການ ງຸ່ມ ໂຄງ​ການ​ຢ່າງ​ຊັດ​ເຈນ​ໃນ​ໃດໆ​
ທ້ອງຖິ່ນທີ່ຕ້ອງການໂດຍການຕັ້ງຄ່າສະພາບແວດລ້ອມໃນແກະ.

ພຶດຕິກໍາທີ່ບໍ່ໄດ້ກໍານົດທີ່ເປັນຜົນມາຈາກ NULs ໃນການສະແດງອອກປົກກະຕິທີ່ຂະຫຍາຍໄດ້ອະນຸຍາດໃຫ້ໃນອະນາຄົດ
ສ່ວນຂະຫຍາຍສໍາລັບ GNU ແກວ ໂຄງ​ການ​ທີ່​ຈະ​ປະ​ມວນ​ຜົນ​ຂໍ້​ມູນ​ຄູ່​.

ພຶດຕິກໍາໃນກໍລະນີທີ່ບໍ່ຖືກຕ້ອງ ງຸ່ມ ບັນດາໂຄງການ (ລວມທັງ lexical, syntactic, ແລະ
semantic errors) ແມ່ນບໍ່ໄດ້ກໍານົດເນື່ອງຈາກວ່າມັນໄດ້ຖືກພິຈາລະນາຈໍາກັດຫຼາຍເກີນໄປກ່ຽວກັບການຈັດຕັ້ງປະຕິບັດ
ກໍານົດ. ໃນກໍລະນີຫຼາຍທີ່ສຸດ, ຄວາມຜິດພາດດັ່ງກ່າວສາມາດຄາດວ່າຈະຜະລິດການວິນິດໄສແລະບໍ່ແມ່ນ.
ສະຖານະອອກຈາກສູນ. ຢ່າງໃດກໍ່ຕາມ, ການປະຕິບັດບາງຢ່າງອາດຈະເລືອກທີ່ຈະຂະຫຍາຍພາສາໃນທາງ
ທີ່ເຮັດໃຫ້ການນໍາໃຊ້ໂຄງສ້າງທີ່ບໍ່ຖືກຕ້ອງທີ່ແນ່ນອນ. ໂຄງສ້າງທີ່ບໍ່ຖືກຕ້ອງອື່ນໆອາດຈະຖືກພິຈາລະນາ
ສົມຄວນ​ທີ່​ຈະ​ມີ​ການ​ເຕືອນ​ໄພ, ແຕ່​ບໍ່​ດັ່ງ​ນັ້ນ​ກໍ​ເຮັດ​ໃຫ້​ເກີດ​ການ​ປະພຶດ​ທີ່​ສົມ​ເຫດ​ສົມ​ຜົນ. ຍັງມີການກໍ່ສ້າງອື່ນໆ
ອາດຈະມີຄວາມຫຍຸ້ງຍາກຫຼາຍທີ່ຈະກວດພົບໃນບາງການປະຕິບັດ. ນອກຈາກນີ້, ການປະຕິບັດທີ່ແຕກຕ່າງກັນ
ອາດ​ຈະ​ກວດ​ພົບ​ຄວາມ​ຜິດ​ພາດ​ທີ່​ໄດ້​ຮັບ​ໃນ​ລະ​ຫວ່າງ​ການ​ວິ​ເຄາະ​ເບື້ອງ​ຕົ້ນ​ຂອງ​ໂຄງ​ການ (ກ່ອນ​ທີ່​ຈະ​ອ່ານ​ໃດໆ​
input files) ໃນຂະນະທີ່ຄົນອື່ນອາດຈະກວດພົບມັນໃນເວລາທີ່ດໍາເນີນການໂຄງການຫຼັງຈາກອ່ານບາງ
ວັດສະດຸປ້ອນ. ຜູ້ຈັດຕັ້ງປະຕິບັດຄວນຮູ້ວ່າການວິນິດໄສຄວາມຜິດພາດໄວເທົ່າທີ່ຈະໄວໄດ້ແລະ
ການ​ຜະ​ລິດ​ວິ​ນິດ​ໄສ​ທີ່​ເປັນ​ປະ​ໂຫຍດ​ສາ​ມາດ​ຫຼຸດ​ຜ່ອນ​ການ debugging ຂອງ​ຄໍາ​ຮ້ອງ​ສະ​ຫມັກ​, ແລະ​ດັ່ງ​ນັ້ນ​ຈຶ່ງ​ເຮັດ​ໃຫ້​ເປັນ​
ການ​ປະ​ຕິ​ບັດ​ໄດ້​ຮັບ​ການ​ນໍາ​ໃຊ້​ຫຼາຍ​ຂຶ້ນ​.

ພຶດຕິກໍາທີ່ບໍ່ໄດ້ລະບຸຈາກການໃຊ້ຫຼາຍຕົວອັກສອນ RS ຄຸນຄ່າແມ່ນເພື່ອອະນຸຍາດໃຫ້ອະນາຄົດທີ່ເປັນໄປໄດ້
ສ່ວນຂະຫຍາຍໂດຍອີງໃສ່ການຂະຫຍາຍປົກກະຕິທີ່ໃຊ້ສໍາລັບຕົວແຍກບັນທຶກ. ປະຫວັດສາດ
ການປະຕິບັດເອົາລັກສະນະທໍາອິດຂອງສະຕິງແລະບໍ່ສົນໃຈຕົວອື່ນໆ.

ພຶດຕິກໍາທີ່ບໍ່ໄດ້ລະບຸເມື່ອ ແບ່ງປັນ(string,array, ) ຖືກນໍາໃຊ້ແມ່ນເພື່ອອະນຸຍາດໃຫ້ສະເຫນີໃນອະນາຄົດ
ສ່ວນຂະຫຍາຍທີ່ຈະແຍກສະຕຣິງອອກເປັນ array ຂອງຕົວອັກສອນແຕ່ລະອັນ.

ໃນສະພາບການຂອງ ສາຍ ການທໍາງານ, ການໂຕ້ຖຽງທີ່ດີເທົ່າທຽມກັນສໍາລັບລໍາດັບຄວາມສໍາຄັນທີ່ແຕກຕ່າງກັນ
ຂອງ | ແລະ < ຜູ້ປະກອບການສາມາດເຮັດໄດ້. ການປະຕິບັດປະຫວັດສາດແມ່ນ:

ສາຍ < "ກ" "ຂ"

ຖືກວິເຄາະເປັນ:

( ສາຍ < "ກ" ) "ຂ"

ເຖິງແມ່ນວ່າຫຼາຍໆຄົນຈະໂຕ້ຖຽງວ່າຄວາມຕັ້ງໃຈແມ່ນໄຟລ໌ດັ່ງກ່າວ ab ຄວນອ່ານ. ແນວໃດກໍ່ຕາມ:

ສາຍ < "x" + 1

parses ເປັນ:

ສາຍ < ( "x" + 1 )

ບັນຫາທີ່ຄ້າຍຄືກັນເກີດຂຶ້ນກັບ | ສະບັບຂອງ ສາຍ, ໂດຍສະເພາະໃນການປະສົມປະສານກັບ $.
ຍົກ​ຕົວ​ຢ່າງ:

$"ສຽງ ສະບາຍດີ" | ສາຍ

(ສະຖານະການນີ້ແມ່ນບັນຫາໂດຍສະເພາະເມື່ອໃຊ້ໃນ a ພິມ ຖະແຫຼງການ, ບ່ອນທີ່
|getline ສ່ວນຫນຶ່ງອາດຈະເປັນການປ່ຽນເສັ້ນທາງຂອງ ພິມ.)

ເນື່ອງຈາກວ່າໃນກໍລະນີຫຼາຍທີ່ສຸດ, ການກໍ່ສ້າງດັ່ງກ່າວແມ່ນບໍ່ (ຫຼືຢ່າງຫນ້ອຍບໍ່ຄວນ) ຖືກໃຊ້ (ເພາະວ່າພວກມັນ
ມີຄວາມບໍ່ຊັດເຈນທາງທໍາມະຊາດທີ່ບໍ່ມີການແຍກແບບທໍາມະດາ), ຄວາມຫມາຍຂອງສິ່ງເຫຼົ່ານີ້
ການກໍ່ສ້າງໄດ້ຖືກສ້າງຂື້ນຢ່າງຈະແຈ້ງ. (ຜົນ​ກະ​ທົບ​ແມ່ນ​ວ່າ​ເປັນ​ການ​ສອດ​ຄ່ອງ​
ຄໍາຮ້ອງສະຫມັກທີ່ແລ່ນເຂົ້າໄປໃນບັນຫາຕ້ອງວົງເລັບເພື່ອແກ້ໄຂຄວາມບໍ່ແນ່ນອນ
ປະກົດວ່າມີຈຳນວນໜ້ອຍຫາກນຳໃຊ້ຕົວຈິງຂອງການກໍ່ສ້າງດັ່ງກ່າວ.

ໄວຍະກອນສາມາດຂຽນໄດ້ທີ່ຈະເຮັດໃຫ້ເກີດຄວາມຜິດພາດພາຍໃຕ້ສະຖານະການເຫຼົ່ານີ້. ຢູ່ໃສ
backward-compatibility ບໍ່ແມ່ນການພິຈາລະນາຂະຫນາດໃຫຍ່, ຜູ້ປະຕິບັດອາດຈະຕ້ອງການທີ່ຈະນໍາໃຊ້ດັ່ງກ່າວ
ໄວຍາກອນ.

ການປະຕິບັດປະຫວັດສາດບາງຢ່າງໄດ້ອະນຸຍາດໃຫ້ບາງຫນ້າທີ່ກໍ່ສ້າງຢູ່ໃນເອີ້ນວ່າໂດຍບໍ່ມີການ
ບັນຊີລາຍຊື່ argument, ຜົນໄດ້ຮັບເປັນລາຍການ argument ເລີ່ມຕົ້ນທີ່ເລືອກໃນບາງ ``ສົມເຫດສົມຜົນ''
ທາງ. ການນໍາໃຊ້ ຄວາມຍາວ ເປັນຄໍາສັບຄ້າຍຄືສໍາລັບ ຄວາມຍາວ($0) ແມ່ນຫນຶ່ງໃນຮູບແບບເຫຼົ່ານີ້ເທົ່ານັ້ນ
ຄິດວ່າເປັນທີ່ຮູ້ຈັກຢ່າງກວ້າງຂວາງຫຼືຖືກນໍາໃຊ້ຢ່າງກວ້າງຂວາງ; ແບບຟອມສະເພາະນີ້ແມ່ນຖືກບັນທຶກໄວ້ໃນປະເພດຕ່າງໆ
ສະຖານທີ່ (ຕົວຢ່າງ, ປະຫວັດສາດທີ່ສຸດ ງຸ່ມ ຫນ້າອ້າງອີງ, ເຖິງແມ່ນວ່າບໍ່ໄດ້ຢູ່ໃນການອ້າງອີງ
ໄດ້ AWK ດໍາເນີນໂຄງການ ພາສາ) ເປັນການປະຕິບັດທີ່ຖືກຕ້ອງ. ມີຂໍ້ຍົກເວັ້ນນີ້, ຄ່າເລີ່ມຕົ້ນ
ບັນຊີລາຍຊື່ການໂຕ້ຖຽງແມ່ນບໍ່ມີເອກະສານແລະຖືກກໍານົດຢ່າງຈະແຈ້ງ, ແລະມັນບໍ່ແມ່ນທັງຫມົດ
ລ້າງວິທີການ (ຫຼືຖ້າ) ພວກເຂົາຄວນຈະຖືກນໍາໄປໃຊ້ໂດຍທົ່ວໄປໃນຫນ້າທີ່ກໍານົດໂດຍຜູ້ໃຊ້. ພວກເຂົາເພີ່ມບໍ່ມີປະໂຫຍດ
ການທໍາງານແລະຂັດຂວາງການຂະຫຍາຍໃນອະນາຄົດທີ່ເປັນໄປໄດ້ທີ່ອາດຈະຈໍາເປັນຕ້ອງຕັ້ງຊື່ຫນ້າທີ່
ໂດຍບໍ່ມີການໂທຫາພວກເຂົາ. ບໍ່ໄດ້ມາດຕະຖານໃຫ້ເຂົາເຈົ້າເບິ່ງຄືວ່າເປັນຫຼັກສູດທີ່ງ່າຍດາຍທີ່ສຸດ. ມາດຕະຖານ
ນັກພັດທະນາພິຈາລະນາວ່າ ຄວາມຍາວ ໄດ້ຮັບການປິ່ນປົວພິເສດ, ຢ່າງໃດກໍຕາມ, ນັບຕັ້ງແຕ່ມັນໄດ້
ບັນທຶກໃນອະດີດ ແລະເຫັນວ່າມີການນຳໃຊ້ຢ່າງຫຼວງຫຼາຍໃນໂຄງການປະຫວັດສາດ.
ຕາມ​ນັ້ນ​ແລ້ວ, ການ​ນຳ​ໃຊ້​ນີ້​ໄດ້​ຖືກ​ສ້າງ​ຂຶ້ນ​ຢ່າງ​ຖືກຕ້ອງ​ຕາມ​ກົດໝາຍ, ​ແຕ່​ສະບັບ​ທີ 5 ​ໄດ້​ລົບ​ລ້າງ​ການ​ລ້າ​ສະ​ໄໝ​ອອກ​ໄປ
ການເຮັດເຄື່ອງຫມາຍສໍາລັບການປະຕິບັດທີ່ສອດຄ່ອງກັບ XSI ແລະຫຼາຍໆຄໍາຮ້ອງສະຫມັກທີ່ສອດຄ່ອງກັນ
ຂຶ້ນກັບຄຸນສົມບັດນີ້.

In ການຍ່ອຍ ແລະ gsub, ຖ້າ ແທນ ແມ່ນຕົວໜັງສືສະຕຣິງ (the lexical token ຄັກ), ຫຼັງຈາກນັ້ນສອງ
ຕິດຕໍ່ກັນ ຕົວອັກສອນຄວນຖືກໃຊ້ໃນສະຕຣິງເພື່ອຮັບປະກັນອັນດຽວ
ຈະນໍາຫນ້າ ເມື່ອສະຕຣິງຜົນໄດ້ຮັບຖືກສົ່ງໄປຫາ
ຫນ້າທີ່. (ຍົກ​ຕົວ​ຢ່າງ​, ການ​ລະ​ບຸ​ຕົວ​ອັກ​ສອນ​ຫນຶ່ງ​ ໃນ string ການທົດແທນ, ໃຊ້
gsub(TIME, "\\&"))

ໃນປະຫວັດສາດ, ລັກສະນະພິເສດພຽງແຕ່ໃນ ແທນ ການໂຕ້ຖຽງຂອງ ການຍ່ອຍ ແລະ gsub string
ຫນ້າທີ່ແມ່ນ ('&') ລັກ​ສະ​ນະ​ແລະ​ນໍາ​ຫນ້າ​ມັນ​ກັບ​
ລັກ​ສະ​ນະ​ໄດ້​ຖືກ​ນໍາ​ໃຊ້​ເພື່ອ​ປິດ​ຄວາມ​ຫມາຍ​ພິ​ເສດ​ຂອງ​ຕົນ​.

ຄຳອະທິບາຍໃນມາດຕະຖານ ISO POSIX-2:1993 ໄດ້ນຳສະເໜີພຶດຕິກຳດັ່ງກ່າວ
ລັກ​ສະ​ນະ​ເປັນ​ລັກ​ສະ​ນະ​ພິ​ເສດ​ອື່ນ​ແລະ​ມັນ​ບໍ່​ໄດ້​ລະ​ບຸ​ວ່າ​ມີ​
ມີລັກສະນະພິເສດອື່ນໆ. ລາຍ​ລະ​ອຽດ​ນີ້​ນໍາ​ສະ​ເຫນີ​ການ Portable ຫຼາຍ​
ບັນຫາ, ບາງສ່ວນຂອງທີ່ຖືກອະທິບາຍຂ້າງລຸ່ມນີ້, ແລະດັ່ງນັ້ນມັນໄດ້ຖືກທົດແທນດ້ວຍຫຼາຍ
ລາຍ​ລະ​ອຽດ​ປະ​ຫວັດ​ສາດ​. ບາງບັນຫາລວມມີ:

* ໃນປະຫວັດສາດ, ເພື່ອສ້າງສະຕຣິງທົດແທນ, script ສາມາດໃຊ້ gsub(TIME, "\\&"),
ແຕ່ດ້ວຍມາດຕະຖານ ISO POSIX-2: 1993, ມັນຈໍາເປັນຕ້ອງໃຊ້ gsub(TIME,
"\\\\&"). ໄດ້ ຕົວອັກສອນຖືກເພີ່ມເປັນສອງເທົ່າຢູ່ທີ່ນີ້ເພາະວ່າຕົວໜັງສືສະຕຣິງທັງໝົດແມ່ນ
ຂຶ້ນກັບການວິເຄາະ lexical, ເຊິ່ງຈະຫຼຸດລົງແຕ່ລະຄູ່ ຕົວອັກສອນເພື່ອ
ດຽວ ກ່ອນທີ່ຈະຖືກສົ່ງໄປຫາ gsub.

* ເນື່ອງຈາກມັນບໍ່ໄດ້ຖືກລະບຸວ່າຕົວອັກສອນພິເສດແມ່ນຫຍັງ, ສໍາລັບສະຄຣິບແບບພົກພາໄປ
ຮັບ​ປະ​ກັນ​ວ່າ​ຕົວ​ອັກ​ສອນ​ໄດ້​ຖືກ​ພິມ​ອອກ​ຕາມ​ຕົວ​ອັກ​ສອນ​, ແຕ່​ລະ​ຕົວ​ອັກ​ສອນ​ຕ້ອງ​ໄດ້​ກ່ອນ​ຫນ້າ​
ກັບ ກ . (ຕົວຢ່າງ, script ເຄື່ອນທີ່ຕ້ອງໃຊ້ gsub(TIME, "\\ h\\i") ໄປ
ຜະລິດສາຍພັນທົດແທນຂອງ "ສະບາຍດີ".)

ຄໍາອະທິບາຍສໍາລັບການປຽບທຽບໃນມາດຕະຖານ ISO POSIX-2: 1993 ບໍ່ໄດ້ອະທິບາຍຢ່າງຖືກຕ້ອງ
ການປະຕິບັດປະຫວັດສາດເນື່ອງຈາກວ່າວິທີການຈໍານວນຕົວເລກຖືກປຽບທຽບເປັນຕົວເລກ. ໄດ້
ກົດລະບຽບໃນປະຈຸບັນເຮັດໃຫ້ລະຫັດຕໍ່ໄປນີ້:

if (0 == "000")
ພິມ "ແປກ, ແຕ່ ຈິງ"
ອື່ນ
ພິມ "ບໍ່ ຈິງ"

ເພື່ອເຮັດການປຽບທຽບຕົວເລກ, ເຊິ່ງກໍ່ໃຫ້ເກີດ if ສໍາເລັດ. ມັນຄວນຈະຈະແຈ້ງ intuitively
ວ່ານີ້ແມ່ນພຶດຕິກໍາທີ່ບໍ່ຖືກຕ້ອງ, ແລະແທ້ຈິງແລ້ວ, ບໍ່ມີການຈັດຕັ້ງປະຕິບັດປະຫວັດສາດ ງຸ່ມ ຕົວຈິງແລ້ວ
ປະພຶດແບບນີ້.

ເພື່ອແກ້ໄຂບັນຫານີ້, ຄໍານິຍາມຂອງ numeric string ໄດ້ຖືກປັບປຸງໃຫ້ປະກອບມີພຽງແຕ່ເຫຼົ່ານັ້ນ
ຄ່າທີ່ໄດ້ຮັບຈາກສະຖານະການສະເພາະ (ສ່ວນຫຼາຍແມ່ນແຫຼ່ງພາຍນອກ) ບ່ອນທີ່ມັນບໍ່ແມ່ນ
ເປັນໄປໄດ້ເພື່ອກໍານົດຢ່າງບໍ່ຊັດເຈນວ່າຄ່າແມ່ນມີຈຸດປະສົງເປັນ string ຫຼື a
ຕົວເລກ.

ຕົວແປທີ່ຖືກມອບໝາຍໃຫ້ກັບສະຕຣິງຕົວເລກຍັງຈະຖືກປະຕິບັດເປັນສະຕຣິງຕົວເລກ.
(ຕົວຢ່າງ, ແນວຄວາມຄິດຂອງສາຍຕົວເລກສາມາດແຜ່ຂະຫຍາຍໃນທົ່ວວຽກ.) ໃນ
ການປຽບທຽບ, ທຸກຕົວແປທີ່ມີມູນຄ່າ uninitialized ຈະຖືກປະຕິບັດເປັນຕົວເລກ.
operand ປະເມີນຄ່າຕົວເລກສູນ.

ຕົວແປທີ່ຍັງບໍ່ທັນໄດ້ລວມເອົາຕົວແປທຸກປະເພດລວມທັງ scalar, ອົງປະກອບອາເຣ,
ແລະທົ່ງນາ. ຄໍານິຍາມຂອງຄ່າ uninitialized ໃນ Variables ແລະ ພິເສດ Variables is
ມີຄວາມຈໍາເປັນເພື່ອອະທິບາຍມູນຄ່າທີ່ວາງໄວ້ໃນຕົວແປທີ່ບໍ່ໄດ້ກໍານົດເອງແລະໃນຊ່ອງຂໍ້ມູນທີ່ມີ
ຖືກຕ້ອງ (ຕົວຢ່າງ, < $NF) ແຕ່ບໍ່ມີຕົວລະຄອນໃນພວກມັນ ແລະອະທິບາຍວິທີການເຫຼົ່ານີ້
ຕົວແປຈະຖືກນໍາໃຊ້ໃນການປຽບທຽບ. ຊ່ອງຂໍ້ມູນທີ່ຖືກຕ້ອງ, ເຊັ່ນ: $1, ທີ່ບໍ່ມີຕົວອັກສອນ
ໃນ ມັນ ສາ ມາດ ໄດ້ ຮັບ ຈາກ ເສັ້ນ ປະ ກອບ ຂອງ "\t\t" ໃນເວລາທີ່ FS='\t'. ໃນປະຫວັດສາດ, ໄດ້
ການ​ປຽບ​ທຽບ ($110) ໄດ້ເຮັດເປັນຕົວເລກຫຼັງຈາກການປະເມີນ $1 ກັບຄ່າສູນ.

ປະໂຫຍກ ``... ຍັງຈະຕ້ອງມີຄ່າຕົວເລກຂອງສະຕຣິງຕົວເລກ'' ຖືກລຶບອອກ
ຈາກ​ຫຼາຍ​ພາກ​ສ່ວນ​ຂອງ​ມາດ​ຕະ​ຖານ ISO POSIX-2:1993 ເນື່ອງ​ຈາກ​ວ່າ​ໄດ້​ລະ​ບຸ​ໄວ້​ບໍ່​ຈໍາ​ເປັນ
ລາຍ​ລະ​ອຽດ​ການ​ປະ​ຕິ​ບັດ​. ມັນບໍ່ຈໍາເປັນສໍາລັບ POSIX.1-2008 ເພື່ອລະບຸວ່າວັດຖຸເຫຼົ່ານີ້
ໄດ້ຮັບການມອບຫມາຍສອງຄ່າທີ່ແຕກຕ່າງກັນ. ມັນເປັນສິ່ງຈໍາເປັນພຽງແຕ່ເພື່ອກໍານົດວ່າວັດຖຸເຫຼົ່ານີ້ອາດຈະ
ປະເມີນເປັນສອງຄ່າທີ່ແຕກຕ່າງກັນຂຶ້ນກັບບໍລິບົດ.

ການປະຕິບັດປະຫວັດສາດຂອງ ງຸ່ມ ບໍ່ໄດ້ວິເຄາະຈຳນວນເຕັມເລກຖານສິບຫົກ ຫຼືຄ່າຄົງທີ່ທີ່ເລື່ອນໄດ້
ຄື "0xa" ແລະ "0xap0". ເນື່ອງຈາກການກວດກາ, ສະບັບ 2001 ຫາ 2004 ນີ້
ສະຫນັບສະຫນູນມາດຕະຖານທີ່ຕ້ອງການສໍາລັບຄ່າຄົງທີ່ລອຍຕົວເລກຖານສິບຫົກ. ນີ້ແມ່ນເນື່ອງມາຈາກ
ອ້າງເຖິງ atof(). ສະບັບຂອງມາດຕະຖານນີ້ອະນຸຍາດໃຫ້ແຕ່ບໍ່ຕ້ອງການ
ການ​ປະ​ຕິ​ບັດ​ການ​ນໍາ​ໃຊ້​ atof() ແລະປະກອບມີຄໍາອະທິບາຍວິທີການຕົວເລກຈຸດລອຍຕົວ
ຖືກຮັບຮູ້ວ່າເປັນທາງເລືອກທີ່ຈະກົງກັບພຶດຕິກໍາປະຫວັດສາດ. ຈຸດປະສົງຂອງການປ່ຽນແປງນີ້ແມ່ນເພື່ອ
ອະ​ນຸ​ຍາດ​ໃຫ້​ການ​ປະ​ຕິ​ບັດ​ເພື່ອ​ຮັບ​ຮູ້​ຄົງ​ທີ່​ຈຸດ​ທີ່​ເລື່ອນ​ໄດ້​ອີງ​ຕາມ​ການ​ທັງ
ມາດຕະຖານ ISO/IEC 9899:1990 ຫຼືມາດຕະຖານ ISO/IEC 9899:1999, ແລະອະນຸຍາດໃຫ້ (ແຕ່ບໍ່ຕ້ອງການ)
ການປະຕິບັດເພື່ອຮັບຮູ້ຄ່າຄົງທີ່ຂອງເລກທົດສະນິຍົມເລກສິບຫົກ.

ການປະຕິບັດປະຫວັດສາດຂອງ ງຸ່ມ ບໍ່ໄດ້ສະຫນັບສະຫນູນຈຸດທີ່ບໍ່ມີຂອບເຂດທີ່ລອຍຕົວແລະ NaNs ໃນ
numeric strings; ຕົວຢ່າງ: "−INF" ແລະ "ນາ". ຢ່າງໃດກໍຕາມ, ການປະຕິບັດການນໍາໃຊ້ atof() ຫລື
strtod() ຫນ້າທີ່ເຮັດການປ່ຽນໃຈເຫລື້ອມໃສທີ່ເກັບຂຶ້ນສະຫນັບສະຫນູນຄ່າເຫຼົ່ານີ້ຖ້າພວກເຂົາໃຊ້ a
ISO/IEC 9899:1999 ຮຸ່ນມາດຕະຖານຂອງຟັງຊັນແທນມາດຕະຖານ ISO/IEC 9899:1990
ສະບັບ. ເນື່ອງຈາກການກວດກາ, ສະບັບ 2001 ຫາ 2004 ຂອງມາດຕະຖານນີ້ບໍ່ໄດ້
ອະ​ນຸ​ຍາດ​ໃຫ້​ສະ​ຫນັບ​ສະ​ຫນູນ infinity ແລະ NaNs​, ແຕ່​ໃນ​ການ​ສະ​ຫນັບ​ສະ​ຫນູນ​ການ​ດັດ​ແກ້​ນີ້​ແມ່ນ​ອະ​ນຸ​ຍາດ​ໃຫ້ (ແຕ່​ບໍ່​ໄດ້​
ຕ້ອງການ). ນີ້ແມ່ນການປ່ຽນແປງຢ່າງງຽບໆກັບພຶດຕິກໍາຂອງ ງຸ່ມ ໂຄງການ; ສໍາລັບຕົວຢ່າງ, ໃນ
POSIX ກຳນົດສະຖານທີ່ຂອງສຳນວນ:

("-INF" + 0 < 0)

ເມື່ອກ່ອນມີມູນຄ່າ 0 ເພາະວ່າ "−INF" ປ່ຽນເປັນ 0, ແຕ່ຕອນນີ້ມັນອາດຈະມີມູນຄ່າ 0 ຫຼື
1.

ອະນາຄົດ DIRECTIONS

ບໍ່ມີ.

ໃຊ້ awkposix ອອນລາຍໂດຍໃຊ້ບໍລິການ onworks.net