# JavaScript មូលដ្ឋាន៖ ការធ្វើសេចក្តីសម្រេច ![JavaScript Basics - Making decisions](../../../../translated_images/km/webdev101-js-decisions.69e1b20f272dd1f0.webp) > សេចក្តីសង្ខេបដោយ [Tomomi Imura](https://twitter.com/girlie_mac) ```mermaid journey title ការផ្សងព្រេងការជ្រើសរើស JavaScript របស់អ្នក section មូលដ្ឋាន តម្លៃ Boolean: 5: អ្នក អូបឺរ៉ាទ័រប្រកួតប្រជែង: 4: អ្នក សிந்தិតយុទ្ធសាស្ត្រពិតប្រាកដ: 5: អ្នក section ការជ្រើសរើសមូលដ្ឋាន ពាក្យបោះពុម្ភ If: 4: អ្នក តិចតួច If-Else: 5: អ្នក ពាក្យបោះពុម្ភ Switch: 4: អ្នក section យុទ្ធសាស្ត្រលំដាប់ខ្ពស់ អូបឺរ៉ាទ័រយុទ្ធសាស្ត្រ: 5: អ្នក លក្ខខណ្ឌស្មុគស្មាញ: 4: អ្នក ដំណាក់កាល Ternary: 5: អ្នក ``` តើអ្នកធ្លាប់ចាប់អារម្មណ៍ថាអ្នកប្រើកម្មវិធីធ្វើសេចក្តីសម្រេចយ៉ាងច្បាស់យ៉ាងដូចម្តេចទេ? ដូចជា របៀបដែលប្រព័ន្ធណាវីហ្គេសិនជ្រើសរើសផ្លូវដែលលឿនបំផុត ឬរបៀបដែលធម្មតាស្ថិតិគណនាតម្លៃការបើកឬបិទកំដៅ? នេះជាគំនិតមូលដ្ឋាននៃការធ្វើសេចក្តីសម្រេចក្នុងកម្មវិធី។ ដូចដែលម៉ាស៊ីនវិភាគលំអិតរបស់ Charles Babbage ត្រូវបានរចនាឡើងដើម្បីដើរការប្រតិបត្តិលំដាប់ផ្សេងៗតាមលក្ខខណ្ឌ កម្មវិធី JavaScript សម័យទំនើបត្រូវការធ្វើជម្រើសដោយផ្អែកលើស្ថានភាពនិងលក្ខខណ្ឌអាចផ្លាស់ប្តូរបាន។ សមត្ថភាពក្នុងការបំបែកផ្លូវ និងធ្វើសេចក្តីសម្រេចនេះគឺជាអ្វីដែលបំលែងកូដជាស្ថិតសាស្ត្រជាកម្មវិធីឆ្លាតវៃឆ្លើយតប។ នៅក្នុងមេរៀននេះ អ្នកនឹងរៀនរបៀបដើម្បីអនុវត្តន៍បច្ចេកទេសលក្ខខណ្ឌនៅក្នុងកម្មវិធីរបស់អ្នក។ យើងនឹងស្វែងយល់អំពីពាក្យសន្សំពាក្យមានលក្ខខណ្ឌ អ្នកបញ្ជាការប្រៀបធៀប និងពាក្យសម្តីយល់ស្មារតីដែលអាចអនុញ្ញាតឱ្យកូដរបស់អ្នកវាយតម្លៃលក្ខខណ្ឌហើយឆ្លើយតបត្រឹមត្រូវ។ ## សំណួរប្រឡងមុនមេរៀន [សំណួរប្រឡងមុនមេរៀន](https://ff-quizzes.netlify.app/web/quiz/11) សមត្ថភាពក្នុងការធ្វើសេចក្តីសម្រេច និងគ្រប់គ្រងការចរន្តកម្មវិធីគឺជាផ្នែកមូលដ្ឋាននៃកម្មវិធី។ ផ្នែកនេះគ្របដណ្ដប់ពីរបៀបគ្រប់គ្រងផ្លូវអនុវត្តន៍កម្មវិធី JavaScript របស់អ្នកដោយប្រើតម្លៃ Boolean និងបច្ចេកទេសលក្ខខណ្ឌ។ [![Making Decisions](https://img.youtube.com/vi/SxTp8j-fMMY/0.jpg)](https://youtube.com/watch?v=SxTp8j-fMMY "Making Decisions") > 🎥 ចុចរូបភាពខាងលើសម្រាប់វីដេអូអំពីការធ្វើសេចក្តីសម្រេច។ > អ្នកអាចយកមេរៀននេះនៅលើ [Microsoft Learn](https://docs.microsoft.com/learn/modules/web-development-101-if-else/?WT.mc_id=academic-77807-sagibbon) បានផងដែរ! ```mermaid mindmap root((ការប្រក្រតីសំរើស)) Boolean Logic ពិត/មិនពិត លទ្ធផលការប្រៀបធៀប សមីការយល់ធម្មតា Conditional Statements ប្រក្រតី if លក្ខខណ្ឌតែមួយ ការអនុវត្តកូដ if-else ផ្លូវពីរទៅ សកម្មភាពជាជម្រើសផ្សេងទៀត switch ជម្រើសច្រើន រចនាសម្ព័ន្ធស្អាត Operators Comparison === !== < > <= >= ទំនាក់ទំនងតម្លៃ Logical && || ! បញ្ចូលលក្ខខណ្ឌ Advanced Patterns Ternary ? : វិធីសាស្រ្ត ការសំរើសត្រង់បន្ទាត់ Complex Logic លក្ខខណ្ឌសុីវិលផ្សំ ធាតុច្រើន ``` ## ការត្រួតពិនិត្យវិញរហ័សអំពី Boolean មុននឹងស្វែងយល់អំពីការធ្វើសេចក្តីសម្រេច មកត្រួតពិនិត្យតម្លៃ Boolean ដែលយើងបានរៀននៅមេរៀនមុនវិញ។ តម្លៃទាំងនេះមានឈ្មោះបន្ទាប់ពីអ្នកគណិតវិទ្យា George Boole ដែលតំណាងឱ្យស្ថានភាពពីរប្រភេទពីរប្រភេទ — ឬជា `true` ឬជា `false`។ គ្មានភាពអន្មត់មួយណាទេ ពុំមានចំណុចកណ្តាលទេ។ តម្លៃពីរប្រភេទនេះគឺជាមូលដ្ឋាននៃកំណត់ត្រាអាល់ហ្គូរីធម៍គណនា។ សេចក្តីសម្រេចគ្រប់យ៉ាងដែលកម្មវិធីរបស់អ្នកធ្វើការ វាជាការវាយតម្លៃ Boolean។ ការបង្កើតអថេរ Boolean គឺសាមញ្ញ៖ ```javascript let myTrueBool = true; let myFalseBool = false; ``` នេះបង្កើតអថេរស្នាដៃពីរដែលមានតម្លៃ Boolean ប្រាក់ប្រាស់។ ✅ Boolean មានឈ្មោះបន្ទាប់ពីអ្នកគណិតវិទ្យា និងទស្សនវិជ្ជាជន និងអ្នកវិភាគតំណាងថាមនុស្សលោក George Boole (1815–1864)។ ## អ្នកបញ្ជាការប្រៀបធៀប និង Boolean នៅក្នុងការអនុវត្ត អ្នកធ្លាប់តិចតួចប្រើតម្លៃ Boolean ដោយដៃ។ ផ្ទុយទៅវិញ អ្នកនឹងបង្កើតវាដោយការវាយតម្លៃលក្ខខណ្ឌ៖ "លេខនេះធំជាងលេខនោះទេ?" ឬ "តម្លៃទាំងនេះស្មើគ្នាទេ?" អ្នកបញ្ជាការប្រៀបធៀបអនុញ្ញាតឱ្យធ្វើការវាយតម្លៃទាំងនេះ។ ពួកវាប្រៀបធៀបទម្លៃ និងបញ្ចេញតម្លៃ Boolean មួយស្រាប់លើទំនាក់ទំនងរវាងអូប៉េរ៉ង់។ | រូបសញ្ញា | សង្ខេបមាតិការពិពណ៍នា | ឧទាហរណ៍ | | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------- | | `<` | **តិចជាង**៖ ប្រៀបធៀបទាំពីរតម្លៃ ហើយបញ្ចេញតម្លៃ Boolean `true` ប្រសិនបើតម្លៃនៅជាគ្រងខាងឆ្វេងតិចជាងតម្លៃខាងស្ដាំ | `5 < 6 // true` | | `<=` | **តិចជាងឬស្មើ**៖ ប្រៀបធៀបទាំពីរតម្លៃ ហើយបញ្ចេញតម្លៃ Boolean `true` ប្រសិនបើតម្លៃនៅជាគ្រងខាងឆ្វេងតិចឬស្មើតម្លៃខាងស្ដាំ | `5 <= 6 // true` | | `>` | **ធំជាង**៖ ប្រៀបធៀបទាំពីរតម្លៃ ហើយបញ្ចេញតម្លៃ Boolean `true` ប្រសិនបើតម្លៃនៅជាគ្រងខាងឆ្វេងធំជាងតម្លៃខាងស្ដាំ | `5 > 6 // false` | | `>=` | **ធំជាងឬស្មើ**៖ ប្រៀបធៀបទាំពីរតម្លៃ ហើយបញ្ចេញតម្លៃ Boolean `true` ប្រសិនបើតម្លៃនៅជាគ្រងខាងឆ្វេងធំជាងឬស្មើតម្លៃខាងស្ដាំ | `5 >= 6 // false` | | `===` | **ស្មើខ្លាំង**៖ ប្រៀបធៀបទាំពីរតម្លៃ ហើយបញ្ចេញតម្លៃ Boolean `true` ប្រសិនបើតម្លៃនៅជាគ្រងឆ្វេង និងស្ដាំស្មើគ្នា ព្រមទាំងជាប្រភេទទិន្នន័យដូចគ្នា | `5 === 6 // false` | | `!==` | **មិនស្មើគ្នា**៖ ប្រៀបធៀបទាំពីរតម្លៃ ហើយបញ្ចេញតម្លៃ Boolean ផ្ទុយពីស្មើខ្លាំង | `5 !== 6 // true` | ✅ ពិនិត្យជំនាញរបស់អ្នកដោយការសរសេរប្រៀបធៀបមួយចំនួននៅក្នុងកុងសូលរបស់អ្នក។ តើមានទិន្នន័យដែលត្រូវតាមដែលធ្វើឲ្យអ្នកភ្ញាក់ផ្អើលទេ? ```mermaid flowchart LR A["🔢 តម្លៃ"] --> B["⚖️ ការស្ទង់ប្រៀបធៀប"] B --> C["✅ លទ្ធផលប៊ូលីយ៉ង់"] D["5"] --> E["< 6"] E --> F["ពិត"] G["10"] --> H["=== '10'"] H --> I["មិនពិត"] J["'សួស្តី'"] --> K["!== 'ពិភពលោក'"] K --> L["ពិត"] M["📋 ប្រភេទប្រតិបត្តិករ"] --> M1["សមភាពៈ === !=="] M --> M2["ទាក់ទងៈ < > <= >="] M --> M3["តឹងល្ង់ ល្ហុង"] style A fill:#e3f2fd style C fill:#e8f5e8 style M fill:#fff3e0 ``` ### 🧠 **ការត្រួតពិនិត្យជំនាញប្រៀបធៀប៖ យល់ដឹងអំពីលក្ខខណ្ឌ Boolean** **សាកល្បងយល់ដឹងរបស់អ្នកអំពីការប្រៀបធៀប៖** - ហេតុអ្វីបានជា `===` (ស្មើខ្លាំង) ត្រូវបានចំណូលចិត្តជាចម្បងជាង `==` (ស្មើយឺត)? - តើអ្នកអាចទិត្យមើលថា `5 === '5'` នឹងផ្ដល់អ្វី? តើ `5 == '5'` បែបណា? - តើខុសគ្នារវាង `!==` និង `!=` គឺជាអ្វី? ```mermaid stateDiagram-v2 [*] --> Comparison: តម្លៃពីរ Comparison --> StrictEqual: === ឬ !== Comparison --> Relational: < > <= >= StrictEqual --> TypeCheck: ពិនិត្យប្រភេទនិងតម្លៃ Relational --> NumberCompare: បម្លែងទៅជាលេខ TypeCheck --> BooleanResult: ពិត ឬ មិនពិត NumberCompare --> BooleanResult note right of StrictEqual វិធីសាស្ត្រដែលចេញនិយាយ គ្មានការបម្លែងប្រភេទ end note note right of Relational មានប្រយោជន៍សម្រាប់ចន្លោះ ការប្រៀបធៀបលេខ end note ``` > **គំនួញជំនាញ**: ប្រើ `===` និង `!==` សម្រាប់ការត្រួតពិនិត្យស្មើភាព លុះត្រាតែអ្នកត្រូវការបម្លែងប្រភេទខុសឆ្គង។ វាជាជំរើសប្រសើរដើម្បីជៀសវាងឥរិយាបថមិនចង់បាន! ## ពាក្យបញ្ជា If ពាក្យបញ្ជា `if` គឺដូចជាការសួរពីសំណួរមួយជាភាសាកូដរបស់អ្នក។ "បើលក្ខខណ្ឌនេះជាពិត សូមធ្វើរឿងនេះ។" វាគឺជាឧបករណ៍សំខាន់បំផុតដែលអ្នកនឹងប្រើសម្រាប់ការធ្វើសេចក្តីសម្រេចនៅក្នុង JavaScript។ នេះជារបៀបដំណើរការ៖ ```javascript if (condition) { // គោលលក្ខខ័ណ្ឌពិត។ កូដនៅក្នុងប្លុកនេះនឹងរត់។ } ``` លក្ខខណ្ឌស្ថិតនៅក្នុងសញ្ញាកោសិកា ហើយបើវាជា `true` JavaScript នឹងដំណើរការកូដក្នុងសញ្ញាចែដាស់បន្ទាប់។ ប្រសិនបើវាជា `false` JavaScript នឹងរំលងប្លុកនោះទាំងមូល។ អ្នកជាញឹកញាប់នឹងប្រើអ្នកបញ្ជាការប្រៀបធៀបដើម្បីបង្កើតលក្ខខណ្ឌទាំងនេះ។ មកមើលឧទាហរណ៍ប្រតិបត្តិ៖ ```javascript let currentMoney = 1000; let laptopPrice = 800; if (currentMoney >= laptopPrice) { // លក្ខខណ្ឌត្រូវ។ កូដនៅក្នុងប្លុកនេះនឹងដំណើរការ។ console.log("Getting a new laptop!"); } ``` ដោយសារតែ `1000 >= 800` វាយតម្លៃទៅជា `true` កូដក្នុងប្លុកនោះត្រូវបានដំណើរការ បង្ហាញ "កំពុងទិញកុំព្យូទ័រយួរដៃថ្មី!" នៅក្នុងកុងសូល។ ```mermaid flowchart TD A["🚀 ចាប់ផ្តើមកម្មវិធី"] --> B{"💰 currentMoney >= laptopPrice?"} B -->|true| C["🎉 'ទិញកុំព្យូទ័រយួរដៃថ្មី!'"] B -->|false| D["⏭️ ហួសផ្លាស់ប្តូរកូដ"] C --> E["📋 បន្តកម្មវិធី"] D --> E F["📊 រចនាសម្ព័ន្ធបញ្ជា If"] --> F1["if (condition) {"] F1 --> F2[" // កូដដើម្បីដំណើរការបើត្រូវ"] F2 --> F3["}"] style B fill:#fff3e0 style C fill:#e8f5e8 style D fill:#ffebee style F fill:#e3f2fd ``` ## ពាក្យបញ្ជា If..Else ប៉ុន្តែបើអ្នកចង់ឲ្យកម្មវិធីរបស់អ្នកធ្វើរឿងខុសពីនេះនៅពេលលក្ខខណ្ឌគឺ false? នោះជាទីតាំងដែល `else` បង្ហាញ — វាដូចជាមានផែនការទុកចិត្ដ។ ពាក្យបញ្ជា `else` ផ្តល់មុខងារអនុញ្ញាតឱ្យអ្នកនិយាយថា "បើលក្ខខណ្ឌនេះមិនត្រូវ ទើបធ្វើរឿងផ្សេងជំនួស"។ ```javascript let currentMoney = 500; let laptopPrice = 800; if (currentMoney >= laptopPrice) { // លក្ខខណ្ឌគឺពិត។ កូដនៅក្នុងប្លុកនេះនឹងរត់។ console.log("Getting a new laptop!"); } else { // លក្ខខណ្ឌគឺមិនពិត។ កូដនៅក្នុងប្លុកនេះនឹងរត់។ console.log("Can't afford a new laptop, yet!"); } ``` ឥពើយ `500 >= 800` ជា `false` កម្មវិធី JavaScript ភ្លេចប្លុកដំបូង ហើយដំណើរការប្លុក `else` ជំនួស។ អ្នកនឹងឃើញ "ពុំអាចទិញកុំព្យូទ័រយួរដៃថ្មីបានទេ!" នៅក្នុងកុងសូល។ ✅ សាកល្បងយល់ដឹងរបស់អ្នកអំពីកូដនេះ និងកូដក្រោយដោយដំណើរការវានៅក្នុងកុងសូលប្រ៉ៅសឺរ។ ប្ដូរតម្លៃអថេរ currentMoney និង laptopPrice ដើម្បីផ្លាស់ប្តូរអ្វីដែលត្រូវបង្ហាញតាម `console.log()`។ ### 🎯 **ការត្រួតពិនិត្យទ្រឹស្តី If-Else៖ ផ្លូវសាហាវ** **វាយតម្លៃយល់ដឹងរបស់អ្នកអំពីលក្ខខណ្ឌ៖** - តើមានអ្វីកើតឡើងបើ `currentMoney` ស្មើ `laptopPrice`? - តើអ្នកអាចគិតឧទាហរណ៍ពិតណាមួយដែលពួកឧបករណ៍ if-else គឺមានប្រយោជន៍ដែរឬទេ? - តើអ្នកអាចបន្ថែមវាដើម្បីគ្រប់គ្រងតម្លៃជាច្រើនបែបណាបាន? ```mermaid flowchart TD A["🔍 ប៉ិនប្រសប់ល័ក្ខខ័ណ្ឌ"] --> B{"ល័ក្ខខ័ណ្ឌត្រឹមត្រូវ?"} B -->|បាទ| C["📤 ប្រតិបត្តិការ IF"] B -->|ទេ| D["📥 ប្រតិបត្តិការ ELSE"] C --> E["✅ មួយផ្លូវត្រូវបានយក"] D --> E F["🌐 ឧទាហរណ៍ពិភពលោកពិត"] --> F1["ស្ថានភាពចូលប្រើប្រាស់"] F --> F2["ការត្រួតពិនិត្យអាយុ"] F --> F3["ការបម្រុងទម្រង់"] F --> F4["ការផ្លាស់ប្ដូរជាក់ស្តែងលំហ"] style B fill:#fff3e0 style C fill:#e8f5e8 style D fill:#e3f2fd style F fill:#f3e5f5 ``` > **ចំណុចសំខាន់**៖ If-else ធានាថាប្លុកមួយតែប៉ុណ្ណោះត្រូវបានជ្រើសរើស។ វាផ្តល់ការប្រាកដថាកម្មវិធីរបស់អ្នកមានការឆ្លើយតបច្បាស់ក្នុងស្ថានភាពណាមួយ។ ## ពាក្យបញ្ជា Switch ខណៈពេលដែលអ្នកត្រូវប្រៀបធៀបតម្លៃមួយជាមួយជម្រើសជាច្រើន។ ខណៈដែលអ្នកអាចចាក់ជួរពាក្យបញ្ជា `if..else` ជាច្រើន ការប្រកបនេះអាចធ្វើឲ្យវាស្មុគស្មាញ។ ពាក្យបញ្ជា `switch` ផ្តល់រចនាសម្ព័ន្ធស្អាតសម្រាប់គ្រប់គ្រងតម្លៃផ្សេងៗជាច្រើន។ គំនិតនេះដូចជាការប្តូរតុល្យភាពគ្រឿងចង្កឹះតាមរយៈប្រព័ន្ធទូរស័ព្ទដ៏ចាស់មួយ — តម្លៃបញ្ចូលគត់កំណត់មុខងារដែលបន្ទាត់អនុវត្តត្រូវបន្ត។ ```javascript switch (expression) { case x: // ប្លុកកូដ break; case y: // ប្លុកកូដ break; default: // ប្លុកកូដ } ``` នេះជារបៀបរចនាដូចខាងក្រោម៖ - JavaScript វាយតម្លៃពាក្យបញ្ជាដងតែមួយ - វាស្វែងរក `case` រាល់មុខដើម្បីស្វែងរកការប្រកួត - ពេលវាមានការប្រកួត វានឹងដំណើរការប្លុកកូដនោះ - `break` ប្រាប់ JavaScript ឱ្យឈប់ និងចេញពី switch - ប្រសិនបើគ្មាន case ណាមួយប្រកួត វានឹងដំណើរការប្លុក `default` (បើអ្នកមាន) ```javascript // កម្មវិធីប្រើប្តូរប្រកាសសម្រាប់ថ្ងៃនៃសប្តាហ៍ let dayNumber = 2; let dayName; switch (dayNumber) { case 1: dayName = "Monday"; break; case 2: dayName = "Tuesday"; break; case 3: dayName = "Wednesday"; break; default: dayName = "Unknown day"; break; } console.log(`Today is ${dayName}`); ``` ក្នុងឧទាហរណ៍នេះ JavaScript មើលឃើញថា `dayNumber` មានតម្លៃ `2` រក `case 2` ដែលត្រូវគ្នា កំណត់ `dayName` ទៅជា "Tuesday" បន្ទាប់មកផុតចេញពី switch។ លទ្ធផលវិញគឺ "Today is Tuesday" ត្រូវបានបង្ហាញនៅក្នុងកុងសូល។ ```mermaid flowchart TD A["📥 switch(expression)"] --> B["🔍 វាយតម្លៃម្តង"] B --> C{"តំណាងសម្រង់លេខ 1?"} C -->|បាទ| D["📋 ដំណើរការតំណាងលេខ 1"] C -->|ទេ| E{"តំណាងសម្រង់លេខ 2?"} E -->|បាទ| F["📋 ដំណើរការតំណាងលេខ 2"] E -->|ទេ| G{"តំណាងសម្រង់លេខ 3?"} G -->|បាទ| H["📋 ដំណើរការតំណាងលេខ 3"] G -->|ទេ| I["📋 ដំណើរការតំណាងលំនាំដើម"] D --> J["🛑 បញ្ឈប់"] F --> K["🛑 បញ្ឈប់"] H --> L["🛑 បញ្ឈប់"] J --> M["✅ ចាកចេញពី switch"] K --> M L --> M I --> M style A fill:#e3f2fd style B fill:#fff3e0 style M fill:#e8f5e8 ``` ✅ សាកល្បងយល់ដឹងរបស់អ្នកអំពីកូដនេះ និងកូដក្រោយដោយដំណើរការវានៅក្នុងកុងសូលប្រ៉ៅសឺរ។ ប្ដូរតម្លៃអថេរ a ដើម្បីផ្លាស់ប្តូរអ្វីដែលត្រូវបង្ហាញតាម `console.log()`។ ### 🔄 **ការត្រួតពិនិត្យជំនាញ Switch៖ ជម្រើសជាច្រើន** **សាកល្បងយល់ដឹងរបស់អ្នកអំពី switch៖** - តើមានអ្វីកើតឡើងបើអ្នកភ្លេចប្រើ `break`? - តើ​អ្នកចង់ប្រើ `switch` នៅពេលណាមុន `if-else` ច្រើនដង? - ហេតុអ្វីបានជា `default` មានប្រយោជន៍ ទោះបីអ្នកគិតថាអ្នកគ្របដណ្តប់គ្រប់សក្តានុពលទាំងអស់ហើយ? ```mermaid pie title "ពេលណាដើម្បីប្រើរៀងរាល់រចនាសម្ព័ន្ធសំរាំងសម្រេច" "ប្រសិនបើ-មិនប្រសិនបើ ងាយៗ" : 40 "ខ្សែប្រសិនបើ-មិនប្រសិនបើ ស្មុគស្មាញ" : 25 "ពាក្យបញ្ជា Switch" : 20 "អុបឺរ៉ាតួរ Ternary" : 15 ``` > **អនុវត្តន៍ល្អបំផុត**៖ ប្រើ `switch` នៅពេលប្រៀបធៀបអថេរច្រើនជាមួយតម្លៃជាក់លាក់។ ប្រើ `if-else` សម្រាប់ត្រួតពិនិត្យជួរឬលក្ខខណ្ឌស្មុគស្មាញ! ## អ្នកបញ្ជាការយល់ស្មារតី និង Boolean ការធ្វើសេចក្តីសម្រេចស្មុគស្មាញភាគច្រើនទាមទារការវាយតម្លៃលក្ខខណ្ឌច្រើននៅពេលតែមួយ។ ដូចដែលពណ៌នាគណិតវិទ្យាភាពសម្បូរបែប Boolean អនុញ្ញាតឱ្យអ្នកគណិតិយកលក្ខខណ្ឌយល់ស្មារតីចំរូងគ្នា ការសរសេរកម្មវិធីផ្តល់អ្នកបញ្ជាការយល់ស្មារតីដើម្បីភ្ជាប់លក្ខខណ្ឌ Boolean ច្រើន។ អ្នកបញ្ជាការនេះអនុញ្ញាតឱ្យអ្នកបង្កើតលក្ខខណ្ឌស្មុគស្មាញដោយការបញ្ចូលការវាយតម្លៃ true/false ងាយៗ។ | រូបសញ្ញា | សង្ខេបមាតិការពិពណ៍នា | ឧទាហរណ៍ | | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- | | `&&` | **AND និយមន័យយល់ស្មារតី**៖ ប្រៀបធៀបពាក្យរកសមមូល Boolean ពីរពាក្យ។ បញ្ចេញ true **តែ** បើទាំងពីរផ្នែកពិត។ | `(5 > 3) && (5 < 10) // ទាំងពីរផ្នែកពិត។ បញ្ចេញ true` | | `\|\|` | **OR និយមន័យយល់ស្មារតី**៖ ប្រៀបធៀបពាក្យរកសមមូល Boolean ពីរពាក្យ។ បញ្ចេញ true ប្រសិនបើមានយ៉ាងហោចណាស់មួយផ្នែកពិត។ | `(5 > 10) \|\| (5 < 10) // មួយផ្នែកមិនពិត ភាគតែម្ខាងពិត។ បញ្ចេញ true` | | `!` | **NOT និយមន័យយល់ស្មារតី**៖ បញ្ចេញតម្លៃផ្ទុយពីពាក្យBoolean | `!(5 > 10) // 5 មិនធំជាង 10 ទេ ដូច្នេះ "!" ធ្វើឱ្យវាជា true` | អ្នកបញ្ជាការនេះអនុញ្ញាតឱ្យអ្នកភ្ជាប់លក្ខខណ្ឌជាដំណាក់កាលបាន៖ - AND (`&&`) មានន័យថាលក្ខខណ្ឌទាំងពីរត្រូវតែពិត - OR (`||`) មានន័យថាយ៉ាងហោចណាស់មួយលក្ខខណ្ឌត្រូវតែពិត - NOT (`!`) បម្លែង true ទៅ false (និងព្រមទាំង trái lại) ```mermaid flowchart LR A["🔗 អូប៉េរ៉ាត័រណ៍និ логិច"] --> B["&& និង"] A --> C["|| ឬ"] A --> D["! មិន"] B --> B1["ទាំងពីរត្រូវតែពិត"] B --> B2["ពិត && ពិត = ពិត"] B --> B3["ពិត && មិនពិត = មិនពិត"] C --> C1["ល្មមមួយយ៉ាងតិចពិត"] C --> C2["ពិត || មិនពិត = ពិត"] C --> C3["មិនពិត || មិនពិត = មិនពិត"] D --> D1["បង្វិលតម្លៃ"] D --> D2["!ពិត = មិនពិត"] D --> D3["!មិនពិត = ពិត"] E["🌍 ឧទាហរណ៍ពិត"] --> E1["អាយុ >= 18 && មានใบអនុញ្ញាត"] E --> E2["គ្រិស្ដស័ក || ថ្ងៃឈប់សម្រាក"] E --> E3["!មិនបានចូលប្រើ"] style A fill:#e3f2fd style B fill:#e8f5e8 style C fill:#fff3e0 style D fill:#f3e5f5 style E fill:#e0f2f1 ``` ## លក្ខខណ្ឌ និងសេចក្តីសម្រេចជាមួយអ្នកបញ្ជា មកមើលអ្នកបញ្ជាការយល់ស្មារតីទាំងនេះនៅក្នុងឧទាហរណ៍ជាក់ស្តែងមួយ៖ ```javascript let currentMoney = 600; let laptopPrice = 800; let laptopDiscountPrice = laptopPrice - (laptopPrice * 0.2); // តម្លៃកុំព្យូទ័រយួរដៃបញ្ចុះតម្លៃ ២០ ភាគរយ if (currentMoney >= laptopPrice || currentMoney >= laptopDiscountPrice) { // លក្ខខណ្ឌត្រឹមត្រូវ។ កូដក្នុងប្លុកនេះនឹងរត់។ console.log("Getting a new laptop!"); } else { // លក្ខខណ្ឌមិនត្រឹមត្រូវ។ កូដក្នុងប្លុកនេះនឹងរត់។ console.log("Can't afford a new laptop, yet!"); } ``` ក្នុងឧទាហរណ៍នេះ៖ យើងគណនាតម្លៃបញ្ចុះពាន់ ២០% (640) បន្ទាប់មកវាយតម្លៃថាតើហិរញ្ញវត្ថុដែលមានគ្របដណ្តប់តម្លៃទាំងអស់ ឬតម្លៃបញ្ចុះនេះ។ ដោយសារតែ 600 មិនបរិមាណលើផលបញ្ចុះ 640 ទេ គឺលក្ខខណ្ឌវាយតម្លៃទៅជា true។ ### 🧮 **ការត្រួតពិនិត្យអ្នកបញ្ជាការយល់ស្មារតី៖ ការភ្ជាប់លក្ខខណ្ឌ** **សាកល្បងយល់ដឹងរបស់អ្នកអំពីអ្នកបញ្ជាការយល់ស្មារតី៖** - ក្នុងពាក្យបញ្ជា `A && B` តើមានអ្វីកើតឡើងបើ A ជា false? តើ B បានបាយតម្លៃទេ? - តើអ្នកអាចគិតឧទាហរណ៍ណាដែលអ្នកត្រូវការអ្នកបញ្ជា ៣ ដង (&&, ||, !) ព្រមគ្នា? - ផ្សេងគ្នារវាង `!user.isActive` និង `user.isActive !== true` គឺជាអ្វី? ```mermaid stateDiagram-v2 [*] --> EvaluateA: A && B EvaluateA --> CheckB: A ជា​ពិត EvaluateA --> ReturnFalse: A ជា​មិន​ពិត CheckB --> ReturnTrue: B ជា​ពិត CheckB --> ReturnFalse: B ជា​មិន​ពិត [*] --> EvaluateC: A || B EvaluateC --> ReturnTrue: A ជា​ពិត EvaluateC --> CheckD: A ជា​មិន​ពិត CheckD --> ReturnTrue: B ជា​ពិត CheckD --> ReturnFalse: B ជា​មិន​ពិត note right of EvaluateA ការវាយតម្លៃបែកឆ្អឹងខ្លី: ប្រសិនបើ A ជា​មិន​ពិត B មិនដែលត្រូវបានពិនិត្យឡើយ end note ``` > **គំនួញបង្កើនប្រសិទ្ធភាព**៖ JavaScript ប្រើការវាយតម្លៃ "short-circuit" - ក្នុង `A && B` ប្រសិនបើ A ជា false, B មិនត្រូវបានវាយតម្លៃទេ។ ប្រើអត្ថប្រយោជន៍នេះដើម្បីធ្វើឱ្យកូដមានប្រសិទ្ធភាព! ### អ្នកបញ្ជាផ្ទុយ ខ្លះៗ ពេលវេលាល្អជាងក្នុងការគិតពេលអ្វីមិនមែនជា true។ ដូចជាការសួរថា "តើអ្នកប្រើបានចូលបញ្ចូលហើយទេ?" អ្នកអាចចង់សួរថា "តើអ្នកប្រើមិនទាន់ចូលបញ្ចូលទេ?" អ្នកបញ្ជាផ្ទុយ (`!`) បម្លែងលក្ខខណ្ឌនេះ។ ```javascript if (!condition) { // ប្រតិបត្តិ ប្រសិនបើលក្ខខណ្ឌមិនត្រឹមត្រូវ } else { // ប្រតិបត្តិ ប្រសិនបើលក្ខខណ្ឌត្រឹមត្រូវ } ``` អ្នកបញ្ជា `!` គឺដូចជាការនិយាយថា "វាផ្ទុយពី..." — ប្រសិនបើអ្វីមួយជា `true` អ្នកបញ្ជា `!` ធ្វើឲ្យវាជា `false` ហើយវា័ត្រឡប់វិញ។ ### ពាក្យសម្តីតែរីនារី សម្រាប់ការបែងចែកលក្ខខណ្ឌសាមញ្ញ JavaScript ផ្តល់អ្នកបញ្ជាផ្ទុយតែរីនារី។ វាជាភាសាសរសេរជួរเดียว ដែលជួយអ្នកសរសេរពាក្យសម្តីលក្ខខណ្ឌពីរជាមួយគ្នា។ ```javascript let variable = condition ? returnThisIfTrue : returnThisIfFalse; ``` វាអានដូចសំនួរ៖ "តើលក្ខខណ្ឌនេះជាពិតទេ? ប្រសិនបើមែន ប្រើតម្លៃនេះ។ ប្រសិនបើមិនមែន ប្រើតម្លៃនោះ។" ឧទាហរណ៍ពិតប្រាកដនៅខាងក្រោម៖ ```javascript let firstNumber = 20; let secondNumber = 10; let biggestNumber = firstNumber > secondNumber ? firstNumber : secondNumber; ``` ✅ ចំណាយពេលមួយនាទីអានកូដនេះច្រើនដង។ តើអ្នកយល់ថាអ្នកបញ្ជាការជាថ្មីៗទាំងនេះដំណើរការយ៉ាងដូចម្តេច? នេះជាអ្វីដែលបន្ទាត់នេះនិយាយ៖ "តើ `firstNumber` ធំជាង `secondNumber` ទេ? ប្រសិនបើមែន ទទួលយកនៅក្នុង `biggestNumber`។ ប្រសិនបើមិនមែន ទទួលយក `secondNumber` នៅក្នុង `biggestNumber`។" អ្នកបញ្ជាថែរីនារីគ្រាន់តែជារបៀបខ្លីដើម្បីសរសេរ `if..else` ធម្មតា៖ ```javascript let biggestNumber; if (firstNumber > secondNumber) { biggestNumber = firstNumber; } else { biggestNumber = secondNumber; } ``` ទោលធ្វើឲ្យទាំងពីរបង្ហាញលទ្ធផលដូចគ្នា។ អ្នកបញ្ជាថែរីនារីផ្តល់នូវភាពខ្លី ស្រួលបកស្រាយ ផ្ទុយពីរចនាសម្ព័ន្ធ if-else ដែលអាចអានបានល្អសម្រាប់លក្ខខណ្ឌស្មុគស្មាញ។ ```mermaid flowchart LR A["🤔 អូបប៉េរ៉ាត័រតើនារី"] --> B["លក្ខខណ្ឌ ?"] B --> C["តម្លៃប្រសិនបើពិត :"] C --> D["តម្លៃប្រសិនបើមិនពិត"] E["📝 ការប្រើ If-Else សាមញ្ញ"] --> F["if (លក្ខខណ្ឌ) {"] F --> G[" return តម្លៃប្រសិនបើពិត"] G --> H["} else {"] H --> I[" return តម្លៃប្រសិនបើមិនពិត"] I --> J["}"] K["⚡ ពេលណាចាំបាច់ប្រើ"] --> K1["ការចាត់តាំងសាមញ្ញ"] K --> K2["លក្ខខណ្ឌខ្លីៗ"] K --> K3["ការសម្រេចចិត្តឆ្លាត"] K --> K4["ការប្រើកថាភាសា return"] style A fill:#e3f2fd style E fill:#fff3e0 style K fill:#e8f5e8 ``` --- ## 🚀 챌린지 បង្កើតកម្មវិធីមួយដែលសរសេរជាលើកដំបូងដោយមានអ្នកបញ្ជារយល់ស្មារតី ហើយបន្ទាប់មកសរសេរឡើងវិញដោយប្រើពាក្យសម្តីតែរីនារី។ តើយើងចូលចិត្តរចនាសម្ព័ន្ធណា? --- ## GitHub Copilot Agent Challenge 🚀 ប្រើម៉ូដ Agent ដើម្បីបញ្ចប់ចំណាត់តំណាងខាងក្រោម៖ **សេចក្តីពិពណ៌នា:** បង្កើតកម្មវិធីគណនាគុណភាពដែលបង្ហាញពីគំនិតជាច្រើននៃការធ្វើសេចក្តីសម្រេចពីមេរៀននេះ រួមមានពាក្យបញ្ជា if-else, switch, អ្នកបញ្ជារយល់ស្មារតី និងពាក្យសម្តីតែរីនារី។ **ដំណើរការ:** សរសេរកម្មវិធី JavaScript មួយ ដែលទទួលបានពិន្ទុគណនា (0-100) នៃសិស្ស ហើយកំណត់ថាគុណភាពលិខិតរបស់គាត់ដោយគោលការណ៍ដូចខាងក្រោម៖ - A: 90-100 - B: 80-89 - C: 70-79 - D: 60-69 - F: ក្រោម 60 តម្រូវការ: 1. ប្រើប្រយោគ if-else ដើម្បីកំណត់ពិន្ទុជាតួអក្សរ 2. ប្រើប្រតិបត្តិការ​ត្រឹមត្រូវ​ទាំងស្រុង​ដើម្បី​ត្រួតពិនិត្យថានិស្សិតជាប់​​​​​​​​ (ពិន្ទុ >= 60) និងមានកិត្តិយស (ពិន្ទុ >= 90) 3. ប្រើប្រយោគ switch ដើម្បីផ្តល់មតិកម្រិតលម្អិតសម្រាប់ពិន្ទុតួអក្សរ​នីមួយៗ 4. ប្រើប្រតិបត្តិការ ternary ដើម្បីកំណត់ថានិស្សិតមានសិទ្ធិចូលរៀនវគ្គបន្ទាប់ទេឬអត់ (ពិន្ទុ >= 70) 5. រួមបញ្ចូលការត្រួតពិនិត្យបញ្ចូលទិន្នន័យដើម្បីធានាថា​ពិន្ទុស្ថិតនៅចន្លោះ 0 ទៅ 100 សាកល្បងកម្មវិធីរបស់អ្នកជាមួយពិន្ទុផ្សេងៗ រួមទាំងករណីជិតខាងដូចជា 59, 60, 89, 90, និងបញ្ចូលទិន្នន័យមិនត្រឹមត្រូវ។ ស្វែងយល់បន្ថែមអំពី [agent mode](https://code.visualstudio.com/blogs/2025/02/24/introducing-copilot-agent-mode) នៅទីនេះ។ ## Post-Lecture Quiz [Post-lecture quiz](https://ff-quizzes.netlify.app/web/quiz/12) ## Review & Self Study អានបន្ថែមអំពីប្រាតិបត្តិការជាច្រើន​ដែលមានស្រាប់សម្រាប់អ្នកប្រើ [លើ MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators)។ ពិពណ៌នាឆ្លៀតមើលការស្វែងរកប្រតិបត្តិការ​ដោយ Josh Comeau អសកម្មនេះ [operator lookup](https://joshwcomeau.com/operator-lookup/)! ## Assignment [Operators](assignment.md) --- ## 🧠 **សង្ខេបឧបករណ៍សម្រេចចិត្តរបស់អ្នក** ```mermaid graph TD A["🎯 ការសម្រេចចិត្ត JavaScript"] --> B["🔍 តBuk់តម្រូវត្រីវិទ្យា Boolean"] A --> C["📊 ពាក្យបញ្ជា Conditional"] A --> D["🔗 អ្នកប្រើហ្គោលិចល័យ"] A --> E["⚡ រចនាសម្ព័ន្ធឧត្តម"] B --> B1["តម្លៃត្រឹមត្រូវ/ខុស"] B --> B2["អ្នកប្រើប្រាស់ទំនៀមទំលាប់"] B --> B3["គំនិតភាពពិត"] C --> C1["ពាក្យបញ្ជា if"] C --> C2["ខ្សែ if-else"] C --> C3["ពាក្យបញ្ជា switch"] D --> D1["&& (AND)"] D --> D2["|| (OR)"] D --> D3["! (NOT)"] E --> E1["អ្នកប្រើ ternary"] E --> E2["ការប៉ាន់ស្មាន short-circuit"] E --> E3["លក្ខខ័ណ្ឌស្មុគស្មាញ"] F["💡 គោលការណ៍សំខាន់"] --> F1["លក្ខខ័ណ្ឌអានច្បាស់"] F --> F2["រចនាប័ទ្មតួប្រៀបធៀបចំណង់ចំណូល"] F --> F3["លំដាប់គោលការណ៍ប្រើ"] F --> F4["លំដាប់ប្រសិទ្ធភាពប៉ាន់ស្មាន"] style A fill:#e3f2fd style B fill:#e8f5e8 style C fill:#fff3e0 style D fill:#f3e5f5 style E fill:#e0f2f1 style F fill:#fce4ec ``` --- ## 🚀 បញ្ជីព្រឹត្តិការណ៍ចំណេះដឹងក្នុងការសម្រេចចិត្ត JavaScript របស់អ្នក ### ⚡ **អ្វីដែលអ្នកអាចធ្វើបានក្នុង 5 នាទីក្រោយ** - [ ] អនុវត្តប្រតិបត្តិការ​ប្រស់ភាគនៅក្នុងកុងសូលរុករករបស់អ្នក - [ ] សរសេរប្រយោគ if-else សាមញ្ញដើម្បីភាសិតអាយុរបស់អ្នក - [ ] សាកល្បងបញ្ហាចម្រុះ៖ សរសេរឡើងវិញ if-else ដោយប្រើប្រតិបត្តិការ ternary - [ ] សាកល្បងវ៉ាន់តម្លៃ "truthy" និង "falsy" ផ្សេងៗគ្នា ### 🎯 **អ្វីដែលអ្នកអាចសម្រេចបានក្នុងមួយម៉ោងនេះ** - [ ] បញ្ចប់កម្រងប្រលងបន្ទាប់ម៉ោងសិក្សា និងពិនិត្យវិធីសាស្ត្រដែលមិនច្បាស់ - [ ] សង់កម្មវិធីគណនាពិន្ទុស្មុគស្មាញពីបញ្ហា GitHub Copilot - [ ] បង្កើតដើមឈើសម្រេចចិត្តសាមញ្ញសម្រាប់ស្ថានการณ์ពិត (ដូចជា ជ្រើសរើសអ្វីពាក់) - [ ] អនុវត្តការរួមបញ្ចូលលក្ខខ័ណ្ឌជាច្រើនជាមួយប្រតិបត្តិការ​ត្រឹមត្រូវ​ទាំងស្រុង - [ ] សាកល្បងប្រយោគ switch សម្រាប់ករណីប្រើប្រាស់ផ្សេងៗ ### 📅 **ការរីកចម្រើនជំនាញផ្នែកណែនាំតំណាលរយ:សប្តាហ៏** - [ ] បញ្ចប់កិរិយាសព្ទក្នុងកិច្ចការជាមួយឧទាហរណ៍ច្នៃប្រឌិត - [ ] សង់កម្មវិធីប្រលងតូចដោយប្រើរចនាសម្ព័ន្ធលក្ខខ័ណ្ឌផ្សេងៗ - [ ] បង្កើតកម្មវិធីផ្ទៀងផ្ទាត់បែបបទដែលបានត្រួតពិនិត្យលក្ខខ័ណ្ឌច្រើន - [ ] អនុវត្តលំហាត់ Josh Comeau [operator lookup](https://joshwcomeau.com/operator-lookup/) - [ ] បញ្ចេញកូដដែលមានស្រាប់ទៅប្រើរចនាសម្ព័ន្ធលក្ខខណ្ឌដែលសមរម្យជាងនេះ - [ ] អះអាងការវាយតម្លៃ short-circuit និងផលប៉ះពាល់លើកម្រិតប្រសិទ្ធភាព ### 🌟 **ការបម្លែងជំនាញក្នុងរយៈពេលមួយខែ** - [ ] ជំនាញលក្ខខណ្ឌស្មុគស្មាញដែលស្ថិតនៅក្នុងគ្នា និងរក្សាការអានបានខាងក្នុងកូដ - [ ] សង់កម្មវិធីដោយប្រើតារាងសម្រេចចិត្តដ៏ប្រសើរណាស់ - [ ] មានការរួមចំណែកលើប្រភពបើកប្រើដោយកែលម្អលក្ខខណ្ឌសម្រេចចិត្តនៅក្នុងគម្រោងស្រាប់ - [ ] បង្រៀនអ្នកដទៃអំពីរចនាសម្ព័ន្ធលក្ខខណ្ឌគ្រប់ប្រភេទ និងពេលវេលាដែលត្រូវប្រើប្រាស់ - [ ] ស្វែងយល់ពីវិធីសាស្ត្រកម្មវិធីមុខងារសម្រាប់លក្ខខណ្ឌសម្រេចចិត្ត - [ ] បង្កើតមគ្គុទេសក៍ផ្ទាល់ខ្លួនសម្រាប់លក្ខខណ្ឌល្អបំផុត ### 🏆 **ការត្រួតពិនិត្យជើងឯកផ្នែកសម្រេចចិត្តចុងក្រោយ** **អបអរសាទរជំនាញគិតផ្លូវយុតិ្តសាស្ត្រ​របស់អ្នក៖** - តើលក្ខខណ្ឌសម្រេចចិត្តដ៏ស្មុគស្មាញបំផុតដែលអ្នកបានអនុវត្តជោគជ័យគឺអ្វី? - តើរចនាសម្ព័ន្ធលក្ខខណ្ឌណាដែលអ្នកមានអារម្មណ៍ថាធម្មតាជាងគេហើយហេតុអ្វី? - តើការស្វែងយល់អំពីប្រតិបត្តិការ​ត្រឹមត្រូវ​ទាំងស្រុងបានផ្លាស់ប្តូរយុទ្ធសាស្ត្រដោះស្រាយបញ្ហារបស់អ្នកយ៉ាងដូចម្តេច? - តើកម្មវិធីពិតប្រាកដណាដែលនឹងទទួលបានអត្ថប្រយោជន៍ពីលក្ខខណ្ឌសម្រេចចិត្តលំអិត? ```mermaid journey title ការប្រសើរឡើងនៃការគិតយ៉ាងត្រឹមត្រូវរបស់អ្នក section ថ្ងៃនេះ ការជ្រុះច្រឡំពី Boolean: 3: You ការយល់ដឹងពី If-Else: 4: You ការទទួលស្គាល់ Operator: 5: You section សប្តាហ៍នេះ លក្ខខណ្ឌស្មុគស្មាញ: 4: You ជំនាញ Switch: 5: You ការបំលាសតំណាងយ៉ាងត្រឹមត្រូវ: 5: You section ខែក្រោយ លំនាំកម្រិតខ្ពស់: 5: You ការយល់ដឹងអំពីប្រសិទ្ធភាព: 5: You ការបង្រៀនអ្នកដទៃ: 5: You ``` > 🧠 **អ្នកបានសម្រេចជំនាញស្នាដៃនៃការសម្រេចចិត្តឌីជីថលរួចរាល់!** កម្មវិធីអន្តរកម្មគ្រប់ប្រភេទពឹងផ្អែកលើលក្ខខណ្ឌសម្រេចចិត្តដើម្បីឆ្លើយតបយ៉ាងមាន ចំណេះដឹងចំពោះសកម្មភាពអ្នកប្រើ និងលក្ខខណ្ឌផ្លាស់ប្តូរ។ ឥឡូវនេះ អ្នកយល់ពីរបៀបធ្វើឲ្យកម្មវិធីរបស់អ្នកគិត អះអាង និងជ្រើសរើសចម្លើយសមរម្យ។ មូលដ្ឋានយុទ្ធសាស្ត្រនេះ នឹងជាជំនួយដល់កម្មវិធីផ្លាស់ប្តូរបានគ្រប់ប្រភេទដែលអ្នកបង្កើត! 🎉 --- **ការរក្សាសិទ្ធិមិនទទួលខុសត្រូវ**៖ ឯកសារនេះត្រូវបានបកប្រែដោយប្រើសេវាកម្មបកប្រែ AI [Co-op Translator](https://github.com/Azure/co-op-translator)។ ខណៈពេលដែលយើងខំប្រឹងប្រែងសំរាប់ភាពត្រឹមត្រូវ សូមយល់ថាការបកប្រែដោយស្វ័យប្រវត្តិនេះអាចមានកំហុសឬភាពមិនត្រឹមត្រូវបាន។ ឯកសារដើមក្នុងភាសាពុម្ពដើមគួរត្រូវបានគេពិចារណាថាជាផ្លូវការផ្ទាល់។ សម្រាប់ព័ត៌មានសំខាន់ៗ ការបកប្រែដោយមនុស្សជំនាញត្រូវបានផ្តល់អនុសាសន៍។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំនោះ ឬការបកប្រែខុសក្នុងការប្រើប្រាស់បកប្រែនេះឡើយ។