សួស្តីអ្នកទាំងអស់គ្នា! មេរៀន PHP មួយទៀតបានមកដល់ហើយ។ ប្រធានបទថ្ងៃនេះគឺជារឿងមួយដែលចូលចិត្តបំផុតក្នុងចំណោមអ្នកដែលចាប់ផ្តើមសរសេរកម្មវិធី។ ជាការពិតណាស់ ដោយសារតែលក្ខខណ្ឌនៅក្នុង PHP គឺជាអ្វីដែលអនុញ្ញាតឱ្យយើងសរសេរ algorithms ផ្សេងៗ។ វាអាស្រ័យលើលក្ខខណ្ឌដែលកម្មវិធីនឹងមានឥរិយាបទមួយឬផ្សេងទៀត។ ហើយវាគឺជាអរគុណដល់ពួកគេដែលយើងអាចទទួលបានលទ្ធផលខុសៗគ្នាជាមួយនឹងទិន្នន័យបញ្ចូលផ្សេងៗគ្នា។ PHP មានសំណង់ជាច្រើនដែលអាចត្រូវបានប្រើដើម្បីអនុវត្តលក្ខខណ្ឌ។ ពួកវាទាំងអស់ត្រូវបានប្រើប្រាស់ និងមានគុណសម្បត្តិរបស់ពួកគេក្នុងស្ថានភាពផ្សេងៗគ្នា ឬបើអ្នកចូលចិត្តលក្ខខណ្ឌ។ មាន​លក្ខខណ្ឌ​ដូច​គ្នា​នៅ​ជុំវិញ​មែន​ទេ? ដូច្នេះ។ គ្មាននរណាម្នាក់នឹងប្រកែកថានៅក្នុងជីវិតពិតអាស្រ័យលើកាលៈទេសៈយើងធ្វើសកម្មភាពខុសគ្នា។ ក្នុងការសរសេរកម្មវិធីនេះគឺមិនសំខាន់តិចទេ ហើយឥឡូវនេះយើងនឹងរៀនវា។

ដូចដែលអ្នកគួរចងចាំពីមេរៀនចុងក្រោយនៅក្នុង PHP អាស្រ័យលើប្រតិបត្តិករ operands ត្រូវបានបោះទៅប្រភេទជាក់លាក់មួយ។ សម្រាប់ប្រតិបត្តិករតាមលក្ខខណ្ឌនៅក្នុង PHP ច្បាប់ដូចគ្នាត្រូវបានអនុវត្ត ហើយនៅទីនេះ operand តែងតែត្រូវបានបោះទៅតម្លៃប៊ូលីន។ ក្នុងករណីតម្លៃនេះ។ ពិតបន្ទាប់មកយើងពិចារណាថាលក្ខខណ្ឌត្រូវបានបំពេញហើយប្រសិនបើ មិនពិត- លក្ខខណ្ឌនេះមិនត្រូវបានបំពេញ។ អាស្រ័យ​លើ​លក្ខខណ្ឌ​ដែល​ត្រូវ​បាន​បំពេញ យើង​អាច​ធ្វើ​ឬ​មិន​ធ្វើ​សកម្មភាព​ខ្លះ។ ហើយនៅទីនេះខ្ញុំស្នើឱ្យពិចារណាប្រតិបត្តិករដែលមានលក្ខខណ្ឌដំបូង - ប្រសិនបើ.

លក្ខខណ្ឌប្រសិនបើសេចក្តីថ្លែងការណ៍

នេះគឺជាប្រតិបត្តិករសាមញ្ញបំផុត និងប្រើញឹកញាប់បំផុត។ ជាទូទៅការរចនាមើលទៅដូចនេះ:

ហើយនៅក្នុងជីវិតពិតដោយប្រើប្រតិបត្តិករ ប្រសិនបើមើលទៅដូចនេះ៖

នៅទីនេះយើងបានបញ្ជូនតម្លៃយ៉ាងច្បាស់ទៅឱ្យប្រតិបត្តិករ ពិត. ជាការពិតណាស់ នេះគឺគ្មានន័យទាល់តែសោះ។ ចូរប្រើលក្ខខណ្ឌដើម្បីកំណត់លេខធំជាង 10។ វាសាមញ្ញណាស់៖

10) (បន្ទរ "លេខគឺធំជាង 10";)

ហើយបន្ទាប់ពីដំណើរការយើងនឹងឃើញលទ្ធផល៖

លេខធំជាង 10

ការសាងសង់ប្រសិនបើផ្សេងទៀត។

តើវាអាចទៅរួចទេដែលថានៅពេលដែលលក្ខខណ្ឌមិនត្រូវបានបំពេញ កូដផ្សេងទៀតត្រូវបានប្រតិបត្តិ? ជាការពិតណាស់អ្នកអាចធ្វើបាន! ដើម្បីធ្វើដូចនេះរួមគ្នាជាមួយប្រតិបត្តិករ ប្រសិនបើប្រើប្រតិបត្តិករ ផ្សេងទៀត។(ជាភាសារុស្សី - បើមិនដូច្នេះទេ) ។ វាត្រូវបានសរសេរបន្ទាប់ពីដង្កៀបអង្កាញ់ដែលរុំព័ទ្ធកូដដែលត្រូវបានប្រតិបត្តិនៅពេលដែលលក្ខខណ្ឌត្រូវបានបំពេញ។ ហើយការរចនាមើលទៅដូចនេះ៖

10) (បន្ទរ "លេខធំជាង 10"; ) ផ្សេងទៀត (បន្ទរ "ចំនួនតិចជាង ឬស្មើ 10";)

នៅទីនេះសារមួយនឹងត្រូវបានបង្ហាញនៅលើអេក្រង់ម្តងទៀត៖

លេខធំជាង 10

ទោះយ៉ាងណាក៏ដោយ ប្រសិនបើយើងផ្លាស់ប្តូរទិន្នន័យបញ្ចូល និងអថេរ $xនៅដើមដំបូងយើងកំណត់តម្លៃ 8 សារនឹងត្រូវបានបង្ហាញ៖

ចំនួនតិចជាង ឬស្មើ 10

សាកល្បងវាឥឡូវនេះ។

if-elseif-else construct: លក្ខខណ្ឌច្រើន។

ក្នុងករណីដែលអ្នកត្រូវការពិនិត្យមើលលក្ខខណ្ឌជាច្រើនបន្ទាប់ពីប្រតិបត្តិករ ប្រសិនបើប្រតិបត្តិករក៏ត្រូវបានបន្ថែមផងដែរ។ elseif. វានឹងពិនិត្យលក្ខខណ្ឌលុះត្រាតែលក្ខខណ្ឌទីមួយមិនត្រូវបានបំពេញ។ ឧទាហរណ៍៖

10) (បន្ទរ "លេខគឺធំជាង 10"; ) elseif ($x == 10) (បន្ទរ "លេខគឺ 10"; )

ក្នុងករណីនេះអេក្រង់នឹងបង្ហាញ៖

លេខគឺ 10

ហើយបាទ បន្ទាប់ពីប្រតិបត្តិករនេះ អ្នកអាចបន្ថែមបាន។ ផ្សេងទៀត។. កូដនៅខាងក្នុងវានឹងត្រូវបានប្រតិបត្តិប្រសិនបើគ្មានលក្ខខណ្ឌណាមួយត្រូវបានបំពេញ៖

10) (បន្ទរ "លេខគឺធំជាង 10"; ) elseif ($x == 10) (បន្ទរ "លេខគឺ 10"; ) else (បន្ទរ "ចំនួនតិចជាង 10"; )

លទ្ធផលនៃកូដនេះ ខ្ញុំជឿថា មិនចាំបាច់ពន្យល់ទេ។ បាទ, ដោយវិធីនេះ, បញ្ជីទាំងមូលនៃ elseif-s ឧទាហរណ៍ដូចនេះ៖

បោះទៅប៊ូលីន

សូមចាំថានៅក្នុងមេរៀនអំពី យើងបានរៀនពីរបៀបក្នុងការបោះតម្លៃយ៉ាងច្បាស់លាស់ទៅប្រភេទមួយចំនួន។ ឧទាហរណ៍៖

លទ្ធផលនឹងជា ពិត.
ធ្វើការតាមរបៀបដូចគ្នា មានតែការបំប្លែងដោយប្រយោលប៉ុណ្ណោះ ដែលតែងតែកើតឡើងក្នុងលក្ខខណ្ឌ។ ឧទាហរណ៍លក្ខខណ្ឌដូចខាងក្រោមៈ

នឹងជោគជ័យព្រោះលេខ 3 នឹងត្រូវបានបំប្លែងទៅជា ពិត. TO មិនពិតតម្លៃខាងក្រោមនឹងត្រូវបានផ្តល់ឱ្យ:

• "" (ខ្សែអក្សរទទេ)
• 0 (លេខ 0)

ដូច្នេះ​លេខ​មិន​សូន្យ​និង​ខ្សែ​មិន​សូន្យ​នឹង​ត្រូវ​បំប្លែង​ទៅ ពិតហើយលក្ខខណ្ឌនឹងត្រូវបានបំពេញ។ ករណីលើកលែងគឺជាបន្ទាត់ដែលមានលេខសូន្យមួយ៖

វាក៏នឹងត្រូវបានបំប្លែងទៅជា មិនពិត.

ខ្ញុំបានប៉ះលើប្រធានបទនេះដោយយោងទៅ ប៊ូលីននៅក្នុងកិច្ចការផ្ទះសម្រាប់មេរៀននេះ។ ត្រូវប្រាកដថាបំពេញវា។ ឥឡូវនេះ ចូរយើងបន្តទៅសេចក្តីថ្លែងការណ៍តាមលក្ខខណ្ឌបន្ទាប់។

ការផ្លាស់ប្តូរសេចក្តីថ្លែងការណ៍

លើសពីការរចនា បើ​ផ្សេងមានប្រតិបត្តិករលក្ខខណ្ឌមួយបន្ថែមទៀត។ នេះ - ប្តូរ. នេះគឺជាប្រតិបត្តិករគួរឱ្យចាប់អារម្មណ៍ខ្លាំងណាស់ដែលតម្រូវឱ្យមានការទន្ទេញចាំច្បាប់ជាច្រើន។ ដំបូង​យើង​មើល​ថា​តើ​វា​មាន​រូបរាង​យ៉ាង​ណា​ក្នុង​ឧទាហរណ៍​ខាង​ក្រោម៖

ដំបូង ប្រតិបត្តិករនេះអាចហាក់ដូចជាស្មុគស្មាញណាស់។ ទោះជាយ៉ាងណាក៏ដោយប្រសិនបើអ្នកក្រឡេកមើលវាអ្វីៗនឹងច្បាស់។ នៅក្នុងប្រតិបត្តិការ ប្តូរកន្សោមខ្លះត្រូវបានបញ្ជាក់។ ក្នុងករណីរបស់យើងនេះគឺជាអថេរ $xឬអត្ថន័យរបស់វា - 1 .

នៅក្នុងដង្កៀបអង្កាញ់ យើងរាយបញ្ជីប្រតិបត្តិករ ករណីបន្ទាប់ពីនោះយើងបង្ហាញពីតម្លៃដែលតម្លៃ operand ត្រូវបានប្រៀបធៀប ប្តូរ. ការប្រៀបធៀបមិនមានភាពតឹងរ៉ឹងទេ ពោលគឺវាដូចជាយើងកំពុងប្រើប្រតិបត្តិករ ==។ ហើយប្រសិនបើលក្ខខណ្ឌត្រូវបានបំពេញ នោះលេខកូដដែលបានបញ្ជាក់បន្ទាប់ពីពោះវៀនធំត្រូវបានប្រតិបត្តិ។ ប្រសិនបើគ្មានលក្ខខណ្ឌណាមួយត្រូវបានបំពេញ នោះលេខកូដពីផ្នែកត្រូវបានប្រតិបត្តិ លំនាំដើមដែលជាទូទៅប្រហែលជាមិនមានទេ ហើយបន្ទាប់មកគ្មានអ្វីនឹងត្រូវបានប្រតិបត្តិទេ។ សូមចំណាំថានៅក្នុងផ្នែកនីមួយៗ ករណីនៅចុងបញ្ចប់យើងសរសេរប្រតិបត្តិករ សម្រាក. នេះត្រូវបានធ្វើដូច្នេះបន្ទាប់ពីកូដត្រូវបានប្រតិបត្តិ ប្រសិនបើលក្ខខណ្ឌត្រូវបានបំពេញ លក្ខខណ្ឌនឹងមិនបន្តត្រូវបានត្រួតពិនិត្យទេ។ នោះគឺប្រសិនបើវាមិនមែនសម្រាប់ សម្រាកនៅចុងបញ្ចប់នៃផ្នែក ករណីទី 1បន្ទាប់មកបន្ទាប់ពីអត្ថបទត្រូវបានបង្ហាញ

លេខគឺ 1

លក្ខខណ្ឌប្រៀបធៀបជាមួយ 2 ហើយបន្ទាប់មកលេខកូដនៅក្នុងផ្នែកនឹងត្រូវបានប្រតិបត្តិ លំនាំដើម. កុំភ្លេចសរសេរ សម្រាក!

ការប្រៀបធៀបកុងតាក់ជាមួយ if

ជាទូទៅ កូដនេះក៏អាចត្រូវបានសរសេរដោយប្រើសំណង់ផងដែរ។ if-elseif-else:

ប៉ុន្តែនៅក្នុងទម្រង់នៃការរចនា ករណីប្តូរកូដនៅក្នុងករណីពិសេសនេះមើលទៅសាមញ្ញជាង។ ហើយនេះជាមូលហេតុ៖

1. យើងឃើញភ្លាមៗ តើ​យើង​ប្រៀបធៀប​អ្វី​ឲ្យ​ប្រាកដ?(អថេរ $x) ហើយយើងយល់ថា ក្នុងលក្ខខណ្ឌនីមួយៗ យើងកំពុងប្រៀបធៀបតម្លៃនេះពិតប្រាកដ មិនមែនតម្លៃផ្សេងទៀតទេ។
2. វាកាន់តែងាយស្រួលសម្រាប់ភ្នែកដើម្បីយល់ តើយើងប្រៀបធៀបជាមួយអ្វី?- ផ្នែក ករណីទី 1, ករណីទី 2មើលឃើញកាន់តែងាយស្រួល តម្លៃប្រៀបធៀបគឺគួរឱ្យកត់សម្គាល់ជាង។

ហើយម្តងទៀតអំពីការផ្លាស់ប្តូរ

ហើយខ្ញុំមិនបាននិយាយអ្វីទាំងអស់អំពី ប្តូរ- អ្នកអាចសរសេរជាច្រើន។ ករណី-s ក្នុងមួយជួរ បន្ទាប់មកលេខកូដនឹងត្រូវបានប្រតិបត្តិដោយផ្តល់ថាយ៉ាងហោចណាស់មួយក្នុងចំណោមពួកវាត្រូវបានប្រតិបត្តិ។ ឧទាហរណ៍៖

យល់ស្រប នេះអាចជាការងាយស្រួល។

មិនអីទេ តោះទៅមើលលក្ខណៈពិសេសរបស់ប្រតិបត្តិករ ប្តូរដែលត្រូវតែចងចាំជានិច្ច។

1. សម្រាករំខានសំណុំនៃលក្ខខណ្ឌ កុំភ្លេចបញ្ជាក់វា;
2. ផ្នែក លំនាំដើមនឹងត្រូវបានប្រតិបត្តិប្រសិនបើគ្មានលក្ខខណ្ឌណាមួយត្រូវបានបំពេញ។ វាអាចអវត្តមានទាំងស្រុង;
3. ខ្លះ ករណី-s អាចត្រូវបានសរសេរជាជួរ បន្ទាប់មកកូដនៅក្នុងផ្នែកនឹងត្រូវបានប្រតិបត្តិប្រសិនបើយ៉ាងហោចណាស់លក្ខខណ្ឌមួយត្រូវបានបំពេញ។

ការអនុវត្តតិចតួច

មែនហើយ តើអ្នកចាំប្រតិបត្តិករដែលមានលក្ខខណ្ឌទេ? ចូរយើងអនុវត្តវាជាមួយនឹងឧទាហរណ៍ជាក់ស្តែងបន្ថែមទៀត។

សូម្បីតែឬសេស

នេះគឺជាឧទាហរណ៍មួយ - អ្នកត្រូវកំណត់ថាតើលេខមួយស្មើឬអត់។ ដើម្បីធ្វើដូចនេះយើងត្រូវពិនិត្យមើលថានៅសល់នៃការបែងចែកដោយ 2 នឹងស្មើគ្នា 0 . សូមអានបន្ថែមអំពីប្រតិបត្តិករ។ តោះធ្វើដូចនេះ៖

ព្យាយាមផ្លាស់ប្តូរតម្លៃអថេរដោយខ្លួនឯង។ $x. ឡូយមែនទេ? វាដំណើរការ!

ម៉ូឌុល

ឥឡូវនេះ ចូរយើងរៀនពីរបៀបគណនាម៉ូឌុលនៃចំនួនមួយ។ ប្រសិនបើលេខធំជាង ឬស្មើសូន្យ នោះអ្នកត្រូវបញ្ចេញលេខនេះដោយខ្លួនឯង ប្រសិនបើវាតិចជាង សូមជំនួសសញ្ញាពីដកទៅបូក។

= 0) ( បន្ទរ "ម៉ូឌុលលេខ៖ " . $x; ) else ( បន្ទរ "ម៉ូឌុលលេខ៖ " . -$x; )

លទ្ធផល៖

ម៉ូឌុលលេខ៖ ២

ដូចដែលយើងឃើញ អ្វីៗដំណើរការដោយជោគជ័យ។

ប្រតិបត្តិករ Ternary

លើសពីនេះទៀត PHP មានប្រតិបត្តិករមួយផ្សេងទៀតដែលជាទម្រង់ខ្លីនៃការសាងសង់ បើ​ផ្សេង. នេះគឺជាប្រតិបត្តិករ ternary ។ ក្នុងពេលជាមួយគ្នានេះគាត់ ត្រឡប់មកវិញលទ្ធផលខុសគ្នាអាស្រ័យលើលក្ខខណ្ឌត្រូវបានបំពេញឬអត់។ ជាទូទៅការប្រើប្រាស់របស់វាមើលទៅដូចនេះ៖

លក្ខខណ្ឌ? result_if_true៖ result_if_false

ឬប្រើឧទាហរណ៍នៃទីតាំងម៉ូឌុលដូចគ្នា៖

= 0 ? $x: -$x; បន្ទរ "ម៉ូឌុល៖" ។ $mod;

លទ្ធផល៖

ម៉ូឌុល៖ ២

ឡូយមែនទេ? ប្រតិបត្តិករ ternary សមនៅក្នុងឆើតឆាយណាស់នៅពេលដោះស្រាយបញ្ហាសាមញ្ញបែបនេះ។

និងការអនុវត្តបន្តិចទៀត។

លក្ខខណ្ឌអាចត្រូវបានដាក់នៅខាងក្នុងគ្នាទៅវិញទៅមកហើយជាទូទៅអ្វីដែលអ្នកមិនអាចធ្វើបានជាមួយពួកគេ។ ឧទាហរណ៍៖

0) (ប្រសិនបើ ($x >= 100) ( បន្ទរ "ចំនួនធំជាង ឬស្មើ 100"; ) else (បន្ទរ "លេខធំជាង 0 ប៉ុន្តែតិចជាង 100"; ) ) else (បន្ទរ "លេខ តិចជាង ឬស្មើ 0";)

បន្ទាត់ខាងក្រោម

មិត្តៗ ខ្ញុំសង្ឃឹមថាអ្នកចូលចិត្តមេរៀន។ បើដូច្នេះមែន ខ្ញុំនឹងរីករាយប្រសិនបើអ្នកចែករំលែកវានៅលើបណ្តាញសង្គម ឬប្រាប់មិត្តភក្តិរបស់អ្នក។ នេះគឺជាការគាំទ្រដ៏ល្អបំផុតសម្រាប់គម្រោង។ សូមអរគុណចំពោះអ្នកដែលធ្វើបែបនេះ។ ប្រសិនបើអ្នកមានសំណួរ ឬមតិយោបល់ណាមួយ សូមសរសេរអំពីវានៅក្នុងមតិយោបល់។ ហើយឥឡូវនេះ ចូរយើងធ្វើកិច្ចការផ្ទះរបស់យើងឱ្យបានលឿន វាមានឧទាហរណ៍គួរឱ្យចាប់អារម្មណ៍ជាច្រើនទៀតជាមួយនឹងលក្ខខណ្ឌ។ សួស្តីអ្នកទាំងអស់គ្នា!

ដូច្នេះហើយ យើងដឹងពីរបៀបបង្កើត និងបង្ហាញអថេរ។ យើង​ក៏​មាន​គំនិត​ច្បាស់​លាស់​រួច​ទៅ​ហើយ​អំពី​របៀប​ដែល​អថេរ​ធ្វើ​អន្តរកម្ម​ជាមួយ​គ្នា​ក្នុង PHP។ ឥឡូវនេះវាដល់ពេលហើយដើម្បីបន្តទៅ IF-ELSE ដ៏សំខាន់បំផុត (ប្រសិនបើ - បើមិនដូច្នេះទេ) នៅក្នុង PHP ។

នេះគឺជាវាក្យសម្ព័ន្ធការងារសម្រាប់ការសាងសង់នេះ៖

IF (លក្ខខណ្ឌ) - ប្រសិនបើលក្ខខណ្ឌគឺពិត នោះ
{
សកម្មភាព
}
ផ្សេងទៀត - ប្រសិនបើលក្ខខណ្ឌមិនពិត នោះពួកគេត្រូវបានប្រតិបត្តិ
{
សកម្មភាព
}
?>

តោះមើលពីរបៀបដែលរចនាសម្ព័ន្ធដំណើរការដោយប្រើឧទាហរណ៍ជាក់លាក់មួយ៖

$c = 3;
$d = 5;
ប្រសិនបើ ($c ==$d)
{
អេកូ "អថេរគឺស្មើគ្នា";
}
ផ្សេងទៀត។
{
អេកូ "អថេរមិនស្មើគ្នា";
}
?>

អ្នក​អាច​ឃើញ​ថា​នៅ​ដើម​ដំបូង​យើង​បាន​កំណត់​អថេរ $c និង $d តម្លៃ​ខុស​គ្នា។ បន្ទាប់មកយើងកំណត់លក្ខខណ្ឌមួយ ហើយពិនិត្យមើលថាតើអថេរទាំងនេះស្មើគ្នាទៅវិញទៅមកឬអត់។ ហើយដោយសារពួកវាមិនស្មើគ្នា ផ្នែកផ្សេងទៀត និងសេចក្តីថ្លែងការណ៍អេកូត្រូវបានកេះ។ នោះគឺលទ្ធផលនៃការប្រតិបត្តិកូដនេះនឹងជាសិលាចារឹកនៅលើអេក្រង់ - អថេរមិនស្មើគ្នា។ បើមានចម្ងល់អាចសួរបាន! ខ្ញុំនឹងរីករាយឆ្លើយពួកគេ។

លក្ខខណ្ឌ IF-ELSE ទ្វេដង

វាក្យសម្ព័ន្ធដែលបានបង្ហាញខាងលើក៏អាចត្រូវបានគេហៅថាសំណង់ IF-ELSE លក្ខខណ្ឌតែមួយ។ ឥឡូវ​សូម​ធ្វើ​ឱ្យ​ស្មុគស្មាញ​ឧទាហរណ៍​ដែល​ខ្ញុំ​បាន​បង្ហាញ​ខាង​លើ ហើយ​បន្ថែម​លក្ខខណ្ឌ​មួយ​ទៀត។ ដើម្បីធ្វើដូច្នេះ យើងនឹងបង្កើតឧទាហរណ៍ 1 បន្ថែមទៀត ប៉ុន្តែយើងនឹងអនុវត្តលក្ខខណ្ឌ IF-ELSE ពីរដងរួចហើយ។

$c = 3;
$d = 5;
$e = 8;
$k = 10;
ប្រសិនបើ ($c !=$d និង $e !=$k)
{
អេកូ "អថេរមិនស្មើគ្នា";
}
ផ្សេងទៀត។
{
អេកូ "អថេរគឺស្មើគ្នា";
}
?>

ខ្ញុំចង់កត់សម្គាល់ថា != - នៅក្នុង php មានន័យថា "មិនស្មើគ្នា" ។
លក្ខខណ្ឌទ្វេរដងក្នុង php ត្រូវបានបង្កើតដោយប្រើមុខងារប៊ូលីន៖

• និង (ឡូជីខល និង php ក៏អនុញ្ញាតឱ្យអ្នកសរសេរ && ជំនួសឱ្យ និង);
• ឬ (ឡូជីខល ឬ php ក៏អនុញ្ញាតឱ្យអ្នកសរសេរ || ជំនួសឱ្យ ឬ) ។

លទ្ធផលនៃការប្រតិបត្តិកម្មវិធីរបស់យើងគឺការបង្ហាញសារ "អថេរមិនស្មើគ្នា" ។

ដូចភាសាសរសេរកម្មវិធីផ្សេងទៀត PHP មានសេចក្តីថ្លែងការណ៍ជ្រើសរើស។ សរុបមានបីប្រភេទ៖

• សេចក្តីថ្លែងការណ៍តាមលក្ខខណ្ឌប្រសិនបើ ... ផ្សេងទៀត ;
• កុងតាក់ប្តូរ;
• ប្រតិបត្តិការតាមលក្ខខណ្ឌ (?);

វាគួរឱ្យកត់សម្គាល់ថានៅក្នុង PHP មិនមានការលោតដោយគ្មានល័ក្ខខ័ណ្ឌនៅលើស្លាក goto នោះទេប៉ុន្តែទោះបីជានេះក៏ដោយពាក្យគន្លឹះ goto ត្រូវបានបម្រុងទុក។

នៅក្នុងមេរៀននេះ យើងនឹងពិនិត្យមើល if...else statement និងប្រតិបត្តិការតាមលក្ខខណ្ឌ ហើយមេរៀនបន្ទាប់នឹងគ្របដណ្តប់លើ switch switch ។

វាក្យសម្ព័ន្ធ if...else គឺដូចគ្នាទៅនឹងនៅក្នុង C:

// ប្រសិនបើ uslovie ជាការពិត នោះយើងមកទីនេះប្រតិបត្តិករ 1; // ក្នុងករណីប្រតិបត្តិករមួយប្រតិបត្តិករ 2; ... ) ផ្សេងទៀត។ {// ស្រេចចិត្ត// ប្រសិនបើ uslovie មិនពិត នោះយើងទៅទីនេះ // ក្នុងករណីប្រតិបត្តិករមួយប្រតិបត្តិករ 3; ប្រតិបត្តិករ 4; ... } ?>

// ដង្កៀបអង្កាញ់គឺស្រេចចិត្ត

• កំណត់ចំណាំ៖
• else មិនមែនជាផ្នែកដែលត្រូវការទេ ប៉ុន្តែវាត្រូវបានគេប្រើញឹកញាប់បំផុតដោយសារតែ តក្កវិជ្ជាទាមទារវា។

ដូចដែលបានកត់សម្គាល់នៅក្នុងសេចក្តីអធិប្បាយកូដ ខ្សែដៃអង្កាញ់ () មិនចាំបាច់ទេ ប្រសិនបើយើងមានសេចក្តីថ្លែងការណ៍តែមួយ។ ដោយសារលក្ខខណ្ឌអាចជាពិត (1) ឬមិនពិត (0) ទាំង operator1, operator2, etc., or operator3, operator4, etc. នឹងត្រូវបានប្រតិបត្តិ។

នេះគឺជាឧទាហរណ៍ជាក់លាក់មួយនៅក្នុង PHP៖// កំណត់តម្លៃអថេរ $num1 = 10; $num2 = 7; ប្រសិនបើ ($num1 > $num2) (// លក្ខខណ្ឌគឺពិត ដែលមានន័យថាយើងមកដល់ទីនេះ
បន្ទរ "លក្ខខណ្ឌគឺពិតព្រោះ ១០ > ៧ "; $num1+=$num2;// បន្ថែមអថេរ $num2 ទៅ $num1; បន្ទរ "\$num1 = "។ $num1;// លទ្ធផលនឹងមាន ១៧ ) else បន្ទរ "ចាប់តាំងពីស្ថានភាពវិជ្ជមាន យើងមិនមកទីនេះទេ"; ?>

// មាន​សេចក្តី​ថ្លែង​ការណ៍​មួយ​ផ្សេង​ទៀត ដូច្នេះ​មិន​មាន​ដង្កៀប​រួញ​ទេ។

នេះគឺជាឧទាហរណ៍មួយដែលឃ្លាផ្សេងទៀតត្រូវបានលុបចោល ហើយលក្ខខណ្ឌមានលក្ខខណ្ឌពីរ៖ 6) បន្ទរ "លក្ខខណ្ឌគឺពិត"; // ឧទាហរណ៍មួយទៀត៖ ប្រសិនបើ ($num1 == 10 || $num2 >= 100) បន្ទរ "លក្ខខណ្ឌគឺពិត"; ?>

// ក្នុងករណីទាំងអស់លក្ខខណ្ឌគឺពិត

សំបុកប្រសិនបើលក្ខខណ្ឌ

ដូចនៅក្នុងភាសា C ដែរ PHP អនុញ្ញាតឱ្យប្រើលក្ខខណ្ឌដែលជាប់គាំង៖// ប្រសិនបើ uslovie1 និង uslovie2 ជាការពិត នោះយើងមកទីនេះ ) ផ្សេងទៀត (// ប្រសិនបើ uslovie1 និង uslovie2 ជាការពិត នោះយើងមកទីនេះ // ប្រសិនបើ uslovie1 ពិត ហើយ uslovie2 មិនពិត នោះយើងមកទីនេះ } ?>

// ប្រសិនបើ uslovie1 និង uslovie2 មិនពិត នោះយើងមកទីនេះ

អ្នក​អាច​សរសេរ​បាន​ច្រើន​តាម​ការ​ចង់​បាន ប៉ុន្តែ​សំណង់​បែប​នេះ​គឺ​ស្មុគស្មាញ​ណាស់ ដូច្នេះ​វា​នឹង​ពិបាក​ណាស់​ក្នុង​ការ​យល់​ពី​ពួកវា​ពេល​បំបាត់​កំហុស​កម្មវិធី។ នេះជាឧទាហរណ៍ជាមួយ nested if statements៖ ?>

// លទ្ធផលនៃស្គ្រីបនេះនឹងក្លាយជាសារ៖ // $flag1 គឺពិត ហើយ $flag2 មិនពិត

លក្ខខណ្ឌសំបុកដោយប្រើ if...elseif...else

ក្នុង​ការ​សាង​សង់​បែប​នេះ ផ្សេង​ទៀត​អាច​សរសេរ​បាន​តែ​មួយ​ដង​ប៉ុណ្ណោះ ប៉ុន្តែ​បើ​អាច​សរសេរ​បាន​ច្រើន​ដង​តាម​ចិត្ត។ វាក៏ត្រូវបានគេចាត់ទុកថាការរចនាខាងលើគឺទាបជាងកុងតាក់កុងតាក់។

ដោយប្រើប្រតិបត្តិករ endif

ស្ទើរតែគ្រប់ម៉ាស៊ីនដែលបានបង្កើតនៅក្នុង PHP ប្រើប្រតិបត្តិករ endif ។ ការសាងសង់ប្រតិបត្តិករនេះត្រូវបានបង្ហាញដូចខាងក្រោម:

... ស្លាក html និងមាតិកា; ... ... ស្លាក html និងមាតិកា; ...

វាគួរអោយយកចិត្តទុកដាក់ចំពោះភាពងាយស្រួលនៃការរចនានេះជាងប្រសិនបើយើងបញ្ចេញមាតិកាទាំងអស់តាមរយៈអេកូ។ កុំភ្លេចដាក់ពោះវៀនធំក្រោយស្ថានភាព!

ការប្រើប្រាស់ប្រតិបត្តិករតាមលក្ខខណ្ឌ (?)

ការប្រើប្រាស់ប្រតិបត្តិករតាមលក្ខខណ្ឌមិនមែនជាវិធីសាស្រ្តទូទៅមិនត្រឹមតែនៅក្នុង PHP ប៉ុណ្ណោះទេប៉ុន្តែក៏ជាភាសាស្រដៀងគ្នាផ្សេងទៀតផងដែរ ប៉ុន្តែពួកគេមិនគួរត្រូវបានបំភ្លេចចោលឡើយ។ វាក្យសម្ព័ន្ធនៃប្រតិបត្តិការតាមលក្ខខណ្ឌមានដូចខាងក្រោម៖

ដំបូងមកលក្ខខណ្ឌមួយចំនួន។ ប្រសិនបើវាជាការពិត នោះ operator_1 ត្រូវបានប្រតិបត្តិ បើមិនដូច្នេះទេ operator_2 ត្រូវបានប្រតិបត្តិ។ ខ្ញុំ​គិត​ថា​ការ​សាង​សង់​មិន​សូវ​ច្បាស់​ទេ ដូច្នេះ​វា​មាន​តម្លៃ​ផ្តល់​ឧទាហរណ៍​ពីរ​បី​របស់ PHP ដើម្បី​បញ្ជាក់។ ឧទាហរណ៍ ដោយប្រើប្រតិបត្តិករតាមលក្ខខណ្ឌ អ្នកអាចអនុវត្តម៉ូឌុលនៃលេខបានយ៉ាងងាយស្រួល៖

ប្រតិបត្តិការតាមលក្ខខណ្ឌអាចមានអត្ថប្រយោជន៍ក្នុងការប្រើក្នុងកន្សោមខ្លីមួយចំនួន ដែលអ្នកត្រូវផ្លាស់ប្តូរតម្លៃនៃអថេរតែមួយអាស្រ័យលើលក្ខខណ្ឌមួយ។

ប្រសិនបើសាងសង់

វាក្យសម្ព័ន្ធសំណង់ ប្រសិនបើការរចនាស្រដៀងគ្នា ប្រសិនបើជាភាសា C៖

if (boolean expression) statement;
?>

នេះបើយោងតាមកន្សោម PHP ការសាងសង់ ប្រសិនបើមានកន្សោមប៊ូលីន។ ប្រសិនបើកន្សោម Boolean គឺពិត ( ពិត) បន្ទាប់មកប្រតិបត្តិករបន្ទាប់ពីការសាងសង់ ប្រសិនបើនឹងត្រូវបានប្រតិបត្តិ ហើយប្រសិនបើកន្សោមឡូជីខលមិនពិត ( មិនពិត) បន្ទាប់មកបន្ទាប់បន្ទាប់ ប្រសិនបើសេចក្តីថ្លែងការណ៍នឹងមិនត្រូវបានអនុវត្តទេ។ នេះគឺជាឧទាហរណ៍មួយចំនួន៖

ប្រសិនបើ ($a> $b) បន្ទរ "តម្លៃនៃ a គឺធំជាង b";
?>

ក្នុងឧទាហរណ៍ខាងក្រោម ប្រសិនបើអថេរ $aមិនស្មើនឹងសូន្យទេ ខ្សែអក្សរ “តម្លៃនៃ a គឺពិត” នឹងត្រូវបានបោះពុម្ព៖

ប្រសិនបើ ($a) បន្ទរ "តម្លៃនៃ a គឺពិត";
?>

ក្នុងឧទាហរណ៍ខាងក្រោម ប្រសិនបើ $a ជាមោឃៈ ខ្សែអក្សរ "តម្លៃនៃ a គឺមិនពិត" នឹងត្រូវបានបោះពុម្ព៖

ប្រសិនបើ (!$a) បន្ទរ "តម្លៃនៃ a គឺមិនពិត";
?>

ជាញឹកញាប់អ្នកនឹងត្រូវការប្លុកនៃសេចក្តីថ្លែងការណ៍ដែលនឹងត្រូវបានប្រតិបត្តិក្រោមលក្ខខណ្ឌលក្ខខណ្ឌជាក់លាក់មួយ បន្ទាប់មកសេចក្តីថ្លែងការណ៍ទាំងនេះនឹងត្រូវដាក់នៅក្នុងដង្កៀបអង្កាញ់។ {...} ឧទាហរណ៍៖

ប្រសិនបើ ($a > $b) (
បន្ទរ "a គឺធំជាង b";
$b = $a ;
}
?>

ឧទាហរណ៍ខាងលើនឹងបង្ហាញសារ "a គឺធំជាង b" ប្រសិនបើ $a > $bហើយបន្ទាប់មកអថេរ $aនឹងត្រូវបានស្មើនឹងអថេរ $b. ចំណាំថាប្រតិបត្តិករទាំងនេះត្រូវបានប្រតិបត្តិក្នុង ប្រសិនបើ.

ប្រសិនបើ (boolean_expression):
ក្រុម;
elseif (កន្សោម_ឡូជីខល ផ្សេងទៀត)៖
other_commands;
ផ្សេងទៀត៖
else_commands;
ចុង

យកចិត្តទុកដាក់លើការដាក់ពោះវៀនធំ ( : )! ប្រសិនបើអ្នករំលងវា សារកំហុសនឹងត្រូវបានបង្កើត។ ហើយរឿងមួយទៀត៖ ដូចធម្មតា ប្លុក elseifនិង ផ្សេងទៀត។អាចត្រូវបានលុបចោល។

elseif សាងសង់

elseifគឺជាការរួមបញ្ចូលគ្នានៃការរចនា ប្រសិនបើនិង ផ្សេងទៀត។. សំណង់នេះពង្រីកការសាងសង់តាមលក្ខខណ្ឌ បើ​ផ្សេង.

នេះគឺជាវាក្យសម្ព័ន្ធនៃសំណង់៖ elseif:

ប្រសិនបើ (boolean_expression_1)
operator_1;
elseif (boolean_expression_2)
operator_2;
ផ្សេងទៀត។
operator_3;

ឧទាហរណ៍ជាក់ស្តែងនៃការប្រើប្រាស់ការរចនា elseif:

ប្រសិនបើ ($a > $b) (
បន្ទរ "a គឺធំជាង b";
) elseif ($a == $b) (
អេកូ "a គឺស្មើនឹង b";
) ផ្សេងទៀត (
អេកូ "a គឺតិចជាង b";
}
?>

សេចក្តីថ្លែងការណ៍សំខាន់ពីរដែលផ្តល់នូវរចនាសម្ព័ន្ធសាខាតាមលក្ខខណ្ឌគឺ if និង switch ។ ត្រូវបានគេប្រើយ៉ាងទូលំទូលាយបំផុត ប្រសិនបើសេចក្តីថ្លែងការណ៍ត្រូវបានប្រើនៅក្នុងរចនាសម្ព័ន្ធលោតតាមលក្ខខណ្ឌ។ ម៉្យាងវិញទៀត នៅក្នុងស្ថានភាពមួយចំនួន ជាពិសេសប្រសិនបើអ្នកត្រូវរុករកតាមសាខាជាច្រើន អាស្រ័យលើតម្លៃនៃកន្សោមតែមួយ ហើយការប្រើប្រាស់ចំនួន if statements នាំទៅរកកូដស្មុគស្មាញ នោះ switch statement កាន់តែងាយស្រួល។ .

មុនពេលសិក្សាប្រតិបត្តិករទាំងនេះ អ្នកត្រូវយល់អំពីកន្សោមឡូជីខល និងប្រតិបត្តិការ។

ប្រតិបត្តិការឡូជីខល

ប្រតិបត្តិការឡូជីខលអនុញ្ញាតឱ្យអ្នកបញ្ចូលគ្នានូវតម្លៃឡូជីខល (ហៅផងដែរថាតម្លៃការពិត) ដើម្បីបង្កើតតម្លៃតក្កវិជ្ជាថ្មី។ ដូចដែលបានបង្ហាញក្នុងតារាងខាងក្រោម PHP គាំទ្រប្រតិបត្តិករតក្កវិជ្ជាស្តង់ដារ (និង ឬមិនមែន និង xor) ដោយពីរដំបូងមានកំណែជំនួស។

ប្រតិបត្តិការឡូជីខល PHP

ប្រតិបត្តិការ	ការពិពណ៌នា
និង	ប្រតិបត្តិការ​ដែល​លទ្ធផល​គឺ​ពិត ប្រសិន​បើ​ប្រតិបត្តិករ​ទាំងពីរ​របស់​វា​ពិត
ឬ	ប្រតិបត្តិការដែលលទ្ធផលគឺពិត ប្រសិនបើ operand មួយរបស់វា (ឬទាំងពីរ operand) គឺពិត
!	ប្រតិបត្តិការដែលលទ្ធផលគឺពិត ប្រសិនបើ operand តែមួយរបស់វា (ផ្តល់ទៅខាងស្ដាំនៃសញ្ញាប្រតិបត្តិការ) មិនពិត ហើយមិនពិត ប្រសិនបើ operand របស់វាពិត
xor	ប្រតិបត្តិការ​ដែល​លទ្ធផល​គឺ​ពិត ប្រសិនបើ​ប្រតិបត្តិករ​ណាមួយ​របស់វា (ប៉ុន្តែ​មិនមែន​ទាំងពីរ) គឺពិត
&&	ដូច​គ្នា​នឹង​ប្រតិបត្តិករ​ដែរ ប៉ុន្តែ​ចង​ប្រតិបត្តិករ​របស់​វា​ឱ្យ​តឹង​ជាង​ប្រតិបត្តិករ​នេះ។
||	ដូចគ្នានឹងប្រតិបត្តិករ ឬប្រតិបត្តិករដែរ ប៉ុន្តែចងប្រតិបត្តិកររបស់វាឱ្យតឹងជាងប្រតិបត្តិករនេះ។

ប្រតិបត្តិការ && និង || គួរតែស្គាល់អ្នកសរសេរកម្មវិធី C ។ ជាធម្មតាត្រូវបានគេហៅថាមិនមែនដោយសារតែវាក្លាយជាការបដិសេធនៃ operand ដែលវាត្រូវបានអនុវត្ត។

ដើម្បីសាកល្បងថាតើ operand ទាំងពីរគឺពិតឬអត់ អ្នកអាចប្រើ AND operator ដែលអាចត្រូវបានសរសេរជា double ampersand (&&) ផងដែរ។ ទាំងប្រតិបត្តិករ AND និង & គឺជាប្រតិបត្តិករឡូជីខល ភាពខុសគ្នាតែមួយគត់គឺថា ប្រតិបត្តិករ && មានអាទិភាពខ្ពស់ជាងប្រតិបត្តិករ AND ។ ដូចគ្នានេះដែរអនុវត្តចំពោះប្រតិបត្តិករ OR និង || ។ ប្រតិបត្តិករ AND ត្រឡប់ TRUE លុះត្រាតែប្រតិបត្តិករទាំងពីរគឺពិត។ បើមិនដូច្នេះទេ FALSE ត្រូវបានត្រឡប់មកវិញ។

ដើម្បីពិនិត្យមើលថាតើយ៉ាងហោចណាស់ operand មួយត្រឹមត្រូវឬអត់ អ្នកអាចប្រើ OR operator ដែលអាចត្រូវបានសរសេរជាបន្ទាត់បញ្ឈរទ្វេ (||) ផងដែរ។ ប្រតិបត្តិករនេះត្រឡប់ TRUE ប្រសិនបើយ៉ាងហោចណាស់ប្រតិបត្តិករមួយរបស់វាគឺ TRUE ។

នៅពេលប្រើប្រតិបត្តិករ OR នៅក្នុងកម្មវិធី កំហុសឡូជីខលតិចតួចអាចលេចឡើង។ ប្រសិនបើ PHP រកឃើញថា operand ទីមួយគឺ TRUE វានឹងមិនវាយតម្លៃតម្លៃនៃ operand ទីពីរទេ។ វាជួយសន្សំសំចៃពេលវេលាប្រតិបត្តិ ប៉ុន្តែអ្នកត្រូវតែប្រយ័ត្នដើម្បីធានាថា កូដដែលកម្មវិធីអាស្រ័យលើដំណើរការបានត្រឹមត្រូវមិនត្រូវបានដាក់ក្នុង operand ទីពីរទេ។

ប្រតិបត្តិករ XOR អនុញ្ញាតឱ្យអ្នកពិនិត្យមើលថាតើមានតែ operand មួយប៉ុណ្ណោះ (ប៉ុន្តែមិនមែនទាំងពីរទេ) គឺពិត។ ប្រតិបត្តិករ​នេះ​ត្រឡប់ TRUE ប្រសិនបើ​ប្រតិបត្តិករ​មួយ និង​មាន​តែ​មួយ​នៃ​ប្រតិបត្តិករ​របស់​វា​គឺ TRUE ។ ប្រសិនបើប្រតិបត្តិករទាំងពីរគឺពិត នោះប្រតិបត្តិករនឹងត្រឡប់ FALSE ។

អ្នកអាចដាក់បញ្ច្រាសតម្លៃឡូជីខលដោយប្រើ NOT operator ដែលជារឿយៗត្រូវបានសរសេរជាសញ្ញាឧទាន (!)។ វាត្រឡប់ TRUE ប្រសិនបើ operand គឺ FALSE និង FALSE ប្រសិនបើ operand ពិត។

តារាងខាងក្រោមបង្ហាញពីកន្សោម Boolean មួយចំនួន និងលទ្ធផលរបស់វា៖

ប្រតិបត្តិការប្រៀបធៀប

តារាងខាងក្រោមបង្ហាញពីប្រតិបត្តិការប្រៀបធៀបដែលអាចប្រើបានទាំងលេខ ឬខ្សែ៖

ប្រតិបត្តិការប្រៀបធៀប

ប្រតិបត្តិការ	ឈ្មោះ	ការពិពណ៌នា
==	ស្មើ	ប្រតិបត្តិការដែលលទ្ធផលគឺពិត ប្រសិនបើ operand របស់វាស្មើគ្នា និងមិនពិត
!=	មិនស្មើគ្នា	ប្រតិបត្តិការ​ដែល​លទ្ធផល​មិន​ពិត ប្រសិនបើ​ប្រតិបត្តិករ​របស់​វា​ស្មើគ្នា និង​ពិត​បើ​មិន​ដូច្នេះ​ទេ។
<	តិច	ប្រតិបត្តិការដែលលទ្ធផលគឺពិត ប្រសិនបើ operand ខាងឆ្វេងតិចជាង operand ខាងស្តាំ ហើយមិនពិត
>	ច្រើនទៀត	ប្រតិបត្តិការដែលលទ្ធផលគឺពិត ប្រសិនបើ operand ខាងឆ្វេងធំជាង operand ខាងស្តាំ ហើយមិនពិត
<=	តិចជាង ឬស្មើ	ប្រតិបត្តិការដែលលទ្ធផលគឺពិត ប្រសិនបើ operand ខាងឆ្វេងតិចជាង ឬស្មើនឹង operand ខាងស្តាំ ហើយមិនពិត
>=	ធំជាង ឬស្មើ	ប្រតិបត្តិការដែលលទ្ធផលគឺពិត ប្រសិនបើ operand ខាងឆ្វេងធំជាង ឬស្មើនឹង operand ខាងស្តាំ ហើយមិនពិត
===	ដូចគ្នាបេះបិទ	ប្រតិបត្តិការដែលលទ្ធផលគឺពិត ប្រសិនបើ operand ទាំងពីរស្មើគ្នា និងប្រភេទដូចគ្នា ហើយមិនពិត

កំហុសទូទៅមួយដែលអ្នកត្រូវធ្វើគឺមិនត្រូវច្រឡំប្រតិបត្តិករកិច្ចការ (=) ជាមួយប្រតិបត្តិករប្រៀបធៀប (==) ។

អាទិភាពប្រតិបត្តិការ

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

កូដ PHP $var1 = 14; $var2 = 15; ប្រសិនបើ (($var1< $var2) && ($var2 < 20)) echo "$var2 больше $var1 но меньше 20";

អាចត្រូវបានសរសេរឡើងវិញជា

កូដ PHP ...ប្រសិនបើ ($var1< $var2 && $var2 < 20) ...

សេចក្តីថ្លែងការណ៍ if-else

សេចក្តីណែនាំ ប្រសិនបើអនុញ្ញាតឱ្យប្លុកនៃកូដត្រូវបានប្រតិបត្តិ ប្រសិនបើកន្សោមតាមលក្ខខណ្ឌនៅក្នុងការណែនាំនេះវាយតម្លៃទៅ TRUE ។ បើមិនដូច្នេះទេ ប្លុកកូដមិនត្រូវបានប្រតិបត្តិទេ។ កន្សោមណាមួយអាចត្រូវបានប្រើជាលក្ខខណ្ឌ រួមទាំងការធ្វើតេស្តសម្រាប់តម្លៃមិនសូន្យ សមភាព NULL ពាក់ព័ន្ធនឹងអថេរ និងតម្លៃដែលត្រឡប់ដោយអនុគមន៍។

វាមិនមានបញ្ហាអ្វីដែលលក្ខខណ្ឌបុគ្គលបង្កើតជាប្រយោគតាមលក្ខខណ្ឌនោះទេ។ ប្រសិនបើលក្ខខណ្ឌគឺពិត កូដកម្មវិធីដែលរុំព័ទ្ធដោយដង្កៀបអង្កាញ់ (()) ត្រូវបានប្រតិបត្តិ។ បើមិនដូច្នោះទេ PHP មិនអើពើនឹងវា ហើយបន្តទៅពិនិត្យលក្ខខណ្ឌទីពីរ ដោយពិនិត្យមើលលក្ខខណ្ឌទាំងអស់ដែលអ្នកបានសរសេរចុះរហូតដល់វាប៉ះនឹងសេចក្តីថ្លែងការណ៍ ផ្សេងទៀត។បន្ទាប់ពីនោះវានឹងដំណើរការប្លុកនេះដោយស្វ័យប្រវត្តិ។ សេចក្តីថ្លែងការណ៍ផ្សេងទៀតគឺស្រេចចិត្ត.

វាក្យសម្ព័ន្ធនៃសេចក្តីថ្លែងការណ៍ if គឺ៖

ប្រសិនបើ (កន្សោមតាមលក្ខខណ្ឌ) (ប្លុកនៃកូដកម្មវិធី;)

ប្រសិនបើលទ្ធផលនៃការវាយតម្លៃកន្សោមតាមលក្ខខណ្ឌគឺពិត នោះប្លុកនៃកូដកម្មវិធីដែលមានទីតាំងនៅបន្ទាប់ពីវានឹងត្រូវបានប្រតិបត្តិ។ ក្នុងឧទាហរណ៍ខាងក្រោម ប្រសិនបើ $username ត្រូវបានកំណត់ទៅជា "Admin" សារស្វាគមន៍នឹងត្រូវបានបង្ហាញ។ បើមិនដូច្នោះទេគ្មានអ្វីនឹងកើតឡើងទេ៖

កូដ PHP $username = "អ្នកគ្រប់គ្រង"; if ($username == "Admin") (បន្ទរ "សូមស្វាគមន៍មកកាន់ទំព័រគ្រប់គ្រង។";)

ប្រសិនបើប្លុកនៃកូដកម្មវិធីមានការណែនាំតែមួយ នោះដង្កៀបអង្កាញ់គឺជាជម្រើស ប៉ុន្តែវាជាទម្លាប់ល្អក្នុងការប្រើពួកវាជានិច្ច ព្រោះវាធ្វើឱ្យកូដងាយស្រួលអាន និងកែសម្រួល។

សេចក្តីថ្លែងការណ៍ជាជម្រើសផ្សេងទៀតគឺជាប្លុកនៃកូដដែលត្រូវបានប្រតិបត្តិតាមលំនាំដើមនៅពេលដែលកន្សោមតាមលក្ខខណ្ឌវាយតម្លៃទៅ FALSE ។ សេចក្តីថ្លែងការ else មិនអាចប្រើដាច់ដោយឡែកពីសេចក្តីថ្លែងការណ៍ if បានទេ ពីព្រោះវាមិនមានកន្សោមតាមលក្ខខណ្ឌផ្ទាល់ខ្លួនទេ។ នោះគឺ ផ្សេងទៀត និងប្រសិនបើគួរតែនៅជាមួយគ្នាជានិច្ចនៅក្នុងកូដរបស់អ្នក៖

if និងសេចក្តីថ្លែងការណ៍ផ្សេងទៀត។ $username = "គ្មានអ្នកគ្រប់គ្រង"; if ($username == "Admin") (បន្ទរ "សូមស្វាគមន៍មកកាន់ទំព័រអ្នកគ្រប់គ្រង"; ) else (បន្ទរ "សូមស្វាគមន៍មកកាន់ទំព័រអ្នកប្រើប្រាស់។";)

សូមចងចាំថាត្រូវបិទប្លុកនៃកូដនៅក្នុងសេចក្តីថ្លែងការណ៍ if ជាមួយនឹងដង្កៀបអង្កាញ់ ប្រសិនបើអ្នកដាក់ទ្រនិចកោងនៅដើមប្លុក។ ប្លុកផ្សេងទៀតក៏ត្រូវតែមានដង្កៀបបើក និងបិទផងដែរ ដូចទៅនឹង if block ដែរ។

នេះគឺល្អទាំងអស់ លើកលែងតែពេលដែលអ្នកត្រូវពិនិត្យមើលលក្ខខណ្ឌជាច្រើនជាប់គ្នា។ ការណែនាំគឺសមរម្យសម្រាប់ការនេះ។ elseif. វាអនុញ្ញាតឱ្យលក្ខខណ្ឌបន្ថែមត្រូវបានសាកល្បងរហូតដល់ការពិតត្រូវបានរកឃើញ ឬឈានដល់ប្លុកផ្សេងទៀត។ សេចក្តីថ្លែងការណ៍ elseif នីមួយៗមានប្លុកកូដផ្ទាល់ខ្លួនរបស់វាដែលដាក់ភ្លាមៗបន្ទាប់ពីកន្សោមតាមលក្ខខណ្ឌរបស់ elseif ។ សេចក្តីថ្លែងការ elseif កើតឡើងបន្ទាប់ពីសេចក្តីថ្លែងការណ៍ if និងមុនសេចក្តីថ្លែងការ else if មានមួយ។

វាក្យសម្ព័ន្ធសេចក្តីថ្លែងការ elseif មានភាពស្មុគស្មាញបន្តិច ប៉ុន្តែឧទាហរណ៍ខាងក្រោមនឹងជួយអ្នកឱ្យយល់ពីវា៖

ពិនិត្យលក្ខខណ្ឌជាច្រើន។ $username = "ភ្ញៀវ"; if ($username == "Admin") (echo "Welcome to the admin page"; ) elseif ($username == "Guest") (echo "Viewing not available"; ) else (echo "Welcome to the page អ្នកប្រើប្រាស់។ ;)

នៅទីនេះលក្ខខណ្ឌពីរត្រូវបានត្រួតពិនិត្យ ហើយអាស្រ័យលើតម្លៃនៃអថេរ $username សកម្មភាពផ្សេងគ្នាត្រូវបានអនុវត្ត។ ហើយនៅតែមានឱកាសដើម្បីធ្វើអ្វីមួយប្រសិនបើតម្លៃនៃអថេរខុសពីពីរដំបូង។

ប្រតិបត្តិករ Ternary?

The ?: operator គឺជាប្រតិបត្តិករ ternary (ternary) ដែលយក operands បី។ វាដំណើរការស្រដៀងនឹង if statement ប៉ុន្តែត្រឡប់តម្លៃនៃកន្សោមមួយក្នុងចំណោមពីរ។ កន្សោមដែលនឹងត្រូវបានវាយតម្លៃត្រូវបានកំណត់ដោយកន្សោមតាមលក្ខខណ្ឌ។ ពោះវៀនធំ (:) ដើរតួជាអ្នកបំបែកកន្សោម៖

(លក្ខខណ្ឌ)? evaluate_if_condition_true៖ evaluate_if_condition_false;

ឧទាហរណ៍ខាងក្រោមពិនិត្យតម្លៃមួយ ហើយត្រឡប់ខ្សែផ្សេងគ្នាអាស្រ័យលើថាតើវាពិត ឬមិនពិត៖

បង្កើតសារដោយប្រើប្រតិបត្តិករ ? $logged_in = TRUE; $user = "Igor"; $banner = (!$logged_in) ? "ចុះឈ្មោះ!" ៖ "សូមស្វាគមន៍ការត្រលប់មកវិញ $user!"; បដា $ បដា;

វាច្បាស់ណាស់ថាសេចក្តីថ្លែងការណ៍ខាងលើគឺស្មើនឹងសេចក្តីថ្លែងការណ៍ដូចខាងក្រោម:

កូដ PHP $logged_in = TRUE; $user = "Igor"; if (!$logged_in) ( $banner = "ចុះឈ្មោះ!"; ) else ( $banner = "Welcome back, $user!"; ) បន្ទរ $banner;

ការផ្លាស់ប្តូរសេចក្តីថ្លែងការណ៍

សេចក្តីណែនាំ ប្តូរប្រៀបធៀបកន្សោមជាមួយតម្លៃច្រើន។ តាមក្បួន អថេរមួយត្រូវបានប្រើជាកន្សោម អាស្រ័យលើតម្លៃដែលប្លុកជាក់លាក់នៃកូដត្រូវតែត្រូវបានប្រតិបត្តិ។ ជាឧទាហរណ៍ ស្រមៃមើលអថេរ $action ដែលអាចមានតម្លៃ "ADD", "MODIFY" (change) និង "DELETE"។ សេចក្តីថ្លែងការណ៍ប្តូរធ្វើឱ្យងាយស្រួលក្នុងការកំណត់ប្លុកនៃកូដដែលគួរតែត្រូវបានប្រតិបត្តិសម្រាប់តម្លៃនីមួយៗនៃតម្លៃទាំងនេះ។

ដើម្បីបង្ហាញភាពខុសគ្នារវាង if និង switch statements សូមសាកល្បង variable ទល់នឹងតម្លៃច្រើន។ ឧទាហរណ៍ខាងក្រោមបង្ហាញកូដកម្មវិធីដែលអនុវត្តការត្រួតពិនិត្យបែបនេះដោយផ្អែកលើសេចក្តីថ្លែងការណ៍ if ហើយក្នុងឧទាហរណ៍ខាងក្រោម ផ្អែកលើសេចក្តីថ្លែងការណ៍ប្តូរ៖

ការធ្វើតេស្តធៀបនឹងតម្លៃមួយក្នុងចំណោមតម្លៃជាច្រើន (ប្រសិនបើសេចក្តីថ្លែងការណ៍) if ($action == "ADD") (បន្ទរ "អនុវត្តការបន្ថែម។"; បន្ទរ "ចំនួនការណែនាំក្នុងប្លុកនីមួយៗគឺគ្មានដែនកំណត់។"; ) elseif ($action == "MODIFY") (បន្ទរ "អនុវត្តការផ្លាស់ប្តូរ "; ) elseif ($action == "DELETE") (បន្ទរ "អនុវត្តការលុប។"; ) ការធ្វើតេស្តប្រឆាំងនឹងតម្លៃមួយក្នុងចំណោមតម្លៃជាច្រើន (សេចក្តីថ្លែងការណ៍ប្តូរ) switch ($action) ( case "ADD": បន្ទរ "អនុវត្តការបន្ថែម។"; បន្ទរ "ចំនួនការណែនាំក្នុងប្លុកនីមួយៗគឺគ្មានដែនកំណត់។"; break; case "MODIFY": echo "Perform a change"; break; ករណី "DELETE"៖ បន្ទរ "អនុវត្តការលុប។";

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

កន្សោមនៅជាប់នឹងសេចក្តីថ្លែងការប្តូរត្រូវតែត្រឡប់តម្លៃនៃប្រភេទបុព្វកាល ដូចជាលេខ ឬខ្សែអក្សរ។ អារេអាចប្រើជាធាតុដាច់ដោយឡែកដែលមានតម្លៃនៃប្រភេទបឋមប៉ុណ្ណោះ។

ការជ្រើសរើសលំនាំដើម

ប្រសិនបើតម្លៃនៃកន្សោមតាមលក្ខខណ្ឌមិនត្រូវគ្នានឹងជម្រើសណាមួយដែលបានស្នើឡើងក្នុង case statements នោះ switch statement ក្នុងករណីនេះអនុញ្ញាតឱ្យអ្នកធ្វើអ្វីមួយ ដូចជា statement ផ្សេងទៀតនៃ if, elseif, else សំណង់។ ដើម្បីធ្វើដូច្នេះ អ្នកត្រូវធ្វើការណែនាំជាជម្រើសចុងក្រោយក្នុងបញ្ជីជ្រើសរើស លំនាំដើម:

ការបង្កើតសារកំហុសដោយប្រើសេចក្តីថ្លែងការណ៍លំនាំដើម $action = "យកចេញ"; switch ($action) ( case "ADD": បន្ទរ "អនុវត្តការបន្ថែម។"; បន្ទរ "ចំនួនការណែនាំក្នុងប្លុកនីមួយៗគឺគ្មានដែនកំណត់។"; break; case "MODIFY": echo "Perform a change"; break; case "DELETE" : echo "អនុវត្តការលុប។"; break default: echo "Error: $action command is not valid, ".

បន្ថែមពីលើពាក្យធម្មតា សេចក្តីថ្លែងការណ៍ប្តូរគាំទ្រវាក្យសម្ព័ន្ធជំនួស - ការស្ថាបនាពាក្យគន្លឹះ switch/endswitchកំណត់ការចាប់ផ្តើម និងចុងបញ្ចប់នៃសេចក្តីថ្លែងការណ៍ជំនួសឱ្យដង្កៀបអង្កាញ់៖

សេចក្តីថ្លែងការណ៍នៃការផ្លាស់ប្តូរបញ្ចប់ដោយពាក្យគន្លឹះបញ្ចប់ switch ($action): case "ADD": បន្ទរ "អនុវត្តការបន្ថែម។";

បន្ទរ "ចំនួនការណែនាំក្នុងប្លុកនីមួយៗគឺគ្មានដែនកំណត់។";

សម្រាក;

ករណី "MODIFY"៖ បន្ទរ "អនុវត្តការកែប្រែ។"; សម្រាក;
case "DELETE"៖ បន្ទរ "អនុវត្តការលុប។";
សម្រាក;
"; }

default: echo "Error: $action command is not valid, ".

"មានតែពាក្យបញ្ជា ADD, MODIFY និង DELETE ប៉ុណ្ណោះដែលអាចប្រើបាន។"; កុងតាក់បញ្ចប់;

សន្មតថាដំណាក់កាលសាងសង់ត្រូវបានបញ្ចប់ហើយអថេរ $action ត្រូវបានកំណត់ទៅជា "PACKAGE" លទ្ធផលខាងក្រោមនឹងទទួលបាន៖

ខ្ចប់។ ប្រគល់ជូនអតិថិជន។

ជួនកាល ការមិនមានសេចក្តីថ្លែងការណ៍បំបែកគឺមានប្រយោជន៍ ដូចក្នុងឧទាហរណ៍ខាងលើ ដែលដំណាក់កាលនៃការបញ្ជាទិញត្រូវបានបង្កើតឡើង ប៉ុន្តែក្នុងករណីភាគច្រើនសេចក្តីថ្លែងការណ៍នេះគួរតែត្រូវបានប្រើ។

ប្រភេទទិន្នន័យ Cycles 1 2 3 4 5 6 7 8 9 10