ការណែនាំអំពីភាសាដ៏អស្ចារ្យមួយដែលមានឈ្មោះចម្លែក
Daniel Robbins ប្រធាន/CEO, Gentoo Technologies, Inc.
ការពិពណ៌នា: Awk គឺជាភាសាដ៏អស្ចារ្យមួយដែលមានឈ្មោះចម្លែកណាស់។ នៅក្នុងអត្ថបទដំបូងនៃស៊េរីបីផ្នែកនេះ Daniel Robbins ផ្តល់ឱ្យ ការណែនាំខ្លីៗនៅក្នុងមូលដ្ឋាននៃការសរសេរកម្មវិធីនៅក្នុង awk ។ អត្ថបទនាពេលអនាគតនៅក្នុងស៊េរីនឹងគ្របដណ្តប់លើប្រធានបទកម្រិតខ្ពស់បន្ថែមទៀត ដែលឈានដល់ការបង្កើតកម្មវិធីសាកល្បង awk ជីវិតពិតដ៏ធ្ងន់ធ្ងរ។
អត្ថបទនេះដាក់ស្លាក៖ awk
ដាក់ទង់នេះ!
កាលបរិច្ឆេទ៖ 01/29/2009
កម្រិតលំបាក៖ ងាយស្រួល
មតិយោបល់៖ 0 (មើល | បន្ថែមមតិយោបល់ - ចូល)
វាយតម្លៃអត្ថបទនេះ។
ដើម្បីការពារអាក
នៅក្នុងស៊េរីនៃអត្ថបទនេះ ខ្ញុំនឹងធ្វើឱ្យអ្នកអានក្លាយជាអ្នកសរសេរកម្មវិធី awk ដែលមានជំនាញ។ ខ្ញុំយល់ស្របថា awk មិនមានឈ្មោះល្អ ឬពេញនិយមបំផុតនោះទេ ហើយកំណែ GNU នៃ awk ដែលហៅថា gawk ស្តាប់ទៅដូចជាចំលែកណាស់។ អ្នកសរសេរកម្មវិធីដែលមិនស៊ាំនឹងភាសានេះ ឮឈ្មោះរបស់វា អាចស្រមៃមើលកូដបុរាណ និងហួសសម័យ ដែលអាចជំរុញឱ្យឆ្កួតបំផុត។ អ្នកឯកទេសដែលមានចំណេះដឹងលើយូនីក (ធ្វើឱ្យគាត់លាន់មាត់ថា "សម្លាប់ -៩!" ហើយរត់រកកាហ្វេឥតឈប់ឈរ) ។
បាទ, awk មិន ឈ្មោះដ៏អស្ចារ្យ. ប៉ុន្តែវាជាភាសាដ៏អស្ចារ្យ។ Awk ត្រូវបានរចនាឡើងសម្រាប់ដំណើរការអត្ថបទ និងការរាយការណ៍ ប៉ុន្តែវាមានលក្ខណៈពិសេសដែលត្រូវបានបង្កើតឡើងយ៉ាងល្អដែលបើកដំណើរការកម្មវិធីធ្ងន់ធ្ងរ។ ទោះយ៉ាងណាក៏ដោយ មិនដូចភាសាផ្សេងទៀតទេ វាក្យសម្ព័ន្ធរបស់ awk គឺស៊ាំ និងខ្ចីបានល្អបំផុតពីភាសាដូចជា C, python និង bash (ទោះបីជា awk ត្រូវបានបង្កើតជាផ្លូវការមុន python និង bash)។ Awk គឺជាភាសាមួយក្នុងចំនោមភាសាទាំងនោះដែលនៅពេលរៀនម្តង ក្លាយជាផ្នែកសំខាន់នៃឃ្លាំងយុទ្ធសាស្ត្ររបស់អ្នកសរសេរកម្មវិធី។
ជំហានដំបូងនៅក្នុង awk
តោះចាប់ផ្តើម ហើយសាកល្បងសាកល្បងជាមួយ awk ដើម្បីមើលពីរបៀបដែលវាដំណើរការ។ នៅបន្ទាត់ពាក្យបញ្ជា បញ្ចូលពាក្យបញ្ជាខាងក្រោម៖ $ awk "( print )" /etc/passwd
លទ្ធផលគួរតែបង្ហាញមាតិកានៃឯកសារ /etc/passwd ។ ឥឡូវនេះ - ការពន្យល់អំពីអ្វីដែល awk បានធ្វើ។ នៅពេលហៅ awk យើងបានបញ្ជាក់ /etc/passwd ជាឯកសារបញ្ចូល។ នៅពេលដែលយើងដំណើរការ awk វាដំណើរការពាក្យបញ្ជាបោះពុម្ពសម្រាប់បន្ទាត់នីមួយៗក្នុង /etc/passwd តាមលំដាប់លំដោយ។ លទ្ធផលទាំងអស់ត្រូវបានបញ្ជូនទៅ stdout ហើយយើងទទួលបានលទ្ធផលដូចគ្នាទៅនឹងលទ្ធផល ពាក្យបញ្ជាឆ្មា/etc/passwd. ឥឡូវសូមពន្យល់ពីប្លុក (បោះពុម្ព)។ នៅក្នុង awk ដង្កៀបត្រូវបានប្រើដើម្បីដាក់ជាក្រុមប្លុកអត្ថបទដូចជានៅក្នុង C. ប្លុកអត្ថបទរបស់យើងមានពាក្យបញ្ជាបោះពុម្ពតែមួយប៉ុណ្ណោះ។ នៅក្នុង awk ពាក្យបញ្ជាបោះពុម្ពគឺដោយគ្មាន ប៉ារ៉ាម៉ែត្របន្ថែមបោះពុម្ពមាតិកាទាំងអស់។ បន្ទាត់បច្ចុប្បន្ន.
នេះជាឧទាហរណ៍មួយទៀតនៃកម្មវិធី awk ដែលធ្វើដូចគ្នា៖ $ awk "( print $0 )" /etc/passwd
ជាអកុសល អថេរ $0 តំណាងឱ្យបន្ទាត់បច្ចុប្បន្នទាំងមូល ដូច្នេះការបោះពុម្ព និងបោះពុម្ព $0 ធ្វើដូចគ្នាទាំងស្រុង។ ប្រសិនបើអ្នកចូលចិត្ត អ្នកអាចបង្កើតកម្មវិធីមួយក្នុង awk ដែលនឹងបញ្ចេញទិន្នន័យដែលមិនទាក់ទងទាំងស្រុងទៅនឹងទិន្នន័យបញ្ចូល។ នេះជាឧទាហរណ៍៖ $ awk "( print "" )" /etc/passwd
នៅពេលអ្នកបញ្ជូនខ្សែអក្សរ "" ទៅពាក្យបញ្ជាបោះពុម្ព វាតែងតែបោះពុម្ពខ្សែអក្សរទទេ។ ប្រសិនបើអ្នកសាកល្បងស្គ្រីបនេះ អ្នកនឹងឃើញថា awk ចេញបន្ទាត់ទទេមួយក្នុងមួយជួរក្នុង /etc/passwd ។ វាកើតឡើងម្តងទៀតដោយសារតែ awk ប្រតិបត្តិស្គ្រីបសម្រាប់បន្ទាត់នីមួយៗនៅក្នុងឯកសារបញ្ចូល។ នេះជាឧទាហរណ៍មួយទៀត៖ $ awk "( print "hiya" )" /etc/passwd
ប្រសិនបើអ្នកដំណើរការស្គ្រីបនេះ វានឹងបំពេញអេក្រង់ដោយពាក្យ "ចាស"។ :)
វាលច្រើន។
Awk គឺស័ក្តិសមសម្រាប់ដំណើរការអត្ថបទដែលត្រូវបានបំបែកទៅជាវាលឡូជីខលច្រើន ហើយធ្វើឱ្យវាងាយស្រួលក្នុងការចូលប្រើវាលនីមួយៗពីក្នុងស្គ្រីប awk។ ស្គ្រីបខាងក្រោមនឹងបោះពុម្ពបញ្ជីគណនីទាំងអស់នៅលើប្រព័ន្ធ៖ $ /etc/passwd
នៅក្នុងការហៅ awk ក្នុងឧទាហរណ៍ខាងលើ ជម្រើស –F បញ្ជាក់ ":" ជាសញ្ញាបំបែកវាល។ នៅពេលដំណើរការពាក្យបញ្ជា print $1, awk បោះពុម្ពវាលដំបូងដែលបានជួបប្រទះនៅលើបន្ទាត់នីមួយៗនៃឯកសារបញ្ចូល។ នេះជាឧទាហរណ៍មួយទៀត៖ $ awk -F":" "(បោះពុម្ព $1 $3)" /etc/passwd
នេះគឺជាបំណែកពីលទ្ធផលអេក្រង់នៃស្គ្រីបនេះ៖ halt7
ដូចដែលអ្នកអាចឃើញ awk បញ្ចេញវាលទីមួយ និងទីបីនៃឯកសារ /etc/passwd ដែលជាឈ្មោះអ្នកប្រើប្រាស់ និងវាល uid រៀងគ្នា។ ទោះយ៉ាងណាក៏ដោយ ទោះបីជាស្គ្រីបដំណើរការក៏ដោយ វាមិនល្អឥតខ្ចោះទេ - មិនមានចន្លោះរវាងវាលលទ្ធផលទាំងពីរទេ! អ្នកទាំងឡាយណាដែលធ្លាប់សរសេរកម្មវិធីជា bash ឬ python ប្រហែលជារំពឹងថានឹងមានពាក្យបញ្ជា print $1 $3 ដើម្បីបញ្ចូលចន្លោះរវាងវាលទាំងពីរនេះ។ ទោះយ៉ាងណាក៏ដោយ នៅពេលដែលបន្ទាត់ពីរលេចឡើងនៅជាប់គ្នាក្នុងកម្មវិធី awk នោះ awk ភ្ជាប់ពួកវាដោយមិនបន្ថែមចន្លោះរវាងពួកវា។ ពាក្យបញ្ជាខាងក្រោមនឹងបញ្ចូលចន្លោះរវាងវាល៖ $awk -F":" "(បោះពុម្ព $1 " " $3 )" /etc/passwd
នៅពេលបោះពុម្ពត្រូវបានគេហៅថាវិធីនេះ វាភ្ជាប់ $1, " " និង $3 ជាស៊េរី ដោយបង្កើតលទ្ធផលដែលអាចអានបានដោយមនុស្សនៅលើអេក្រង់។ ជាការពិតណាស់ យើងក៏អាចបញ្ចូលស្លាកវាលប្រសិនបើចាំបាច់៖ $ awk -F":" "( print " username: " $1 "\t\tuid: " $3" )" /etc/passwd
ជាលទ្ធផល យើងទទួលបានលទ្ធផលដូចខាងក្រោម៖ username: halt uid: 7
ឈ្មោះអ្នកប្រើ៖ ប្រតិបត្តិករ uid: ១១
ឈ្មោះអ្នកប្រើប្រាស់៖ root uid៖ ០
ឈ្មោះអ្នកប្រើប្រាស់៖ បិទ uid៖ ៦
ឈ្មោះអ្នកប្រើប្រាស់៖ ធ្វើសមកាលកម្ម uid៖ ៥
ឈ្មោះអ្នកប្រើប្រាស់៖ bin uid: ១
ស្គ្រីបខាងក្រៅ
បញ្ជូនស្គ្រីបទៅ awk ជាអាគុយម៉ង់ បន្ទាត់ពាក្យបញ្ជាប្រហែលជាងាយស្រួលសម្រាប់អត្ថបទមួយបន្ទាត់តូច ប៉ុន្តែនៅពេលនិយាយអំពីកម្មវិធីពហុជួរដ៏ស្មុគស្មាញ វាពិតជាប្រសើរជាងក្នុងការសរសេរស្គ្រីបជា ឯកសារខាងក្រៅ. បន្ទាប់មកអ្នកអាចចង្អុល awk ទៅកាន់ឯកសារស្គ្រីបនេះដោយប្រើជម្រើស -f:$ awk -f myscript.awk myfile.in
ការដាក់ស្គ្រីបនៅក្នុងឯកសារអត្ថបទដាច់ដោយឡែកក៏អនុញ្ញាតឱ្យអ្នកទាញយកអត្ថប្រយោជន៍ផងដែរ។ អត្ថប្រយោជន៍បន្ថែមអូក។ ឧទាហរណ៍ ស្គ្រីបពហុជួរខាងក្រោមធ្វើដូចគ្នានឹងបន្ទាត់មួយពីមុនរបស់យើងដែរ - បោះពុម្ពវាលទីមួយនៃបន្ទាត់នីមួយៗពី /etc/passwd: BEGIN (
ភាពខុសគ្នារវាងវិធីសាស្រ្តទាំងពីរនេះគឺជារបៀបដែលយើងបញ្ជាក់សញ្ញាបំបែកវាល។ នៅក្នុងស្គ្រីបនេះ អ្នកបំបែកវាលត្រូវបានបញ្ជាក់ខាងក្នុងដោយកម្មវិធីខ្លួនវា (ដោយកំណត់អថេរ FS) ចំណែកឯនៅក្នុងឧទាហរណ៍មុនរបស់យើង FS ត្រូវបានកំណត់រចនាសម្ព័ន្ធដោយឆ្លងកាត់ជម្រើស awk -F":" នៅលើបន្ទាត់ពាក្យបញ្ជា។ ជាធម្មតាវាជាការល្អបំផុតក្នុងការបញ្ជាក់អ្នកបំបែកវាលនៅក្នុងស្គ្រីបខ្លួនវា ដោយគ្រាន់តែព្រោះវានឹងមិនតម្រូវឱ្យអ្នកចងចាំអាគុយម៉ង់បន្ទាត់ពាក្យបញ្ជាផ្សេងទៀតទេ។ យើងនឹងពិនិត្យមើលអថេរ FS នៅក្នុងលម្អិតបន្ថែមទៀតនៅពេលក្រោយនៅក្នុងអត្ថបទនេះ។
BEGIN និង END ប្លុក
ជាធម្មតា awk ប្រតិបត្តិប្លុកនីមួយៗនៅក្នុងអត្ថបទស្គ្រីបម្តងសម្រាប់បន្ទាត់បញ្ចូលនីមួយៗ។ ទោះយ៉ាងណាក៏ដោយ ជារឿយៗមានស្ថានភាពក្នុងការសរសេរកម្មវិធី ដែលអ្នកត្រូវប្រតិបត្តិកូដចាប់ផ្តើម មុនពេល awk ចាប់ផ្តើមដំណើរការអត្ថបទពីឯកសារបញ្ចូល។ សម្រាប់ករណីបែបនេះ awk ផ្តល់នូវសមត្ថភាពក្នុងការកំណត់ប្លុក BEGIN ។ យើងបានប្រើប្លុក BEGIN នៅក្នុងឧទាហរណ៍មុន។ ដោយសារតែប្លុក BEGIN ត្រូវបានដំណើរការមុនពេល awk ចាប់ផ្តើមដំណើរការឯកសារបញ្ចូល នេះជាកន្លែងដ៏ល្អមួយដើម្បីចាប់ផ្តើមអថេរ FS (អ្នកបំបែកវាល) បញ្ចេញបឋមកថា ឬចាប់ផ្តើមអថេរសកលផ្សេងទៀតដែលនឹងត្រូវបានប្រើនៅពេលក្រោយនៅក្នុងកម្មវិធី។
Awk ក៏ផ្តល់នូវប្លុកពិសេសមួយទៀតដែលហៅថាប្លុក END ។ Awk ប្រតិបត្តិប្លុកនេះបន្ទាប់ពីបន្ទាត់ទាំងអស់នៅក្នុងឯកសារបញ្ចូលត្រូវបានដំណើរការ។ ជាធម្មតា ប្លុក END ត្រូវបានប្រើដើម្បីអនុវត្តការគណនាចុងក្រោយ ឬលទ្ធផលលទ្ធផលដែលគួរតែលេចឡើងនៅចុងបញ្ចប់នៃស្ទ្រីមលទ្ធផល។
កន្សោមធម្មតានិងប្លុក
Awk អនុញ្ញាតឱ្យអ្នកប្រើ កន្សោមធម្មតា។សម្រាប់ដំណើរការជ្រើសរើសប្លុកកម្មវិធីនីមួយៗ អាស្រ័យលើថាតើកន្សោមធម្មតាត្រូវគ្នានឹងបន្ទាត់បច្ចុប្បន្នឬអត់។ នេះជាឧទាហរណ៍ស្គ្រីបដែលបោះពុម្ពតែបន្ទាត់ទាំងនោះដែលមានលំដាប់តួអក្សរ foo:/foo/ (បោះពុម្ព)
ជាការពិតណាស់ អ្នកអាចប្រើកន្សោមធម្មតាដែលស្មុគស្មាញជាង។ នេះជាស្គ្រីបដែលនឹងបោះពុម្ពតែបន្ទាត់ដែលមានអណ្តែត៖ //+\.*/ (បោះពុម្ព)
កន្សោមនិងប្លុក
មានវិធីជាច្រើនទៀតដើម្បីជ្រើសរើសដំណើរការប្លុកនៃកម្មវិធីមួយ។ យើងអាចដាក់កន្សោម Boolean ណាមួយមុនប្លុកកម្មវិធី ដើម្បីគ្រប់គ្រងការប្រតិបត្តិនៃប្លុកនោះ។ Awk នឹងដំណើរការប្លុកកម្មវិធីតែប៉ុណ្ណោះ ប្រសិនបើកន្សោម Boolean ពីមុនវាយតម្លៃទៅពិត។ ស្គ្រីបឧទាហរណ៍ខាងក្រោមនឹងបញ្ចេញវាលទីបីនៃបន្ទាត់ទាំងអស់ដែលវាលទីមួយត្រូវបាន fred ។ ប្រសិនបើវាលដំបូងនៃបន្ទាត់បច្ចុប្បន្នមិន fred នោះ awk នឹងបន្តដំណើរការឯកសារ ហើយនឹងមិនចេញសេចក្តីថ្លែងការបោះពុម្ពសម្រាប់បន្ទាត់បច្ចុប្បន្នទេ: :$1 == "fred" (បោះពុម្ព $3)
Awk ផ្តល់ជូន សំណុំពេញលេញប្រតិបត្តិករប្រៀបធៀប រួមទាំង "=="," ធម្មតា<", ">", "<=", ">=" និង "!=" ។ លើសពីនេះ awk ផ្ដល់នូវសញ្ញា "~" និង "!"~" ដែលមានន័យថា "ផ្គូផ្គង" និង "មិនផ្គូផ្គង។" ពួកគេដាក់អថេរទៅខាងឆ្វេងនៃ operator និងកន្សោមធម្មតា នៅខាងស្ដាំរបស់វា នេះជាឧទាហរណ៍ដែលមានតែវាលទី 3 នៃបន្ទាត់ប៉ុណ្ណោះដែលត្រូវបានបោះពុម្ព ប្រសិនបើវាលទី 5 នៃបន្ទាត់ដូចគ្នាមានឫសលំដាប់តួអក្សរ: $5 ~ / root/ (បោះពុម្ព $ 3)
សេចក្តីថ្លែងការណ៍តាមលក្ខខណ្ឌ
Awk ក៏ផ្តល់នូវសេចក្តីថ្លែងការណ៍ C-like ដ៏ស្រស់ស្អាតផងដែរ។ ប្រសិនបើចង់បាន អ្នកអាចសរសេរអក្សរពីមុនឡើងវិញដោយប្រើ if:(
ប្រសិនបើ ($5 ~ / root/) (
ស្គ្រីបទាំងពីរដំណើរការដូចគ្នាបេះបិទ។ ក្នុងឧទាហរណ៍ទីមួយ កន្សោម boolean គឺនៅក្រៅប្លុក ខណៈពេលដែលនៅក្នុងឧទាហរណ៍ទីពីរ ប្លុកត្រូវបានប្រតិបត្តិសម្រាប់បន្ទាត់បញ្ចូលនីមួយៗ ហើយយើងជ្រើសរើសប្រតិបត្តិពាក្យបញ្ជាបោះពុម្ពដោយប្រើ if statement ទាំងពីរដំណើរការ ហើយយើងអាចជ្រើសរើសមួយ។ នោះ។ នៅក្នុងវិធីដ៏ល្អបំផុតបញ្ចូលគ្នាជាមួយផ្នែកផ្សេងទៀតនៃស្គ្រីប។
នេះជាច្រើនទៀត ឧទាហរណ៍ស្មុគស្មាញប្រសិនបើសេចក្តីថ្លែងការណ៍នៅក្នុង awk ។ ដូចដែលអ្នកអាចឃើញ ទោះបីជាមានលក្ខខណ្ឌដាក់គ្នាស្មុគស្មាញក៏ដោយ ប្រសិនបើសេចក្តីថ្លែងការណ៍មើលទៅដូចគ្នាបេះបិទទៅនឹងសមភាគី C របស់ពួកគេ :(
ប្រសិនបើ ($1 == "foo") (
ប្រសិនបើ ($2 == "foo") (
) ផ្សេងទៀតប្រសិនបើ ($1 == "របារ") (
ដោយប្រើ if statements យើងអាចបំប្លែងកូដនេះបាន៖ ! /matchme/ (បោះពុម្ព 1$3$4)
ដូចនេះ៖ (
ប្រសិនបើ ($0 !~ /matchme/) (
ស្គ្រីបទាំងពីរនឹងបោះពុម្ពតែបន្ទាត់ដែលមិនមានលំដាប់តួអក្សរ matchme ប៉ុណ្ណោះ។ ហើយក្នុងករណីនេះផងដែរ អ្នកអាចជ្រើសរើសវិធីសាស្រ្តដែលដំណើរការប្រសើរជាងនៅក្នុងកម្មវិធីជាក់លាក់មួយ។ ពួកគេទាំងពីរធ្វើដូចគ្នា។
Awk ក៏ផ្តល់ឱ្យអ្នកនូវសមត្ថភាពក្នុងការប្រើប្រតិបត្តិករប៊ូលីន "||" ("ឡូជីខល OR") និង "&&" ("ឡូជីខល AND") ដែលអនុញ្ញាតឱ្យអ្នកបង្កើតកន្សោមប៊ូលីនស្មុគស្មាញបន្ថែមទៀត៖ ($1 == "foo") && ($2 == "bar") (បោះពុម្ព)
ឧទាហរណ៍នេះនឹងចេញតែជួរដេកដែលវាលទីមួយគឺ foo ហើយវាលទីពីរគឺរបារ។
អថេរជាលេខ!
រហូតមកដល់ពេលនេះ យើងបានបោះពុម្ពអថេរខ្សែអក្សរ ខ្សែអក្សរទាំងមូល ឬវាលជាក់លាក់។ ទោះជាយ៉ាងណាក៏ដោយ awk ក៏ផ្តល់ឱ្យយើងនូវសមត្ថភាពក្នុងការធ្វើការប្រៀបធៀបទាំងចំនួនគត់ និងលេខចំនុចអណ្តែត។ ដោយប្រើកន្សោមគណិតវិទ្យា វាងាយស្រួលណាស់ក្នុងការសរសេរស្គ្រីបដែលរាប់លេខ បន្ទាត់ទទេនៅក្នុងឯកសារ។ នេះគឺជាស្គ្រីបមួយ៖ BEGIN (x=0)
បញ្ចប់ (បោះពុម្ព "រកឃើញ " x " បន្ទាត់ទទេ។ :)"
នៅក្នុងប្លុក BEGIN យើងចាប់ផ្តើមអថេរចំនួនគត់របស់យើង x ទៅសូន្យ។ បន្ទាប់មក រាល់ពេលដែល awk ជួបនឹងបន្ទាត់ទទេ វានឹងប្រតិបត្តិសេចក្តីថ្លែងការណ៍ x=x+1 ដោយបង្កើន x ដោយ 1។ នៅពេលដែលបន្ទាត់ទាំងអស់ត្រូវបានដំណើរការ ប្លុក END នឹងត្រូវបានប្រតិបត្តិ ហើយ awk នឹងបោះពុម្ពសរុបចុងក្រោយដោយចង្អុលបង្ហាញ ចំនួនបន្ទាត់ទទេដែលបានរកឃើញ។
អថេរខ្សែអក្សរ
រឿងដ៏ល្អមួយអំពីអថេរ awk គឺថាពួកវាជា "ធម្មតា និងអក្សរតូច" ។ ខ្ញុំហៅអថេរ awk ថា "string" ពីព្រោះអថេរ awk ទាំងអស់ត្រូវបានរក្សាទុកនៅខាងក្នុងជាខ្សែអក្សរ។ ក្នុងពេលជាមួយគ្នានោះ អថេរ awk គឺ "សាមញ្ញ" ពីព្រោះអ្នកអាចធ្វើប្រតិបត្តិការគណិតវិទ្យាលើអថេរ ហើយប្រសិនបើវាមាន បន្ទាត់លេខ, awk នឹងថែរក្សាការបំប្លែងខ្សែអក្សរទៅជាលេខដោយស្វ័យប្រវត្តិ។ ដើម្បីដឹងថាខ្ញុំមានន័យយ៉ាងណា សូមមើលឧទាហរណ៍នេះ៖ x="1.01"
# យើងបង្កើត x មាន *string* "1.01"
# យើងទើបតែបន្ថែម 1 ទៅ *string*
#នេះជាមតិយោបល់ :)
Awk នឹងបញ្ចេញ៖ 2.01
ឆ្ងល់! ទោះបីជាយើងបានកំណត់តម្លៃខ្សែអក្សរ 1.01 ទៅ x ក៏ដោយ យើងនៅតែអាចបន្ថែមមួយទៅវាបាន។ យើងមិនអាចធ្វើបែបនេះដោយប្រើបាស ឬពស់ថ្លាន់ទេ។ ជាដំបូង bash មិនគាំទ្រលេខនព្វន្ធចំណុចអណ្តែតទេ។ ហើយខណៈពេលដែល bash មានអថេរ "ខ្សែអក្សរ" ពួកគេមិនមែនជា "សាមញ្ញ" ទេ។ ដើម្បីអនុវត្តណាមួយ។ ប្រតិបត្តិការគណិតវិទ្យា bash តម្រូវឱ្យយើងរុំការគណនារបស់យើងជា $() constructs ដ៏អាក្រក់។ ប្រសិនបើយើងកំពុងប្រើ python យើងនឹងត្រូវការបំប្លែងខ្សែអក្សរ 1.01 របស់យើងឱ្យច្បាស់លាស់ទៅជាតម្លៃចំនុចអណ្តែតទឹក មុនពេលធ្វើការគណនាជាមួយវា។ ទោះបីជាវាមិនពិបាកក៏ដោយក៏វានៅតែដដែល ជំហានបន្ថែម. ក្នុងករណី awk ទាំងអស់នេះត្រូវបានធ្វើដោយស្វ័យប្រវត្តិ ហើយវាធ្វើឱ្យកូដរបស់យើងស្អាត និងស្អាត។ ប្រសិនបើយើងត្រូវការការ៉េទីមួយនៃខ្សែបញ្ចូលនីមួយៗ ហើយបន្ថែមមួយទៅវា យើងនឹងប្រើស្គ្រីបដូចនេះ៖ (បោះពុម្ព ($1^2)+1)
ប្រសិនបើអ្នកពិសោធន៍បន្តិច អ្នកនឹងឃើញថា ប្រសិនបើអថេរមិនមានលេខត្រឹមត្រូវ awk នឹងចាត់ទុកអថេរនោះជាលេខសូន្យ នៅពេលវាយតម្លៃកន្សោមគណិតវិទ្យា។
ប្រតិបត្តិករជាច្រើន។
លក្ខណៈពិសេសល្អមួយទៀតរបស់ awk គឺ សំណុំពេញលេញប្រតិបត្តិករគណិតវិទ្យា។ បន្ថែមពីលើការបូក ដក គុណ និងចែកជាស្តង់ដារ awk ផ្តល់ឱ្យយើងនូវសមត្ថភាពក្នុងការប្រើសញ្ញាប្រមាណវិធីនិទស្សន្តដែលបានបង្ហាញពីមុន "^", សញ្ញាប្រមាណវិធីដែលនៅសល់ ការបែងចែកចំនួនគត់"%" និងប្រតិបត្តិករកិច្ចការងាយស្រួលជាច្រើនទៀតដែលខ្ចីពី C.
ទាំងនេះរួមមាន ប្រតិបត្តិករចាត់តាំងមុន និងក្រោយការបន្ថែម/បន្ថយ (i++, --foo) ប្រតិបត្តិករចាត់ចែងជាមួយការបូក/ដក/គុណ/ចែក (a+=3, b*=2, c/=2.2, d-=6.2) . ប៉ុន្តែនោះមិនមែនទាំងអស់នោះទេ - យើងក៏មានប្រតិបត្តិករការចាត់តាំងដ៏ងាយស្រួលជាមួយនឹងការគណនានៅសល់នៃការបែងចែកចំនួនគត់ និងនិទស្សន្ត (a^=2, b%=4)។
ឧបករណ៍បំបែកវាល
awk មានសំណុំអថេរពិសេសផ្ទាល់ខ្លួន។ ពួកគេខ្លះធ្វើឱ្យវាអាចទៅរួច ការលៃតម្រូវការងារ awk និងផ្សេងទៀតមាន ព័ត៌មានដ៏មានតម្លៃអំពីការបញ្ចូល។ យើងបានប៉ះលើអថេរពិសេសមួយក្នុងចំណោមអថេរទាំងនេះរួចហើយ FS ។ ដូចដែលបានរៀបរាប់ពីមុន អថេរនេះអនុញ្ញាតឱ្យអ្នកបញ្ជាក់លំដាប់នៃតួអក្សរដែល awk នឹងចាត់ទុកជាសញ្ញាបំបែកវាល។ នៅពេលដែលយើងប្រើ /etc/passwd ជាការបញ្ចូល FS ត្រូវបានកំណត់ទៅជា ":" ។ វាបានប្រែទៅជាគ្រប់គ្រាន់ ប៉ុន្តែ FS ផ្តល់ឱ្យយើងនូវភាពបត់បែនកាន់តែច្រើន។
តម្លៃនៃអថេរ FS មិនចាំបាច់ជាតួអក្សរតែមួយទេ។ វាអាចត្រូវបានកំណត់ជាកន្សោមធម្មតាដែលបញ្ជាក់លំនាំតួអក្សរនៃប្រវែងណាមួយ។ ប្រសិនបើអ្នកកំពុងដំណើរការវាលដែលបំបែកដោយតួអក្សរផ្ទាំងមួយ ឬច្រើននោះ FS ត្រូវតែកំណត់រចនាសម្ព័ន្ធដូចខាងក្រោម៖ FS="\t+"
ខាងលើយើងបានប្រើ តួអក្សរពិសេសកន្សោមធម្មតា "+" ដែលមានន័យថា "ការកើតឡើងមួយ ឬច្រើននៃតួអក្សរមុន" ។
ប្រសិនបើវាលត្រូវបានបំបែកដោយចន្លោះពណ៌ស (ចន្លោះមួយ ឬច្រើន ឬផ្ទាំង) អ្នកប្រហែលជាចង់កំណត់ FS ទៅជាកន្សោមធម្មតាខាងក្រោម៖ FS="[[:space:]+]"
ខណៈពេលដែលការដំឡើងនេះនឹងដំណើរការ វាមិនចាំបាច់ទេ។ ហេតុអ្វី? ដោយសារតែតម្លៃលំនាំដើមនៃ FS គឺជាតួអក្សរដកឃ្លាមួយ ដែល awk បកប្រែថាជា "ចន្លោះមួយ ឬច្រើន ឬផ្ទាំង"។ នៅក្នុងរបស់យើង។ ឧទាហរណ៍ជាក់លាក់តម្លៃ FS លំនាំដើមគឺពិតជាអ្វីដែលយើងត្រូវការ!
ក៏មិនមានបញ្ហាជាមួយនឹងកន្សោមធម្មតាស្មុគស្មាញដែរ។ ទោះបីជាកំណត់ត្រាត្រូវបានបំបែកដោយពាក្យ "foo" អមដោយបីខ្ទង់ក៏ដោយ កន្សោមធម្មតាខាងក្រោមនឹងញែកទិន្នន័យឱ្យបានត្រឹមត្រូវ៖ FS="foo"
ចំនួនវាល
អថេរពីរបន្ទាប់ដែលយើងនឹងមើលជាធម្មតាមិនមានន័យថាត្រូវបានសរសេរទៅនោះទេ ប៉ុន្តែត្រូវបានប្រើដើម្បីអាន និងទទួលបាន ព័ត៌មានមានប្រយោជន៍អំពីការបញ្ចូល។ ទីមួយនៃទាំងនេះគឺជាអថេរ NF ដែលត្រូវបានគេហៅថា "ចំនួនវាល" ផងដែរ។ Awk កំណត់តម្លៃនៃអថេរនេះដោយស្វ័យប្រវត្តិទៅចំនួនវាលនៅក្នុងកំណត់ត្រាបច្ចុប្បន្ន។ អ្នកអាចប្រើអថេរ NF ដើម្បីបង្ហាញតែបន្ទាត់បញ្ចូលជាក់លាក់ប៉ុណ្ណោះ៖ NF == 3 (បោះពុម្ព "មានវាលបីនៅក្នុងធាតុនេះ៖ " $0 )
ជាការពិតណាស់ អថេរ NF ក៏អាចត្រូវបានប្រើនៅក្នុង សេចក្តីថ្លែងការណ៍តាមលក្ខខណ្ឌឧទាហរណ៍៖(
ប្រសិនបើ (NF > 2) (
បោះពុម្ព $1 " " $2 " : " $3
លេខកត់ត្រា
អថេរងាយស្រួលមួយទៀតគឺលេខកំណត់ត្រា (NR) ។ វាតែងតែមានលេខនៃកំណត់ត្រាបច្ចុប្បន្ន (awk ចាត់ទុកកំណត់ត្រាដំបូងជាកំណត់ត្រាលេខ 1) ។ រហូតមកដល់ពេលនេះយើងបានដោះស្រាយ ឯកសារបញ្ចូលដែលមានធាតុមួយក្នុងមួយជួរ។ ក្នុងស្ថានភាពបែបនេះ NR ក៏នឹងរាយការណ៍អំពីលេខបន្ទាត់បច្ចុប្បន្នផងដែរ។ ទោះជាយ៉ាងណាក៏ដោយ នៅពេលដែលយើងចាប់ផ្តើមដោះស្រាយកំណត់ត្រាពហុជួរនៅក្នុងអត្ថបទក្រោយៗទៀតនៅក្នុងស៊េរីនេះ វានឹងលែងជាករណីទៀតហើយ ដូច្នេះអ្នកត្រូវប្រុងប្រយ័ត្ន! NR អាចត្រូវបានប្រើដូចជាអថេរ NF ដើម្បីបញ្ចេញតែប៉ុណ្ណោះ។ បន្ទាត់ជាក់លាក់បញ្ចូល៖(NR< 10) || (NR >100) (បោះពុម្ព "យើងស្ថិតនៅលើកំណត់ត្រាលេខ 1-9 ឬ 101 ឬច្រើនជាងនេះ")
ឧទាហរណ៍មួយទៀត៖(
ប្រសិនបើ (NR> 10) (
បោះពុម្ព "ឥឡូវនេះព័ត៌មានពិតនឹងមកដល់!"
Awk ផ្តល់អថេរបន្ថែមដែលអាចត្រូវបានប្រើសម្រាប់គោលបំណងផ្សេងៗ។ យើងនឹងពិនិត្យមើលអថេរទាំងនេះនៅក្នុងអត្ថបទនាពេលអនាគត។ យើងបានឈានដល់ការបញ្ចប់នៃការស្វែងរកដំបូងរបស់ awk ។ នៅក្នុងអត្ថបទនាពេលអនាគតនៅក្នុងស៊េរី ខ្ញុំនឹងបង្ហាញមុខងារ awk កម្រិតខ្ពស់បន្ថែមទៀត ហើយយើងនឹងបញ្ចប់ស៊េរីនេះជាមួយនឹងកម្មវិធី awk ពិភពពិត។ ក្នុងពេលនេះ ប្រសិនបើអ្នកចង់ស្វែងយល់បន្ថែម អ្នកអាចពិនិត្យមើលធនធានដែលមានរាយខាងក្រោម។
04.10.2015
16:55
ឧបករណ៍ប្រើប្រាស់ awk គឺជាឧទាហរណ៍នៃបុរាណមួយ។ កម្មវិធីលីនុចសម្រាប់ដំណើរការអត្ថបទ។ វាគឺជាការល្អប្រសើរនិងមានប្រសិទ្ធិភាពខ្លាំងណាស់ទោះបីជាវាមិនបានផ្តល់នូវភាសាកម្មវិធីពេញលេញ។ ទោះជាយ៉ាងណាក៏ដោយ សូមប្រាកដថា សមត្ថភាពរបស់វាគ្រប់គ្រាន់ក្នុងការដោះស្រាយបញ្ហាជាច្រើន។ ដំណើរការដោយស្វ័យប្រវត្តិអត្ថបទ (ជាពិសេសនៅពេលរួមបញ្ចូលគ្នាជាមួយឧបករណ៍ប្រើប្រាស់កុងសូលផ្សេងទៀត) ។
វិធីដើម្បីដំណើរការកម្មវិធី awk
ប្រសិនបើកម្មវិធី awk គឺសាមញ្ញ និងខ្លី នោះកូដរបស់វាអាចត្រូវបានវាយដោយផ្ទាល់ទៅក្នុងកុងសូល៖
អាក"< код awk-программы >" < имя_файла_для_обработки >
អ្នកអាចប្រើច្រើនជាង awk ជាការបញ្ចូល៖ ឯកសារអត្ថបទប៉ុន្តែក៏មានទិន្នផលផងដែរ។ ស្ទ្រីមស្តង់ដារកម្មវិធីផ្សេងទៀត៖
< некое_приложение >| អូក"< код awk-программы >"
ក្នុងករណីដែលកូដកម្មវិធី awk មានទំហំធំ ឬត្រូវតែរក្សាទុកសម្រាប់ ប្រើឡើងវិញវាអាចត្រូវបានហៅចេញពីឯកសារដែលមានកុងតាក់ -f៖
អាក-f< имя_файла_с_кодом_awk_программы > < имя_файла_для_обработки >
ដើម្បីអនុវត្តការពិសោធន៍ យើងប្រើឯកសារ test.cpp ដែលយើងនឹងពិនិត្យមើលលទ្ធផលនៃកម្មវិធី awk៖
# រួមបញ្ចូល
ការផ្សាយពាណិជ្ជកម្ម
ត្រងខ្សែអក្សរដោយប្រើ awk
ជាដំបូង awk អនុញ្ញាតឱ្យអ្នកជ្រើសរើសបន្ទាត់ពីអត្ថបទដោយផ្អែកលើកន្សោមធម្មតា និងលក្ខខណ្ឌជាលេខមួយចំនួន។
ការជ្រើសរើសខ្សែអក្សរដែលត្រូវគ្នានឹងកន្សោមធម្មតា។
ឧទាហរណ៍ ដើម្បីទទួលបានបន្ទាត់ទាំងអស់នៅក្នុងឯកសារ test.cpp ដែលមានការណែនាំ #include preprocessor យើងនឹងប្រើពាក្យបញ្ជាខាងក្រោម៖
Awk "/^#\s*include/" test.cpp
កន្សោមធម្មតាត្រូវបានសរសេររវាងពីរ/តួអក្សរ។ ជាលទ្ធផលយើងទទួលបាន៖
# រួមបញ្ចូល
ការជ្រើសរើសខ្សែអក្សរដែលមិនត្រូវគ្នានឹងកន្សោមធម្មតា។
ដើម្បីទុកបន្ទាត់ទាំងអស់ដែលមិនត្រូវគ្នានឹងកន្សោមធម្មតា ប្រើពាក្យបញ្ជាពីផ្នែករងមុន ហើយបន្ថែមសញ្ញាឧទានមួយទៅដើមនៃកូដ awk ។ ជាឧទាហរណ៍ វិធីនេះយើងនឹងដកចេញនូវបន្ទាត់ដែលបានអធិប្បាយទាំងអស់៖
អាក់ "! /^[/](2).*/" test.cpp
នេះជាអ្វីដែលនៅសេសសល់៖
# រួមបញ្ចូល
ការជ្រើសរើសជួរពីជួរដែលបានផ្តល់ឱ្យ
អ្នកអាចកំណត់ជួរនៃខ្សែដែលត្រូវបង្ហាញនៅលើអេក្រង់ដោយប្រើកន្សោមធម្មតាពីរ ដោយបំបែកដោយសញ្ញាក្បៀស។ ជាឧទាហរណ៍ ចូរយើងស្វែងរកនិយមន័យនៃមុខងារទាំងអស់ដែលត្រឡប់ int៖
Awk "/^int .*.*) (/, /^)/" test.cpp
លទ្ធផលពាក់ព័ន្ធ៖
int main(int argc, char** argv) ( std::cout<< "Hello, world!" << std::endl; for(int i = 0; i < 10; ++i) { std::cout << i << std::endl; } return 0; } int test2() { std::cout << "Hello, test2!" << std::endl; }
ការរួមបញ្ចូលគ្នានៃលក្ខខណ្ឌតម្រង
ដើម្បីពិនិត្យខ្សែអក្សរប្រឆាំងនឹងលក្ខខណ្ឌជាច្រើនក្នុងពេលតែមួយ សូមប្រើសញ្ញា && (AND) និង || ។ (ឬ)។
ពាក្យបញ្ជាខាងក្រោមបោះពុម្ពមតិយោបល់ទាំងអស់ដែលមិនមានមេ៖
Awk "/[/](2).*/ && ! /main/"test.cpp
ជាលទ្ធផលយើងមាន៖
// អត្ថាធិប្បាយរចនាប័ទ្ម C សម្រាប់មុខងារ test1() // មតិយោបល់រចនាប័ទ្ម C សម្រាប់មុខងារ test2()
ពីមុន យើងបានស្វែងរកជួរនៃបន្ទាត់ដោយប្រើកន្សោមធម្មតាពីរ ប៉ុន្តែប្រសិនបើលេខបន្ទាត់ដែលត្រូវការលទ្ធផលត្រូវបានដឹងជាមុន នោះអ្វីៗទាំងអស់ត្រូវបានធ្វើឱ្យសាមញ្ញ៖
អាក” ៤< NR && NR < 7" test.cpp
NR គឺជាអថេរ awk ដែលបញ្ជាក់លេខបន្ទាត់។ ដូច្នេះ កូដដែលបានបង្ហាញចេញពីជួរទី ៥ និងទី ៦៖
ការធ្វើតេស្ត 1(); int test2();
ការជ្រើសរើសបន្ទាត់ដោយផ្អែកលើលក្ខខណ្ឌទាក់ទងនឹងពាក្យបុគ្គល
Awk អាចត្រងអត្ថបទមិនត្រឹមតែតាមបន្ទាត់ប៉ុណ្ណោះទេ ប៉ុន្តែក៏ដោយពាក្យនីមួយៗផងដែរ។ ពាក្យ i -th នៅក្នុងបន្ទាត់អាចត្រូវបានយោងដោយប្រើ $i ។ លេខរៀងចាប់ផ្តើមពីមួយ ហើយ $0 កំណត់មាតិកានៃបន្ទាត់ទាំងមូល។ ចំនួនពាក្យនៅក្នុងបន្ទាត់មួយត្រូវបានកំណត់ដោយប្រើអថេរ NF ដូច្នេះ $NF ចង្អុលទៅពាក្យចុងក្រោយ។ ជាឧទាហរណ៍ សូមស្វែងរកបន្ទាត់ដែលពាក្យដំបូងគឺ int ឬចាត់ទុកជាមោឃៈ។
Awk "$1 == "int" || $1 == "void"" test.cpp
ទិន្នផលកុងសូលដែលត្រូវគ្នា៖
ការធ្វើតេស្ត 1(); int test2(); int main(int argc, char** argv) ( void test1() ( int test2() (
ទោះយ៉ាងណាក៏ដោយ វាកាន់តែងាយស្រួលប្រើការត្រួតពិនិត្យកន្សោមធម្មតាប្រឆាំងនឹងពាក្យមួយ។ ដើម្បីធ្វើដូច្នេះ awk ផ្តល់នូវប្រតិបត្តិករពិសេស ~ ដែលត្រូវតែដាក់នៅចន្លោះអថេរដែលចង្អុលទៅពាក្យ និងកន្សោមធម្មតា។ ជាឧទាហរណ៍ ចូរយើងសរសេរពាក្យបញ្ជាពីមុនឡើងវិញក្នុងទម្រង់បង្រួមជាងមុន៖
Awk "$1 ~ / int|void/" test.cpp
ជ្រើសរើសជួរដេកដោយផ្អែកលើលក្ខណៈលេខ
ប្រតិបត្តិករនព្វន្ធភាសា C មាននៅក្នុង awk ដែលផ្តល់ឱ្យអ្នកនូវសេរីភាពនៃសកម្មភាព។ ឧទាហរណ៍ខាងក្រោមបោះពុម្ពបន្ទាត់គូទាំងអស់ (NR គឺជាលេខបន្ទាត់)៖
Awk "NR %2 == 0" test.cpp
ទិន្នផលដែលពាក់ព័ន្ធ៖
# រួមបញ្ចូល
កម្មវិធី awk ខាងក្រោមបោះពុម្ពបន្ទាត់ទាំងអស់ដែលពាក្យទី 1 មានប្រវែងបី៖
Awk "ប្រវែង($1) == 3" test.cpp
ជាលទ្ធផលយើងទទួលបាន៖
តេស្ត int2(); int main(int argc, char** argv) ( int test2() (
Awk "NF == 2" test.cpp
និងទិន្នផលដែលត្រូវគ្នា៖
# រួមបញ្ចូល
ការផ្សាយពាណិជ្ជកម្ម
ត្រឡប់ 0;
ធ្វើការជាមួយខ្សែអក្សរនៅក្នុង awk
ដូចដែលអ្នកអាចឃើញ awk មានសំណុំមុខងារដ៏ល្អសម្រាប់ត្រងខ្សែអក្សរ។ ទោះយ៉ាងណាក៏ដោយ អ្នកនៅតែអាចធ្វើការបំប្លែងផ្សេងៗលើខ្សែទាំងនេះបាន។ ពាក្យបញ្ជាខ្សែអក្សរត្រូវតែរុំដោយដង្កៀបអង្កាញ់ (...) ។ កូដក្នុងវង់ក្រចកត្រូវបានហៅតាមលំដាប់លំដោយសម្រាប់បន្ទាត់នីមួយៗនៃអត្ថបទដែលកំពុងដំណើរការ។
លទ្ធផលដែលបានធ្វើទ្រង់ទ្រាយ
Awk មានសមមូលផ្ទាល់ទៅនឹងមុខងារ C printf()។ ជាឧទាហរណ៍ ចូរយើងបោះពុម្ពលេខរបស់វានៅដើមបន្ទាត់នីមួយៗ៖
Awk "( printf "%-2d %s\n", NR, $0 )" test.cpp
នេះជាអ្វីដែលយើងទទួលបាន៖
4 5 ការធ្វើតេស្តចាត់ទុកជាមោឃៈ1(); 6 int test2(); 7 8 // អត្ថាធិប្បាយរចនាប័ទ្ម C សម្រាប់អនុគមន៍ main() 9 int main(int argc, char** argv) ( 10 std::cout
មុខងារបំប្លែង
បន្ថែមពីលើ printf() awk មានមុខងារផ្សេងទៀត។ ឧទាហរណ៍ print() និង topper()៖
លទ្ធផលពាក់ព័ន្ធ៖
#រួមបញ្ចូល
លក្ខខណ្ឌ
សេចក្តីថ្លែងការណ៍ If-else មាននៅក្នុងកម្មវិធី awk ។ ឧទាហរណ៍ កូដខាងក្រោមបោះពុម្ពដោយមិនផ្លាស់ប្តូរបន្ទាត់ដែលមាន int នៅក្នុងទីតាំងទី 1 ហើយ (នៅចុងក្រោយ បើមិនដូច្នេះទេ --- ត្រូវបានបញ្ជូនទៅកុងសូល៖
Awk " (ប្រសិនបើ($1 == "int" && $NF == "() print; else print "---" )" test.cpp
ដំណើរការកូដបង្កើតលទ្ធផលដូចខាងក្រោមៈ
Int main (int argc, char** argv) ( --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- - --- --- int test2() ( --- ---
អថេរ
អថេរដែលមិនចាំបាច់ត្រូវបានប្រកាសជាមុនក៏មាននៅក្នុងកម្មវិធី awk ផងដែរ។ កូដខាងក្រោមសម្រាប់រាប់ចំនួនបន្ទាត់ និងពាក្យនៅក្នុងអត្ថបទនឹងត្រូវបានដាក់ក្នុងឯកសារ stat.awk៖
( lineCount ++; wordCount += NF ) END ( printf "ចំនួនបន្ទាត់៖ %d, ចំនួនពាក្យ៖ %d\n", lineCount, wordCount)
បន្ទាប់មកវាត្រូវបានគេហៅថា:
Awk -f stat.awk test.cpp
លទ្ធផលអនុវត្ត៖
ចំនួនបន្ទាត់៖ ២៧, ចំនួនពាក្យ៖ ៨៨
តម្រង END បញ្ជាក់ថាកូដក្នុងវង់ក្រចកបន្ទាប់ពីវាគួរត្រូវបានប្រតិបត្តិតែបន្ទាប់ពីបន្ទាត់ទាំងអស់ត្រូវបានឆ្លងកាត់ប៉ុណ្ណោះ។ តម្រង BEGIN ក៏មាននៅក្នុង awk ផងដែរ ដូច្នេះក្នុងករណីទូទៅ កម្មវិធីមានទម្រង់៖
BEGIN (បានហៅមុនពេលការឆ្លងកាត់ជួរដេកចាប់ផ្តើម) (បានហៅសម្រាប់ជួរនីមួយៗបន្ទាប់ពីផ្នែក BEGIN ប៉ុន្តែមុនផ្នែក END) END (ហៅបន្ទាប់ពីជួរដេកឆ្លងកាត់បានបញ្ចប់)
Wc -lw test.cpp
វដ្ត
នៅក្នុងកម្មវិធី awk អ្នកក៏មានសិទ្ធិចូលប្រើរចនាប័ទ្ម C សម្រាប់ និងខណៈពេលរង្វិលជុំផងដែរ។ ជាឧទាហរណ៍ ចូរយើងបោះពុម្ពបន្ទាត់ទាំងអស់តាមលំដាប់បញ្ច្រាស។ តោះបង្កើតឯកសារ reverse.awk ដែលមានខ្លឹមសារដូចខាងក្រោម៖
(សម្រាប់(i = NF; i> 0; --i) printf "%s ", $i; printf "\n" )
តោះហៅកម្មវិធីដូចខាងក្រោម៖
Awk -f reverse.awk test.cpp
ជាលទ្ធផល ពាក្យនៅក្នុងបន្ទាត់នីមួយៗនឹងត្រូវបានបោះពុម្ពតាមលំដាប់បញ្ច្រាស៖
សញ្ញាបំបែកពាក្យមិនស្តង់ដារ
តាមលំនាំដើម awk ប្រើតួអក្សរដកឃ្លាជាសញ្ញាបំបែកពាក្យ ប៉ុន្តែឥរិយាបថនេះអាចត្រូវបានផ្លាស់ប្តូរ។ ដើម្បីធ្វើដូចនេះសូមប្រើកុងតាក់ -F បន្តដោយបន្ទាត់កំណត់សញ្ញាបំបែក។ ឧទាហរណ៍ កម្មវិធីខាងក្រោមបង្ហាញឈ្មោះក្រុម និងអ្នកប្រើប្រាស់របស់វា (ប្រសិនបើមានអ្នកប្រើប្រាស់នៅក្នុងក្រុម) ពីឯកសារ /etc/group ដោយប្រើតួអក្សរសញ្ញាសម្គាល់ជាសញ្ញាកំណត់៖
Awk -F":" "(if($4) printf "%15s: %s\n", $1, $4 )" /etc/group
ការរួមបញ្ចូលគ្នានៃតម្រង និងពាក្យបញ្ជាបោះពុម្ព
តម្រងដែលបានពិភាក្សាពីមុនទាំងអស់អាចត្រូវបានប្រើដោយភ្ជាប់ជាមួយពាក្យបញ្ជាដំណើរការខ្សែអក្សរ។ វាគ្រប់គ្រាន់ហើយក្នុងការសរសេរការរឹតបន្តឹងមុនពេលដង្កៀបអង្កាញ់។ ខាងក្រោមនេះជាឧទាហរណ៍ដើម្បីបោះពុម្ព 9 ជួរដំបូងនៃលទ្ធផលនៃពាក្យបញ្ជា ps ដែលមានព័ត៌មានអំពីអ្នកប្រើប្រាស់ លេខសម្គាល់ដំណើរការ និងឈ្មោះពាក្យបញ្ជា៖
Ps axu | awk "NR< 10 { print $1, $2, $NF }"
បន្ទាប់ពីការបើកដំណើរការយើងនឹងឃើញ:
អ្នកប្រើប្រាស់ PID ពាក្យបញ្ជា root 1 /sbin/init root 2 root 3 root 5 root 7 root 8 root 9 root 10
នៅក្នុងអត្ថបទនេះ ខ្ញុំមានគម្រោងចែករំលែកឧទាហរណ៍ដែលមានប្រយោជន៍ដែលជួយខ្ញុំដោះស្រាយបញ្ហាប្រចាំថ្ងៃ និងធ្វើឱ្យការប្រើប្រាស់បន្ទាត់ពាក្យបញ្ជាមានភាពសាមញ្ញ។ សម្រាប់អ្នកដែលមិនទាន់ស្គាល់ AWK ខ្ញុំសូមណែនាំថាអ្នកប្រាកដជាស្ទាត់ជំនាញភាសាស្គ្រីបនេះ មិនមានអ្វីស្មុគស្មាញទេ។ ខ្ញុំមានគម្រោងអមជាមួយឧទាហរណ៍នីមួយៗជាមួយនឹងមតិយោបល់តូចៗដែលបំភ្លឺលើភាពខុសប្លែកនៃការប្រើប្រាស់ប្រតិបត្តិករជាក់លាក់។
.
យើងកំពុងស្វែងរកបន្ទាត់ដែលមានប៉ារ៉ាម៉ែត្រ bind-អាសយដ្ឋាននៅក្នុងឯកសារកំណត់រចនាសម្ព័ន្ធ។
root@debian៖ ~# awk '/bind-address/' /etc/mysql/my.cnf
bind-address = 127.0.0.1
bind-address = 192.168.1.110
ការពន្យល់៖ AWK មានវាក្យសម្ព័ន្ធ និងជម្រើសដូចខាងក្រោម។
អូក[-f program_file | 'កម្មវិធី'] [-Fdelimiter]
[-v variable=value] [ឯកសារ ...]
-Fតម្លៃ — កំណត់សញ្ញាបំបែក (កំណត់តម្លៃនៃអថេរ FS ដែលភ្ជាប់មកជាមួយ);
-fឯកសារ - អត្ថបទកម្មវិធីត្រូវបានអានពីឯកសារជំនួសឱ្យបន្ទាត់ពាក្យបញ្ជា។ ការអានពីឯកសារច្រើនត្រូវបានគាំទ្រ។
-v var=value - ផ្តល់តម្លៃដែលត្រូវការទៅអថេរ;
−−
- សម្គាល់ចុងបញ្ចប់នៃបញ្ជីជម្រើស។
ឧទាហរណ៍លេខ 2
នៅក្នុងឧទាហរណ៍ខាងលើ ការស្វែងរកត្រូវបានធ្វើឡើងក្នុងឯកសារមួយ ប៉ុន្តែ AWK ក៏អាចទទួលយកលទ្ធផលនៃពាក្យបញ្ជាផ្សេងទៀតផងដែរ។ ចូរយើងព្យាយាមធ្វើឲ្យឧទាហរណ៍របស់យើងស្មុគស្មាញទៅតាម។
root@debian-wordpress:~# ឆ្មា /etc/mysql/my.cnf | awk '/bind-address/'
bind-address = 127.0.0.1
bind-address = 192.168.1.110
ដូចដែលអ្នកអាចឃើញលទ្ធផលលទ្ធផលនៅតែដដែលទោះបីជាការរចនាកាន់តែស្មុគស្មាញក៏ដោយ។ វាត្រូវតែនិយាយថានៅក្នុងឧទាហរណ៍នេះវាមិនត្រូវបានគេណែនាំឱ្យប្រើជម្រើសទីពីរទាំងស្រុងទេព្រោះវាមានភាពស្មុគស្មាញជាង។ ចូរយើងព្យាយាមពិចារណាស្ថានភាពផ្សេងទៀតដែលការប្រើប្រាស់ការរចនាបែបនេះនឹងមានភាពយុត្តិធម៌។
ឧទាហរណ៍លេខ 3
រាយតំណនិមិត្តសញ្ញា និងផ្លូវទៅកាន់ឯកសារគោលដៅ។
root@debian៖ ~# ls -l /bin/ | awk '/lrwxrwxrwx/ (បោះពុម្ព $9, $10, $11)'
bzcmp -> bzdiff
bzegrep -> bzgrep
bzfgrep -> bzgrep
bzless -> bzmore
lessfile -> បំពង់តិច
lsmod -> kmod
mt -> /etc/alternatives/mt
nc -> /etc/alternatives/nc
netcat -> /etc/alternatives/netcat
បើក -> openvt
pidof -> /sbin/killall5
rbash -> បាស
rnano -> ណាណូ
sh -> សញ្ញា
sh.distrib -> សញ្ញា
ការពន្យល់៖ កម្មវិធី awk គឺជាគូគំរូ ( លំនាំ) និងសកម្មភាព ( (សកម្មភាព)) ក៏ដូចជានិយមន័យនៃមុខងារកំណត់ដោយអ្នកប្រើប្រាស់។ គំរូ និងសកម្មភាពមើលទៅដូចនេះ៖ លំនាំ (សកម្មភាព) គំរូ ឬសកម្មភាពអាចត្រូវបានលុបចោល។ ក្នុងករណីទីមួយ សកម្មភាពនឹងត្រូវបានអនុវត្តនៅលើបន្ទាត់នីមួយៗ ហើយទីពីរ លទ្ធផលធម្មតាទៅកាន់អេក្រង់នឹងត្រូវបានអនុវត្ត ស្មើនឹងពាក្យបញ្ជា។(បោះពុម្ព). ពាក្យគន្លឹះទាំងនេះមិនអាចរួមបញ្ចូលជាមួយលំនាំផ្សេងទៀតបានទេ។.
ខ្សែអក្សរបញ្ចូលជាធម្មតាមានវាលដែលបំបែកដោយដកឃ្លា។ (ការកំណត់លំនាំដើមនេះអាចត្រូវបានផ្លាស់ប្តូរដោយប្រើអថេរដែលភ្ជាប់មកជាមួយ អេសឬជម្រើស -F កំណត់ព្រំដែន.) វាលត្រូវបានកំណត់ $1, $2, …; $0 សំដៅលើបន្ទាត់ទាំងមូល។
ឧទាហរណ៍លេខ 4
ដោយផ្អែកលើព័ត៌មានខាងលើ សូមក្រឡេកមើលឧទាហរណ៍មួយជាមួយនឹងការផ្លាស់ប្តូរសញ្ញាបំបែកលំនាំដើម - មើលបញ្ជីអ្នកប្រើប្រាស់ទាំងអស់ដោយគ្មានព័ត៌មានបន្ថែម។
root@debian៖ ~# awk -F ":" '(បោះពុម្ព $1)' /etc/passwd
ឫស
ដេមិន
ធុង
ស៊ីស
ធ្វើសមកាលកម្ម
ហ្គេម
បុរស
(ទិន្នផលពាក្យបញ្ជាត្រូវបានកាត់បន្ថយ)
ការពន្យល់៖ តាំងពីក្នុងឯកសារ /etc/passwdកំណត់ត្រាត្រូវបានរក្សាទុកក្នុងទម្រង់ " root:x:0:0:root:/root:/bin/bash", វាពិតជាឡូជីខលណាស់ក្នុងការជ្រើសរើសសញ្ញាសម្គាល់ជាសញ្ញាបំបែក ហើយបង្ហាញវាលដំបូងបំផុត ( $1 ) បន្ទាត់នីមួយៗ ( $0 ).
ឧទាហរណ៍លេខ 5
ទាំងអស់នៅក្នុងឯកសារដូចគ្នាជាមួយអ្នកប្រើប្រាស់ អ្នកអាចរាប់លេខរបស់ពួកគេ។
root@debian៖ ~# awk 'END (បោះពុម្ព NR)' /etc/passwd
25
ការពន្យល់៖ គំរូពិសេស ចាប់ផ្តើមនិង ចប់អាចត្រូវបានប្រើដើម្បីទទួលបានការគ្រប់គ្រង មុនពេលអានបន្ទាត់បញ្ចូលទីមួយ និងបន្ទាប់ពីអានបន្ទាត់បញ្ចូលចុងក្រោយរៀងៗខ្លួន។
Awk គឺជាអ្នកកែសម្រួលស្ទ្រីមជាមូលដ្ឋានដូចជា sed ។ អ្នកអាចបញ្ចូលអត្ថបទទៅក្នុងកម្មវិធីនេះ ហើយវាអាចរៀបចំវាតាមបន្ទាត់។ កម្មវិធីក៏អាចអានពីឯកសារផងដែរ។ Awk ក៏ជាភាសាសរសេរកម្មវិធីផងដែរ។ នេះមានន័យជាមូលដ្ឋានថា awk អាចធ្វើអ្វីគ្រប់យ៉ាងដែល sed អាចធ្វើបាន និងច្រើនទៀត។
មិនដូច sed ទេ awk អាចចងចាំបរិបទ ធ្វើការប្រៀបធៀប និងអ្វីៗជាច្រើនទៀតដែលភាសាសរសេរកម្មវិធីផ្សេងទៀតអាចធ្វើបាន។ ជាឧទាហរណ៍ វាមិនត្រូវបានកំណត់ចំពោះបន្ទាត់តែមួយទេ។ ដោយមានជំនាញត្រឹមត្រូវ វាអាចភ្ជាប់ខ្សែជាច្រើន។
ទម្រង់សាមញ្ញបំផុតនៃ awk មើលទៅដូចនេះ:
Awk "(សកម្មភាពខ្លះនៅទីនេះ)"
"Some_action_here" អាចជាកន្សោមសាមញ្ញមួយដើម្បីបោះពុម្ពលទ្ធផល ឬអ្វីដែលស្មុគស្មាញជាងនេះ។ វាក្យសម្ព័ន្ធគឺស្រដៀងនឹងភាសាសរសេរកម្មវិធី "C" ។ ឧទាហរណ៍សាមញ្ញ៖
Awk "(បោះពុម្ព $1, $3)"
មានន័យថាបោះពុម្ពជួរឈរទីមួយ និងទីបី ដែលជួរឈរមានន័យថា "វត្ថុដែលបំបែកដោយចន្លោះស"។ ចន្លោះពណ៌ស = ផ្ទាំង ឬចន្លោះ។
ឧទាហរណ៍ផ្ទាល់៖
បន្ទរ "1 2 3 4" | awk "(បោះពុម្ព $1,$3)" 1 3
ផ្នែកទីពីរ៖ តើ AWK អាចធ្វើអ្វីបាន?
គោលបំណងសំខាន់របស់ AWK ក្នុងជីវិតគឺដើម្បីរៀបចំការបញ្ចូលរបស់វាតាមបន្ទាត់មួយៗ។ កម្មវិធី awk ជាធម្មតាដំណើរការក្នុងរចនាប័ទ្ម
ប្រសិនបើអ្វីដែលអ្នកចង់ធ្វើមិនសមនឹងម៉ូដែលនេះ នោះ awk ប្រហែលជាមិនសមនឹងគំនិតរបស់អ្នកទេ។
វាក្យសម្ព័ន្ធធម្មតាដែលប្រើក្នុងការសរសេរកម្មវិធី awk អាចត្រូវបានពិពណ៌នាដូចខាងក្រោមៈ
គំរូ Awk (ពាក្យបញ្ជា)
នេះមានន័យថា
“សូមមើលបន្ទាត់បញ្ចូលនីមួយៗ ដើម្បីមើលថាតើមានលំនាំនៅទីនោះឬអត់។ ប្រសិនបើវានៅទីនោះ រត់អ្វីដែលនៅចន្លោះ ()"
អ្នកអាចរំលង SAMPLE ឬ Command
ប្រសិនបើអ្នកមិនបញ្ជាក់លំនាំទេ ពាក្យបញ្ជានឹងត្រូវបានអនុវត្តទៅគ្រប់បន្ទាត់។
ប្រសិនបើពាក្យបញ្ជាត្រូវបានលុបចោល នោះវាស្មើនឹងការបញ្ជាក់ (គ្រាន់តែបោះពុម្ពបន្ទាត់)៖
(បោះពុម្ព)
ឧទាហរណ៍ជាក់លាក់៖
Awk "/#/ (បោះពុម្ព "មានមតិយោបល់លើបន្ទាត់នេះ")" /etc/hosts
នឹងបោះពុម្ព "បន្ទាត់នេះមានមតិយោបល់" សម្រាប់គ្រប់បន្ទាត់ដែលមានយ៉ាងហោចណាស់មួយ "#" កន្លែងណាមួយនៅលើបន្ទាត់ក្នុង /etc/hosts
ការកែប្រែសម្រាប់ភាពច្បាស់លាស់
Awk "/#/ (បោះពុម្ព $0 ":\t មានមតិនៅលើបន្ទាត់នេះ)" /etc/hosts
ធាតុ "//" នៅក្នុងលំនាំគឺជាវិធីមួយដើម្បីបញ្ជាក់ការផ្គូផ្គង។ វាក៏មានវិធីផ្សេងទៀតដើម្បីកំណត់ថាតើខ្សែអក្សរត្រូវគ្នាដែរឬទេ។ ឧ.
Awk "$1 =="#" (បោះពុម្ព "បន្ទាត់ចាប់ផ្តើមដោយសញ្ញា")" /etc/hosts
នឹងផ្គូផ្គងជួរដេកដែលជួរឈរដំបូងគឺ "#" តែមួយ។ លំដាប់នៃតួអក្សរ "==" មានន័យថាការផ្គូផ្គងជាក់លាក់នៃជួរទីមួយទាំងមូល។
ការកែប្រែសម្រាប់ភាពច្បាស់លាស់៖
Awk "$1 =="#" (បោះពុម្ព $0 "\tline ចាប់ផ្តើមដោយ hash)" /etc/hosts
ម្យ៉ាងវិញទៀត ប្រសិនបើអ្នកចង់បានការផ្គូផ្គងផ្នែកនៃជួរឈរជាក់លាក់មួយ សូមប្រើសញ្ញា "~"
Awk "$1 ~ /#/ (បោះពុម្ព "កន្លែងណាមួយមានសញ្ញានៅក្នុងជួរទី 1")" /etc/hosts
សូមចងចាំថា ជួរទីមួយអាចនៅក្រោយកន្លែងពណ៌ស។
ការកែប្រែសម្រាប់ភាពច្បាស់លាស់៖
Awk "$1 ~ /#/ (បោះពុម្ព $0 "\tមានសញ្ញាមួយនៅត្រង់ជួរទី 1)" /etc/hosts
ការបញ្ចូល "#comment" នឹងត្រូវគ្នា។
ការបញ្ចូល "#comment" នឹងដូចគ្នាផងដែរ។
ប្រសិនបើអ្នកចង់បានការផ្គូផ្គងជាក់លាក់នៃ "ខ្សែអក្សរដែលចាប់ផ្តើមដោយពិតប្រាកដ # និងដកឃ្លា" អ្នកនឹងប្រើ
អាក់ "/^# / (ធ្វើអ្វីមួយ)"
ការប្រកួតជាច្រើន។
Awk នឹងដំណើរការលំនាំទាំងអស់ដែលត្រូវនឹងបន្ទាត់បច្ចុប្បន្ន។ ដូច្នេះប្រសិនបើយើងប្រើឧទាហរណ៍ខាងក្រោម
Awk " /// (បោះពុម្ព "មានមតិយោបល់") $1 =="#" (បោះពុម្ព "មតិយោបល់ក្នុងជួរទីមួយ") /^# / (បោះពុម្ព "មតិយោបល់នៅដើមដំបូង") " /etc/hosts
ធាតុចំនួន 3 នឹងត្រូវបានចេញសម្រាប់បន្ទាត់ដូចខាងក្រោម:
#នេះជាមតិ
ធាតុពីរសម្រាប់
# នេះជាមតិចូលបន្ទាត់
និងតែមួយគត់សម្រាប់
1.2.3.4 ឈ្មោះម៉ាស៊ីន # មតិចុងក្រោយ
ការតាមដានបរិបទ
មិនមែនខ្សែទាំងអស់ត្រូវបានបង្កើតស្មើគ្នាទេ បើទោះបីជាពួកវាមើលទៅដូចគ្នាក៏ដោយ។ ពេលខ្លះអ្នកចង់ធ្វើអ្វីមួយទៅខ្សែមួយអាស្រ័យលើបន្ទាត់ដែលមកមុនវា។
នេះជាឧទាហរណ៍រហ័សដែលបោះពុម្ពបន្ទាត់ "ADDR" ប្រសិនបើអ្នកមិននៅក្នុងផ្នែក "សម្ងាត់"
Awk " /secretstart/ (secretstart/ (secret=1) /ADDR/ ( if(secret==0) print $0) /* $0 គឺជាបន្ទាត់ពេញលេញ */ /secretend/ (secret=0)"
ខាងក្រោមនឹងបោះពុម្ពមាតិកាដែលមាន "ADDR" នៅខាងក្នុង លុះត្រាតែឃើញខ្សែអក្សរ "secretstart" ប៉ុណ្ណោះ។ ការបញ្ជាទិញបញ្ហា។ ឧទាហរណ៍ប្រសិនបើអ្នកសរសេរវាដូចនេះ៖
Awk " /ADDR/ (ប្រសិនបើ (secret==0) បោះពុម្ព $0) /* $0 គឺជាបន្ទាត់ពេញលេញ */ /secretstart/ (secret=1) /secretend/ (secret=0)"
និងផ្តល់ការបញ្ចូលដូចខាងក្រោម
ADDR a addr secretstart ADDR a secret addr ADDR មួយទៀត secret addr សម្ងាត់ទីបី ADDR secretend ADDR ធម្មតាផងដែរ
បន្ទាប់មកកម្មវិធីបន្ថែម "សម្ងាត់" ដំបូងនឹងត្រូវបានបោះពុម្ព។ ដែលបានផ្តល់ឱ្យថាឧទាហរណ៍ដើមនឹងលាក់អាថ៌កំបាំងទាំងពីរ។
ផ្នែកទីបី៖ អថេរពិសេស
យើងបាននិយាយរួចហើយអំពីវាក្យសម្ព័ន្ធ awk ធម្មតា។ ឥឡូវនេះសូមចាប់ផ្តើមមើលម៉ូដទាន់សម័យ។
awk មានខ្សែអក្សរដែលត្រូវគ្នា "ពិសេស"៖ " ចាប់ផ្តើម"ហើយ" ចប់"
សេចក្តីណែនាំ ចាប់ផ្តើមហៅម្តងមុនពេលអានជួរណាមួយពីទិន្នន័យ មិនដែលម្តងទៀតទេ។
សេចក្តីណែនាំ ចប់ហៅបន្ទាប់ពីបន្ទាត់ទាំងអស់ត្រូវបានអាន។ ប្រសិនបើឯកសារជាច្រើនត្រូវបានផ្តល់ឱ្យ នោះវាត្រូវបានហៅតែបន្ទាប់ពីឯកសារចុងក្រោយបំផុតបានបញ្ចប់។
ជាធម្មតាអ្នកនឹងប្រើ ចាប់ផ្តើមសម្រាប់ការចាប់ផ្តើមផ្សេងគ្នា និង ចប់សម្រាប់ការសង្ខេបឬការសម្អាត។
BEGIN ( maxerrors=3 ; logfile=/var/log/something ; tmpfile=/tmp/blah) ... ( blah blah blah ) /^header/ ( headercount += 1 ) END ( printf("ក្បាលសរុបត្រូវបានរាប់=% d\n", ចំនួនបឋមកថា);
ឧទាហរណ៍នេះនឹងរាប់ចំនួនដងដែល "បឋមកថា" លេចឡើងក្នុងឯកសារបញ្ចូល ហើយបោះពុម្ពសរុបបន្ទាប់ពីដំណើរការឯកសារទាំងមូលបានបញ្ចប់។
AWK ក៏មានតម្លៃពិសេសជាច្រើនទៀតដែលអ្នកអាចប្រើនៅក្នុងផ្នែក ( )។ ឧ.
បោះពុម្ព NF
នឹងផ្តល់ឱ្យអ្នកនូវចំនួនសរុបនៃជួរឈរ (ចំនួនវាល) ក្នុងជួរបច្ចុប្បន្ន។ FILENAMEនឹងជាឈ្មោះឯកសារបច្ចុប្បន្ន ដោយបញ្ជាក់ថាឈ្មោះឯកសារត្រូវបានបញ្ជូនទៅ awk ជាជាងប្រើបំពង់។
អ្នកមិនអាចផ្លាស់ប្តូរបានទេ។ NFដោយខ្លួនឯង។
ដូចគ្នាជាមួយនឹងអថេរ NRដែលប្រាប់អ្នកពីចំនួនជួរដែលអ្នកបានដំណើរការ។ ("ចំនួនកំណត់ត្រា" - ចំនួនកំណត់ត្រា)
មានអថេរពិសេសផ្សេងទៀត សូម្បីតែមួយដែលអ្នកអាចផ្លាស់ប្តូរនៅពាក់កណ្តាលកម្មវិធី។
ផ្នែកទី 4៖ ឧទាហរណ៍សាមញ្ញ Awk
ដើម្បីបង្ហាញនិងពង្រឹងអ្វីដែលបាននិយាយ សូមយើងមើលឧទាហរណ៍ជាក់លាក់មួយចំនួន។ សម្រាប់ពួកគេយើងនឹងត្រូវការឯកសារអត្ថបទតូចៗចំនួនបី។
សម្រាប់ឧទាហរណ៍ខាងក្រោម ចូរយើងបង្កើតឯកសារ field_data.txt ដែលមានខ្លឹមសារដូចខាងក្រោម៖
ផ្កាកុលាបមានពណ៌ក្រហម ពណ៌ស្វាយមានពណ៌ខៀវ ស្ករគឺផ្អែម ហើយអ្នកក៏ដូចគ្នាដែរ។
Echo -e "ផ្កាកុលាបមានពណ៌ក្រហម\nViolets មានពណ៌ខៀវ\nស្ករគឺផ្អែម\nហើយអ្នកក៏ដូចគ្នាដែរ"។ >field_data.txt
តោះបង្កើតឯកសារ letters.txt ដែលមានខ្លឹមសារដូចខាងក្រោម
A bb ccc dddd ggg hh i
នៅលើបន្ទាត់ពាក្យបញ្ជាអ្នកអាចធ្វើដូចនេះ:
Echo -e "a\nbb\nccc\ndddd\nggg\nhh\ni" > letters.txt
ជាចុងក្រោយ ចូរយើងបង្កើតឯកសារ mail-data ដែលមានខ្លឹមសារដូចខាងក្រោម៖
អាមេលា 555-5553 [អ៊ីមែលការពារ] F Anthony 555-3412 [អ៊ីមែលការពារ]បេកគី ៥៥៥-៧៦៨៥ [អ៊ីមែលការពារ]វិក័យប័ត្រ 555-1675 [អ៊ីមែលការពារ] A Broderick 555-0542 [អ៊ីមែលការពារ] R Camilla 555-2912 [អ៊ីមែលការពារ] R Fabius 555-1234 [អ៊ីមែលការពារ] F Julie 555-6699 [អ៊ីមែលការពារ] F Martin 555-6480 [អ៊ីមែលការពារ]សាំយូអែល 555-3430 [អ៊ីមែលការពារ]ហ្សង់-ប៉ូល ៥៥៥-២១២៧ [អ៊ីមែលការពារ]រ
នេះអាចត្រូវបានធ្វើនៅលើបន្ទាត់ពាក្យបញ្ជាដូចនេះ:
Wget https://raw.githubusercontent.com/tdhopper/awk-lessons/master/data/mail-data -O mail-data
គំរូសាមញ្ញ (គំរូ)
ប្រសិនបើយើងត្រូវការបន្ទាត់វែងជាងពីរតួអក្សរ ហើយយើងចង់ប្រើសកម្មភាពលំនាំដើម ( បោះពុម្ព) បន្ទាប់មកយើងទទួលបាន៖
Awk "ប្រវែង $0 > 2" letters.txt bb ccc dddd ggg hh
$0 គឺជាអថេរដែលភ្ជាប់មកជាមួយដែលមានខ្សែអក្សរ។
មុខងារសាមញ្ញ
ប្រសិនបើយើងមិនបញ្ជាក់លំនាំទេនោះ បន្ទាត់នីមួយៗនឹងត្រូវគ្នា។ សកម្មភាពតូចតាចមួយនឹងបោះពុម្ពបន្ទាត់នីមួយៗ៖
Awk "(បោះពុម្ព)" letters.txt a bb ccc dddd ggg hh i
ការប្រើប្រាស់មុខងារ ប្រវែងជាសកម្មភាពរបស់យើង យើងអាចទទួលបានប្រវែងនៃបន្ទាត់នីមួយៗ៖
Awk "( ប្រវែងបោះពុម្ព )" letters.txt 1 2 3 4 3 2 1
សកម្មភាពនេះអនុវត្តដោយគ្មានលក្ខខណ្ឌចំពោះជួរទាំងមូល។ យើងក៏អាចបញ្ជាក់រឿងនេះឱ្យច្បាស់ផងដែរ៖
Awk "( ប្រវែងបោះពុម្ព $0 )" letters.txt 1a 2bb 3ccc 4dddd 3ggg 2hh 1i
Awk មានការគ្រប់គ្រងពិសេសសម្រាប់ដំណើរការកូដមួយចំនួន មុនពេលការបញ្ចូលឯកសារចាប់ផ្តើម និងបន្ទាប់ពីការបំពេញឯកសារ។
Awk "BEGIN (បោះពុម្ព "HI") (បោះពុម្ព $0) END (បោះពុម្ព "BYE!")" letters.txt HI a bb ccc dddd ggg hh i BYE!
យើងអាចមាន ធាតុជាច្រើនទៀតគ្រប់គ្រងកំឡុងពេលបោះពុម្ពដោយប្រើ បោះពុម្ព.
Awk "BEGIN ( printf "%-10s %s\n", "ឈ្មោះ", "លេខ" \ printf "%-10s %s\n", "----", "------" ) \ ( printf "%-10s %s\n", $1, $2 )" mail-data Name Number ---- ------ Amelia 555-5553 Anthony 555-3412 Becky 555-7685 Bill 555-1675 Broderick 555-0542 Camilla 555-2912 Fabius 555-1234 Julie 555-6699 Martin 555-6480 Samuel 555-3430 Jean-Paul 555-2127
ការរួមបញ្ចូលគ្នានៃគំរូនិងមុខងារ
ជាការពិតណាស់ លំនាំ និងមុខងារអាចត្រូវបានផ្សំគ្នា ដូច្នេះមុខងារនឹងត្រូវបានអនុវត្តលុះត្រាតែខ្សែអក្សរត្រូវគ្នានឹងលំនាំ។
យើងអាចបោះពុម្ពប្រវែងបន្ទាត់ទាំងអស់ដែលវែងជាង 2 តួអក្សរ។
Awk "length($0) > 2 ( print length($0))" letters.txt 3 4 3
តាមពិតទៅ យើងមិនចាំបាច់ដាក់កម្រិត Awk ត្រឹមតែគំរូមួយទេ! យើងអាចមានចំនួនលំនាំតាមអំពើចិត្ត ដែលកំណត់ដោយសញ្ញាក្បៀស ឬបន្ទាត់ថ្មី៖
Awk "length($0) > 2 ( print "Long:" length($0)); length($0)< 2 { print "Short: " length($0) }" letters.txt Short: 1 Long: 3 Long: 4 Long: 3 Short: 1
វាលជាច្រើន។
Awk ត្រូវបានរចនាឡើងសម្រាប់ដំណើរការទិន្នន័យសាមញ្ញជាមួយនឹងវាលជាច្រើនក្នុងមួយជួរ។ សញ្ញាបំបែកវាលអាចត្រូវបានបញ្ជាក់ដោយគ្រាប់ចុច -F.
ឧទាហរណ៍នៃឯកសារដែលកំណត់ព្រំដែនគឺជាដកឃ្លា៖
Awk "( print )" field_data.txt ផ្កាកុលាបមានពណ៌ក្រហម ពណ៌ស្វាយមានពណ៌ខៀវ ស្ករគឺផ្អែម ហើយអ្នកក៏ដូចគ្នាដែរ។
ប្រសិនបើយើងបញ្ជាក់អ្នកបំបែកវាល យើងអាចបោះពុម្ពវាលទីពីរនៃបន្ទាត់នីមួយៗ៖
Awk -F " " "( បោះពុម្ព $2 )" field_data.txt គឺដូច្នេះ
យើងនឹងមិនទទួលបានកំហុសទេ ប្រសិនបើជួរដេកមិនមានវាលដែលត្រូវគ្នា យើងនឹងបង្ហាញបន្ទាត់ទទេ៖
Awk -F " " "( បោះពុម្ព $4 )" field_data.txt អ្នក។
ដោយសារសញ្ញាបំបែកលំនាំដើមគឺជាចន្លោះមួយ ពាក្យបញ្ជាពីមុននឹងផ្តល់លទ្ធផលដូចគ្នាដោយមិនប្រើជម្រើស -F ។សម្រាប់ឧទាហរណ៍ដែលមានន័យជាងនេះ ចូរយើងបង្កើតឯកសារមួយទៀត។ rates.txtជាមួយនឹងខ្លឹមសារដូចខាងក្រោម៖
Pilcrow, Humphrey, 3 Pilcrow, Zora, 1 Plinius, Oldone, 4 Razniecki, Anton, 7 Russell, Bertrand, 0
ឥឡូវនេះយើងបង្ហាញជាសញ្ញាបំបែក , (សញ្ញាក្បៀស) ហើយបង្ហាញមាតិកានៃជួរទីពីរ៖
Awk -F "," "(បោះពុម្ព $2 )" rates.txt Humphrey Zora Oldone Anton Bertrand
កន្សោមកំណត់ព្រំដែនត្រូវបានបកស្រាយថាជាកន្សោមធម្មតា។
Awk -F "((so)?are|is) " "(print "Field 1: " $1 "\nField 2: " $2)" field_data.txt Field 1: Roses Field 2: red, Field 1: Violets Field 2 :blue, Field 1: Sugar Field 2: sweet, Field 1: And Field 2: you.
កន្សោមធម្មតា។
លំនាំអាចជាកន្សោមធម្មតា មិនមែនគ្រាន់តែជាមុខងារដែលភ្ជាប់មកជាមួយនោះទេ។
យើងអាចប្រើកន្សោមធម្មតាដើម្បីស្វែងរកពាក្យទាំងអស់ក្នុងពិភពយូនីកដោយមានស្រៈ 5 ជាប់គ្នា។
Awk "/(5)/" /usr/share/dict/words cadiueio Chaouia euouae Guauaenok
បញ្ជូនអថេរទៅកម្មវិធី
ជម្រើស -vសម្រាប់ Awk អនុញ្ញាតឱ្យយើងបញ្ជូនអថេរទៅក្នុងកម្មវិធី។ ឧទាហរណ៍ យើងអាចប្រើវាសម្រាប់កូដថេរ។
Awk -v pi = 3.1415 "BEGIN (បោះពុម្ព pi)" 3.1415
យើងក៏អាចប្រើផងដែរ។ -vដើម្បីឆ្លងកាត់អថេរ Bash ជាអថេរ Awk
Awk -v user=$USER "BEGIN (អ្នកប្រើប្រាស់បោះពុម្ព)" mial
កន្សោមប្រសិនបើផ្សេងទៀត។
ប្រសិនបើ - ផ្សេងទៀត។កន្សោមនៅក្នុង Awk មើលទៅដូចនេះ៖
ប្រសិនបើ (លក្ខខណ្ឌ) រាងកាយ - បន្ទាប់មក
ឧទាហរណ៍៖
បោះពុម្ព "1\n2\n3\n4" | awk \"( \ if ($1 %2 == 0) បោះពុម្ព $1 "គឺស្មើ"; \ else print $1 "គឺសេស" \)" 1 គឺសេស 2 គឺសូម្បីតែ 3 គឺសេស 4 គឺគូ
វដ្ត
Awk រួមបញ្ចូលកន្សោមរង្វិលជុំជាច្រើន៖ ខណៈពេលដែល, ធ្វើខណៈពេលដែលនិង សម្រាប់.
ពួកគេមានវាក្យសម្ព័ន្ធ C ដែលរំពឹងទុក។
Awk\"BEGIN(\i=0;\while(i< 5) { print i; i+=1; } \ }" 0 1 2 3 4 awk \ "BEGIN { \ i = 0; \ do { print i; i+=1; } while(i < 0) \ }" 0 awk \ "BEGIN { \ i = 0; \ for(i = 0; i<5; i++) print i \ }" 0 1 2 3 4
សម្រាប់ក៏អាចកំណត់រង្វិលជុំតាមរយៈគ្រាប់ចុចអារេ ដែលនឹងត្រូវបានពិភាក្សានៅពេលក្រោយ។
ផ្នែកទី ៥៖ មុខងារហៅទូរសព្ទ
សមាសធាតុបន្ទាប់របស់ AWK គឺជាមុខងារពិសេសទាំងអស់របស់វា។
AWK មានលក្ខណៈពិសេសដែលនឹងធ្វើឱ្យអ្នកសរសេរកម្មវិធី C ជាមធ្យមសប្បាយចិត្តណាស់។ នៅទីនេះមានរឿងដូចជា sin()/cos()/tan(), rand(), index(), sprintf(), tolower(), system()
មុខងារត្រូវបានដាក់ជាក្រុម ហើយអាចមើលបានដូចខាងក្រោម៖
គណិតវិទ្យា
+, -, /, *, sin(), cos(), tan(), atan(), sqrt(), rand(), srand()
ពួកគេនិយាយដោយខ្លួនឯង យ៉ាងហោចណាស់ខ្ញុំចង់គិតដូច្នេះ។
Awk -v pi=3.1415 "BEGIN (បោះពុម្ព exp(1), log(exp(1)), sqrt(2), sin(pi), cos(pi), atan2(pi, 2))" 2.71828 1 1.41421 9.26536 e-05 -1 1.00387
កម្មវិធីអាចបង្កើតលេខចៃដន្យក្នុងជួរ (0, 1)។
តាមលំនាំដើម Awk ចាប់ផ្តើមពីការចាប់ផ្តើមដូចគ្នា (គ្រាប់ពូជ) សម្រាប់ Awk ។ ការរត់ពាក្យបញ្ជានេះពីរដងក្នុងមួយជួរនឹងផ្តល់លទ្ធផលដូចគ្នា៖
Awk "BEGIN (print rand(); print rand())" 0.237788 0.291066
ដើម្បីកំណត់ការចាប់ផ្តើម (គ្រាប់ពូជ) អ្នកអាចប្រើមុខងារ srand:
Awk "BEGIN (srand(10); print rand(); print rand())" 0.255219 0.898883 awk "BEGIN (srand(10); print rand(); print rand())" 0.255219 0.898883
មុខងារ intត្រឡប់ "ចំនួនគត់ជិតបំផុតទៅ x រវាង x និងសូន្យ ជាមួយនឹងការបោះចោលសូន្យនាំមុខ។"
Awk "BEGIN (បោះពុម្ព "int(0.9) = "int(0.9); បោះពុម្ព "int(-0.9) = "int(-0.9))" int(0.9) = 0 int(-0.9) = 0
ការរៀបចំខ្សែអក្សរ
- សន្ទស្សន៍()នឹងប្រាប់អ្នកថាតើ ហើយប្រសិនបើដូច្នេះនៅកន្លែងណា ខ្សែអក្សរកើតឡើងនៅក្នុងខ្សែអក្សររង។
- ប្រកួត()ស្រដៀងគ្នា ប៉ុន្តែដំណើរការសម្រាប់កន្សោមធម្មតា។
- sprintf()ផ្តល់ឱ្យអ្នកនូវវិធីដើម្បីធ្វើទ្រង់ទ្រាយលទ្ធផល និងធ្វើការបំប្លែងតាមវិធីនេះ។ នេះគួរតែស្គាល់អ្នកដែលធ្លាប់ប្រើ printf() ជាមួយ C. ឧទាហរណ៍។
"បោះពុម្ពខ្សែអក្សរថ្មី។%d
"" និយាយថា "បោះពុម្ពតម្លៃដែលត្រូវនឹងខ្ញុំជាលេខទសភាគ"%s
" និយាយថា "បោះពុម្ពតម្លៃដែលត្រូវនឹងខ្ញុំជាខ្សែអក្សរ"
ទាំងនោះ។ ប្រសិនបើអ្នកចង់ភ្ជាប់ពីរបន្ទាត់ដោយមិនមានការបំបែកនោះ វិធីមួយនឹងត្រូវប្រើ
- Newstring=sprintf("%s%s", មួយ, ពីរ)ប្រវែង ()
មុខងារ គ្រាន់តែផ្តល់ឱ្យអ្នកនូវវិធីងាយស្រួលក្នុងការរាប់ចំនួនតួអក្សរក្នុងបន្ទាត់មួយ ប្រសិនបើអ្នកត្រូវការវា។ substr(s,m,n) នឹងត្រឡប់ខ្សែអក្សររងចូល- តួអក្សរចាប់ផ្តើមពីទីតាំង មរាប់ចាប់ពី 1 ។
Awk "(បោះពុម្ព $1, substr($1, 2, 3))" field_data.txt Roses ose Violets iol Sugar uga And nd
សន្ទស្សន៍(s, t)ត្រឡប់ 'ទីតាំងនៅក្នុង សដែលបន្ទាត់កើតឡើង tឬ 0 ប្រសិនបើវាមិនកើតឡើង។`
គំរូសម្រាប់លិបិក្រមមិនមែនជាកន្សោមធម្មតាទេ។
Awk "( បោះពុម្ព $1, index($1, "s") )" field_data.txt Roses 3 Violets 7 Sugar 0 និង 0
ការប្រកួត(s, r)ត្រឡប់ទីតាំងនៅក្នុង សដែលកន្សោមធម្មតាកើតឡើង rឬ 0 ប្រសិនបើវាមិនកើតឡើង។ អថេរ RSTARTនិង ប្រវែងត្រូវបានកំណត់ទៅទីតាំង និងប្រវែងនៃខ្សែដែលត្រូវគ្នា។
ការប្រកួត- ថាម៉េច សន្ទស្សន៍លើកលែងតែគំរូគឺជាកន្សោមធម្មតា។
Awk "( print $1, match($1, "") )" field_data.txt Roses 3 Violets 7 Sugar 1 And 0 # "Find three or more repeating letters" awk "( match($1, "(3)"); print $1, "\tpattern start:", RSTART, "\tpattern end:", RLENGTH )" letters.txt a pattern start: 0 pattern end: -1 bb pattern start: 0 pattern end: -1 ccc pattern start: 1 pattern បញ្ចប់៖ 3 dddd pattern start: 1 pattern end: 3 ggg pattern start: 1 pattern end: 3 hh pattern start: 0 pattern end: -1 i pattern start: 0 pattern end: -1
បំបែក (s, a, fs)បំបែកខ្សែអក្សរទៅជាអារេនៃធាតុ a, a, …, a និង ត្រឡប់ នឹងត្រឡប់ខ្សែអក្សររងចូល.
ការបែងចែកត្រូវបានធ្វើឡើងដោយការបញ្ចេញមតិធម្មតា។ fsឬជាមួយឧបករណ៍បំបែកវាល អេស, ប្រសិនបើ fsមិនត្រូវបានផ្តល់ឱ្យ។ ខ្សែអក្សរទទេជាឧបករណ៍បំបែកវាលបំបែកខ្សែអក្សរទៅជាអារេនៃធាតុដោយតួអក្សរ។
Awk "BEGIN ( print split("It-was_the-best_of-times", output_array, "[-_]"), output_array, output_array )" 6 គឺល្អបំផុត
រង (r, t, s)ជំនួសដោយ tការកើតឡើងដំបូងនៃការបញ្ចេញមតិធម្មតា។ rនៅក្នុងបន្ទាត់ ស. ប្រសិនបើ s មិនត្រូវបានផ្តល់ឱ្យ, បន្ទាប់មកប្រើ $0
សគឺជាខ្សែដែលការជំនួសកើតឡើង។ ជំនួសឱ្យការត្រឡប់ខ្សែថ្មីជាមួយនឹងការជំនួសដែលបានធ្វើ ចំនួននៃការជំនួសដែលបានធ្វើ (0 ឬ 1) នឹងត្រូវបានត្រឡប់មកវិញ។
Awk "BEGIN (s = "វាជាពេលវេលាល្អបំផុត វាជាពេលវេលាដ៏អាក្រក់បំផុត"; \ print "Num. matches replaced:", sub("times", "gifs", s); \ print s )" លេខ ការប្រកួតត្រូវបានជំនួស: 1 វាគឺជាការល្អបំផុតនៃ gifs វាជាពេលវេលាដ៏អាក្រក់បំផុត
gsubធ្វើដូចគ្នានឹង រងលើកលែងតែរាល់ការកើតឡើងនៃកន្សោមធម្មតាត្រូវបានជំនួស។ រងនិង gsubត្រឡប់ចំនួននៃការជំនួស។
Awk "BEGIN (s = "វាជាពេលវេលាល្អបំផុត វាជាពេលវេលាដ៏អាក្រក់បំផុត"; \ print "Num. matches replaced:", gsub("times", "cats", s); \ print s)" លេខ ការផ្គូផ្គងជំនួស៖ 2 វាល្អបំផុតសម្រាប់ឆ្មា វាអាក្រក់បំផុតនៃឆ្មា sprintf sprintf(fmt, expr, ...) ត្រឡប់ខ្សែអក្សរដែលមកពីការធ្វើទ្រង់ទ្រាយ expr ... យោងទៅតាមទម្រង់ printf(3) fmt awk "BEGIN ( x = sprintf("[%8.3f]", 3.141592654); បោះពុម្ព x )" [ 3.142]
មុខងារកម្រិតប្រព័ន្ធ
ប្រព័ន្ធ()អនុញ្ញាតឱ្យអ្នកហៅឯកសារដែលអាចប្រតិបត្តិបានណាមួយដែលមានសក្តានុពលនៅលើប្រព័ន្ធ។ កម្មវិធីគោលដៅអាចស្ថិតនៅក្នុងរបស់អ្នក។ $PATHឬអ្នកអាចបញ្ជាក់វាដោយប្រើផ្លូវដាច់ខាត។
ឧទាហរណ៍គួរឱ្យខ្លាច
ប្រព័ន្ធ("rm -rf $HOME");
ប្រព័ន្ធ("/ធុង/សម្លាប់ 1")
បើអ្នកចង់ធ្វើរឿងស្មុគស្មាញជាងនេះ អ្នកប្រហែលជានឹងបញ្ចប់ការធ្វើអ្វីមួយដូចជា
Sysstring=sprintf("ពាក្យបញ្ជាមួយចំនួន %s %s", arg1, arg2);
ប្រព័ន្ធ (ប្រព័ន្ធ)បិទ () ជាលក្ខណៈសំខាន់មួយដែលច្រើនតែត្រូវបានគេមើលរំលង។ នេះប្រហែលជាដោយសារមិនមានការហៅច្បាស់លាស់បើក () ប្រព័ន្ធ (ប្រព័ន្ធ)នោះហើយជាមូលហេតុដែលមនុស្សមិនគិតពីបញ្ហាប្រឈម
. ហើយសម្រាប់គោលបំណងភាគច្រើនវាមិនចាំបាច់ទេ។ ប៉ុន្តែអ្នកត្រូវតែធ្វើដូចនេះ ប្រសិនបើអ្នកកំពុងដោះស្រាយជាមួយឯកសារលទ្ធផលច្រើនជាងមួយ។
Awk ផ្តល់ឱ្យអ្នកនូវសមត្ថភាពក្នុងការបើកឯកសារបំពានភ្លាមៗ។ ឧទាហរណ៍
/^file/ (បោះពុម្ព $3 >> $2)
គួរតែយកបន្ទាត់ "file output here-is-a-word" បើកឯកសារ "output" ហើយបោះពុម្ព "here-is-a-word" ចូលទៅក្នុងវា។
AWK គឺ "ឆ្លាត" ដែលវាតាមដានឯកសារដែលអ្នកបើក ហើយទុកវាឱ្យបើក។ វាសន្មត់ថាប្រសិនបើអ្នកបើកឯកសារម្តង អ្នកទំនងជានឹងធ្វើវាម្តងទៀត។ ជាអកុសល នេះមានន័យថា ប្រសិនបើអ្នកបើកឯកសារច្រើន អ្នកអាចនឹងអស់ឯកសារពិពណ៌នា។ ដូច្នេះនៅពេលដែលអ្នកដឹងថាអ្នកបានបញ្ចប់ជាមួយឯកសារមួយ សូមបិទវា។ ដូច្នេះ ដើម្បីកែលម្អឧទាហរណ៍ខាងលើ អ្នកគួរតែប្រើអ្វីមួយដូចជាបន្ទាត់ខាងក្រោម៖
/^file/ (ប្រសិនបើ ($2 != oldfile) ( close(oldfile)); បោះពុម្ព $3 >> $2 ; oldfile = $2;)
ផ្នែកទីប្រាំមួយ៖ អារេ
គំនិតអារេ
យើងបានមើលអថេរជាឈ្មោះដែលមានតម្លៃរួចហើយ។ អារេគឺជាផ្នែកបន្ថែមនៃអថេរ។ អារេគឺជាអថេរដែលមានតម្លៃច្រើនជាងមួយ។ ពួកវាអាចមានតម្លៃលើសពីមួយ ព្រោះតម្លៃនីមួយៗមានលេខរៀងៗខ្លួន។
ប្រសិនបើអ្នកត្រូវការតម្លៃបី អ្នកអាចនិយាយថា៖
តម្លៃ 1 = "មួយ"; តម្លៃ 2 = "ពីរ"; តម្លៃ 3 = "បី";
ឬអ្នកអាចប្រើ
ឧទាហរណ៍ទីមួយគឺអថេរបីផ្សេងគ្នាដែលមានឈ្មោះផ្ទាល់ខ្លួនរបស់ពួកគេ (ដែលខុសគ្នាដោយតួអក្សរមួយ) ។ ឧទាហរណ៍ទីពីរគឺជាអារេដែលមានអថេរមួយ ប៉ុន្តែមានតម្លៃជាច្រើន ដែលនីមួយៗមានលេខរៀងៗខ្លួន។
នៅពេលប្រើអថេរជាអារេ អ្នកត្រូវតែបញ្ចូលតម្លៃក្នុងតង្កៀបការ៉េជានិច្ច។ អ្នកអាចជ្រើសរើសឈ្មោះណាមួយសម្រាប់អថេរអារេ ប៉ុន្តែចាប់ពីពេលនេះតទៅឈ្មោះនោះអាចប្រើបានសម្រាប់តែអារេប៉ុណ្ណោះ។ អ្នកមិនអាចធ្វើអ្វីដែលមានន័យ
តម្លៃ = "មួយ"; តម្លៃ = "តម្លៃថ្មី";
ទោះយ៉ាងណាក៏ដោយ អ្នកអាចកំណត់តម្លៃឡើងវិញ ដូចដែលអ្នកចង់បានសម្រាប់អថេរធម្មតា។ ទាំងនោះ។ ខាងក្រោមនេះគឺត្រឹមត្រូវ៖
តម្លៃ = "1"; តម្លៃបោះពុម្ព; តម្លៃ = "មួយ"; តម្លៃបោះពុម្ព;
អ្វីដែលគួរឱ្យចាប់អារម្មណ៍នោះគឺថា មិនដូចភាសាផ្សេងទៀតទេ អ្នកមិនត្រូវបានបង្ខំឱ្យប្រើតែលេខទេ។ នៅក្នុងឧទាហរណ៍ខាងលើ ,, ត្រូវបានបកស្រាយថាជា [“១”], [“២”], [“៣”]។ នេះមានន័យថា អ្នកក៏អាចប្រើខ្សែអក្សរផ្សេងទៀតជាអ្នកកំណត់អត្តសញ្ញាណ និងចាត់ចែងអារេស្ទើរតែដូចជាមូលដ្ឋានទិន្នន័យជួរឈរតែមួយ។ ឈ្មោះផ្លូវការសម្រាប់នេះគឺ "អារេពាក់ព័ន្ធ" ។
លេខ["មួយ"]=1; លេខ["ពីរ"]=2; លេខបោះពុម្ព["មួយ"]; value="ពីរ"; print numbers; value=$1; if(numbers = ""){ print "no such number"; } !}
ពេលណា និងរបៀបប្រើអារេ
វាអាចមានករណីផ្សេងៗដែលអ្នកអាចជ្រើសរើសប្រើអារេ។ មនុស្សមួយចំនួននៅពេលធ្វើការជាមួយ awk ធ្វើដោយគ្មានអារេអ្វីទាំងអស់។ ប៉ុន្តែនេះមិនមែនជាទីតាំងត្រឹមត្រូវទាំងស្រុងនោះទេ៖ សម្រាប់អារេមានអថេរពិសេសដែលឧទាហរណ៍បង្ហាញទំហំរបស់វា (ចំនួនតម្លៃក្នុងអារេ) មានរចនាសម្ព័ន្ធងាយស្រួលសម្រាប់រាប់សមាជិកអារេ ហើយមុខងារមួយចំនួនត្រឡប់តម្លៃ។ ក្នុងទម្រង់ជាអារេ។ យ៉ាងណាក៏ដោយ សូមមើលឧទាហរណ៍មួយចំនួនដែលអាចនឹងមានប្រយោជន៍។
ការរក្សាទុកព័ត៌មានសម្រាប់ការប្រើប្រាស់នៅពេលក្រោយ
នៅពេលប្រើ awk នៅក្នុងស្គ្រីបសែលធំ អ្នកអាចរក្សាទុកព័ត៌មានទៅឯកសារបណ្តោះអាសន្ន។ ប៉ុន្តែអ្នកអាចរក្សាទុកពាក្យដែលអ្នកត្រូវការទៅក្នុងអង្គចងចាំ ហើយបន្ទាប់មកបោះពុម្ពវាទាំងអស់នៅចុងបញ្ចប់ ដែលនឹងលឿនជាងការប្រើឯកសារបណ្តោះអាសន្ន។
/special/(savewords=$2; lnum+=1;) END (រាប់=0; while(savewords != "") (ចំនួន print,savewords; count+=1; ))
ជំនួសឱ្យការបង្ហាញពាក្យសាមញ្ញ អ្នកអាចប្រើផ្នែក END ដើម្បីដំណើរការបន្ថែមណាមួយដែលអ្នកប្រហែលជាត្រូវការ មុនពេលបង្ហាញពួកវា។
ប្រសិនបើអ្នកចង់កំណត់លិបិក្រមតែមួយគត់ចំពោះតម្លៃ (ដើម្បីជៀសវាងការស្ទួន) ជាទូទៅអ្នកអាចយោងទៅលើតម្លៃរបស់ពួកគេតាមជួររបស់ពួកគេផ្ទាល់។ ឬឧទាហរណ៍ រក្សាទុកអារេដែលមានជួរទី 3 ធ្វើលិបិក្រមដោយតម្លៃដែលត្រូវគ្នាក្នុងជួរទី 2 ។
( threecol[$2]=$3 ) END (សម្រាប់ (v in threecol) ( print v, threecol[v] ) )
អារេ និងបំបែក()
ហេតុផលចម្បងផ្សេងទៀតដើម្បីប្រើអារេគឺប្រសិនបើអ្នកចង់ធ្វើវាលរង។ ចូរនិយាយថាអ្នកមានជួរដែលមានការបែងចែកធំ ៗ និងផ្នែកតូចៗជាច្រើន។ ម្យ៉ាងវិញទៀត វាលកម្រិតកំពូលត្រូវបានបំបែកដោយដកឃ្លា ប៉ុន្តែបន្ទាប់មកអ្នកទទួលបានពាក្យតូចៗដែលបំបែកដោយសញ្ញា។
នេះគឺជាអថេរ:field:ប្រភេទបន្ទាត់ វាអាចមានច្រើន:ប្រភេទ:តម្លៃនៅទីនេះ
ក្នុងឧទាហរណ៍ខាងលើ វាលទីបួនដែលបំបែកដោយចន្លោះមួយ មានវាលរងដែលបំបែកដោយសញ្ញា។ ឥឡូវនេះ ចូរនិយាយថាអ្នកចង់ដឹងពីតម្លៃនៃវាលរងទីពីរនៅក្នុងវាលធំទីបួន។ វិធីមួយដើម្បីធ្វើវាគឺហៅ awks ពីរដែលតភ្ជាប់ដោយបំពង់មួយ៖
Awk "(បោះពុម្ព $4)" | awk -F: "(បោះពុម្ព $2)"
វិធីមួយទៀតគឺដើម្បីផ្លាស់ប្តូរតម្លៃនៃ "FS" ភ្លាមៗដែលមានឧបករណ៍បំបែកវាល (តាមមើលទៅវាមិនដំណើរការជាមួយការអនុវត្ត awk ទាំងអស់ទេ)៖
Awk "( newline=$4; fs=FS; FS=":"; $0=newline; print $2; FS=fs; )"
ប៉ុន្តែអ្នកក៏អាចធ្វើដូចនេះជាមួយ arrays ដោយប្រើមុខងារ split() ដូចនេះ៖
Awk "(បន្ទាត់ថ្មី=$4; បំបែក(បន្ទាត់ថ្មី វាលរង":"); វាលរងបោះពុម្ព) "
ក្នុងករណីនេះ ការប្រើអារេគឺជាវិធីសាមញ្ញបំផុត ហើយប្រហែលជាវិធីឆើតឆាយបំផុតដើម្បីធ្វើវា។
ដូច្នេះ Awk ផ្តល់នូវរចនាសម្ព័ន្ធទិន្នន័យចំនួនកំណត់។ បន្ថែមពីលើអថេរ មាត្រដ្ឋាន និងខ្សែអក្សរ ភាសាមានរចនាសម្ព័ន្ធទិន្នន័យដ៏ធំដែលភ្ជាប់មកជាមួយ។ ទោះបីជាត្រូវបានគេហៅថា "អារេ" ជាផ្លូវការក៏ដោយ រចនាសម្ព័ន្ធនេះគឺពិតជាអារេដែលជាប់ទាក់ទងគ្នា ស្រដៀងទៅនឹងរចនាសម្ព័ន្ធទិន្នន័យ dict នៅក្នុង Python ។
អារេមិនចាំបាច់ចាប់ផ្តើមទេ។ អ្នកគ្រាន់តែអាចចាប់ផ្តើមកំណត់តម្លៃ។ ចំណាំថាគ្រាប់ចុចអាចជាលេខ ឬខ្សែអក្សរ។
Awk "BEGIN ( \ a = 1.1; \ a = 0; \ a["DOG"] = "CAT"; \ print a, a, a["DOG"] \)" 1.1 0 CAT
Awk នឹងមិនបោះពុម្ពអថេរដោយគ្មានលិបិក្រមទេ៖
Awk "BEGIN ( \a["DOG"] = "CAT"; \print a\)" awk: cmd. line:3: fatal: ព្យាយាមប្រើអារេ `a” នៅក្នុងបរិបទមាត្រដ្ឋាន
ទោះបីជាយើងអាចរង្វិលជុំដោយគន្លឹះដោយប្រើ សម្រាប់:
Awk "BEGIN ( \ a = 1.1; \ a = 0; \ a["DOG"] = "CAT"; \ for(k in a) print(a[k]) \)" CAT 0 1.1
ផ្នែកទីប្រាំពីរ៖ AWK និងសែល (sh/ksh/bash/csh)
ពេលខ្លះមុខងាររបស់ AWK ប្រហែលជាមិនគ្រប់គ្រាន់ទេ។ ក្នុងករណីនេះ អ្នកអាចបញ្ចូល awk ទៅក្នុងស្គ្រីបសែលរបស់អ្នក។ ខាងក្រោមនេះគឺជាឧទាហរណ៍មួយចំនួននៃរបៀបដែលវាអាចត្រូវបានធ្វើ។
ការសន្និដ្ឋានសាមញ្ញ
ពេលខ្លះអ្នកចង់ប្រើ awk គ្រាន់តែជាទម្រង់ formatter ហើយបោះចោលលទ្ធផលដោយផ្ទាល់ទៅអ្នកប្រើប្រាស់
ចំណាំ៖ ចំណាំថានៅក្នុងស្គ្រីប សម្រង់តែមួយត្រូវបានពង្រីក (មិនជាប់គ្នា) ហើយរវាងគូដែលបានពង្រីកទាំងពីរនៃសម្រង់តែមួយមានអថេរ $1 (ទីពីរ) ដែលក្នុងករណីនេះគឺជាអាគុយម៉ង់ស្គ្រីប ខណៈដែល $1 គឺជាផ្នែកនៃវាក្យសម្ព័ន្ធ $1 (មានន័យថាវាលទីមួយក្នុងជួរ)។
#!/bin/sh ខណៈ [ "$1" !="" ] ; ធ្វើ awk -F: "$1 == ""$1"" (បោះពុម្ព $1,$3) " /etc/passwd shift done
កំណត់អថេរសែលទិន្នផល awk
ពេលខ្លះយើងចង់ប្រើ awk សម្រាប់វិធីរហ័សដើម្បីកំណត់តម្លៃនៃអថេរ។ ដោយប្រើប្រធានបទ passwd យើងមានវិធីមួយដើម្បីស្វែងរកសែលសម្រាប់អ្នកប្រើប្រាស់ ហើយមើលថាតើវាស្ថិតនៅក្នុងបញ្ជីសែលផ្លូវការដែរឬទេ។
ជាថ្មីម្តងទៀត សូមកត់សម្គាល់ពីរបៀបដែលសម្រង់តែមួយត្រូវបានបិទនៅក្នុងកន្សោម awk បន្ទាប់ពីសម្រង់បិទ (ទីពីរ) $1 គឺជាអថេរដែលត្រូវបានបញ្ជូនតម្លៃនៃអាគុយម៉ង់ទីមួយទៅស្គ្រីប មិនមែនជាផ្នែកមួយនៃវាក្យសម្ព័ន្ធ awk ទេ។
#!/bin/sh user="$1" ប្រសិនបើ [ "$user" =="" ] ; បន្ទាប់មកអេកូ ERROR: ត្រូវការឈ្មោះអ្នកប្រើប្រាស់ ; ចេញ; fi usershell=`awk -F: "$1 == ""$1"" (បោះពុម្ព $7) " /etc/passwd` grep -l $usershell /etc/shells ប្រសិនបើ [$? -ne 0] ; បន្ទាប់មកអេកូ កំហុស៖ សែល $usershell សម្រាប់អ្នកប្រើប្រាស់ $user មិននៅក្នុង /etc/shells fi
ជម្មើសជំនួសផ្សេងទៀត៖
# មើល "man regex" usershell=`awk -F: "/^"$1":/ (បោះពុម្ព $7) " /etc/passwd` echo $usershell; # មានតែ awk ទំនើបទេដែលទទួលយក -v. អ្នកប្រហែលជាត្រូវប្រើ "nawk" ឬ "gawk" usershell2=`awk -F: -v user=$1 "$1 == user (បោះពុម្ព $7)" /etc/passwd` echo $usershell2;
ការពន្យល់ពីវិធីសាស្រ្តបន្ថែមខាងលើទុកជាកិច្ចការផ្ទះសម្រាប់អ្នកអាន :)
ផ្ទេរទិន្នន័យទៅ awk តាមរយៈបំពង់
ពេលខ្លះអ្នកចង់ដាក់ awk ជាតម្រងទិន្នន័យ នៅក្នុងកម្មវិធីធំមួយ ឬជាពាក្យបញ្ជាមួយជួរដែលបានបញ្ចូលទៅក្នុងប្រអប់បញ្ចូលសែល។ ឧទាហរណ៍នៃពាក្យបញ្ជាបែបនេះនៅក្នុងស្គ្រីប (បញ្ជីនៃឯកសារកំណត់ហេតុម៉ាស៊ីនមេបណ្តាញត្រូវបានបញ្ជូនជាអាគុយម៉ង់ទៅស្គ្រីប ដោយសារការកត់ត្រាអាចប្ដូរតាមបំណង ហើយកំណត់ហេតុអាចមានរចនាសម្ព័ន្ធផ្សេងគ្នា ដើម្បីដំណើរការក្នុងករណីជាក់លាក់ ពាក្យបញ្ជាអាចត្រូវការ ដែលត្រូវកែតម្រូវ)៖
#!/bin/sh grep -h " /index.html" $* | awk -F\" "(បោះពុម្ព $4)" | តម្រៀប -u
អត្ថបទគួរឱ្យចាប់អារម្មណ៍ខ្ញុំចង់អរគុណអ្នកសម្រាប់ការខិតខំប្រឹងប្រែងរបស់អ្នក។
ខ្ញុំបានរកឃើញថាវាមិនត្រឹមត្រូវ។ ប្រសិនបើអ្នកប្រតិបត្តិបន្ទាត់ពីឧទាហរណ៍
Awk -F " " "( បោះពុម្ព $2 )" field_data.txt
វានឹងចេញលទ្ធផលដូចគ្នា។
Awk "( បោះពុម្ព $2 )" field_data.txt
លទ្ធផលគឺជាឧទាហរណ៍ជាមួយ -Fមិនបានពិពណ៌នាល្អ។
