ហេតុអ្វីអ្នកសរសេរកម្មវិធីត្រូវការគណិតវិទ្យា

មាតិកា

1. គណិតវិទ្យាដែលអ្នកកំពុងប្រើរួចហើយ
2. Bug ប្រាំដែលពិតជា Bug គណិតវិទ្យា
3. អ្វីដែលអ្នកត្រូវការ និងអ្វីដែលអាចរំលងបាន
4. របៀបរៀបចំស៊េរីនេះ
5. ដំឡើង Node.js
6. បង្កើតថត mathlab
7. Module និង Demo ដំបូងរបស់អ្នក
8. របៀបអានកូដក្នុងស៊េរីនេះ
9. រូបមន្ត៖ ពិនិត្យថា mathlab ដំណើរការ
10. សាកល្បងដោយខ្លួនឯង

1. គណិតវិទ្យាដែលអ្នកកំពុងប្រើរួចហើយ

សួរអ្នកសរសេរកម្មវិធីថា តើពួកគេប្រើគណិតវិទ្យានៅកន្លែងធ្វើការទេ ហើយច្រើននាក់នឹងឆ្លើយថា "មិនសូវទេ"។ បន្ទាប់មកសូមមើលអ្វីដែលពួកគេធ្វើក្នុងសប្តាហ៍ធម្មតាមួយ៖

• បង្ហាញ 10 ធាតុក្នុងមួយទំព័រ ដូច្នេះពួកគេគណនាថាតើ 101 ធាតុត្រូវការប៉ុន្មានទំព័រ។
• បំប្លែងពណ៌ hex ដូចជា #1e90ff ទៅជាលេខក្រហម បៃតង និងខៀវ។
• រក្សាទុកសិទ្ធិរបស់អ្នកប្រើជាលេខតែមួយ ជំនួសឲ្យ column ដប់ពីរ។
• ធ្វើឲ្យ carousel ទៅពី slide ចុងក្រោយត្រឡប់ទៅ slide ដំបូងវិញ។
• បូកតម្លៃ ហើយឆ្ងល់ថាហេតុអ្វីផលបូកខុសបន្តិចបន្តួច។
• សម្រេចថា ការស្វែងរកដែលលឿនលើ 100 ជួរ នឹងរួចផុតពី 1,000,000 ឬអត់។

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

ស៊េរីនេះបង្រៀនគណិតវិទ្យាជាក់ស្តែងនោះ។ យើងនឹងប្រើពាក្យ តារាង និងកូដ ហើយរំលងភស្តុតាងទាំងស្រុង។ នៅពេលអ្នករៀនចប់ "នោះគ្រាន់តែជាបញ្ហា modulo" ឬ "នោះជាប្រតិបត្តិការសំណុំ" នឹងក្លាយជាគំនិតដែលអ្នកគិតចេញមកពិតប្រាកដ ហើយវានឹងសន្សំពេលវេលាអ្នក។

2. Bug ប្រាំដែលពិតជា Bug គណិតវិទ្យា

នេះជាកម្មវិធីខ្លីៗប្រាំ។ មួយៗមើលទៅល្អ ប៉ុន្តែសុទ្ធតែខុស។ អ្នកមិនចាំបាច់យល់វាឥឡូវនេះទេ។ មួយៗត្រូវបានដោះស្រាយក្នុងជំពូកក្រោយៗ។

Bug ទី 1៖ តម្លៃដែលមិនមែនជាតម្លៃពិតប្រាកដ។

console.log(0.1 + 0.2);    // 0.30000000000000004
console.log(19.99 * 100);   // 1998.9999999999998

កុំព្យូទ័ររក្សាទុកប្រភាគទសភាគដូចជា 0.1 ជា binary ហើយខ្លះមិនអាចរក្សាទុកបានយ៉ាងត្រឹមត្រូវឡើយ។ ប្រសិនបើអ្នកប្រើលេខ floating-point សម្រាប់លុយ នៅទីបំផុតអ្នកនឹងបាត់មួយសេន។ ជំពូក 2 និង 7 ពន្យល់ពីមូលហេតុ និងអ្វីដែលត្រូវធ្វើជំនួស។

Bug ទី 2៖ carousel ដែលថយក្រោយចូលទៅក្នុងភាពទទេ។

const slides = ["a", "b", "c"];
let current = 0;
current = (current - 1) % slides.length; // ទៅ slide មុន
console.log(current);          // -1
console.log(slides[current]);  // undefined

ក្នុង JavaScript % អាចត្រឡប់លេខអវិជ្ជមាន។ ប៊ូតុង "មុន" នៅលើ slide ដំបូងបង្ហាញទំព័រទទេ។ ជំពូក 6 ដោះស្រាយវា។

Bug ទី 3៖ ទំព័រដែលមិនមាន។

const items = 101;
const perPage = 10;
console.log(Math.floor(items / perPage)); // 10
console.log(Math.ceil(items / perPage));  // 11

ជាមួយ Math.floor ធាតុទី 101 គ្មានទំព័រទេ។ ការបង្គត់ឡើង ឬចុះគឺជាការសម្រេចចិត្ត មិនមែនជាសេចក្តីលម្អិតទេ។ ជំពូក 10 ប្រើវាសម្រាប់ pageCount។

Bug ទី 4៖ ID ដែលប្តូរដោយខ្លួនឯង។

console.log(9007199254740993); // 9007199254740992

អ្នកបានវាយលេខមួយ ប៉ុន្តែ JavaScript បោះពុម្ពលេខផ្សេង។ លេខដែលលើសពី 9007199254740991 បាត់ភាពជាក់លាក់។ ID ធំៗក្នុង database ដែលផ្ញើជាលេខ JSON អាចផ្លាស់ប្តូរដោយស្ងាត់ៗ។ ជំពូក 7 គ្របដណ្តប់រឿងនេះ និង BigInt។

Bug ទី 5៖ មុខងារដែលលឿនលើ laptop របស់អ្នក។ ទំព័រដែលប្រៀបធៀបគ្រប់ធាតុជាមួយគ្រប់ធាតុផ្សេងទៀត ធ្វើ 100 x 100 = 10,000 ជំហានសម្រាប់ 100 ធាតុ ប៉ុន្តែ 1,000,000 x 1,000,000 = 1,000,000,000,000 សម្រាប់មួយលាន។ កូដមិនបានផ្លាស់ប្តូរទេ។ ការលូតលាស់ទេដែលផ្លាស់ប្តូរ។ ជំពូក 8 និង 9 បង្រៀនអ្នកឲ្យមើលឃើញវាជាមុន។

សូមកត់សម្គាល់លំនាំ៖ គ្មានមួយណាត្រូវការ calculus ទេ។ ពួកវាត្រូវការឲ្យអ្នកដឹងពីរបៀបដែលលេខត្រូវបានរក្សាទុក របៀបដែលសំណល់ដើរតួ របៀបបង្គត់ និងរបៀបដែលបរិមាណលូតលាស់។

3. អ្វីដែលអ្នកត្រូវការ និងអ្វីដែលអាចរំលងបាន

នេះជាការបែងចែកដោយស្មោះត្រង់។

Vector, matrix និង calculus សំខាន់ខ្លាំងណាស់សម្រាប់ machine learning និងក្រាហ្វិក ដូច្នេះពួកវាមានកន្លែងផ្ទាល់ខ្លួនក្នុងស៊េរី Math for AI ដែលមានផែនការ។ អ្នកអាចកសាងអាជីពក្នុងការងារ web, mobile ឬ backend ហើយកម្រប៉ះពួកវា។ ប៉ុន្តែអ្នកមិនអាចធ្វើបានដោយគ្មានប្រធានបទក្នុងតារាងខាងលើទេ។

អ្នកក៏មិនចាំបាច់ "ពូកែគណិតវិទ្យា" ដែរ។ បើអ្នកអាចបូក ដក គុណ ចែក និងអានតារាងបាន អ្នកមានគ្រប់គ្រាន់ហើយ។ អ្វីៗផ្សេងទៀតត្រូវបានណែនាំនៅពេលត្រូវការ ហើយរាល់និមិត្តសញ្ញាត្រូវបានពន្យល់។

4. របៀបរៀបចំស៊េរីនេះ

មាន 12 ជំពូកក្នុងពីរផ្នែក។

ពាក់កណ្តាលទីមួយ៖ របៀបដែលកុំព្យូទ័របង្ហាញ និងផ្សំតម្លៃ (ជំពូកទី 1 ដល់ 7)។

1. ហេតុអ្វីអ្នកសរសេរកម្មវិធីត្រូវការគណិតវិទ្យា (ជំពូកនេះ)
2. លេខ និងប្រព័ន្ធលេខ
3. Bitwise Operation និង Flag
4. Boolean Logic
5. សំណុំ និងប្រតិបត្តិការសំណុំ
6. នព្វន្ត Modular
7. Integer, Overflow និងភាពជាក់លាក់

ពាក់កណ្តាលទីពីរ៖ របៀបដែលកូដពង្រីកខ្នាត និងរបៀបគិតអំពីឱកាស (ជំពូកទី 8 ដល់ 12)។

8. Function, ការលូតលាស់ និង Logarithm
9. សញ្ញា Big-O
10. ការរាប់៖ Permutation និង Combination
11. មូលដ្ឋានគ្រឹះប្រូបាប
12. កូអរដោនេ ធរណីមាត្រ និងការដាក់ទាំងអស់ចូលគ្នា

រាល់ជំពូកមានរូបរាងដូចគ្នា។ វាពន្យល់គំនិតមួយដោយឧទាហរណ៍តូចៗ បន្ទាប់មកបញ្ចប់ដោយ រូបមន្ត (Recipe) ដែលបន្ថែម module មួយទៅគម្រោងឈ្មោះ mathlab ហើយចុងក្រោយជាបញ្ជីលំហាត់ សាកល្បងដោយខ្លួនឯង។ សូមធ្វើរូបមន្តក្នុងគ្រប់ជំពូក។ ការអានអំពីគណិតវិទ្យាងាយភ្លេច ប៉ុន្តែការសរសេរ function ដែលប្រើវាមិនភ្លេចទេ។

5. ដំឡើង Node.js

កូដទាំងអស់ក្នុងស៊េរីនេះដំណើរការក្នុង Node.js ដែលអនុញ្ញាតឲ្យអ្នករត់ JavaScript ក្នុង terminal។ ប្រសិនបើអ្នកបានធ្វើតាម មូលដ្ឋានគ្រឹះ JavaScript និង TypeScript អ្នកប្រហែលជាមានវារួចហើយ។ ពិនិត្យ៖

node --version

អ្នកគួរតែឃើញលេខកំណែដូចជា v22.12.0។ កំណែ LTS (long-term support) បច្ចុប្បន្នណាក៏ដំណើរការបាន។ ប្រសិនបើអ្នកឃើញ "command not found" សូមទាញយក installer LTS ពី nodejs.org ហើយរត់វា បន្ទាប់មកបើក terminal ថ្មី ហើយពិនិត្យម្តងទៀត។

ប្រសិនបើ command ណាមួយក្នុង terminal នៅក្នុងជំពូកនេះមើលទៅមិនធ្លាប់ស្គាល់ មូលដ្ឋានគ្រឹះ Command Line គ្របដណ្តប់ cd, mkdir និងអ្វីផ្សេងទៀត។

6. បង្កើតថត mathlab

ជ្រើសរើសទីតាំងមួយសម្រាប់គម្រោងរបស់អ្នក បន្ទាប់មកបង្កើតរចនាសម្ព័ន្ធថត៖

mkdir mathlab
cd mathlab
mkdir src

នៅក្នុង mathlab/ បង្កើតឯកសារឈ្មោះ package.json ដែលមានខ្លឹមសារនេះ៖

{
  "name": "mathlab",
  "version": "1.0.0",
  "type": "module"
}

បន្ទាត់ "type": "module" ប្រាប់ Node ថាឯកសារ .js ក្នុងថតនេះប្រើ import និង export (ES module) ជំនួសឲ្យ require ដែលចាស់ជាង។ វាសំខាន់៖ បើគ្មានវា Node បដិសេធមិនរត់ឯកសាររបស់យើងទេ។

នៅពេលយើងបញ្ចប់ជំពូកនេះ ថតមើលទៅដូចនេះ៖

mathlab/
  package.json
  demo.js          <- we run this to try things
  src/
    index.js       <- re-exports every module

គំនិត៖ ជំពូកនីមួយៗបន្ថែម ឯកសារមួយ នៅក្នុង src/ (ឧទាហរណ៍ src/numbers.js ក្នុងជំពូកទី 2)។ src/index.js ប្រមូលផ្តុំពួកវា ដើម្បីឲ្យ demo.js អាច import អ្វីៗទាំងអស់ពីកន្លែងតែមួយ។ គ្មានអ្វីត្រូវដំឡើង ហើយគ្មាន dependency ទេ។ អ្នកមិនដែលរត់ npm install ក្នុងស៊េរីនេះទេ។

7. Module និង Demo ដំបូងរបស់អ្នក

បង្កើត src/index.js៖

// Every module we write is re-exported from here.
export const version = "0.1.0";

ឥឡូវនេះវា export តែ constant មួយ។ ក្នុងជំពូកក្រោយៗ អ្នកនឹងបន្ថែមបន្ទាត់ដូចជា export * from "./numbers.js"; ដែលមានន័យថា "re-export អ្វីៗទាំងអស់ដែលឯកសារនោះ export"។

បន្ទាប់មក បង្កើត demo.js នៅ root នៃ mathlab/៖

import { version } from "./src/index.js";

console.log(`mathlab v${version}`);
console.log("7 % 2 =", 7 % 2);
console.log("0.1 + 0.2 =", 0.1 + 0.2);
console.log("2 ** 10 =", 2 ** 10);

រត់វាពីក្នុងថត mathlab៖

node demo.js

លទ្ធផលដែលរំពឹងទុក៖

mathlab v0.1.0
7 % 2 = 1
0.1 + 0.2 = 0.30000000000000004
2 ** 10 = 1024

មានរឿងពីរដែលត្រូវកត់សម្គាល់។ ទីមួយ path នៃ import គឺ "./src/index.js"៖ ជាមួយ ES module អ្នកត្រូវសរសេរ ./ និង extension .js។ ទីពីរ វាមកទៀតហើយ៖ 0.1 + 0.2 បោះពុម្ព 0.30000000000000004។ នៅចុងជំពូកបន្ទាប់ អ្នកនឹងដឹងច្បាស់ពីមូលហេតុ។

8. របៀបអានកូដក្នុងស៊េរីនេះ

ទំនៀមទម្លាប់មួយចំនួនធ្វើឲ្យកូដងាយតាមដាន។

• Code block ដែលដាក់ tag js គឺជា JavaScript។ Block ដែលដាក់ tag bash គឺជា command សម្រាប់ terminal របស់អ្នក។
• Comment នៅចុងបន្ទាត់ ដូចជា // 1024 បង្ហាញអ្វីដែលបន្ទាត់នោះបោះពុម្ព ឬបង្កើត។ សូមរត់កូដដោយខ្លួនឯង ហើយប្រៀបធៀប។
• Function មានឈ្មោះសាមញ្ញដូចជា toBinary និង hasFlag។ ឈ្មោះទាំងនោះត្រូវបានចែករំលែករវាងជំពូក ដូច្នេះជំពូកក្រោយៗអាចប្រើ module ពីមុន។
• នៅពេលលំហាត់និយាយថា "ពង្រីក demo" សូមបន្ថែមបន្ទាត់ទៅ demo.js។ រក្សាបន្ទាត់ចាស់ទុក។ demo ដែលរីកធំឡើងគឺជា regression test ឥតគិតថ្លៃ។

ប្រសិនបើលទ្ធផលរបស់អ្នកខុសពី comment សូមកុំទាន់បន្តទៅមុខ។ ពិនិត្យកំហុសវាយ និង path នៃ import ជាមុន។ កំហុសភាគច្រើននៅដំណាក់កាលនេះគឺខ្វះ .js ឬរត់ command ពីថតខុស។

9. រូបមន្ត៖ ពិនិត្យថា mathlab ដំណើរការ

រូបមន្តនេះបញ្ចប់គ្រោងឆ្អឹងនៃគម្រោង។ បញ្ជាក់ធាតុនីមួយៗ៖

1. mathlab/package.json មាន ហើយមាន "type": "module"។
2. mathlab/src/index.js export version។
3. node demo.js ដែលរត់ពីថត mathlab បោះពុម្ពបួនបន្ទាត់។
4. ក្នុង demo ប្តូរ "2 ** 10 =" ទៅ "2 ** 16 =" ហើយ expression ឲ្យត្រូវគ្នា។ អ្នកគួរតែឃើញ 65536។

ប្រសិនបើអ្នកឃើញ SyntaxError: Cannot use import statement outside a module មានន័យថា package.json របស់អ្នកខ្វះ "type": "module" ឬអ្នករត់ Node ពីថតផ្សេង។ ប្រសិនបើអ្នកឃើញ ERR_MODULE_NOT_FOUND សូមពិនិត្យអក្ខរាវិរុទ្ធ និង .js ក្នុង path នៃ import។

ឥឡូវនេះអ្នកមាន toolkit ទទេមួយ។ ក្នុងជំពូកបន្ទាប់ យើងបន្ថែម module ពិតប្រាកដដំបូង។

10. សាកល្បងដោយខ្លួនឯង

1. រកមើលគណិតវិទ្យា។ មើលគម្រោងតូចមួយដែលអ្នកធ្លាប់សរសេរ។ រកកន្លែងបីដែលអ្នកប្រើសំណល់ function បង្គត់ ការប្រៀបធៀបលេខ ឬលេខដែលលូតលាស់តាមទំហំ input។ សរសេរមួយៗចុះ។
2. ទាយ រួចរត់។ ដោយមិនរត់វា សូមទាយថា console.log(10 % 3, -10 % 3, 10 % -3) បោះពុម្ពអ្វី។ រត់វា។ លទ្ធផលមួយណាធ្វើឲ្យអ្នកភ្ញាក់ផ្អើល? (ជំពូកទី 6 ពន្យល់វា។)
3. បង្គត់បីវិធី។ បោះពុម្ព Math.floor, Math.ceil និង Math.round នៃ 7 / 2 និងនៃ -7 / 2។ តើអ្នកនឹងប្រើមួយណាសម្រាប់ចំនួនទំព័រ? សម្រាប់ "តើខ្ញុំអាចបំពេញប្រអប់ពេញបានប៉ុន្មាន"?
4. បន្ថែមបន្ទាត់។ បន្ថែម console.log("Cambodia riel per dollar:", 4100) ទៅ demo.js បន្ទាប់មកបោះពុម្ពតម្លៃកាហ្វេ $2.50 ជារៀលដោយប្រើ 2.5 * 4100។ តើចម្លើយដូចអ្វីដែលអ្នករំពឹងទុកយ៉ាងពិតប្រាកដឬទេ?
5. ធ្វើឲ្យវាខូចដោយចេតនា។ លុប "type": "module" ចេញពី package.json ហើយរត់ node demo.js។ អានសារកំហុស បន្ទាប់មកដាក់បន្ទាត់ត្រឡប់វិញ។ ការដឹងថាកំហុសនេះមើលទៅដូចអ្វី នឹងសន្សំពេលវេលាអ្នកនៅពេលក្រោយ។

ជាមួយនឹងគ្រោងឆ្អឹងរួចរាល់ ជំពូកបន្ទាប់ចាប់ផ្តើមពីមូលដ្ឋានបំផុត៖ លេខ និងប្រព័ន្ធលេខ បង្ហាញពីរបៀបដែលកុំព្យូទ័រសរសេរលេខជា binary និង hex ហើយចុងក្រោយពន្យល់ថាហេតុអ្វី 0.1 + 0.2 មិនស្មើ 0.3។