មាតិកា
នៅក្នុងដំណើរការនៃការរៀនកម្មវិធី ជារឿយៗចាំបាច់ត្រូវបង្កើតកម្មវិធីដែលមិនងាយស្រួលអនុវត្តក្នុងជីវិតពិត។ យ៉ាងណាមិញ ពីពេលមួយទៅពេលមួយ អ្នកត្រូវតែធ្វើតាមការណែនាំតែក្នុងលក្ខខណ្ឌមួយចំនួនប៉ុណ្ណោះ។ ដើម្បីអាចអនុវត្តវាក្នុងកម្មវិធី ភាសាទាំងអស់មានសេចក្តីថ្លែងការណ៍គ្រប់គ្រង។ ដោយមានជំនួយរបស់ពួកគេ អ្នកអាចគ្រប់គ្រងលំហូរនៃការអនុវត្តកូដ បង្កើតរង្វិលជុំ ឬអនុវត្តសកម្មភាពជាក់លាក់បានលុះត្រាតែលក្ខខណ្ឌជាក់លាក់មួយជាការពិត។
ថ្ងៃនេះយើងនឹងនិយាយអំពី if statement ដែលពិនិត្យមើលស្ថានភាពបច្ចុប្បន្នសម្រាប់លក្ខខណ្ឌជាក់លាក់មួយ ហើយផ្អែកលើព័ត៌មាននេះ ធ្វើការសម្រេចចិត្តអំពីសកម្មភាពបន្ថែមទៀត។
ប្រភេទនៃសេចក្តីថ្លែងការណ៍ត្រួតពិនិត្យ
ជាទូទៅ ប្រសិនបើមិនមែនជាសេចក្តីថ្លែងការណ៍តែមួយគត់ដែលគ្រប់គ្រងលំហូរនៃកម្មវិធីនោះទេ។ ក៏ដូចជាគាត់ផ្ទាល់អាចជាធាតុផ្សំនៃខ្សែសង្វាក់ប្រតិបត្តិករដ៏ធំ។
វាក៏មានរង្វិលជុំ និងសេចក្តីថ្លែងការណ៍ដែលគ្រប់គ្រងដំណើរការនៃការប្រតិបត្តិរបស់វា។ ថ្ងៃនេះយើងនឹងនិយាយអំពីប្រតិបត្តិករដែលមានលក្ខខណ្ឌ និងខ្សែសង្វាក់ដែលវាអាចចូលរួមបាន។
ក្នុងការសរសេរកម្មវិធីមានរឿងមួយដូចជាការបែកបាក់។ វាច្បាស់ណាស់ថានេះមានន័យថាលំដាប់នៃពាក្យបញ្ជាដែលត្រូវបានប្រតិបត្តិលុះត្រាតែលក្ខខណ្ឌជាក់លាក់មួយគឺពិត។ លក្ខណៈវិនិច្ឆ័យខ្លួនឯងអាចខុសគ្នា៖
- សមភាពនៃអថេរទៅតម្លៃជាក់លាក់មួយ។
- អនុវត្តសកម្មភាពជាក់លាក់មួយ។
- ស្ថានភាពកម្មវិធី (ដួលរលំឬអត់) ។
វិសាលគមអាចមានទំហំធំជាង។ សេចក្តីថ្លែងការណ៍តាមលក្ខខណ្ឌមានច្រើនប្រភេទ៖
- ជាមួយនឹងសាខាមួយ។ នោះគឺការត្រួតពិនិត្យតែមួយត្រូវបានអនុវត្ត ដែលជាលទ្ធផលដែលសកម្មភាពជាក់លាក់ត្រូវបានអនុវត្ត។
- ជាមួយនឹងសាខាពីរឬច្រើន។ ប្រសិនបើលក្ខណៈវិនិច្ឆ័យ 1 គឺពិត បន្ទាប់មកពិនិត្យមើលលក្ខណៈវិនិច្ឆ័យ 2. ប្រសិនបើវាជាការពិត នោះពិនិត្យមើល 3. ដូច្នេះហើយ ធ្វើការត្រួតពិនិត្យឱ្យបានច្រើនតាមតម្រូវការ។
- ជាមួយនឹងលក្ខខណ្ឌមួយចំនួន។ អ្វីគ្រប់យ៉ាងគឺសាមញ្ញនៅទីនេះ។ អ្នកបកប្រែពិនិត្យមើលលក្ខខណ្ឌជាច្រើន ឬមួយក្នុងចំណោមពួកគេ។
ប្រសិនបើសេចក្តីថ្លែងការណ៍
រចនាសម្ព័ន្ធនៃសេចក្តីថ្លែងការណ៍ if គឺស្រដៀងគ្នានៅក្នុងគ្រប់ភាសា។ ទោះយ៉ាងណាក៏ដោយនៅក្នុង Python វាក្យសម្ព័ន្ធរបស់វាគឺខុសគ្នាខ្លះពីអ្វីផ្សេងទៀតទាំងអស់៖
ប្រសិនបើលក្ខខណ្ឌ៖
<входящее выражение ១>
<входящее выражение ១>
<не входящее выражение>
ដំបូងប្រតិបត្តិករខ្លួនឯងត្រូវបានប្រកាសបន្ទាប់ពីនោះលក្ខខណ្ឌដែលវាចាប់ផ្តើមដំណើរការត្រូវបានសរសេរ។ លក្ខខណ្ឌអាចពិតឬមិនពិត។
នេះត្រូវបានបន្តដោយប្លុកដែលមានពាក្យបញ្ជា។ ប្រសិនបើវាធ្វើតាមលក្ខណៈវិនិច្ឆ័យដែលត្រូវបំពេញភ្លាមៗនោះ លំដាប់នៃពាក្យបញ្ជាដែលត្រូវគ្នាត្រូវបានគេហៅថា ប្លុក if ។ អ្នកអាចប្រើពាក្យបញ្ជាមួយចំនួននៅក្នុងវា។
យកចិត្តទុកដាក់! ការចូលបន្ទាត់នៅក្នុងទាំងអស់ប្រសិនបើពាក្យបញ្ជាប្លុកត្រូវតែមានទំហំដូចគ្នា។ ព្រំដែនប្លុកត្រូវបានកំណត់ដោយការចូលបន្ទាត់។
យោងតាមឯកសារភាសា ការចូលបន្ទាត់គឺ 4 ដកឃ្លា។
តើប្រតិបត្តិករនេះដំណើរការយ៉ាងដូចម្តេច? នៅពេលអ្នកបកប្រែឃើញពាក្យ if វាពិនិត្យកន្សោមភ្លាមៗប្រឆាំងនឹងលក្ខណៈវិនិច្ឆ័យដែលកំណត់ដោយអ្នកប្រើប្រាស់។ ប្រសិនបើនេះជាករណីនោះ គាត់ចាប់ផ្តើមស្វែងរកការណែនាំ ហើយធ្វើតាមពួកគេ។ បើមិនដូច្នេះទេ ពាក្យបញ្ជាទាំងអស់ពីប្លុកនេះត្រូវបានរំលង។
ប្រសិនបើសេចក្តីថ្លែងការណ៍បន្ទាប់ពីលក្ខខណ្ឌមិនត្រូវបានចូលបន្ទាត់ វាមិនត្រូវបានចាត់ទុកជា if block ទេ។ នៅក្នុងស្ថានភាពរបស់យើងបន្ទាត់នេះគឺ
នេះគឺជាព័ត៌មានសង្ខេបនៃកូដសម្រាប់ឧទាហរណ៍អំពីរបៀបដែលប្រតិបត្តិករនេះដំណើរការ។
លេខ = int(បញ្ចូល("បញ្ចូលលេខ៖"))
ប្រសិនបើលេខ > 10:
បោះពុម្ព ("លេខធំជាង 10")
កម្មវិធីនេះជម្រុញឱ្យអ្នកប្រើប្រាស់នូវលេខមួយ ហើយពិនិត្យមើលថាតើវាធំជាង 10 ដែរឬទេ។ បើដូច្នេះមែន វាត្រឡប់ព័ត៌មានដែលសមរម្យ។ ឧទាហរណ៍ប្រសិនបើអ្នកប្រើបញ្ចូលលេខ 5 នោះកម្មវិធីនឹងបញ្ចប់ដោយសាមញ្ញហើយនោះជាវា។
ប៉ុន្តែប្រសិនបើអ្នកបញ្ជាក់លេខ 100 នោះអ្នកបកប្រែនឹងយល់ថាវាលើសពីដប់ហើយរាយការណ៍វា។
យកចិត្តទុកដាក់! ក្នុងករណីរបស់យើង ប្រសិនបើលក្ខខណ្ឌមិនពិត នោះកម្មវិធីនឹងឈប់ ព្រោះគ្មានពាក្យបញ្ជាណាមួយត្រូវបានផ្តល់ឱ្យបន្ទាប់ពីការណែនាំនោះទេ។
មានពាក្យបញ្ជាតែមួយគត់នៅក្នុងកូដខាងលើ។ ប៉ុន្តែមានពួកគេជាច្រើនទៀត។ តម្រូវការតែមួយគត់គឺការចូលបន្ទាត់។
ឥឡូវនេះសូមវិភាគលំដាប់នៃពាក្យបញ្ជានេះ។
លេខ = int(បញ្ចូល("សរសេរលេខ៖"))
ប្រសិនបើលេខ > 10:
បោះពុម្ព ("ជួរទីមួយ")
បោះពុម្ព ("បន្ទាត់ទីពីរ")
បោះពុម្ព ("បន្ទាត់ទីបី")
បោះពុម្ព ("បន្ទាត់ដែលត្រូវបានប្រតិបត្តិ ដោយមិនគិតពីលេខដែលបានបញ្ចូល")
បោះពុម្ព ("កម្មវិធីបញ្ចប់")
ព្យាយាមទាយថាតើលទ្ធផលនឹងទៅជាយ៉ាងណា ប្រសិនបើអ្នកបញ្ចូលតម្លៃ 2, 5, 10, 15, 50 ។
ដូចដែលអ្នកអាចឃើញប្រសិនបើលេខដែលបានបញ្ចូលដោយអ្នកប្រើប្រាស់គឺច្រើនជាងដប់នោះ បីបន្ទាត់គឺលទ្ធផល + មួយជាមួយនឹងអត្ថបទ "រត់រាល់ពេល ... " និងមួយ "បញ្ចប់" ហើយប្រសិនបើតិចជាងដប់ នោះមានតែមួយជាមួយ អត្ថបទផ្សេង។ មានតែបន្ទាត់ 3,4,5 នឹងត្រូវបានប្រតិបត្តិប្រសិនបើពិត។ ទោះយ៉ាងណាក៏ដោយ បន្ទាត់ពីរចុងក្រោយនឹងត្រូវបានសរសេរមិនថាលេខអ្វីដែលអ្នកប្រើប្រាស់បញ្ជាក់នោះទេ។
ប្រសិនបើអ្នកប្រើសេចក្តីថ្លែងការណ៍ដោយផ្ទាល់នៅក្នុងកុងសូល លទ្ធផលនឹងខុសគ្នា។ អ្នកបកប្រែនឹងបើករបៀបពហុបន្ទាត់ភ្លាមៗ ប្រសិនបើបន្ទាប់ពីបញ្ជាក់លក្ខណៈវិនិច្ឆ័យនៃការផ្ទៀងផ្ទាត់រួច ចុច Enter ។
ឧបមាថាយើងបានសរសេរលំដាប់ដូចខាងក្រោមនៃពាក្យបញ្ជា។
>>>
>>> n = 100
>>> ប្រសិនបើ n > 10:
...
បន្ទាប់ពីនោះ យើងនឹងឃើញថា >>> ត្រូវបានជំនួសដោយពងក្រពើ។ នេះមានន័យថារបៀបបញ្ចូលពហុបន្ទាត់ត្រូវបានបើក។ នៅក្នុងពាក្យសាមញ្ញប្រសិនបើអ្នកចុច Enter អ្នកនឹងត្រូវបានផ្ទេរទៅការបញ្ចូលនៃដំណាក់កាលទីពីរនៃការណែនាំ។
ហើយដើម្បីចេញពីប្លុកនេះ អ្នកត្រូវបន្ថែមសំណង់មួយបន្ថែមទៀតទៅប្លុក if.
>>>
>>> n = 100
>>> ប្រសិនបើ n > 10:
… បោះពុម្ព(«nv 10»)
...
ប្រសិនបើលក្ខខណ្ឌមិនពិត នោះកម្មវិធីនឹងបញ្ចប់។ នេះជាបញ្ហា ដោយសារអ្នកប្រើអាចយល់ឃើញថាកម្មវិធីដូចជាបានបិទដោយសារតែបរាជ័យ។ ដូច្នេះ ចាំបាច់ត្រូវផ្តល់មតិត្រឡប់ទៅកាន់អ្នកប្រើប្រាស់។ សម្រាប់ការនេះ តំណភ្ជាប់មួយត្រូវបានប្រើប្រាស់ ប្រសិនបើមានផ្សេងទៀត.
ប្រតិបត្តិករកន្សោម ប្រសិនបើមានផ្សេងទៀត
ប្រតិបត្តិករនេះអនុញ្ញាតឱ្យអ្នកអនុវត្តតំណមួយ៖ ប្រសិនបើកន្សោមត្រូវគ្នានឹងច្បាប់ជាក់លាក់ អនុវត្តសកម្មភាពទាំងនេះ ហើយបើមិនដូច្នេះទេ នោះផ្សេងទៀត។ នោះគឺវាអនុញ្ញាតឱ្យអ្នកបែងចែកលំហូរនៃកម្មវិធីទៅជាផ្លូវពីរ។ វាក្យសម្ព័ន្ធគឺវិចារណញាណ៖
ប្រសិនបើលក្ខខណ្ឌ៖
# ប្រសិនបើរារាំង
សេចក្តីថ្លែងការណ៍ 1
សេចក្តីថ្លែងការណ៍ 2
លល
ផ្សេងទៀត:
# ប្លុកផ្សេងទៀត។
សេចក្តីថ្លែងការណ៍ 3
សេចក្តីថ្លែងការណ៍ 4
លល:
ចូរពន្យល់ពីរបៀបដែលប្រតិបត្តិករនេះដំណើរការ។ ដំបូង សេចក្តីថ្លែងការណ៍ស្តង់ដារត្រូវបានប្រតិបត្តិក្នុងខ្សែស្រឡាយ បាទ ពិនិត្យមើលថាតើវាត្រូវគ្នា។ ស្ថានភាព "ត្រូវឬខុស"។ សកម្មភាពបន្ថែមទៀតអាស្រ័យលើលទ្ធផលនៃការត្រួតពិនិត្យ។ ប្រសិនបើជាការពិត ការណែនាំដែលមាននៅក្នុងលំដាប់នៃការណែនាំដែលធ្វើតាមលក្ខខណ្ឌត្រូវបានប្រតិបត្តិដោយផ្ទាល់។ បាទ ប្រសិនបើវាមិនពិត ផ្សេងទៀត.
វិធីនេះអ្នកអាចដោះស្រាយកំហុស។ ឧទាហរណ៍ អ្នកប្រើប្រាស់ត្រូវបញ្ចូលកាំ។ ជាក់ស្តែង វាអាចគ្រាន់តែជាលេខដែលមានសញ្ញាបូក ឬវាជាតម្លៃទទេ។ ប្រសិនបើវាតិចជាង 0 នោះអ្នកត្រូវចេញសារដែលសុំឱ្យអ្នកបញ្ចូលលេខវិជ្ជមាន។
នេះគឺជាកូដដែលអនុវត្តកិច្ចការនេះ។ ប៉ុន្តែមានកំហុសមួយនៅទីនេះ។ សាកទាយមើលថាមួយណា។
កាំ = int(បញ្ចូល("បញ្ចូលកាំ៖"))
ប្រសិនបើកាំ >= 0:
បោះពុម្ព ("រង្វង់ = ", 2 * 3.14 * កាំ)
បោះពុម្ព ("តំបន់ = ", 3.14 * កាំ ** 2)
ផ្សេងទៀត:
បោះពុម្ព ("សូមបញ្ចូលលេខវិជ្ជមាន")
កំហុសការចូលបន្ទាត់មិនត្រូវគ្នា។ ប្រសិនបើ និងផ្សេងទៀត។ ត្រូវតែមានទីតាំងនៅដោយគ្មានពួកវា ឬជាមួយចំនួនដូចគ្នានៃពួកវា (អាស្រ័យលើថាតើពួកវាត្រូវបានដាក់សំបុកឬអត់)។
ចូរផ្តល់ករណីប្រើប្រាស់មួយផ្សេងទៀត (ដែលអ្វីៗនឹងត្រឹមត្រូវជាមួយនឹងការតម្រឹមប្រតិបត្តិករ) - ធាតុកម្មវិធីដែលពិនិត្យពាក្យសម្ងាត់។
ពាក្យសម្ងាត់ = បញ្ចូល (“បញ្ចូលពាក្យសម្ងាត់៖“)
ប្រសិនបើពាក្យសម្ងាត់ == « sshh »:
បោះពុម្ព ("ស្វាគមន៍")
ផ្សេងទៀត:
បោះពុម្ព ("ការចូលប្រើត្រូវបានបដិសេធ")
ការណែនាំនេះរំលងបុគ្គលនោះបន្ថែមទៀត ប្រសិនបើពាក្យសម្ងាត់គឺ sshh ។ ប្រសិនបើការរួមផ្សំគ្នានៃអក្សរ និងលេខណាមួយ នោះវាបង្ហាញសារថា "ការចូលប្រើត្រូវបានបដិសេធ"។
statement-expression if-elif-else
លុះត្រាតែលក្ខខណ្ឌមួយចំនួនមិនពិត សេចក្តីថ្លែងការណ៍ដែលមាននៅក្នុងប្លុកត្រូវបានប្រតិបត្តិ។ ផ្សេងទៀត. កន្សោមនេះដំណើរការដូចនេះ។
ប្រសិនបើលក្ខខណ្ឌ_1:
# ប្រសិនបើរារាំង
សេចក្តីថ្លែងការណ៍
សេចក្តីថ្លែងការណ៍
សេចក្តីថ្លែងការណ៍បន្ថែមទៀត
លក្ខខណ្ឌ elif_2៖
# ប្លុកអេលីហ្វដំបូង
សេចក្តីថ្លែងការណ៍
សេចក្តីថ្លែងការណ៍
សេចក្តីថ្លែងការណ៍បន្ថែមទៀត
លក្ខខណ្ឌ elif_3៖
# ប្លុកអេលីហ្វទីពីរ
សេចក្តីថ្លែងការណ៍
សេចក្តីថ្លែងការណ៍
សេចក្តីថ្លែងការណ៍បន្ថែមទៀត
...
ផ្សេងទៀត
សេចក្តីថ្លែងការណ៍
សេចក្តីថ្លែងការណ៍
សេចក្តីថ្លែងការណ៍បន្ថែមទៀត
អ្នកអាចបញ្ជាក់ចំនួនលក្ខខណ្ឌបន្ថែមណាមួយ។.
សេចក្តីថ្លែងការណ៍ដែលលាក់
វិធីមួយទៀតដើម្បីអនុវត្តលក្ខខណ្ឌជាច្រើនគឺបញ្ចូលការត្រួតពិនិត្យលក្ខខណ្ឌបន្ថែមនៅក្នុង if block ។
ប្រតិបត្តិករ if នៅខាងក្នុងប្លុកលក្ខខណ្ឌផ្សេងទៀត។
gre_score = int(បញ្ចូល("បញ្ចូលដែនកំណត់ឥណទានបច្ចុប្បន្នរបស់អ្នក"))
per_grad = int(បញ្ចូល("បញ្ចូលការវាយតម្លៃឥណទានរបស់អ្នក៖"))
ប្រសិនបើ per_grad > 70:
# ខាងក្រៅប្រសិនបើរារាំង
ប្រសិនបើ gre_score> 150:
# ខាងក្នុងប្រសិនបើប្លុក
បោះពុម្ព ("សូមអបអរសាទរអ្នកបានទទួលប្រាក់កម្ចី")
ផ្សេងទៀត:
បោះពុម្ព ("សូមអភ័យទោស អ្នកមិនមានសិទ្ធិទទួលបានប្រាក់កម្ចី")
កម្មវិធីនេះធ្វើការត្រួតពិនិត្យការវាយតម្លៃឥណទាន។ ប្រសិនបើវាតិចជាង 70 កម្មវិធីរាយការណ៍ថាអ្នកប្រើប្រាស់មិនមានសិទ្ធិទទួលបានឥណទានទេ។ ប្រសិនបើវាធំជាង ការត្រួតពិនិត្យលើកទីពីរត្រូវបានអនុវត្តដើម្បីមើលថាតើដែនកំណត់ឥណទានបច្ចុប្បន្នធំជាង 150។ ប្រសិនបើបាទ/ចាស នោះសារមួយត្រូវបានបង្ហាញថាប្រាក់កម្ចីត្រូវបានចេញ។
ប្រសិនបើតម្លៃទាំងពីរមិនពិត នោះសារមួយត្រូវបានបង្ហាញថាអ្នកប្រើប្រាស់មិនមានលទ្ធភាពទទួលបានប្រាក់កម្ចីទេ។
ឥឡូវយើងធ្វើកម្មវិធីនោះឡើងវិញបន្តិច។
gre_score = int(បញ្ចូល("បញ្ចូលដែនកំណត់បច្ចុប្បន្ន៖"))
per_grad = int(បញ្ចូល("បញ្ចូលពិន្ទុឥណទាន៖"))
ប្រសិនបើ per_grad > 70:
ប្រសិនបើ gre_score> 150:
បោះពុម្ព ("សូមអបអរសាទរអ្នកបានទទួលប្រាក់កម្ចី")
ផ្សេងទៀត:
បោះពុម្ព ("ដែនកំណត់ឥណទានរបស់អ្នកទាប")
ផ្សេងទៀត:
បោះពុម្ព ("សូមទោស អ្នកមិនមានសិទ្ធិទទួលបានឥណទាន")
កូដខ្លួនវាគឺស្រដៀងគ្នាខ្លាំងណាស់ ប៉ុន្តែមានសំបុក if ក៏ផ្តល់នូវក្បួនដោះស្រាយក្នុងករណីដែលលក្ខខណ្ឌពីវាប្រែទៅជាមិនពិត។ នោះគឺដែនកំណត់លើកាតគឺមិនគ្រប់គ្រាន់ទេ ប៉ុន្តែប្រវត្តិឥណទានគឺល្អ សារ "អ្នកមានចំណាត់ថ្នាក់ឥណទានទាប" ត្រូវបានបង្ហាញ។
សេចក្តីថ្លែងការណ៍ if-else នៅក្នុងលក្ខខណ្ឌមួយ។ ផ្សេងទៀត
ចូរបង្កើតកម្មវិធីមួយទៀតដែលកំណត់ថ្នាក់របស់សិស្សដោយផ្អែកលើពិន្ទុតេស្ត។
ពិន្ទុ = int(បញ្ចូល("បញ្ចូលពិន្ទុរបស់អ្នក៖"))
ប្រសិនបើពិន្ទុ >= 90:
បោះពុម្ព ("អស្ចារ្យណាស់! ថ្នាក់របស់អ្នកគឺ A")
ផ្សេងទៀត:
ប្រសិនបើពិន្ទុ >= 80:
បោះពុម្ព ("អស្ចារ្យណាស់! ថ្នាក់របស់អ្នកគឺ B")
ផ្សេងទៀត:
ប្រសិនបើពិន្ទុ >= 70:
បោះពុម្ព ("ល្អ! ថ្នាក់របស់អ្នកគឺ C")
ផ្សេងទៀត:
ប្រសិនបើពិន្ទុ >= 60:
បោះពុម្ព ("ថ្នាក់របស់អ្នកគឺ D. វាមានតម្លៃធ្វើសម្ភារៈម្តងទៀត។")
ផ្សេងទៀត:
បោះពុម្ព ("អ្នកបានបរាជ័យក្នុងការប្រឡង")
កម្មវិធីដំបូងពិនិត្យមើលថាតើពិន្ទុធំជាង ឬស្មើ 90។ ប្រសិនបើបាទ/ចាស នោះវានឹងផ្តល់ពិន្ទុ A មកវិញ។ ប្រសិនបើលក្ខខណ្ឌនេះមិនពិត នោះការត្រួតពិនិត្យជាបន្តបន្ទាប់ត្រូវបានអនុវត្ត។ យើងឃើញថាក្បួនដោះស្រាយគឺស្ទើរតែដូចគ្នានៅ glance ដំបូង។ ដូច្នេះជំនួសឱ្យការពិនិត្យមើលខាងក្នុង ផ្សេងទៀត ល្អប្រសើរជាងមុនដើម្បីប្រើបន្សំ if-elif-else.
ដូច្នេះប្រតិបត្តិករ if អនុវត្តមុខងារសំខាន់ណាស់ - វាធ្វើឱ្យប្រាកដថាបំណែកមួយចំនួននៃកូដត្រូវបានប្រតិបត្តិលុះត្រាតែមានតម្រូវការសម្រាប់វា។ វាមិនអាចទៅរួចទេក្នុងការស្រមៃមើលការសរសេរកម្មវិធីដោយគ្មានវា ពីព្រោះសូម្បីតែក្បួនដោះស្រាយសាមញ្ញបំផុតក៏ទាមទារសមដូចជា "ប្រសិនបើអ្នកទៅខាងឆ្វេង អ្នកនឹងឃើញវា ហើយប្រសិនបើអ្នកទៅខាងស្តាំ នោះអ្នកត្រូវធ្វើដូចនេះ។"