របៀបសរសេរ BASH "សម្រាប់" រង្វិលជុំ

របៀបប្រើ BASH "សម្រាប់" រង្វិលជុំនៅក្នុងសែលស្គ្រីប

BASH (ដែលតំណាងឱ្យ Bourne Again Shell) គឺជាភាសាស្គ្រីបដែលប្រើដោយ ប្រព័ន្ធប្រតិបត្តិការលីនុច និង លីនុច ភាគច្រើនបំផុត។

អ្នកអាចរត់ពាក្យបញ្ជា BASH នៅក្នុងបង្អួចស្ថានីយមួយបន្ទាប់ពីមួយទៀតឬអ្នកអាចបន្ថែមពាក្យបញ្ជាទៅឯកសារអត្ថបទមួយដើម្បីបង្កើតសែលស្គ្រីប។

រឿងដ៏អស្ចារ្យអំពីការសរសេរស្គ្រីបសែលគឺថាអ្នកអាចដំណើរការពួកវាម្តងហើយម្តងទៀត។ ឧទាហរណ៍ស្រមៃថាអ្នកត្រូវការបន្ថែមអ្នកប្រើទៅប្រព័ន្ធកំណត់សិទ្ធិរបស់ពួកគេនិងគ្រប់គ្រងបរិយាកាសចាប់ផ្តើមរបស់ពួកគេ។ អ្នកអាចសរសេរពាក្យបញ្ជានៅលើក្រដាសមួយហើយរត់ពួកវានៅពេលអ្នកបន្ថែមអ្នកប្រើថ្មីឬអ្នកអាចសរសេរស្គ្រីបតែមួយហើយគ្រាន់តែបញ្ជូនប៉ារ៉ាម៉ែត្រទៅក្នុងស្គ្រីបនោះ។

ភាសាស្គ្រីបដូចជា BASH មានការបង្កើតកម្មវិធីស្រដៀងគ្នាជាភាសាដទៃ។ ឧទាហរណ៍អ្នកអាចប្រើប៉ារ៉ាម៉ែត្រនាំចូលដើម្បី ទទួលបានព័ត៌មានបញ្ចូលពីក្តារចុច និងរក្សាទុកពួកវាជាអថេរ។ បន្ទាប់មកអ្នកអាចយកស្គ្រីបដើម្បី អនុវត្តសកម្មភាពជាក់លាក់មួយដោយផ្អែកលើតម្លៃប៉ារ៉ាម៉ែត្របញ្ចូល ។

ផ្នែកសំខាន់នៃការសរសេរកម្មវិធីនិងភាសាស្គ្រីបគឺជាសមត្ថភាពក្នុងការដំណើរការក្រមនៃកូដដូចគ្នាម្តងហើយម្តងទៀត។

មានវិធីមួយចំនួនដើម្បីធ្វើលេខកូដម្តងទៀត (ត្រូវបានគេស្គាល់ផងដែរថាជារង្វិលជុំ) ។ នៅក្នុងមគ្គុទ្ទេសក៍នេះអ្នកនឹងត្រូវបានបង្ហាញរបៀបសរសេររង្វង់ "សម្រាប់" ។

រង្វង់មួយ សម្រាប់ រង្វិលជុំម្តងទៀតផ្នែកមួយនៃលេខកូដម្តងហើយម្តងទៀត។ ពួកវាមានប្រយោជន៍ដូច្នេះស៊េរីនៃពាក្យបញ្ជាអាចបន្តរត់រហូតដល់លក្ខខណ្ឌពិសេសត្រូវបានបំពេញបន្ទាប់ពីពួកគេឈប់។

នៅក្នុងមគ្គុទ្ទេសក៍នេះអ្នកនឹងត្រូវបានបង្ហាញពីវិធីប្រាំយ៉ាងក្នុងការប្រើរង្វិលជុំក្នុងស្គ្រីប BASH ។

មុននឹងចាប់ផ្តើម

មុនពេលអ្នកចាប់ផ្តើមជាមួយឧទាហរណ៍សម្រាប់រង្វិលជុំអ្នកត្រូវបើកផ្ទាំងស្ថានីយហើយអនុវត្តតាមជំហានទាំងនេះ:

1. បញ្ចូល ស្គ្រីប mkdir ( សិក្សាបន្ថែមអំពី mkdir នៅទីនេះ )
2. បញ្ចូល ស្គ្រីបស៊ីឌី (វា ផ្លាស់ប្តូរថត ទៅ ស្គ្រីប )
3. បញ្ចូល nano examplen.sh (ដែល n ជាឧទាហរណ៍ដែលអ្នកកំពុងធ្វើការ)
4. បញ្ចូលស្គ្រីប
5. ចុច CTRL + O ដើម្បីរក្សាទុកនិង CTRL + X ដើម្បីចេញ
6. រត់ batch examplen.sh (ជាថ្មីម្តងទៀតដោយ n ជាឧទាហរណ៍ដែលអ្នកកំពុងធ្វើការជាមួយ)

តើធ្វើដូចម្តេចដើម្បីរង្វិលជុំតាមរយៈបញ្ជីមួយ

#! / bin / bash
សម្រាប់លេខ 1 2 3 4 5
ធ្វើ
echo $ number
បានធ្វើ
ចេញ 0

វិធី BASH នៃការប្រើប្រាស់រង្វិលជុំគឺមានភាពខុសប្លែកពីវិធីដែលភាសាសរសេរកម្មវិធីនិងភាសាស្គ្រីបភាគច្រើនអាចគ្រប់គ្រងបានសម្រាប់រង្វិលជុំ។ សូមបំបែកស្គ្រីបចុះក្រោម ...

ក្នុង BASH "សម្រាប់" រង្វិលជុំទាំងអស់សេចក្តីថ្លែងការណ៍រវាង do និង done ត្រូវបានអនុវត្តម្តងសម្រាប់គ្រប់ធាតុនៅក្នុងបញ្ជី។

ក្នុងឧទាហរណ៍ខាងលើបញ្ជីគឺជាអ្វីគ្រប់យ៉ាងដែលកើតឡើងបន្ទាប់ពីពាក្យ ក្នុង (ឧទាហរណ៍ 1 2 3 4 5) ។

រាល់ពេលរង្វិលជុំវាស់តម្លៃបន្ទាប់នៅក្នុងបញ្ជីត្រូវបានបញ្ចូលទៅក្នុងអថេរដែលបានបញ្ជាក់បន្ទាប់ពីពាក្យ "for" ។ នៅក្នុងរង្វិលជុំខាងលើអថេរត្រូវបានគេហៅថា លេខ ។

សេចក្តីថ្លែងការណ៍ អេកូ ត្រូវបានប្រើដើម្បីបង្ហាញព័ត៌មានទៅអេក្រង់។

ដូច្នេះឧទាហរណ៍នេះយកលេខពីទី 1 ដល់ទី 5 ហើយបង្ហាញលទ្ធផលមួយម្ដងៗលើអេក្រង់:

• 1
• 2
• 3
• 4
• 5

របៀបរារាំងរវាងចំណុចចាប់ផ្តើមនិងចំណុចបញ្ចប់

បញ្ហាដែលមានឧទាហរណ៍ខាងលើនេះគឺថាប្រសិនបើអ្នកចង់ដំណើរការបញ្ជីធំជាង (និយាយពី 1 ទៅ 500) វាត្រូវការអាយុកាលដើម្បីវាយគ្រប់លេខទាំងអស់នៅកន្លែងដំបូង។

នេះនាំយើងទៅឧទាហរណ៏ទីពីរដែលបង្ហាញអំពីរបៀបបញ្ជាក់ចំណុចចាប់ផ្តើមនិងបញ្ចប់:

#! / bin / bash
សម្រាប់លេខនៅក្នុង {1..10}
ធ្វើ
echo "$ number"
បានធ្វើ
ចេញ 0

ច្បាប់គឺមានលក្ខណៈដូចគ្នា។ តម្លៃបន្ទាប់ពីពាក្យ " in" បង្កើតបញ្ជីដើម្បីធ្វើម្តងទៀតហើយតម្លៃនីមួយៗក្នុងបញ្ជីត្រូវបានដាក់ក្នុងអថេរ (ឧ។ លេខ) ហើយរាល់ពេលដែលរង្វិលជុំចាប់ផ្តើមវាធ្វើសេចក្តីថ្លែងការណ៍រវាង ធ្វើ និង ធ្វើរួច ។

ភាពខុសគ្នាសំខាន់គឺវិធីដែលបញ្ជីត្រូវបានបង្កើតឡើង។ តង្កៀបអង្កាញ់ {} ជាមូលដ្ឋានចង្អុលបង្ហាញជួរមួយនិងជួរក្នុងករណីនេះគឺ 1 ដល់ 10 (ចំណុចពីរដាច់ដោយឡែកពីគ្នានូវការចាប់ផ្តើមនិងចុងនៃជួរ) ។

ឧទាហរណ៏នេះរត់តាមរយៈលេខនីមួយៗរវាង 1 និង 10 ហើយបង្ហាញលេខទៅអេក្រង់ដូចខាងក្រោម:

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

រង្វិលជុំដូចគ្នាអាចត្រូវបានសរសេរដូចនេះជាមួយនឹង វាក្យសម្ព័ន្ធ ដូចគ្នាទៅនឹងឧទាហរណ៍ដំបូង:

សម្រាប់លេខ 1 2 3 4 5 6 7 8 9 10

តើធ្វើដូចម្តេចដើម្បីរំលងលេខនៅក្នុងជួរមួយ

ឧទាហរណ៍មុនបានបង្ហាញពីរបៀបរង្វិលជុំរវាងចំណុចចាប់ផ្តើមនិងចំណុចបញ្ចប់ដូច្នេះឥឡូវនេះយើងនឹងពិនិត្យមើលពីរបៀបរំលងលេខនៅក្នុងជួរ។

ស្រមៃថាអ្នកចង់រង្វិលចន្លោះ 0 និង 100 ប៉ុន្តែបង្ហាញតែលេខរៀងទី 10 ប៉ុណ្ណោះ។ ស្គ្រីបខាងក្រោមបង្ហាញពីវិធីធ្វើដូចនោះ:

#! / bin / bash
សម្រាប់លេខនៅក្នុង {0..100..10}
ធ្វើ
echo "$ number"
បានធ្វើ
ចេញ 0

ច្បាប់គឺមានលក្ខណៈដូចគ្នា។ មានបញ្ជីអថេរនិងសំណុំសេចក្តីថ្លែងការណ៍ដែលត្រូវធ្វើរវាងការ ធ្វើ និងការ ធ្វើ ។ បញ្ជីនេះមើលទៅដូចនេះ: {0..100..10} ។

លេខដំបូងគឺ 0 ហើយលេខបញ្ចប់គឺ 100 ។ លេខទីបី (10) គឺចំនួនធាតុនៅក្នុងបញ្ជីដែលវានឹងរំលង។

ឧទាហរណ៍ខាងលើនេះបង្ហាញលទ្ធផលដូចខាងក្រោម:

• 0
• 10
• 20
• 30
• 40
• 50
• 60
• 70
• 80
• 90
• 100

មួយទៀតរកមើលប្រពៃណីសម្រាប់រង្វិលជុំ

វិធីសរសេរ BASH សម្រាប់រង្វិលជុំគឺចម្លែកបន្តិចនៅពេលប្រៀបធៀបទៅនឹងភាសាសរសេរកម្មវិធីផ្សេងទៀត។

អ្នកអាចសរសេររង្វិលជុំសម្រាប់រចនាប័ទ្មស្រដៀងទៅនឹងភាសាសរសេរកម្មវិធីដូចខាងក្រោមនេះ:

#! / bin / bash
សម្រាប់ ((ចំនួន = 1; លេខ <100; ++ ++))
{
ប្រសិនបើ (($ number% 5 == 0))
បន្ទាប់មក
អេកូ "ចំនួន $ អាចបែងចែកបាន 5"
fi
}
ចេញ 0

រង្វិលជុំចាប់ផ្តើមដោយកំណត់ចំនួនអថេរទៅ 1 (ចំនួន = 1 ) ។ រង្វិលជុំនឹងរក្សាការធ្វើដដែលៗខណៈតម្លៃនៃលេខតូចជាង 100 ( ចំនួន <100 ) ។ តម្លៃនៃការផ្លាស់ប្តូរ លេខ ដោយបន្ថែមលេខ 1 ទៅវាបន្ទាប់ពីការធ្ធើឡើងវិញនីមួយៗ ( លេខ ++ ) ។

អ្វីគ្រប់យ៉ាងរវាងដង្កៀបអង្កាញ់ត្រូវបានអនុវត្តតាមរយៈការធ្វើរង្វិលជុំគ្នានៃរង្វិលជុំ។

ប៊ីតរវាងវង់ក្រចកពិនិត្យតម្លៃនៃ ចំនួនលេខ បែងចែកវាដោយលេខ 5 និងប្រៀបធៀបចំនួនដែលនៅសេសទៅ 0 ។ ប្រសិនបើសេសដែលនៅសល់ 0 នោះលេខអាចបែងចែកបាន 5 និងត្រូវបានបង្ហាញនៅលើអេក្រង់។

ឧទាហរណ៍:

• 5 អាចបែងចែកបាន 5
• 10 អាចបែងចែកបាន 5
• 15 អាចបែងចែកបាន 5

ប្រសិនបើអ្នកចង់ផ្លាស់ប្តូរទំហំជំហាននៃការនិយាយអ្នកអាចកែប្រែផ្នែក ++ ដើម្បីក្លាយជា លេខ = លេខ + 2 លេខ = លេខ + 5 ឬ លេខ = លេខ 10 ។ ល។

នេះអាចត្រូវបានកាត់បន្ថយបន្ថែមទៀតទៅ លេខ + = 2 ឬ លេខ + = 5 ។

ឧទាហរណ៍ជាក់ស្តែង

សម្រាប់រង្វិលជុំអាចធ្វើច្រើនជាងបញ្ជីរមូរនៃលេខ។ អ្នកពិតជាអាចប្រើលទ្ធផលនៃពាក្យបញ្ជាផ្សេងទៀតជាបញ្ជី។

ឧទាហរណ៍ដូចខាងក្រោមបង្ហាញពីវិធីបម្លែងឯកសារអូឌីយ៉ូពី MP3 ទៅ WAV :

#! / bin / bash

បញ្ជីក្នុងឧទាហរណ៍នេះគឺគ្រប់ឯកសារដែលមានផ្នែកបន្ថែម .MP3 នៅក្នុងថតបច្ចុប្បន្នហើយអថេរជា ឯកសារ ។

ពាក្យបញ្ជា mpg បម្លែងឯកសារ MP3 ទៅជា WAV ។ ទោះយ៉ាងណាអ្នកប្រហែលជាត្រូវដំឡើងវាដោយប្រើកម្មវិធីគ្រប់គ្រងកញ្ចប់របស់អ្នកជាមុនសិន។