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

ໂຄງການ:

NAME

mawk - ການສະແກນຮູບແບບແລະພາສາການປຸງແຕ່ງຂໍ້ຄວາມ

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

ມອກ [-W ທາງເລືອກ] [-F ມູນຄ່າ] [-v var=ຄ່າ] [--] 'ຂໍ້ຄວາມໂຄງການ' [ໄຟລ໌ ...]
ມອກ [-W ທາງເລືອກ] [-F ມູນຄ່າ] [-v var=ຄ່າ] [-f program-file] [--] [ໄຟລ໌ ...]

ລາຍລະອຽດ

ມອກ ເປັນນາຍພາສາສໍາລັບ AWK Programming Language. ພາສາ AWK ແມ່ນເປັນປະໂຫຍດສໍາລັບ
ການ​ຫມູນ​ໃຊ້​ຂອງ​ໄຟລ​໌​ຂໍ້​ມູນ​, ດຶງ​ຂໍ້​ຄວາມ​ແລະ​ການ​ປຸງ​ແຕ່ງ​, ແລະ​ສໍາ​ລັບ​ການ prototyping ແລະ​
ການທົດລອງກັບ algorithms. ມອກ ເປັນ ໃຫມ່ ງຸ່ມ ຊຶ່ງຫມາຍຄວາມວ່າມັນປະຕິບັດພາສາ AWK
ຕາມທີ່ໄດ້ກໍານົດໄວ້ໃນ Aho, Kernighan ແລະ Weinberger, ໄດ້ AWK ດໍາເນີນໂຄງການ ພາສາ, Addison-wesley
Publishing, 1988. (ຕໍ່​ໄປ​ນີ້​ເອີ້ນ​ວ່າ​ຫນັງ​ສື AWK.) ມອກ ສອດຄ່ອງກັບ Posix
1003.2 (ຮ່າງ 11.3) ຄໍານິຍາມຂອງພາສາ AWK ທີ່ມີຄຸນສົມບັດບໍ່ຫຼາຍປານໃດ
ອະທິບາຍໄວ້ໃນປຶ້ມ AWK, ແລະ ມອກ ສະຫນອງການຂະຫຍາຍຈໍານວນຫນ້ອຍ.

ໂຄງການ AWK ເປັນລໍາດັບຂອງ ຮູບແບບ {action} ຄໍານິຍາມຂອງຄູ່ແລະຫນ້າທີ່. ສັ້ນ
ໂປລແກລມຖືກໃສ່ຢູ່ໃນເສັ້ນຄໍາສັ່ງໂດຍປົກກະຕິແລ້ວຖືກຫຸ້ມຢູ່ໃນ ' ' ເພື່ອຫຼີກເວັ້ນການ shell
ການຕີຄວາມໝາຍ. ໂປຣແກຣມທີ່ຍາວກວ່າສາມາດອ່ານໄດ້ຈາກໄຟລ໌ທີ່ມີຕົວເລືອກ -f. ຂໍ້ມູນ
input ແມ່ນອ່ານຈາກບັນຊີລາຍຊື່ຂອງໄຟລ໌ໃນແຖວຄໍາສັ່ງຫຼືຈາກມາດຕະຖານ input ເມື່ອ the
ບັນຊີລາຍຊື່ຫວ່າງເປົ່າ. ການປ້ອນຂໍ້ມູນຖືກແຍກອອກເປັນບັນທຶກຕາມທີ່ກຳນົດໂດຍຕົວແຍກບັນທຶກ
ຕົວແປ, RS. ໃນເບື້ອງຕົ້ນ, RS = "\n" ແລະບັນທຶກແມ່ນຄ້າຍຄືກັນກັບເສັ້ນ. ແຕ່ລະບັນທຶກແມ່ນ
ປຽບທຽບກັບແຕ່ລະຄົນ ຮູບແບບ ແລະຖ້າມັນກົງກັນ, ຂໍ້ຄວາມໂຄງການສໍາລັບ {action} is
ປະຕິບັດ.

OPTIONS

-F ມູນຄ່າ ກໍາ​ນົດ​ຕົວ​ແຍກ​ພາກ​ສະ​ຫນາມ​, FS, ການ ມູນຄ່າ.

-f ເອກະສານ ຂໍ້ຄວາມໂຄງການແມ່ນອ່ານຈາກ ເອກະສານ ແທນທີ່ຈະມາຈາກເສັ້ນຄໍາສັ່ງ. ຫຼາຍ
-f ທາງ​ເລືອກ​ແມ່ນ​ອະ​ນຸ​ຍາດ​ໃຫ້​.

-v var=ຄ່າ ມອບຫມາຍ ມູນຄ່າ ກັບຕົວແປໂຄງການ var.

-- ຊີ້ໃຫ້ເຫັນເຖິງຈຸດສິ້ນສຸດຂອງທາງເລືອກທີ່ບໍ່ຊັດເຈນ.

ທາງເລືອກຂ້າງເທິງນີ້ຈະມີຢູ່ໃນການປະຕິບັດທີ່ເຫມາະສົມກັບ Posix ຂອງ AWK, ແລະ
ທາງ​ເລືອກ​ສະ​ເພາະ​ການ​ປະ​ຕິ​ບັດ​ແມ່ນ​ໄດ້​ນໍາ​ຫນ້າ​ກັບ​ -W. ມອກ ໃຫ້​ຫົກ​:

-W ສະບັບພາສາ ມອກ ຂຽນສະບັບແລະລິຂະສິດຂອງຕົນເພື່ອ stdout ແລະລວບລວມຂໍ້ຈໍາກັດເພື່ອ
stderr ແລະອອກ 0.

-W dump ຂຽນ assembler ເຊັ່ນ: ບັນຊີລາຍຊື່ຂອງຕົວແທນພາຍໃນຂອງ
ໂຄງ​ການ​ທີ່​ຈະ stdout ແລະ​ອອກ 0 (ກ່ຽວ​ກັບ​ການ​ລວບ​ລວມ​ສົບ​ຜົນ​ສໍາ​ເລັດ​)​.

-W ໂຕ້ຕອບຊຸດການຂຽນແບບບໍ່ມີ buffered ກັບ stdout ແລະເສັ້ນ buffered ອ່ານຈາກ stdin.
ບັນທຶກຈາກ stdin ແມ່ນສາຍໂດຍບໍ່ຄໍານຶງເຖິງມູນຄ່າຂອງ RS.

-W exec ເອກະສານ ຂໍ້ຄວາມໂຄງການແມ່ນອ່ານຈາກ ເອກະສານ ແລະນີ້ແມ່ນທາງເລືອກສຸດທ້າຍ. ມີປະໂຫຍດໃນ
ລະບົບທີ່ສະຫນັບສະຫນູນ #! ສົນທິສັນຍາ "ຕົວເລກ magic" ສໍາລັບການປະຕິບັດ
ອັກສອນ.

-W sprintf=num ປັບ​ຂະ​ຫນາດ​ຂອງ​ mawk ຂອງ buffer sprintf ພາຍໃນກັບ num ໄບຕ໌. ຫຼາຍ​ກວ່າ
ການນໍາໃຊ້ທີ່ຫາຍາກຂອງທາງເລືອກນີ້ຊີ້ໃຫ້ເຫັນ ມອກ ຄວນໄດ້ຮັບການລວບລວມຄືນໃຫມ່.

-W posix_space ກໍາລັງ ມອກ ບໍ່ໃຫ້ພິຈາລະນາ '\n' ເປັນພື້ນທີ່.

ຮູບແບບສັ້ນ -W[vdiesp] ຖືກຮັບຮູ້ແລະຢູ່ໃນບາງລະບົບ -We ແມ່ນບັງຄັບເພື່ອຫຼີກເວັ້ນການ
ຂໍ້ຈໍາກັດຄວາມຍາວຂອງແຖວຄໍາສັ່ງ.

ການ AWK LANGUAGE

1. ໂຄງການ ໂຄງປະກອບການ
ໂຄງການ AWK ເປັນລໍາດັບຂອງ ຮູບແບບ {action} ຄູ່ແລະຄໍານິຍາມຫນ້າທີ່ຜູ້ໃຊ້.

ຮູບແບບສາມາດເປັນ:
ເລີ່ມຕົ້ນ
END
ການສະແດງອອກ
ການສະແດງອອກ, ການສະແດງອອກ

ຫນຶ່ງ, ແຕ່ບໍ່ແມ່ນທັງສອງ, ຂອງ ຮູບແບບ {action} ສາມາດຖືກລະເວັ້ນ. ຖ້າ {action} ຖືກລະເວັ້ນມັນແມ່ນ
implicitly {ພິມ }. ຖ້າ ຮູບແບບ ຖືກລະເວັ້ນ, ຫຼັງຈາກນັ້ນມັນຈະຖືກຈັບຄູ່ກັນຢ່າງບໍ່ຊັດເຈນ. ເລີ່ມຕົ້ນ ແລະ
END ຮູບແບບຮຽກຮ້ອງໃຫ້ມີການປະຕິບັດ.

ຄໍາຖະແຫຼງທີ່ຖືກປິດໂດຍແຖວໃຫມ່, ເຄິ່ງຈໍ້າສອງເມັດຫຼືທັງສອງ. ກຸ່ມຂອງຄໍາຖະແຫຼງເຊັ່ນ
ການປະຕິບັດຫຼືອົງປະກອບຂອງ loop ແມ່ນຖືກບລັອກຜ່ານ { ... } ໃນ C. ຄໍາຖະແຫຼງສຸດທ້າຍໃນບລັອກ
ບໍ່ຈໍາເປັນຕ້ອງມີ terminator. ເສັ້ນຫວ່າງບໍ່ມີຄວາມຫມາຍ; ຄໍາຖະແຫຼງທີ່ຫວ່າງເປົ່າແມ່ນສິ້ນສຸດລົງ
ມີເຄິ່ງຈໍ້າສອງເມັດ. ຂໍ້ຄວາມຍາວສາມາດສືບຕໍ່ໄດ້ດ້ວຍ backslash, \. ຄໍາຖະແຫຼງທີ່ສາມາດເຮັດໄດ້
ຖືກແຍກໂດຍບໍ່ມີ backslash ຫຼັງຈາກເຄື່ອງໝາຍຈຸດ, ວົງເລັບຊ້າຍ, &&, ||, do, ອື່ນ, ສິດ
ວົງເລັບຂອງ an if, ໃນຂະນະທີ່ or ສໍາລັບການ ຖະແຫຼງການ, ແລະວົງເລັບທີ່ຖືກຕ້ອງຂອງຟັງຊັນໃດໜຶ່ງ
ຄໍານິຍາມ. ຄຳເຫັນເລີ່ມຕົ້ນດ້ວຍ # ແລະຂະຫຍາຍໄປ, ແຕ່ບໍ່ລວມເຖິງທ້າຍແຖວ.

ຖະແຫຼງການຕໍ່ໄປນີ້ຄວບຄຸມການໄຫຼເຂົ້າຂອງໂປຣແກຣມພາຍໃນບລັອກ.

if ( ຕົວຢ່າງ ) ຄໍາຖະແຫຼງທີ່

if ( ຕົວຢ່າງ ) ຄໍາຖະແຫຼງທີ່ ອື່ນ ຄໍາຖະແຫຼງທີ່

ໃນຂະນະທີ່ ( ຕົວຢ່າງ ) ຄໍາຖະແຫຼງທີ່

do ຄໍາຖະແຫຼງທີ່ ໃນຂະນະທີ່ ( ຕົວຢ່າງ )

ສໍາລັບການ ( opt_expr ; opt_expr ; opt_expr ) ຄໍາຖະແຫຼງທີ່

ສໍາລັບການ ( var in array ) ຄໍາຖະແຫຼງທີ່

ດໍາເນີນການຕໍ່

ພັກຜ່ອນ

2. ຂໍ້ມູນ ປະເພດ, ການປ່ຽນແປງ ແລະ ການປຽບທຽບ
ມີສອງປະເພດຂໍ້ມູນພື້ນຖານ, ຕົວເລກ ແລະສະຕຣິງ. ຕົວເລກຄົງທີ່ສາມາດເປັນຈໍານວນເຕັມເຊັ່ນ
-2, ທົດສະນິຍົມຄື 1.08, ຫຼືໃນໝາຍເຫດທາງວິທະຍາສາດເຊັ່ນ -1.1e4 ຫຼື .28E-3. ຕົວເລກທັງໝົດແມ່ນ
ເປັນຕົວແທນຢູ່ພາຍໃນ ແລະ ການຄຳນວນທັງໝົດແມ່ນເຮັດຢູ່ໃນເລກເລກຄະນິດທີ່ລອຍຕົວ. ດັ່ງນັ້ນສໍາລັບ
ຕົວຢ່າງ, ການສະແດງອອກ 0.2e2 == 20 ແມ່ນ true ແລະ true ແມ່ນສະແດງເປັນ 1.0.

ຄົງສະຕຣິງຖືກຫຸ້ມຢູ່ໃນວົງຢືມຄູ່.

"ນີ້ແມ່ນສະຕຣິງທີ່ມີແຖວໃໝ່ຢູ່ທ້າຍ.\n"

ສາຍສາມາດສືບຕໍ່ຂ້າມເສັ້ນໄດ້ໂດຍການຫລົບຫນີ (\) ແຖວໃຫມ່. ການຫລົບຫນີຕໍ່ໄປນີ້
ລໍາດັບແມ່ນຮັບຮູ້.

\\
\" "
\a ເຕືອນ, ascii 7
\b backspace, ascii 8
ແຖບ \t, ascii 9
\n ແຖວໃໝ່, ascii 10
\v ແຖບແນວຕັ້ງ, ascii 11
\f formfeed, ascii 12
\r ກັບຄືນ carriage, ascii 13
\ddd 1, 2 ຫຼື 3 ໂຕເລກແປດສໍາລັບ ascii ddd
\xhh 1 ຫຼື 2 ຕົວເລກ hex ສໍາລັບ ascii hh

ຖ້າທ່ານຫລົບຫນີຕົວລະຄອນອື່ນ \c, ທ່ານຈະໄດ້ຮັບ \c, ie, ມອກ ບໍ່ສົນໃຈການຫລົບຫນີ.

ມີແທ້ສາມປະເພດຂໍ້ມູນພື້ນຖານ; ອັນທີສາມແມ່ນ ຈໍານວນ ແລະ string ເຊິ່ງມີທັງ ກ
ຄ່າຕົວເລກ ແລະຄ່າສະຕຣິງໃນເວລາດຽວກັນ. ຕົວແປທີ່ຜູ້ໃຊ້ກໍານົດເຂົ້າມາ
ທີ່ມີຢູ່ແລ້ວໃນເວລາທີ່ອ້າງອີງທໍາອິດແລະຖືກເລີ່ມຕົ້ນກັບ null, ຕົວເລກ ແລະຄ່າສະຕຣິງ
ເຊິ່ງມີຄ່າຕົວເລກ 0 ແລະຄ່າສະຕຣິງ "". ຕົວເລກທີ່ບໍ່ແມ່ນເລື່ອງເລັກໆນ້ອຍໆ ແລະຂໍ້ມູນທີ່ພິມເປັນສະຕຣິງ
ມາຈາກການປ້ອນຂໍ້ມູນ ແລະປົກກະຕິແລ້ວຈະຖືກເກັບໄວ້ໃນຊ່ອງຂໍ້ມູນ. (ເບິ່ງພາກ 4).

ປະເພດຂອງການສະແດງອອກແມ່ນຖືກກໍານົດໂດຍສະພາບການຂອງມັນແລະການແປງປະເພດອັດຕະໂນມັດ
ເກີດຂຶ້ນຖ້າຈໍາເປັນ. ຕົວຢ່າງ, ເພື່ອປະເມີນຄໍາຖະແຫຼງການ

y = x + 2 ; z = x "ສະບາຍດີ"

ຄ່າທີ່ເກັບໄວ້ໃນຕົວແປ y ຈະຖືກພິມເປັນຕົວເລກ. ຖ້າ x ບໍ່ແມ່ນຕົວເລກ, ຄ່າທີ່ອ່ານ
ຈາກ x ຖືກປ່ຽນເປັນຕົວເລກກ່ອນທີ່ມັນຈະເພີ່ມເປັນ 2 ແລະເກັບໄວ້ໃນ y. ມູນຄ່າເກັບຮັກສາໄວ້
ໃນຕົວແປ z ຈະຖືກພິມ string, ແລະຄ່າຂອງ x ຈະຖືກປ່ຽນເປັນ string if
ມີຄວາມຈໍາເປັນແລະ concatenated ກັບ "ສະບາຍດີ". (ແນ່ນອນ, ຄ່າແລະປະເພດທີ່ເກັບໄວ້ໃນ x ແມ່ນ
ບໍ່ມີການປ່ຽນແປງໂດຍການປ່ຽນແປງໃດໆ.) ການສະແດງອອກຂອງສະຕຣິງຖືກປ່ຽນເປັນຕົວເລກໂດຍໃຊ້ຂອງມັນ
ຄຳນຳໜ້າຕົວເລກທີ່ຍາວທີ່ສຸດຄືກັບ atof(3). ການສະແດງອອກເປັນຕົວເລກຖືກປ່ຽນເປັນສະຕຣິງໂດຍ
ປ່ຽນແທນ ຕົວຢ່າງ ກັບ sprintf(CONVFMT, ຕົວຢ່າງ), ເວັ້ນເສຍແຕ່ ຕົວຢ່າງ ສາມາດເປັນຕົວແທນຢູ່ໃນເຈົ້າພາບ
ເຄື່ອງເປັນຈໍານວນທີ່ແນ່ນອນຫຼັງຈາກນັ້ນມັນຖືກປ່ຽນເປັນ ແລ່ນ("%d", ຕົວຢ່າງ). Sprintf() ເປັນ
AWK ກໍ່ສ້າງໃນທີ່ຊ້ໍາກັນການທໍາງານຂອງ ແລ່ນ(3) ແລະ CONVFMT ແມ່ນການກໍ່ສ້າງໃນ
ຕົວແປທີ່ໃຊ້ສໍາລັບການປ່ຽນພາຍໃນຈາກຕົວເລກໄປຫາສະຕຣິງ ແລະເລີ່ມຕົ້ນເປັນ "%.6g".
ການແປງປະເພດທີ່ຈະແຈ້ງສາມາດຖືກບັງຄັບ, ຕົວຢ່າງ "" ແມ່ນ string ແລະ ຕົວຢ່າງ+0 ເປັນຕົວເລກ.

ການ​ປະ​ເມີນ​ຜົນ​, ຕົວຢ່າງ1 rel-op ຕົວຢ່າງ2, ຖ້າຫາກວ່າທັງສອງ operands ເປັນຕົວເລກຫຼືຕົວເລກແລະ string ຫຼັງຈາກນັ້ນ
ການປຽບທຽບແມ່ນຕົວເລກ; ຖ້າທັງສອງ operands ແມ່ນ string ການປຽບທຽບແມ່ນ string; ຖ້າຫນຶ່ງ
operand ແມ່ນ string, operand ທີ່ບໍ່ແມ່ນ string ຖືກປ່ຽນແລະການປຽບທຽບແມ່ນ string. ໄດ້
ຜົນໄດ້ຮັບແມ່ນຕົວເລກ, 1 ຫຼື 0.

ໃນສະພາບການ boolean ເຊັ່ນ, if ( ຕົວຢ່າງ ) ຄໍາຖະແຫຼງທີ່, ການສະແດງອອກຂອງສະຕຣິງປະເມີນເປັນ true if
ແລະພຽງແຕ່ຖ້າມັນບໍ່ແມ່ນສາຍທີ່ຫວ່າງເປົ່າ ""; ຄ່າຕົວເລກຖ້າແລະພຽງແຕ່ຖ້າບໍ່ແມ່ນຕົວເລກ
ສູນ.

3. ເປັນປົກກະຕິ expressions
ໃນພາສາ AWK, ບັນທຶກ, ຊ່ອງຂໍ້ມູນ ແລະສະຕຣິງມັກຈະຖືກທົດສອບການຈັບຄູ່ a ປົກກະຕິ
ການສະແດງອອກ. ການສະແດງອອກແບບປົກກະຕິແມ່ນຖືກຫຸ້ມຢູ່ໃນເຄື່ອງຕັດ, ແລະ

ຕົວຢ່າງ ~/r/

ແມ່ນການສະແດງອອກ AWK ທີ່ປະເມີນເປັນ 1 if ຕົວຢ່າງ "ການແຂ່ງຂັນ" r, ຊຶ່ງຫມາຍຄວາມວ່າ substring ຂອງ
ຕົວຢ່າງ ແມ່ນຢູ່ໃນຊຸດຂອງສາຍທີ່ກໍານົດໂດຍ r. ບໍ່ມີການຈັບຄູ່ການສະແດງອອກປະເມີນເປັນ 0;
ການປ່ຽນແທນ ~ ກັບຕົວປະຕິບັດການ "ບໍ່ກົງກັນ", !~ , ກັບຄືນຄວາມຫມາຍ. ໃນ​ຖາ​ນະ​ເປັນ​ຮູບ​ແບບ​ການ​ປະ​ຕິ​ບັດ​
ຄູ່,

/r/ { ການປະຕິບັດ } ແລະ $0 ~/r/ { ການປະຕິບັດ }

ແມ່ນຄືກັນ, ແລະສໍາລັບແຕ່ລະບັນທຶກການປ້ອນຂໍ້ມູນທີ່ກົງກັນ r, ການປະຕິບັດ ຖືກ​ປະ​ຕິ​ບັດ​. ໃນ​ຄວາມ​ເປັນ​ຈິງ, /r/
ແມ່ນການສະແດງອອກ AWK ທີ່ເທົ່າກັບ ($0 ~/r/) ທຸກບ່ອນຍົກເວັ້ນເມື່ອຢູ່ເບື້ອງຂວາ
ຂ້າງຂອງຕົວປະຕິບັດການຈັບຄູ່ຫຼືຜ່ານເປັນການໂຕ້ຖຽງກັບຟັງຊັນທີ່ສ້າງຂຶ້ນໃນທີ່ຄາດວ່າຈະເປັນ
ການໂຕ້ຖຽງການສະແດງອອກເປັນປົກກະຕິ.

AWK ໃຊ້ການສະແດງອອກປົກກະຕິທີ່ຂະຫຍາຍອອກເຊັ່ນດຽວກັນກັບ ຕົວຢ່າງ(1). ການສະແດງອອກເປັນປົກກະຕິ
metacharacters, ie, ຜູ້ທີ່ມີຄວາມຫມາຍພິເສດໃນການສະແດງອອກປົກກະຕິແມ່ນ

^ $ . [ ] | ( ) * + ?

ການສະແດງອອກປົກກະຕິແມ່ນສ້າງຂຶ້ນຈາກຕົວອັກສອນດັ່ງຕໍ່ໄປນີ້:

c ກົງກັບຕົວອັກສອນທີ່ບໍ່ແມ່ນຕົວແປ c.

\c ກົງກັບຕົວອັກສອນທີ່ກຳນົດໂດຍ ລຳດັບການໜີ ດຽວກັນທີ່ໃຊ້ໃນ
ສະຕຣິງຄົງທີ່ ຫຼືຕົວໜັງສື c ຖ້າ \c ບໍ່ແມ່ນການຫລົບຫນີ
ລໍາດັບ.

. ກົງກັບຕົວອັກສອນໃດນຶ່ງ (ລວມທັງແຖວໃໝ່).

^ ກົງ​ກັບ​ດ້ານ​ຫນ້າ​ຂອງ​ສະ​ຕ​ຣິງ.

$ ກົງກັບດ້ານຫຼັງຂອງສະຕຣິງ.

[c1c2c3...] ກົງກັບຕົວອັກສອນໃດນຶ່ງໃນຊັ້ນຮຽນ c1c2c3... . ໄລຍະຫ່າງຂອງ
ຕົວອັກສອນແມ່ນຫມາຍເຖິງ c1-c2 ພາຍໃນຫ້ອງຮຽນ [... ].

[^c1c2c3...] ກົງກັບຕົວອັກສອນໃດນຶ່ງທີ່ບໍ່ຢູ່ໃນຫ້ອງຮຽນ c1c2c3...

ການສະແດງຜົນປົກກະຕິແມ່ນສ້າງຂຶ້ນຈາກສຳນວນປົກກະຕິອື່ນໆດັ່ງນີ້:

r1r2 matches r1 ປະຕິບັດຕາມທັນທີໂດຍ r2 (concatenation).

r1 | r2 matches r1 ຫຼື r2 (ສະຫຼັບ).

r* ກົງກັນ r ຊ້ຳສູນ ຫຼືຫຼາຍຄັ້ງ.

r+ ກົງກັນ r ຊໍ້າຄືນໜຶ່ງ ຫຼືຫຼາຍຄັ້ງ.

r? ການແຂ່ງຂັນ r ສູນຫຼືຫນຶ່ງຄັ້ງ.

(r) ການ​ແຂ່ງ​ຂັນ​ r, ການສະຫນອງການຈັດກຸ່ມ.

ຄວາມສຳຄັນຂອງຕົວປະຕິບັດການທີ່ເພີ່ມຂຶ້ນແມ່ນ alternation, concatenation ແລະ unary (*, + or
?)

ຍົກ​ຕົວ​ຢ່າງ,

/^[_a-zA-Z][_a-zA-Z0-9]*$/ ແລະ
/^[-+]?([0-9]+\.?|\.[0-9])[0-9]*([eE][-+]?[0-9]+)?$/

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

ການສະແດງອອກໃດໆສາມາດຖືກນໍາໃຊ້ຢູ່ເບື້ອງຂວາຂອງຕົວປະຕິບັດການ ~ ຫຼື !~ ຫຼືສົ່ງໄປຫາ a
built-in ທີ່ຄາດຫວັງວ່າການສະແດງອອກເປັນປົກກະຕິ. ຖ້າຕ້ອງການ, ມັນຖືກປ່ຽນເປັນ string, ແລະ
ຫຼັງ​ຈາກ​ນັ້ນ​ໄດ້​ຕີ​ລາ​ຄາ​ເປັນ​ສໍາ​ນວນ​ປົກ​ກະ​ຕິ​. ຍົກ​ຕົວ​ຢ່າງ,

BEGIN { identifier = "[_a-zA-Z][_a-zA-Z0-9]*" }

$0 ~ "^" ຕົວລະບຸ

ພິມທຸກເສັ້ນທີ່ເລີ່ມຕົ້ນດ້ວຍຕົວລະບຸ AWK.

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

echo abc | mawk { gsub(//, "X"); ພິມ }
XaXbXcX

4. ການບັນທຶກ ແລະ ທົ່ງນາ
ການ​ບັນ​ທຶກ​ແມ່ນ​ໄດ້​ອ່ານ​ໃນ​ຫນຶ່ງ​ທີ່​ໃຊ້​ເວ​ລາ​, ແລະ​ເກັບ​ຮັກ​ສາ​ໄວ້​ໃນ​ ພາກສະຫນາມ ຕົວແປ $0. ບັນທຶກແມ່ນ
ແບ່ງອອກເປັນ ທົ່ງນາ ທີ່​ຖືກ​ເກັບ​ຮັກ​ສາ​ໄວ້​ໃນ​ $1, $2, ... , $NF. ຕົວແປໃນຕົວ NF ແມ່ນໄດ້ກໍານົດໄວ້
ກັບຈໍານວນຂອງພາກສະຫນາມ, ແລະ NR ແລະ FNR ແມ່ນເພີ່ມຂຶ້ນໂດຍ 1. ຊ່ອງຂໍ້ມູນຂ້າງເທິງ $NF ຖືກກໍານົດໃຫ້
"".

ການມອບຫມາຍໃຫ້ $0 ເຮັດ​ໃຫ້​ທົ່ງ​ນາ​ແລະ​ NF ທີ່​ຈະ​ໄດ້​ຮັບ​ການ​ຄິດ​ໄລ່​ຄືນ​ໃຫມ່​. ການມອບຫມາຍໃຫ້ NF ຫຼື
ສາ​ເຫດ​ພາກ​ສະ​ຫນາມ​ $0 ທີ່​ຈະ​ໄດ້​ຮັບ​ການ​ກໍ່​ສ້າງ​ຄືນ​ໃຫມ່​ໂດຍ​ການ concatenating ໄດ້​ $i ຂອງ ແຍກໂດຍ FSO.
ການມອບໝາຍໃຫ້ຊ່ອງຂໍ້ມູນທີ່ມີດັດຊະນີໃຫຍ່ກວ່າ NF, ເພີ່ມຂື້ນ NF ແລະສາເຫດ $0 ຈະ
ກໍ່ສ້າງ ໃໝ່.

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

echo 24 24E |
mawk '{ ພິມ($1>100, $1>"100", $2>100, $2>"100") }'
0 1 1 1

$0 ແລະ $2 ແມ່ນ string ແລະ $1 ແມ່ນຕົວເລກ ແລະສະຕຣິງ. ການປຽບທຽບຄັ້ງທໍາອິດແມ່ນຕົວເລກ, the
ອັນທີສອງແມ່ນ string, ທີສາມແມ່ນ string (100 ຖືກປ່ຽນເປັນ "100"), ແລະສຸດທ້າຍແມ່ນ string.

5. ສຳ ນວນ ແລະ ຜູ້ປະກອບການ
syntax ຂອງ expression ແມ່ນຄ້າຍຄືກັນກັບ C. Primary expressions are numeric constant, string
ຄົງທີ່, ຕົວແປ, ຊ່ອງຂໍ້ມູນ, array ແລະຟັງຊັນໂທ. ຕົວລະບຸຕົວແປ,
array ຫຼື function ສາມາດເປັນລໍາດັບຂອງຕົວອັກສອນ, ຕົວເລກແລະ underscores, ທີ່ບໍ່ແມ່ນ
ເລີ່ມຕົ້ນດ້ວຍຕົວເລກ. ຕົວແປບໍ່ໄດ້ຖືກປະກາດ; ພວກເຂົາເຈົ້າມີຢູ່ໃນເວລາທີ່ທໍາອິດອ້າງອີງແລະເປັນ
ເລີ່ມຕົ້ນເປັນ null.

ການສະແດງອອກໃຫມ່ແມ່ນປະກອບດ້ວຍຕົວປະຕິບັດການດັ່ງຕໍ່ໄປນີ້ເພື່ອເພີ່ມຂຶ້ນ
ອັນດັບຕົ້ນ.

ການມອບຫມາຍ = += -= *= /= %= ^=
ມີເງື່ອນໄຂ ? :
ຢ່າງມີເຫດຜົນ or ||
ຢ່າງມີເຫດຜົນ ແລະ &&
array ສະມາຊິກ in
ການຈັບຄູ່ ~ !~
ທີ່ກ່ຽວຂ້ອງ <> <=>= == !=
ກົງກັນຂ້າມ (ບໍ່ມີຕົວປະຕິບັດການຈະແຈ້ງ)
ເພີ່ມ ops + -
mul ops * /%
unary + -
ຢ່າງມີເຫດຜົນ ບໍ່ !
ເລກກຳລັງ ^
inc ແລະ Dec ++ -- (ທັງໂພດ ແລະກ່ອນ)
ພາກສະຫນາມ $

ການມອບໝາຍ, ເງື່ອນໄຂ ແລະ ເລກກຳລັງທີ່ກ່ຽວຂ້ອງ ຂວາຫາຊ້າຍ; ຜູ້ປະກອບການອື່ນໆ
ສົມທົບຊ້າຍຫາຂວາ. ການສະແດງອອກໃດໆສາມາດຖືກຈັດໃສ່ໃນວົງເລັບ.

6. ອາເລ
Awk ສະໜອງອາເຣແບບໜຶ່ງມິຕິ. ອົງປະກອບອາເຣແມ່ນສະແດງອອກເປັນ array[ຕົວຢ່າງ]. ໝົດອາຍຸ
ຖືກປ່ຽນພາຍໃນເປັນປະເພດສະຕຣິງ, ດັ່ງນັ້ນ, ຕົວຢ່າງ, A[1] ແລະ A["1"] ແມ່ນອັນດຽວກັນ.
ອົງປະກອບແລະດັດຊະນີຕົວຈິງແມ່ນ "1". Arrays indexed by strings ເອີ້ນວ່າ associative
arrays. ໃນເບື້ອງຕົ້ນ array ແມ່ນຫວ່າງເປົ່າ; ອົງປະກອບມີຢູ່ເມື່ອເຂົ້າເຖິງຄັ້ງທໍາອິດ. ການ​ສະ​ແດງ​ອອກ​,
ຕົວຢ່າງ in array ປະເມີນເປັນ 1 ຖ້າ array[ຕົວຢ່າງ] ມີຢູ່, ອື່ນເຖິງ 0.

ມີຮູບແບບຂອງ ສໍາລັບການ ຄໍາຖະແຫຼງທີ່ loops ໃນໄລຍະແຕ່ລະດັດຊະນີຂອງ array.

ສໍາລັບການ ( var in array ) ຄໍາຖະແຫຼງທີ່

ຊຸດ var ແຕ່ລະດັດຊະນີຂອງ array ແລະ​ປະ​ຕິ​ບັດ​ ຄໍາຖະແຫຼງທີ່. ຄໍາ​ສັ່ງ​ທີ່​ var ທາງຂວາງ
ຕົວຊີ້ວັດຂອງ array ບໍ່ໄດ້ກໍານົດ.

ຖະແຫຼງການ, ລຶບ array[ຕົວຢ່າງ], ສາເຫດ array[ຕົວຢ່າງ] ບໍ່​ມີ​. ມອກ ສະຫນັບສະຫນູນເປັນ
ການຂະຫຍາຍ, ລຶບ array, ເຊິ່ງລຶບອົງປະກອບທັງຫມົດຂອງ array.

Multidimensional arrays ຖືກສັງເຄາະດ້ວຍ concatenation ໂດຍໃຊ້ຕົວແປທີ່ສ້າງຂຶ້ນ
SUBSEP. array[ຕົວຢ່າງ1,ຕົວຢ່າງ2] ເທົ່າກັບ array[ຕົວຢ່າງ1 SUBSEP ຕົວຢ່າງ2]. ການທົດສອບສໍາລັບ ກ
ອົງປະກອບ multidimensional ໃຊ້ດັດຊະນີວົງເລັບ, ເຊັ່ນ:

ຖ້າ (i, j) ໃນ A ) ພິມ A[i, j]

7. ຕົວແປໃນຕົວ
ຕົວແປຕໍ່ໄປນີ້ແມ່ນສ້າງໃນຕົວແລະເລີ່ມຕົ້ນກ່ອນການປະຕິບັດໂຄງການ.

ARGC ຈໍານວນຂອງການໂຕ້ຖຽງແຖວຄໍາສັ່ງ.

ARGV array ຂອງ arguments ແຖວຄໍາສັ່ງ, 0..ARGC-1.

CONVFMT ຮູບແບບສໍາລັບການປ່ຽນພາຍໃນຂອງຕົວເລກເປັນສະຕຣິງ, ໃນເບື້ອງຕົ້ນ = "%.6g".

ສະພາບແວດລ້ອມ array ຖືກດັດສະນີໂດຍຕົວແປສະພາບແວດລ້ອມ. ສະ​ຕ​ຣິ​ງ​ສະ​ພາບ​ແວດ​ລ້ອມ​, var=ຄ່າ
ຖືກເກັບໄວ້ເປັນ ສະພາບແວດລ້ອມ[var] = ມູນຄ່າ.

ຊື່​ເອ​ກະ​ສານ ຊື່ຂອງໄຟລ໌ປ້ອນຂໍ້ມູນປະຈຸບັນ.

FNR ຕົວເລກບັນທຶກປະຈຸບັນໃນ ຊື່​ເອ​ກະ​ສານ.

FS ແບ່ງການບັນທຶກເຂົ້າໄປໃນຊ່ອງຂໍ້ມູນເປັນການສະແດງອອກປົກກະຕິ.

NF ຈຳນວນຊ່ອງຂໍ້ມູນໃນບັນທຶກປັດຈຸບັນ.

NR ຕົວເລກບັນທຶກປັດຈຸບັນຢູ່ໃນກະແສການປ້ອນຂໍ້ມູນທັງໝົດ.

OFMT ຮູບແບບສໍາລັບການພິມຕົວເລກ; ໃນເບື້ອງຕົ້ນ = "%.6g".

FSO inserted between fields on output, initially = " ".

ORS ຢຸດແຕ່ລະບັນທຶກກ່ຽວກັບຜົນຜະລິດ, ໃນເບື້ອງຕົ້ນ = "\n".

RLENGTH ຄວາມຍາວທີ່ກໍານົດໄວ້ໂດຍການໂທຫາຄັ້ງສຸດທ້າຍກັບຟັງຊັນໃນຕົວ, ການແຂ່ງຂັນ().

RS ຕົວແຍກບັນທຶກການປ້ອນຂໍ້ມູນ, ໃນເບື້ອງຕົ້ນ = "\n".

RSTART ດັດຊະນີກໍານົດໂດຍການໂທຫາສຸດທ້າຍ ການແຂ່ງຂັນ().

SUBSEP ໃຊ້ເພື່ອສ້າງ subscript array ຫຼາຍ, ໃນເບື້ອງຕົ້ນ = "\034".

8. Built-in ຫນ້າທີ່
ຟັງຊັນສາຍ

gsub(r,s,t) gsub(r, s)
ການທົດແທນທົ່ວໂລກ, ທຸກໆການແຂ່ງຂັນຂອງການສະແດງອອກປົກກະຕິ r ໃນຕົວແປ t is
ແທນທີ່ດ້ວຍ string s. ຈໍານວນການທົດແທນຖືກສົ່ງຄືນ. ຖ້າ t is
ຖືກລະເວັ້ນ, $0 ຖືກນໍາໃຊ້. An & ໃນ string ການທົດແທນ s ຖືກແທນທີ່ດ້ວຍ
ຈັບຄູ່ substring ຂອງ t. \& ແລະ \\ ເອົາຕົວຫນັງສື & ແລະ \, ຕາມລໍາດັບ, ໃນ
ສາຍ​ການ​ທົດ​ແທນ​.

ດັດຊະນີ(s, t)
If t ແມ່ນສາຍຍ່ອຍຂອງ s, ຫຼັງຈາກນັ້ນຕໍາແຫນ່ງທີ່ t ການເລີ່ມຕົ້ນແມ່ນກັບຄືນ, ອື່ນ
0 ຖືກສົ່ງຄືນ. ລັກສະນະທໍາອິດຂອງ s ຢູ່​ໃນ​ຕໍາ​ແຫນ່ງ 1​.

ຄວາມຍາວ(s)
ຕອບຄວາມຍາວຂອງສະຕຣິງ s.

ການແຂ່ງຂັນ(s,r)
ໃຫ້ຜົນເປັນດັດຊະນີຂອງການຈັບຄູ່ທີ່ຍາວທີ່ສຸດຂອງການສະແດງຜົນປົກກະຕິ r in
string s. ຕອບ 0 ຖ້າບໍ່ກົງກັນ. ໃນຖານະເປັນຜົນຂ້າງຄຽງ, RSTART ຖືກຕັ້ງຄ່າໃຫ້
ກັບຄືນມູນຄ່າ. RLENGTH ຖືກກໍານົດເປັນຄວາມຍາວຂອງການແຂ່ງຂັນຫຼື -1 ຖ້າບໍ່ມີການແຂ່ງຂັນ.
ຖ້າສະຕຣິງຫວ່າງຖືກຈັບຄູ່, RLENGTH ຖືກຕັ້ງເປັນ 0, ແລະ 1 ຖືກສົ່ງຄືນຖ້າ
ການແຂ່ງຂັນແມ່ນຢູ່ດ້ານຫນ້າ, ແລະຄວາມຍາວ (s)+1 ຖືກສົ່ງຄືນຖ້າການແຂ່ງຂັນຢູ່ທີ່
ຫລັງ.

ແບ່ງ(s,A,r) ແຍກ(s, ກ)
string s ຖືກແບ່ງອອກເປັນຂົງເຂດໂດຍການສະແດງອອກປົກກະຕິ r ແລະທົ່ງນາແມ່ນ
loaded ເຂົ້າໄປໃນ array A. ຈຳນວນຊ່ອງຂໍ້ມູນຖືກສົ່ງຄືນ. ເບິ່ງພາກ 11
ຂ້າງລຸ່ມນີ້ສໍາລັບລາຍລະອຽດເພີ່ມເຕີມ. ຖ້າ r ຖືກລະເວັ້ນ, FS ຖືກນໍາໃຊ້.

sprintf(format,expr-list)
ຕອບສະຕຣິງທີ່ສ້າງຂຶ້ນຈາກ expr-ບັນຊີລາຍຊື່ ອີງ​ຕາມ ຮູບແບບ. ເບິ່ງ
ລາຍລະອຽດຂອງ printf() ຂ້າງລຸ່ມນີ້.

ຍ່ອຍ(r,s,t) ຍ່ອຍ (r, s)
ການປ່ຽນແທນອັນດຽວ, ຄືກັນກັບ gsub() ຍົກເວັ້ນການປ່ຽນແທນອັນດຽວ.

ຍ່ອຍ(s,i,n) ຍ່ອຍ (s,i)
ສົ່ງຄ່າຍ່ອຍຂອງສະຕຣິງ s, ເລີ່ມຕົ້ນທີ່ດັດຊະນີ i, ຄວາມຍາວ nທີ່ຢູ່ ຖ້າຫາກວ່າ n
ຖືກລະເວັ້ນ, ສ່ວນທ້າຍຂອງ s, ເລີ່ມຕົ້ນຢູ່ i ຖືກສົ່ງຄືນ.

ລຸ່ມ(s)
ສົ່ງຄືນສຳເນົາຂອງ s ກັບຕົວອັກສອນຕົວພິມໃຫຍ່ທັງໝົດປ່ຽນເປັນຕົວພິມນ້ອຍ.

topper(s)
ສົ່ງຄືນສຳເນົາຂອງ s ດ້ວຍການປ່ຽນຕົວອັກສອນຕົວພິມນ້ອຍທັງໝົດເປັນຕົວພິມໃຫຍ່.

ຟັງຊັນເລກຄະນິດ

atan2(y,x) Arctan ຂອງ y/x ລະຫວ່າງ -pi ແລະ pi.

cos(x) ການ​ທໍາ​ງານ​ຂອງ cosine​, x ໃນເຣດຽນ.

exp(x) ການທໍາງານຂອງ exponential.

int(x) ກັບຄືນ x ຕັດໄປທາງສູນ.

ບັນທຶກ(x) logarithm ທໍາ​ມະ​ຊາດ​.

rand() ຕອບຄ່າສຸ່ມລະຫວ່າງສູນ ແລະໜຶ່ງ.

ບາບx) ການ​ທໍາ​ງານ Sine​, x ໃນເຣດຽນ.

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

ແຊນ(ຕົວຢ່າງ) ແຊນ()
ແກ່ນເຄື່ອງກໍາເນີດຕົວເລກແບບສຸ່ມ, ໂດຍໃຊ້ໂມງຖ້າ ຕົວຢ່າງ ຖືກລະເວັ້ນ, ແລະ
ຕອບຄ່າຂອງເມັດກ່ອນໜ້າ. ມອກ ແກ່ນຈໍານວນ Random
ເຄື່ອງກໍາເນີດໄຟຟ້າຈາກໂມງໃນຕອນເລີ່ມຕົ້ນດັ່ງນັ້ນບໍ່ຈໍາເປັນຕ້ອງໂທຫາຢ່າງແທ້ຈິງ
srand(). ແຊນ(ຕົວຢ່າງ) ແມ່ນເປັນປະໂຫຍດສໍາລັບການເຮັດຊ້ໍາລໍາດັບ pseudo random.

9. ການປ້ອນຂໍ້ມູນ ແລະ output
ມີ​ບົດ​ລາຍ​ງານ​ຜົນ​ຜະ​ລິດ​ສອງ​, ພິມ ແລະ printf.

ພິມ​ຂຽນ $0 ORS ຜົນຜະລິດມາດຕະຖານ.

ພິມ ຕົວຢ່າງ1, ຕົວຢ່າງ2, ... , ຕົວຢ່າງn
ຂຽນວ່າ ຕົວຢ່າງ1 FSO ຕົວຢ່າງ2 FSO ... ຕົວຢ່າງn ORS ຜົນຜະລິດມາດຕະຖານ. ຕົວເລກ
expressions ຖືກປ່ຽນເປັນ string ກັບ OFMT.

printf ຮູບແບບ, expr-ບັນຊີລາຍຊື່
duplicates ການຂຽນຟັງຊັນ printf C Library ກັບຜົນໄດ້ຮັບມາດຕະຖານ. ໄດ້
ຂໍ້ມູນຈໍາເພາະຂອງຮູບແບບ ANSI C ຄົບຖ້ວນແມ່ນຖືກຮັບຮູ້ດ້ວຍການແປງ %c,
%d, %e, %E, %f, %g, %G, %i, %o, %s, %u, %x, %X ແລະ %%, ແລະການປ່ຽນແປງ
ຮອບຄັດເລືອກ h ແລະ l.

ລາຍຊື່ອາກິວເມັນທີ່ຈະພິມ ຫຼື printf ສາມາດເລືອກໄດ້ໃນວົງເລັບ. ພິມ
ຮູບແບບຕົວເລກໂດຍໃຊ້ OFMT ຫຼື "%d" ສໍາລັບຈໍານວນເຕັມທີ່ແນ່ນອນ. "%c" ກັບ argument ຕົວເລກ
ພິມຕົວອັກສອນ 8 ບິດທີ່ສອດຄ້ອງກັນ, ດ້ວຍ string argument ມັນພິມຕົວທຳອິດ
ລັກສະນະຂອງສາຍ. ຜົນຜະລິດຂອງພິມແລະ printf ສາມາດຖືກໂອນໄປຫາໄຟລ໌ຫຼື
ຄໍາສັ່ງໂດຍການເພີ່ມເຕີມ > ເອກະສານ, >> ເອກະສານ ຫຼື | ຄໍາສັ່ງ ໃນຕອນທ້າຍຂອງຖະແຫຼງການພິມ.
ເປີດການປ່ຽນເສັ້ນທາງ ເອກະສານ or ຄໍາສັ່ງ ພຽງ​ແຕ່​ຄັ້ງ​ດຽວ, redirections ຕໍ່​ມາ​ຕໍ່​ຫນ້າ​ກັບ​ທີ່​ແລ້ວ
ເປີດກະແສ. ໂດຍສົນທິສັນຍາ, ມອກ ເຊື່ອມໂຍງຊື່ໄຟລ໌ "/dev/stderr"ກັບ stderr ທີ່
ອະນຸຍາດໃຫ້ພິມແລະ printf ຖືກໂອນໄປຫາ stderr. ມອກ ຍັງຮ່ວມ "-" ແລະ
"/dev/stdout" ກັບ stdin ແລະ stdout ທີ່ອະນຸຍາດໃຫ້ນ້ໍາເຫຼົ່ານີ້ຖືກສົ່ງໄປຫາຫນ້າທີ່.

ຟັງຊັນການປ້ອນຂໍ້ມູນ ສາຍ ມີ​ການ​ປ່ຽນ​ແປງ​ດັ່ງ​ຕໍ່​ໄປ​ນີ້​.

ສາຍ
ອ່ານເຂົ້າໄປໃນ $0, ການ​ປັບ​ປຸງ​ພາກ​ສະ​ຫນາມ​, NF, NR ແລະ FNR.

getline ເອກະສານ
ອ່ານເຂົ້າໄປໃນ $0 ຈາກ ເອກະສານ, ປັບປຸງພາກສະຫນາມແລະ NF.

ສາຍ var
ອ່ານບັນທຶກຕໍ່ໄປເຂົ້າໄປໃນ var, ການປັບປຸງ NR ແລະ FNR.

ສາຍ var < ເອກະສານ
ອ່ານບັນທຶກຕໍ່ໄປຂອງ ເອກະສານ ເຂົ້າໄປໃນ var.

ຄໍາສັ່ງ | getline
ທໍ່ບັນທຶກຈາກ ຄໍາສັ່ງ ເຂົ້າໄປໃນ $0 ແລະປັບປຸງພາກສະຫນາມແລະ NF.

ຄໍາສັ່ງ | getline var
ທໍ່ບັນທຶກຈາກ ຄໍາສັ່ງ ເຂົ້າໄປໃນ var.

Getline ໃຫ້ຜົນຕອບແທນ 0 ໃນຕອນທ້າຍຂອງໄຟລ໌, -1 ໃນຄວາມຜິດພາດ, ຖ້າບໍ່ດັ່ງນັ້ນ 1.

ຄໍາສັ່ງກ່ຽວກັບການສິ້ນສຸດຂອງທໍ່ແມ່ນປະຕິບັດໂດຍ /bin/sh.

ຟັງຊັນ ໃກ້(ຕົວຢ່າງ) ປິດໄຟລ໌ຫຼືທໍ່ທີ່ກ່ຽວຂ້ອງກັບ ຕົວຢ່າງ. ປິດຜົນຕອບແທນ 0 ຖ້າ
ຕົວຢ່າງ ເປັນໄຟລ໌ເປີດ, ສະຖານະການອອກຖ້າຫາກວ່າ ຕົວຢ່າງ ແມ່ນຄໍາສັ່ງທໍ່, ແລະ -1 ຖ້າບໍ່ດັ່ງນັ້ນ. ປິດ
ຖືກນໍາໃຊ້ເພື່ອອ່ານໄຟລ໌ຫຼືຄໍາສັ່ງ, ໃຫ້ແນ່ໃຈວ່າປາຍອື່ນໆຂອງທໍ່ຜົນຜະລິດສໍາເລັດ
ຫຼືອະນຸລັກຊັບພະຍາກອນໄຟລ໌.

ຟັງຊັນ ຟຸ່ມເຟືອຍ(ຕົວຢ່າງ) flushes ໄຟລ໌ຜົນຜະລິດຫຼືທໍ່ທີ່ກ່ຽວຂ້ອງກັບ ຕົວຢ່າງ. ຟຸ່ມ
ກັບຄືນ 0 ຖ້າ ຕົວຢ່າງ ເປັນກະແສຜົນຜະລິດເປີດອີກ -1. Flush ໂດຍບໍ່ມີການໂຕ້ຖຽງ flushes
stdout. Fflush ດ້ວຍ argument ຫວ່າງເປົ່າ ("") flushs ຜົນໄດ້ຮັບທີ່ເປີດທັງຫມົດ.

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

10​. ຜູ້​ໃຊ້ ກໍານົດໄວ້ ຫນ້າທີ່
syntax ສໍາລັບຫນ້າທີ່ກໍານົດຂອງຜູ້ໃຊ້ແມ່ນ

ຫນ້າທີ່ ຊື່( ໂຕ້ຖຽງ ) { ບົດລາຍງານ }

ຮ່າງກາຍຂອງຟັງຊັນສາມາດບັນຈຸຄໍາຖະແຫຼງການກັບຄືນ

ການກັບຄືນມາ opt_expr

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

ຟັງຊັນ cplit(s, A, n, i)
{
n = ຄວາມຍາວ
ສໍາລັບ( i = 1 ; i <= n ; i++ ) A[i] = substr(s, i, 1)
ກັບຄືນ n
}

ການວາງພື້ນທີ່ພິເສດລະຫວ່າງການໂຕ້ຖຽງທີ່ຜ່ານ ແລະຕົວແປທ້ອງຖິ່ນແມ່ນເປັນເລື່ອງທຳມະດາ.
ຟັງຊັນສາມາດອ້າງອີງກ່ອນທີ່ຈະຖືກກໍານົດ, ແຕ່ຊື່ຟັງຊັນແລະ '(' ຂອງ
ການໂຕ້ຖຽງຕ້ອງແຕະເພື່ອຫຼີກເວັ້ນການສັບສົນກັບ concatenation.

11​. ການແບ່ງປັນ ສາຍ, ການບັນທຶກ ແລະ ໄຟ
ໂປລແກລມ Awk ໃຊ້ສູດການຄິດໄລ່ດຽວກັນເພື່ອແຍກສະຕຣິງອອກເປັນອາເຣທີ່ມີການແບ່ງປັນ(), ແລະບັນທຶກ.
ເຂົ້າໄປໃນທົ່ງນາ FS. ມອກ ໃຊ້ວິທີອັນສຳຄັນອັນດຽວກັນເພື່ອແບ່ງໄຟລ໌ເປັນບັນທຶກ
on RS.

ແຍກ(expr,A,ກັນຍາ) ເຮັດ​ວຽກ​ດັ່ງ​ຕໍ່​ໄປ​ນີ້​:

(1) ຖ້າ Sep ຖືກລະເວັ້ນ, ມັນຖືກແທນທີ່ດ້ວຍ FS. Sep ສາມາດເປັນການສະແດງອອກຫຼື
ການສະແດງອອກເປັນປົກກະຕິ. ຖ້າມັນເປັນການສະແດງອອກຂອງປະເພດທີ່ບໍ່ແມ່ນສາຍ, ມັນແມ່ນ
ປ່ຽນເປັນສະຕຣິງ.

(2) ຖ້າ Sep = " " (ຊ່ອງດຽວ), ຫຼັງຈາກນັ້ນ ແມ່ນ trimmed ຈາກທາງຫນ້າແລະ
ຫລັງຂອງ ຕົວຢ່າງ, ແລະ Sep ກາຍເປັນ . ມອກ ກໍານົດ ເປັນປົກກະຕິ
ສະແດງອອກ /[ \t\n]+/. ຖ້າບໍ່ດັ່ງນັ້ນ Sep ຖືກປະຕິບັດເປັນການສະແດງອອກເປັນປົກກະຕິ,
ຍົກ​ເວັ້ນ​ຕົວ​ອັກ​ສອນ​ເມ​ຕາ​ແມ່ນ​ຖືກ​ລະ​ເລີຍ​ສໍາ​ລັບ​ການ​ສະ​ຕ​ຣິງ​ຂອງ​ຄວາມ​ຍາວ 1​, ເຊັ່ນ​:
split(x, A, "*") ແລະ split(x, A, /\*/) ແມ່ນອັນດຽວກັນ.

(3) ຖ້າ ຕົວຢ່າງ ບໍ່ແມ່ນ string, ມັນປ່ຽນເປັນ string. ຖ້າ ຕົວຢ່າງ ຫຼັງຈາກນັ້ນແມ່ນຫວ່າງເປົ່າ
string "", split() ຕອບ 0 ແລະ A ຖືກຕັ້ງຫວ່າງເປົ່າ. ຖ້າ​ບໍ່​ດັ່ງ​ນັ້ນ​, ທັງ​ຫມົດ​ທີ່​ບໍ່​ແມ່ນ
ການທັບຊ້ອນກັນ, ການຈັບຄູ່ທີ່ບໍ່ແມ່ນ null ແລະຍາວທີ່ສຸດຂອງ Sep in ຕົວຢ່າງ, ແຍກຕ່າງຫາກ ຕົວຢ່າງ ເຂົ້າໄປໃນ
ທົ່ງນາທີ່ຖືກໂຫລດເຂົ້າໄປໃນ A. ທົ່ງນາຖືກຈັດໃສ່ໃນ A[1], A[2], ...,
A[n] ແລະ split() ສົ່ງຄືນ n, ຈໍານວນຊ່ອງຂໍ້ມູນທີ່ເປັນຈໍານວນ
ກົງກັນບວກຫນຶ່ງ. ຂໍ້ມູນໃສ່ໃນ A ທີ່ມີລັກສະນະເປັນຕົວເລກແມ່ນພິມຕົວເລກແລະ
string

ການແຍກບັນທຶກເຂົ້າໄປໃນທົ່ງນາເຮັດວຽກດຽວກັນຍົກເວັ້ນຕ່ອນທີ່ຖືກໂຫລດເຂົ້າໄປໃນ $1, $2, ... ,
$NFທີ່ຢູ່ ຖ້າຫາກວ່າ $0 ຫວ່າງເປົ່າ, NF ຖືກກໍານົດເປັນ 0 ແລະທັງຫມົດ $i ກັບ "".

ມອກ ແບ່ງໄຟລ໌ເຂົ້າໄປໃນບັນທຶກໂດຍວິທີດຽວກັນ, ແຕ່ມີຄວາມແຕກຕ່າງເລັກນ້ອຍ
RS ແມ່ນແທ້ terminator ແທນທີ່ຈະເປັນຕົວແຍກ. (ORS ກໍ່ແມ່ນຕົວສິ້ນສຸດຄືກັນ).

ຕົວຢ່າງ, ຖ້າ FS = ":+" ແລະ $0 = "a::b:", ແລ້ວ NF = 3 and $1 = "a", $2 = "b" ແລະ $3 =
"", ແຕ່ຖ້າ "a::b:" ແມ່ນເນື້ອໃນຂອງໄຟລ໌ປ້ອນຂໍ້ມູນແລະ RS = ":+", ຫຼັງຈາກນັ້ນມີ
ສອງບັນທຶກ "a" ແລະ "b".

RS = " "ບໍ່ແມ່ນພິເສດ.

If FS = "", ແລ້ວ ມອກ ທໍາລາຍບັນທຶກເປັນລັກສະນະສ່ວນບຸກຄົນ, ແລະ, ເຊັ່ນດຽວກັນ,
ແບ່ງ(s,A,"") ວາງຕົວອັກສອນສ່ວນບຸກຄົນຂອງ s ເຂົ້າໄປໃນ A.

12​. ຫລາຍເສັ້ນ ການບັນທຶກ
ນັບຕັ້ງແຕ່ ມອກ ການຕີຄວາມ ໝາຍ RS ເປັນການສະແດງອອກປົກກະຕິ, ການບັນທຶກຫຼາຍເສັ້ນແມ່ນງ່າຍ. ການຕັ້ງຄ່າ RS
= "\n\n+", ເຮັດ​ໃຫ້​ນຶ່ງ​ຫຼື​ຫຼາຍ​ແຖວ​ຫວ່າງ​ເປົ່າ​ບັນ​ທຶກ​ແຍກ​ຕ່າງ​ຫາກ. ຖ້າ FS = " " (ຄ່າເລີ່ມຕົ້ນ),
ຫຼັງ​ຈາກ​ນັ້ນ​ສາຍ​ໃຫມ່​ດຽວ​, ໂດຍ​ລະ​ບຽບ​ການ​ສໍາ​ລັບ​ການ​ ຂ້າງເທິງ, ກາຍເປັນຊ່ອງແລະເສັ້ນໃຫມ່ດຽວແມ່ນ
ຕົວ​ແຍກ​ພາກ​ສະ​ຫນາມ​.

ຕົວຢ່າງ, ຖ້າໄຟລ໌ແມ່ນ "ab\nc\n\n", RS = "\n\n+" ແລະ FS = " ", ຫຼັງຈາກນັ້ນມີ
ຫນຶ່ງບັນທຶກ "ab\nc" ທີ່ມີສາມຊ່ອງຂໍ້ມູນ "a", "b" ແລະ "c". ການປ່ຽນແປງ FS = "\n", ໃຫ້
ສອງພາກສະຫນາມ "ab" ແລະ "c"; ການປ່ຽນແປງ FS = "", ໃຫ້ຊ່ອງຂໍ້ມູນອັນດຽວກັນກັບ
ບັນທຶກ.

ຖ້າທ່ານຕ້ອງການໃຫ້ເສັ້ນທີ່ມີຊ່ອງຫວ່າງຫຼືແຖບຖືກພິຈາລະນາຫວ່າງເປົ່າ, ໃຫ້ຕັ້ງ RS = "\n([ \t]*\n)+".
ສໍາລັບຄວາມເຂົ້າກັນໄດ້ກັບ awks ອື່ນໆ, ການຕັ້ງຄ່າ RS = "" ມີຜົນກະທົບຄືກັນກັບວ່າເສັ້ນຫວ່າງເປົ່າ
ຖືກຖອດອອກຈາກໄຟລ໌ດ້ານຫນ້າແລະດ້ານຫລັງແລະຫຼັງຈາກນັ້ນບັນທຶກຖືກກໍານົດຄືກັບວ່າ RS =
"\n\n+". Posix ຮຽກຮ້ອງໃຫ້ "\n" ແຍກບັນທຶກສະເໝີເມື່ອ RS = "" ໂດຍບໍ່ຄໍານຶງເຖິງ
ມູນຄ່າຂອງ FS. ມອກ ບໍ່ສະຫນັບສະຫນູນສົນທິສັນຍານີ້, ເພາະວ່າກໍານົດ "\n" ເປັນ
ເຮັດໃຫ້ມັນບໍ່ຈໍາເປັນ.

ສ່ວນໃຫຍ່ຂອງເວລາທີ່ທ່ານປ່ຽນແປງ RS ສໍາລັບການບັນທຶກຫຼາຍແຖວ, ທ່ານຍັງຈະຕ້ອງການປ່ຽນແປງ
ORS ເປັນ "\n\n" ດັ່ງນັ້ນໄລຍະຫ່າງຂອງການບັນທຶກຖືກຮັກສາໄວ້ຢູ່ໃນຜົນຜະລິດ.

13​. ໂຄງການ ການປະຕິບັດ
ພາກນີ້ອະທິບາຍຄໍາສັ່ງຂອງການປະຕິບັດໂຄງການ. ທໍາອິດ ARGC ຖືກກໍານົດເປັນຈໍານວນທັງຫມົດ
ຈໍາ​ນວນ​ຂອງ​ການ​ໂຕ້​ຖຽງ​ເສັ້ນ​ຄໍາ​ສັ່ງ​ທີ່​ຜ່ານ​ໄປ​ໃນ​ໄລ​ຍະ​ການ​ປະ​ຕິ​ບັດ​ຂອງ​ໂຄງ​ການ​. ARGV[0] is
ຕັ້ງຊື່ຂອງນາຍພາສາ AWK ແລະ ARGV[1] ... ARGV[ARGC-1] ຖືສ່ວນທີ່ເຫຼືອ
ການໂຕ້ຖຽງແຖວຄໍາສັ່ງ ຍົກເວັ້ນທາງເລືອກ ແລະແຫຼ່ງໂປຼແກຼມ. ສໍາລັບການຍົກຕົວຢ່າງກັບ

mawk -f prog v=1 A t=ສະບາຍດີ B

ARGC = 5 ກັບ ARGV[0] = "mawk", ARGV[1] = "v=1", ARGV[2] = "A", ARGV[3] = "t = ສະບາຍດີ" ແລະ
ARGV[4] = "ຂ".

ຕໍ່ໄປ, ແຕ່ລະຄົນ ເລີ່ມຕົ້ນ block ແມ່ນປະຕິບັດຕາມລໍາດັບ. ຖ້າຫາກວ່າໂຄງການປະກອບດ້ວຍທັງຫມົດ ເລີ່ມຕົ້ນ
ຕັນ, ຫຼັງຈາກນັ້ນການປະຕິບັດຈະສິ້ນສຸດລົງ, ຖ້າບໍ່ດັ່ງນັ້ນການປ້ອນຂໍ້ມູນຖືກເປີດແລະການປະຕິບັດຍັງສືບຕໍ່.
If ARGC ເທົ່າກັບ 1, ກະແສການປ້ອນຂໍ້ມູນຖືກຕັ້ງເປັນ stdin, ອື່ນແມ່ນ arguments ແຖວຄໍາສັ່ງ
ARGV[1] ... ARGV[ARGC-1] ຖືກກວດສອບການໂຕ້ຖຽງໄຟລ໌.

ການໂຕ້ຖຽງຂອງແຖວຄໍາສັ່ງແບ່ງອອກເປັນສາມຊຸດ: ການໂຕ້ຖຽງໄຟລ໌, ການໂຕ້ຖຽງການມອບຫມາຍ
ແລະສະຕຣິງຫວ່າງເປົ່າ "". ການມອບໝາຍມີແບບຟອມ var=string. ເມື່ອເປັນ ARGV[i] ຖືກກວດ
ເປັນການໂຕ້ຖຽງໄຟລ໌ທີ່ເປັນໄປໄດ້, ຖ້າມັນຫວ່າງເປົ່າມັນຈະຖືກຂ້າມ; ຖ້າມັນເປັນວຽກ
ການໂຕ້ຖຽງ, ການມອບຫມາຍໃຫ້ var ໃຊ້ເວລາສະຖານທີ່ແລະ i ຂ້າມໄປຫາການໂຕ້ຖຽງຕໍ່ໄປ; ອື່ນ ARGV[i]
ຖືກເປີດສໍາລັບການປ້ອນຂໍ້ມູນ. ຖ້າມັນບໍ່ສາມາດເປີດໄດ້, ການປະຕິບັດຈະສິ້ນສຸດດ້ວຍລະຫັດອອກ 2. ຖ້າບໍ່ມີ
argument ແຖວຄໍາສັ່ງແມ່ນ argument ໄຟລ໌, ຫຼັງຈາກນັ້ນການປ້ອນຂໍ້ມູນມາຈາກ stdin. Getline ໃນ a ເລີ່ມຕົ້ນ
ການປະຕິບັດເປີດການປ້ອນຂໍ້ມູນ. "-" ເປັນການໂຕ້ຖຽງໄຟລ໌ຫມາຍເຖິງ stdin.

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

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

ໃນຕົວຢ່າງ, ການມອບຫມາຍ v=1 ເກີດຂຶ້ນຫຼັງຈາກ ເລີ່ມຕົ້ນ ຫຸ້ນ ຖືກ​ປະ​ຕິ​ບັດ​, ແລະ​
ຂໍ້ມູນທີ່ວາງໄວ້ໃນ v ແມ່ນພິມຕົວເລກ ແລະສະຕຣິງ. ຫຼັງຈາກນັ້ນ, ການປ້ອນຂໍ້ມູນຈະຖືກອ່ານຈາກໄຟລ໌ A. ໃນຕອນທ້າຍ
ຂອງໄຟລ໌ A, t ຖືກຕັ້ງເປັນສະຕຣິງ "ສະບາຍດີ", ແລະ B ຖືກເປີດສໍາລັບການປ້ອນຂໍ້ມູນ. ໃນຕອນທ້າຍຂອງເອກະສານ B,
ໄດ້ END ຫຸ້ນ ຖືກ​ປະ​ຕິ​ບັດ​.

ການ​ໄຫຼ​ຂອງ​ໂຄງ​ການ​ທີ່​ ຮູບແບບ {action} ລະດັບສາມາດປ່ຽນແປງໄດ້ດ້ວຍ

ຕໍ່ໄປ
ການທ່ອງທ່ຽວ opt_expr

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

ຕົວຢ່າງ

1. emulate cat.

{ ພິມ }

2. emulate wc.

{ chars += length($0) + 1 # ເພີ່ມອັນໜຶ່ງສຳລັບ \n
ຄໍາ += NF
}

END{ ພິມ NR, ຄໍາ, ຕົວອັກສອນ }

3. ນັບຈໍານວນ "ຄໍາທີ່ແທ້ຈິງ".

BEGIN { FS = "[^A-Za-z]+" }

{ for(i = 1 ; i <= NF ; i++) word[$i] = "" }

END { ລຶບຄຳສັບ[""]
ສໍາລັບ (ຂ້າພະເຈົ້າໃນຄໍາສັບ) cnt ++
ພິມ cnt
}

4. ສະຫຼຸບພາກສະຫນາມທີສອງຂອງທຸກໆບັນທຶກໂດຍອີງໃສ່ພາກສະຫນາມທໍາອິດ.

$1 ~ /credit|gain/ { ລວມ += $2 }
$1 ~ /debit|ການສູນເສຍ/ { sum -= $2 }

ສິ້ນສຸດ { ພິມລວມ }

5. ຈັດຮຽງໄຟລ໌, ປຽບທຽບເປັນ string

{ line[NR] = $0 "" } # ໃຫ້ແນ່ໃຈວ່າປະເພດຂອງການປຽບທຽບ
# ໃນກໍລະນີບາງເສັ້ນເບິ່ງເປັນຕົວເລກ

END { isort(line, NR)
ສໍາລັບ(i = 1 ; i <= NR ; i++) ແຖວພິມ[i]
}

#ການແຊກຂອງ A[1..n]
function isort(A, n, i, j, ຖື)
{
ສໍາລັບ( i = 2 ; i <= n ; i++)
{
ຖື = A[j = i]
ໃນຂະນະທີ່ ( A[j-1] > ຖື )
{ j-- ; A[j+1] = A[j] }
A[j] = ຖື
}
# sentinel A[0] = "" ຈະຖືກສ້າງຂື້ນຖ້າຕ້ອງການ
}

ຄວາມເຂົ້າກັນໄດ້ ບັນຫາ

ຄໍານິຍາມ Posix 1003.2(ຮ່າງ 11.3) ຂອງພາສາ AWK ແມ່ນ AWK ຕາມທີ່ອະທິບາຍໄວ້ໃນ AWK.
ປື້ມທີ່ມີສ່ວນຂະຫຍາຍຈໍານວນຫນ້ອຍທີ່ປາກົດຢູ່ໃນ SystemVR4 nawk. ສ່ວນຂະຫຍາຍແມ່ນ:

ຟັງຊັນໃໝ່: topper() ແລະ tolower().

ຕົວແປໃໝ່: ENVIRON[] ແລະ CONVFMT.

ຂໍ້ກໍາຫນົດການແປງ ANSI C ສໍາລັບ printf() ແລະ sprintf().

ຕົວເລືອກຄໍາສັ່ງໃຫມ່: -v var=value, ຫຼາຍ -f ທາງເລືອກແລະທາງເລືອກການປະຕິບັດ
ເປັນການໂຕ້ຖຽງກັບ -W.

Posix AWK ແມ່ນຮັດກຸມເພື່ອປະຕິບັດການໄຟລ໌ຕໍ່ແຖວ. RS ສາມາດປ່ຽນຈາກ "\n"
ກັບຕົວລະຄອນດຽວອື່ນ, ແຕ່ມັນຍາກທີ່ຈະຊອກຫາການນໍາໃຊ້ສໍາລັບການນີ້ - ບໍ່ມີ
ຕົວຢ່າງໃນປື້ມ AWK. ໂດຍສົນທິສັນຍາ, RS = "", ເຮັດໃຫ້ຫນຶ່ງຫຼືຫຼາຍເສັ້ນຫວ່າງແຍກຕ່າງຫາກ
ການບັນທຶກ, ອະນຸຍາດໃຫ້ບັນທຶກຫຼາຍແຖວ. ເມື່ອ​ໃດ​ RS = "", "\n" ແມ່ນຕົວແຍກຊ່ອງຂໍ້ມູນສະເໝີ
ໂດຍບໍ່ຄໍານຶງເຖິງມູນຄ່າໃນ FS.

ມອກ, ໃນທາງກົງກັນຂ້າມ, ອະນຸຍາດໃຫ້ RS ເພື່ອເປັນການສະແດງອອກເປັນປົກກະຕິ. ເມື່ອ "\n" ປາກົດຢູ່ໃນ
ບັນທຶກ, ມັນຖືກປະຕິບັດເປັນຊ່ອງ, ແລະ FS ກຳນົດເຂດຂໍ້ມູນສະເໝີ.

ການເອົາເສັ້ນອອກໃນຂະບວນວິວັດເວລາສາມາດເຮັດໃຫ້ບາງໂປຣແກມງ່າຍຂຶ້ນ ແລະສາມາດປັບປຸງໄດ້ເລື້ອຍໆ
ການປະຕິບັດ. ຕົວຢ່າງ, ເຮັດຄືນຕົວຢ່າງ 3 ຈາກຂ້າງເທິງ,

BEGIN { RS = "[^A-Za-z]+" }

{ word[ $0 ] = "" }

END { ລຶບຄຳສັບ[ "" ]
ສໍາລັບ (ຂ້າພະເຈົ້າໃນຄໍາສັບ) cnt ++
ພິມ cnt
}

ນັບຈໍານວນຄໍາທີ່ເປັນເອກະລັກໂດຍການເຮັດໃຫ້ແຕ່ລະຄໍາເປັນບັນທຶກ. ໃນ​ໄຟລ​໌​ຂະ​ຫນາດ​ປານ​ກາງ​,
ມອກ ດຳ​ເນີນ​ການ​ໄວ​ເປັນ​ສອງ​ເທົ່າ​, ເນື່ອງ​ຈາກ​ວ່າ​ການ loop ໃນ​ທີ່​ງ່າຍ​ດາຍ​.

ໂປຣແກຣມຕໍ່ໄປນີ້ແທນທີ່ແຕ່ລະຄຳເຫັນໂດຍຊ່ອງຫວ່າງດຽວໃນໄຟລ໌ໂປຣແກຣມ C,

{
RS = "/\*([^*]|\*+[^/*])*\*+/"
# ຄຳເຫັນແມ່ນຕົວແຍກບັນທຶກ
ORS = ""
getline ຖື
}

{ ພິມຄ້າງ ; ຖື = $0 }

END { printf "%s", ຖື }

Buffering ຫນຶ່ງບັນທຶກແມ່ນຈໍາເປັນເພື່ອຫຼີກເວັ້ນການຢຸດການບັນທຶກສຸດທ້າຍທີ່ມີຊ່ອງຫວ່າງ.

ກັບ ມອກ, ຕໍ່ໄປນີ້ແມ່ນທັງຫມົດທຽບເທົ່າ,

x ~ /a\+b/ x ~ "a\+b" x ~ "a\\+b"

ສະຕຣິງຖືກສະແກນສອງເທື່ອ, ນຶ່ງເທື່ອເປັນສະຕຣິງ ແລະເທື່ອດຽວເປັນການສະແດງອອກປົກກະຕິ. ສຸດ
ສະແກນສະຕຣິງ, ມອກ ບໍ່ສົນໃຈການຫລົບຫນີໃນຕົວລະຄອນທີ່ບໍ່ຫລົບຫນີໃນຂະນະທີ່ຜູ້ສະຫນັບສະຫນູນຫນັງສື AWK
\c ໄດ້ຮັບການຍອມຮັບວ່າເປັນ c ເຊິ່ງຈໍາເປັນຕ້ອງມີການຫລົບຫນີສອງເທົ່າຂອງຕົວອັກສອນ meta ໃນ
ສາຍ. Posix ປະຕິເສດຢ່າງຈະແຈ້ງທີ່ຈະກໍານົດພຶດຕິກໍາທີ່ບັງຄັບໂຄງການຢ່າງຕັ້ງຫນ້າ
ທີ່ຕ້ອງດໍາເນີນການພາຍໃຕ້ຄວາມຫລາກຫລາຍຂອງ awks ເພື່ອໃຊ້ແບບພົກພາຫຼາຍແຕ່ອ່ານໄດ້ຫນ້ອຍ, ສອງເທົ່າ
ໜີ.

Posix AWK ບໍ່ຮັບຮູ້ "/dev/std{out,err}" ຫຼື \x hex escape sequences ໃນສະຕຣິງ.
ບໍ່ເຫມືອນກັບ ANSI C, ມອກ ຈໍາ​ກັດ​ຈໍາ​ນວນ​ຂອງ​ຕົວ​ເລກ​ທີ່​ຕາມ​ຫຼັງ \x ເປັນ​ສອງ​ເປັນ​ປັດ​ຈຸ​ບັນ​
ການປະຕິບັດພຽງແຕ່ສະຫນັບສະຫນູນ 8 ຕົວອັກສອນ. ການກໍ່ສ້າງໃນ ຟຸ່ມເຟືອຍ ປາກົດຕົວຄັ້ງທໍາອິດໃນ ກ
ບໍ່ດົນມານີ້ (1993) AT&T awk ປ່ອຍອອກມາເມື່ອ netlib, ແລະບໍ່ແມ່ນສ່ວນຫນຶ່ງຂອງມາດຕະຖານ posix.
ລົບລວມກັບ ລຶບ array ບໍ່ແມ່ນສ່ວນຫນຶ່ງຂອງມາດຕະຖານ posix.

Posix ອອກຈາກພຶດຕິກໍາຂອງ FS = "" undefined, and mentions splitting the
ບັນທຶກເປັນຕົວອັກສອນເປັນການຕີຄວາມທີ່ເປັນໄປໄດ້, ແຕ່ໃນປັດຈຸບັນການນໍາໃຊ້ນີ້ບໍ່ແມ່ນ
Portable ໃນທົ່ວການປະຕິບັດ.

ສຸດທ້າຍ, ນີ້ແມ່ນວິທີການ ມອກ ຈັດການກໍລະນີພິເສດທີ່ບໍ່ໄດ້ສົນທະນາຢູ່ໃນປື້ມ AWK ຫຼື
Posix ຮ່າງ. ມັນບໍ່ປອດໄພທີ່ຈະສົມມຸດຕິຖານໃນທົ່ວ awks ແລະປອດໄພທີ່ຈະຂ້າມໄປຕໍ່ໄປ
ສ່ວນ.

substr(s, i, n) ສົ່ງຄືນຕົວອັກສອນຂອງ s ໃນຈຸດຕັດກັນຂອງປິດ
ໄລຍະຫ່າງ [1, length(s)] ແລະໄລຍະເຄິ່ງເປີດ [i, i+n). ເມື່ອນີ້
ທາງຕັດແມ່ນຫວ່າງເປົ່າ, string ຫວ່າງເປົ່າຖືກສົ່ງຄືນ; ດັ່ງນັ້ນ substr("ABC", 1, 0) = ""
ແລະ substr("ABC", -4, 6) = "A".

ທຸກໆສະຕຣິງ, ລວມທັງສະຕຣິງຫວ່າງເປົ່າ, ກົງກັບສະຕຣິງຫວ່າງຢູ່ດ້ານໜ້າ,
s ~ // ແລະ s ~ "", ແມ່ນສະເຫມີ 1 ເປັນ match(s, //) ແລະ match(s, ""). ສອງອັນສຸດທ້າຍ
ທີ່ກໍານົດໄວ້ RLENGTH to 0

index(s, t) ສະເຫມີຄືກັນກັບ match(s, t1) ທີ່ t1 ແມ່ນຄືກັນກັບ t ກັບ
metacharacters ຫນີ. ເພາະສະນັ້ນ, ຄວາມສອດຄ່ອງຂອງການຈັບຄູ່ຕ້ອງການດັດສະນີ (s, "")
ສະເຫມີກັບຄືນ 1. ນອກຈາກນີ້ເງື່ອນໄຂ, index(s,t) != 0 ຖ້າແລະພຽງແຕ່ t ເປັນ substring
ຂອງ s, ຕ້ອງການ index("","") = 1.

ຖ້າ getline ພົບຈຸດສິ້ນສຸດຂອງໄຟລ໌, getline var, ປ່ອຍໃຫ້ var ບໍ່ປ່ຽນແປງ. ເຊັ່ນດຽວກັນ,
ກ່ຽວກັບການເຂົ້າ END ການກະ ທຳ, $0, ທົ່ງນາແລະ NF ມີຄຸນຄ່າຂອງເຂົາເຈົ້າບໍ່ປ່ຽນແປງຈາກ
ບັນທຶກສຸດທ້າຍ.

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