From 1b9f1259f6f08f9194a1ffb9fad94ee59da3422f Mon Sep 17 00:00:00 2001 From: Hongsreng-P Date: Wed, 5 Jul 2023 10:22:07 +0700 Subject: [PATCH] Added khmer translation for the first five days --- Khmer/02_Day_Data_types/02_day_data_types.md | 986 ++++++++++++++++++ .../03_booleans_operators_date.md | 637 +++++++++++ .../04_day_conditionals.md | 377 +++++++ Khmer/05_Day_Arrays/05_day_arrays.md | 774 ++++++++++++++ 4 files changed, 2774 insertions(+) create mode 100644 Khmer/02_Day_Data_types/02_day_data_types.md create mode 100644 Khmer/03_Day_Booleans_operators_date/03_booleans_operators_date.md create mode 100644 Khmer/04_Day_Conditionals/04_day_conditionals.md create mode 100644 Khmer/05_Day_Arrays/05_day_arrays.md diff --git a/Khmer/02_Day_Data_types/02_day_data_types.md b/Khmer/02_Day_Data_types/02_day_data_types.md new file mode 100644 index 0000000..27c4f46 --- /dev/null +++ b/Khmer/02_Day_Data_types/02_day_data_types.md @@ -0,0 +1,986 @@ +
+

30 ថ្ងៃនៃ JavaScript: ប្រភេទទិន្នន័យ

+ + + + + Twitter Follow + + +អ្នកនិពន្ធ: +Asabeneh Yetayeh
+ មករា, 2020 + + +
+ + +[<< ថ្ងៃទី ១](../readMe.md) | [ថ្ងៃទី ៣ >>](../03_Day_Booleans_operators_date/03_booleans_operators_date.md) + +![Thirty Days Of JavaScript](../images/banners/day_1_2.png) + +- [📔 ថ្ងៃទី​ ២](#-day-2) + - [ប្រភេទទិន្នន័យ](#data-types) + - [ប្រភេទទិន្នន័យបឋម](#primitive-data-types) + - [ប្រភេទទិន្នន័យមិនបឋម](#non-primitive-data-types) + - [Numbers](#numbers) + - [ការប្រកាសប្រភេទទិន្នន័យ Numbers](#declaring-number-data-types) + - [Math Object](#math-object) + - [ការបង្កើតលេខចៃដន្យ](#random-number-generator) + - [Strings](#strings) + - [ការភ្ជាប់ String](#string-concatenation) + - [ការភ្ជាប់ដោយប្រើសញ្ញាបូក](#concatenating-using-addition-operator) + - [Long Literal Strings](#long-literal-strings) + - [Escape Sequences នៅក្នុង Strings](#escape-sequences-in-strings) + - [Template Literals (Strings គំរូ)](#template-literals-template-strings) + - [String Methods](#string-methods) + - [ការពិនិត្យមើលនិងផ្លាស់ប្តូរប្រភេទទិន្នន័យ](#checking-data-types-and-casting) + - [ពិនិត្យប្រភេទទិន្នន័យ](#checking-data-types) + - [ការផ្លាស់ប្តូរប្រភេទទិន្នន័យ (Casting)](#changing-data-type-casting) + - [String ទៅចំនួនគត់](#string-to-int) + - [String ទៅចំនួនទសភាគ](#string-to-float) + - [ចំនួនទសភាគទៅចំនួនគត់](#float-to-int) + - [💻 លំហាត់សម្រាប់ថ្ងៃទី ២](#-day-2-exercises) + - [លំហាត់៖ កម្រិត ១](#exercise-level-1) + - [លំហាត់៖ កម្រិត ២](#exercise-level-2) + - [លំហាត់៖ កម្រិត ៣](#exercises-level-3) + +# 📔 Day 2 + +## ប្រភេទទិន្នន័យ + +នៅក្នុងផ្នែកមុន យើងបានរៀបរាប់បន្តិចអំពីប្រភេទទិន្នន័យ។ ទិន្នន័យ ឬតម្លៃមានប្រភេទទិន្នន័យ។ ប្រភេទទិន្នន័យពិពណ៌នាអំពីលក្ខណៈនៃទិន្នន័យ។ ប្រភេទទិន្នន័យអាចបែងចែកជាពីរ៖ + +1. ប្រភេទទិន្នន័យបឋម +2. ប្រភេទទិន្នន័យមិនបឋម (Object references) + +### ប្រភេទទិន្នន័យបឋម + +ប្រភេទទិន្នន័យបឋមនៅក្នុង JavaScript រួមមាន:: + +1. Number - ចំនួនគត់, ចំនួនទសភាគ +2. String - ទិន្នន័យណាមួយនៅក្រោម single quote, double quote និង backtick quote +3. Booleans - តម្លៃពិតឬមិនពិត +4. Null - តម្លៃទទេ ឬគ្មានតម្លៃ +5. Undefined - អថេរដែលបានប្រកាសដោយគ្មានតម្លៃ +6. Symbol - តម្លៃពិសេសមួយដែលអាចបង្កើតដោយ Symbol constructor + +ប្រភេទទិន្នន័យដែលមិនមែនបឋមនៅក្នុង JavaScript រួមមាន: + +1. Objects +2. Arrays + +ឥឡូវនេះ យើងមើលថាតើប្រភេទទិន្នន័យបឋម និងមិនមែនបឋមមានន័យដូចម្តេច។ +ប្រភេទទិន្នន័យបឋម គឺជាប្រភេទទិន្នន័យដែលមិនអាចកែប្រែបាន។ នៅពេលដែលប្រភេទទិន្នន័យបឋមត្រូវបានបង្កើត យើងមិនអាចកែប្រែវាបានទេ។ + +**ឧទាហរណ៍:** + +```js +let word = "JavaScript"; +``` + +ប្រសិនបើយើងព្យាយាមកែប្រែខ្សែអក្សរដែលរក្សាទុកក្នុងអថេរ _word_ នោះ JavaScript គួរតែបង្កើត error។ ប្រភេទទិន្នន័យណាមួយនៅក្រោម single quote, double quote, រឺ backtick quote គឺជាប្រភេទទិន្នន័យខ្សែអក្សរ។ + +```js +word[0] = "Y"; +``` + +កន្សោមនេះមិនផ្លាស់ប្តូរ string ដែលរក្សាទុកក្នុងអថេរ _word_ ទេ។ ដូច្នេះ យើងអាចនិយាយបានថា string មិនអាចកែប្រែបានទេ។ +ប្រភេទទិន្នន័យបឋមត្រូវបានប្រៀបធៀបដោយតម្លៃរបស់វា។ ឥឡូវ​នេះយើងប្រៀបធៀបតម្លៃទិន្នន័យផ្សេងៗគ្នា។ សូមមើលឧទាហរណ៍ខាងក្រោម៖ + +```js +let numOne = 3; +let numTwo = 3; + +console.log(numOne == numTwo); // ពិត + +let js = "JavaScript"; +let py = "Python"; + +console.log(js == py); // មិនពិត + +let lightOn = true; +let lightOff = false; + +console.log(lightOn == lightOff); // មិនពិត +``` + +### ប្រភេទទិន្នន័យមិនបឋម + +ប្រភេទទិន្នន័យមិនបឋមគឺអាចកែប្រែបាន ឬអាចផ្លាស់ប្តូរបាន។ យើងអាចកែប្រែតម្លៃនៃប្រភេទទិន្នន័យដែលមិនមែនបឋមបន្ទាប់ពីបង្កើតវា។ +យើងអាចមើលឃើញដោយបង្កើត Array។ ​Array គឺជាបញ្ជីតម្លៃទិន្នន័យក្នុងតង្កៀបការ៉េ។ Array អាចមានប្រភេទទិន្នន័យដូចគ្នា ឬផ្សេងគ្នា។ តម្លៃ Array ត្រូវបានយោងដោយ index របស់ពួកគេ។ នៅក្នុង Array index JavaScript ចាប់ផ្តើមនៅសូន្យ។ I.e. ធាតុទីមួយនៃ Array ត្រូវបានរកឃើញនៅ index សូន្យ ធាតុទីពីរនៅ index មួយ និងធាតុទីបីនៅ index ទីពីរ។ល។ + +```js +let nums = [1, 2, 3]; +nums[0] = 10; + +console.log(nums); // [10, 2, 3] +``` + +ដូចដែលអ្នកអាចឃើញ Array ដែលជាប្រភេទទិន្នន័យដែលមិនបឋមគឺអាចផ្លាស់ប្តូរបាន។ ប្រភេទទិន្នន័យដែលមិនមែនបឋមមិនអាចប្រៀបធៀបតាមតម្លៃបានទេ។ ទោះបីជាប្រភេទទិន្នន័យដែលមិនមែនជាបឋមពីរមានលក្ខណៈសម្បត្តិ និងតម្លៃដូចគ្នាក៏ដោយ ពួកវាមិនស្មើគ្នាយ៉ាងតឹងរ៉ឹងទេ។ + +```js +let nums = [1, 2, 3]; +let numbers = [1, 2, 3]; + +console.log(nums == numbers); // មិនពិត + +let userOne = { + name: "Asabeneh", + role: "teaching", + country: "Finland", +}; + +let userTwo = { + name: "Asabeneh", + role: "teaching", + country: "Finland", +}; + +console.log(userOne == userTwo); // មិនពិត +``` + +យើងមិនប្រៀបធៀបប្រភេទទិន្នន័យដែលមិនមែនបឋមទេ។ កុំប្រៀបធៀប Array, Functions ឬ Objects។ +តម្លៃ​ដែល​មិន​មែន​បឋម​ត្រូវ​បាន​គេ​ហៅ​ថា​ជា​ប្រភេទ​ reference​ ព្រោះ​វា​ត្រូវ​បាន​គេ​ប្រៀបធៀប​ដោយ​ reference ​ជា​ជាង​តម្លៃ។ វត្ថុពីរគឺស្មើគ្នាយ៉ាងតឹងរ៉ឹង ប្រសិនបើពួកគេសំដៅទៅលើវត្ថុមូលដ្ឋានដូចគ្នា។ + +```js +let nums = [1, 2, 3]; +let numbers = nums; + +console.log(nums == numbers); // ពិត + +let userOne = { + name: "Asabeneh", + role: "teaching", + country: "Finland", +}; + +let userTwo = userOne; + +console.log(userOne == userTwo); // ពិត +``` + +ប្រសិនបើអ្នកមានការលំបាកក្នុងការយល់ដឹងពីភាពខុសគ្នារវាងប្រភេទទិន្នន័យបឋម និងប្រភេទទិន្នន័យដែលមិនបឋម អ្នកមិនមែនជាមនុស្សតែម្នាក់នោះទេ។ ស្ងប់ស្ងាត់ចុះ ហើយគ្រាន់តែទៅផ្នែកបន្ទាប់ ហើយព្យាយាមត្រឡប់មកវិញបន្ទាប់ពីពេលខ្លះ។ ឥឡូវនេះអនុញ្ញាតឱ្យយើងចាប់ផ្តើមប្រភេទទិន្នន័យតាមប្រភេទលេខ។ + +## Numbers + +Numbers គឺជាចំនួនគត់ និងតម្លៃទសភាគដែលអាចធ្វើប្រតិបត្តិការនព្វន្ធទាំងអស់។ +តោះមើលឧទាហរណ៍មួយចំនួននៃលេខ។ + +### ការប្រកាសប្រភេទទិន្នន័យ Numbers + +```js +let age = 35; +const gravity = 9.81; // យើងប្រើ const សម្រាប់តម្លៃមិនផ្លាស់ប្តូរ +let mass = 72; // ម៉ាស់គិតជាគីឡូក្រាម +const PI = 3.14; // pi ជាតម្លៃថេរ + +// ឧទាហរណ៍ច្រើនទៀត +const boilingPoint = 100; // ចំណុចរំពុះនៃទឹករ +const bodyTemp = 37; // សីតុណ្ហភាពរាងកាយរបស់មនុស្សជាមធ្យម + +console.log(age, gravity, mass, PI, boilingPoint, bodyTemp); +``` + +### Math Object + +នៅក្នុង JavaScript Math Object ផ្តល់នូវវិធីសាស្រ្តជាច្រើនដើម្បីធ្វើការជាមួយលេខ។ + +```js +const PI = Math.PI; + +console.log(PI); // 3.141592653589793 + +// បង្គត់ទៅលេខជិតបំផុត។ +// ឡើងលើបើ .5 ឡើង ចុះក្រោមបើ 0.5 ចុះ + +console.log(Math.round(PI)); // 3 ដើម្បីបង្គត់តម្លៃទៅលេខដែលនៅជិតបំផុត។ + +console.log(Math.round(9.81)); // 10 + +console.log(Math.floor(PI)); // 3 បង្គត់ចុះ + +console.log(Math.ceil(PI)); // 4 បង្គត់ឡើង + +console.log(Math.min(-5, 3, 20, 4, 5, 10)); // -5, ឲតម្លៃអប្បបរមា + +console.log(Math.max(-5, 3, 20, 4, 5, 10)); // 20, ឲតម្លៃអតិបរមា + +const randNum = Math.random(); // បង្កើតលេខចៃដន្យរចន្លោះពី 0 ទៅ 0.999999 +console.log(randNum); + +// យើងបង្កើតលេខចៃដន្យពី 0 ទៅ 10 + +const num = Math.floor(Math.random() * 11); // បង្កើតលេខចៃដន្យពី 0 ទៅ 10 +console.log(num); + +//តម្លៃ​ដាច់ខាត +console.log(Math.abs(-10)); // 10 + +//ឫស​ការេ +console.log(Math.sqrt(100)); // 10 + +console.log(Math.sqrt(2)); // 1.4142135623730951 + +// ស្វ័យគុណ +console.log(Math.pow(3, 2)); // 9 + +console.log(Math.E); // 2.718 + +// លោការីត +// ឲ​លោការីត​ធម្មជាតិ​ជាមួយ​នឹង​គោល E នៃ x, Math.log(x) +console.log(Math.log(2)); // 0.6931471805599453 +console.log(Math.log(10)); // 2.302585092994046 + +// ឲលោការីតធម្មជាតិនៃ 2 និង 10 រៀងគ្នា។ +console.log(Math.LN2); // 0.6931471805599453 +console.log(Math.LN10); // 2.302585092994046 + +// ត្រីកោណមាត្រ +Math.sin(0); +Math.sin(60); + +Math.cos(0); +Math.cos(60); +``` + +#### ការបង្កើតលេខចៃដន្យ + +JavaScript Math Object មាន random() method generator ដែលបង្កើតលេខពី 0 ដល់ 0.999999999... + +```js +let randomNum = Math.random(); // បង្កើត 0 ទៅ 0.999... +``` + +ឥឡូវនេះ អនុញ្ញាតឱ្យយើងមើលពីរបៀបដែលយើងអាចប្រើ random() method ដើម្បីបង្កើតចំនួនចៃដន្យរពី 0 ទៅ 10: + +```js +let randomNum = Math.random(); // បង្កើតលេខពី 0 ទៅ 0.999 +let numBtnZeroAndTen = randomNum * 11; + +console.log(numBtnZeroAndTen); // នេះផ្តល់ឱ្យតម្លៃ៖ អប្បបរមា 0 និងអតិបរមា 10.99 + +let randomNumRoundToFloor = Math.floor(numBtnZeroAndTen); +console.log(randomNumRoundToFloor); // នេះផ្តល់ឱ្យតម្លៃចន្លោះពី 0 ទៅ 10 +``` + +## Strings + +String គឺជាអត្ថបទដែលស្ថិតនៅក្រោម **_single_** , **_double_**, **_back-tick_** quote។ ដើម្បីប្រកាស String យើងត្រូវការឈ្មោះអថេរ assignment operator និងតម្លៃក្រោម single quote, double quote និង backtick quote។ +តោះមើលឧទាហរណ៍ខ្លះនៃ string៖ + +```js +let space = " "; // string ទទេ +let firstName = "Asabeneh"; +let lastName = "Yetayeh"; +let country = "Finland"; +let city = "Helsinki"; +let language = "JavaScript"; +let job = "teacher"; +let quote = "The saying,'Seeing is Believing' is not correct in 2020."; +let quotWithBackTick = `The saying,'Seeing is Believing' is not correct in 2020.`; +``` + +### ការភ្ជាប់ String + +ការភ្ជាប់ String ពីរ ឬច្រើនជាមួយគ្នាត្រូវបានគេហៅថា Concatenation។ ដោយប្រើ String ដែលបានប្រកាសនៅផ្នែកមុន៖ + +```js +let fullName = firstName + space + lastName; // concatenation, merging two string together. +console.log(fullName); +``` + +```sh +Asabeneh Yetayeh +``` + +យើងអាចភ្ជាប់ string តាមវិធីផ្សេងៗគ្នា។ + +#### ការភ្ជាប់ដោយប្រើសញ្ញាបូក + +ការភ្ជាប់ដោយប្រើសញ្ញាបូកគឺជាវិធីចាស់។ វិធីនៃការភ្ជាប់គ្នានេះគឺពិបាកនិងងាយមានកំហុស។ វាជាការល្អក្នុងការដឹងពីរបៀបភ្ជាប់តាមវិធីនេះ ប៉ុន្តែខ្ញុំស្នើឱ្យប្រើ ES6 template strings (ពន្យល់នៅពេលក្រោយ)។ + +```js +// ប្រកាសអថេរផ្សេងៗនៃប្រភេទទិន្នន័យផ្សេងៗគ្នា +let space = " "; +let firstName = "Asabeneh"; +let lastName = "Yetayeh"; +let country = "Finland"; +let city = "Helsinki"; +let language = "JavaScript"; +let job = "teacher"; +let age = 250; + +let fullName = firstName + space + lastName; +let personInfoOne = fullName + ". I am " + age + ". I live in " + country; // ES5 string addition + +console.log(personInfoOne); +``` + +```sh +Asabeneh Yetayeh. I am 250. I live in Finland +``` + +#### Long Literal Strings + +string អាចជាតួអក្សរតែមួយ ឬកថាខណ្ឌ ឬទំព័រមួយ។ ប្រសិនបើប្រវែងខ្សែនេះធំពេក វាមិនសាកសមនឹងបន្ទាត់តែមួយទេ។ យើង​អាច​ប្រើ​តួអក្សរ backslash (\\) នៅ​ខាង​ចុង​បន្ទាត់​នីមួយៗ ដើម្បី​បង្ហាញ​ថា​​អក្សរ​នឹង​បន្ត​នៅ​ជួរ​បន្ទាប់។ +**ឧទាហរណ៍:** + +```js +const paragraph = + "My name is Asabeneh Yetayeh. I live in Finland, Helsinki.\ +I am a teacher and I love teaching. I teach HTML, CSS, JavaScript, React, Redux, \ +Node.js, Python, Data Analysis and D3.js for anyone who is interested to learn. \ +In the end of 2019, I was thinking to expand my teaching and to reach \ +to global audience and I started a Python challenge from November 20 - December 19.\ +It was one of the most rewarding and inspiring experience.\ +Now, we are in 2020. I am enjoying preparing the 30DaysOfJavaScript challenge and \ +I hope you are enjoying too."; + +console.log(paragraph); +``` + +#### Escape Sequences in Strings + +នៅក្នុង JavaScript និងភាសាសរសេរកម្មវិធីផ្សេងទៀតការដាក់ \ នៅពីមុកតួអក្សរមួយចំនួនគឺជា escape sequence។ តោះ​មើល​ escape characters ដែលទូទៅបំផុត៖ + +- \n: បន្ទាត់ថ្មី +- \t: tab មានន័យថា ៨ ចន្លោះ +- \\\\: backslash +- \\': Single quote (') +- \\": Double quote (") + +```js +console.log( + "I hope everyone is enjoying the 30 Days Of JavaScript challenge.\nDo you ?" +); // ការបំបែកបន្ទាត់ +console.log("Days\tTopics\tExercises"); +console.log("Day 1\t3\t5"); +console.log("Day 2\t3\t5"); +console.log("Day 3\t3\t5"); +console.log("Day 4\t3\t5"); +console.log("This is a backslash symbol (\\)"); // ដើម្បីសរសេរ backslash +console.log('In every programming language it starts with "Hello, World!"'); +console.log("In every programming language it starts with 'Hello, World!'"); +console.log("The saying 'Seeing is Believing' isn't correct in 2020"); +``` + +លទ្ធផលនៅក្នុង console + +```sh +I hope everyone is enjoying the 30 Days Of JavaScript challenge. +Do you ? +Days Topics Exercises +Day 1 3 5 +Day 2 3 5 +Day 3 3 5 +Day 4 3 5 +This is a backslash symbol (\) +In every programming language it starts with "Hello, World!" +In every programming language it starts with 'Hello, World!' +The saying 'Seeing is Believing' isn't correct in 2020 +``` + +#### Template Literals (Strings គំរូ) + +ដើម្បីបង្កើត string គំរូ យើងប្រើសញ្ញា back-ticks។ យើងអាចបញ្ចូលទិន្នន័យជាកន្សោមនៅខាងក្នុង string អក្សរគំរូ។ ដើម្បីចាក់បញ្ចូលទិន្នន័យ យើងភ្ជាប់កន្សោមជាមួយនឹងដង្កៀបអង្កាញ់ ({}) ដែលនាំមុខដោយសញ្ញា $ ។ សូមមើល syntax ខាងក្រោម។ + +```js +//Syntax +`String literal text``String literal text ${expression}`; +``` + +**ឧទាហរណ៍: 1** + +```js +console.log(`The sum of 2 and 3 is 5`); // ការសរសេរទិន្នន័យ +let a = 2; +let b = 3; +console.log(`The sum of ${a} and ${b} is ${a + b}`); // ការបញ្ចូលទិន្នន័យ +``` + +**ឧទាហរណ៍:2** + +```js +let firstName = "Asabeneh"; +let lastName = "Yetayeh"; +let country = "Finland"; +let city = "Helsinki"; +let language = "JavaScript"; +let job = "teacher"; +let age = 250; +let fullName = firstName + " " + lastName; + +let personInfoTwo = `I am ${fullName}. I am ${age}. I live in ${country}.`; //ES6 - វិធីសាស្ត្របញ្ចូល string +let personInfoThree = `I am ${fullName}. I live in ${city}, ${country}. I am a ${job}. I teach ${language}.`; +console.log(personInfoTwo); +console.log(personInfoThree); +``` + +```sh +I am Asabeneh Yetayeh. I am 250. I live in Finland. +I am Asabeneh Yetayeh. I live in Helsinki, Finland. I am a teacher. I teach JavaScript. +``` + +ដោយប្រើ string គំរូ ឬវិធីសាស្ត្របញ្ចូល string យើងអាចបន្ថែមកន្សោម ដែលអាចជាតម្លៃ ឬប្រតិបត្តិការមួយចំនួន (ការប្រៀបធៀប, ប្រតិបត្តិការនព្វន្ធ, និង ប្រតិបត្តិការ ternary)។ + +```js +let a = 2; +let b = 3; +console.log(`${a} is greater than ${b}: ${a > b}`); +``` + +```sh +2 is greater than 3: false +``` + +### String Methods + +អ្វីគ្រប់យ៉ាងនៅក្នុង JavaScript គឺជា object។ string គឺជាប្រភេទទិន្នន័យបឋមដែលមានន័យថាយើងមិនអាចកែប្រែវាបានទេនៅពេលដែលវាត្រូវបានបង្កើត។ string object មាន string method ជាច្រើនដែលអាចជួយយើងឱ្យធ្វើការជាមួយ string។ + +1. _length_: string _length_ method ឲ​ចំនួន​តួអក្សរ​ក្នុង​ខ្សែអក្សរ​ដែល​រួម​បញ្ចូលទាំង​ចន្លោះ​ទទេ។ + +**ឧទាហរណ៍:** + +```js +let js = "JavaScript"; +console.log(js.length); // 10 +let firstName = "Asabeneh"; +console.log(firstName.length); // 8 +``` + +2. _ការចាប់យកតួអក្សរក្នុង string_៖ យើងអាចចូលប្រើតួអក្សរនីមួយៗក្នុង string ដោយប្រើ index របស់វា។ ក្នុង​ការ​សរសេរ​កម្មវិធី ការ​រាប់​ចាប់​ផ្ដើម​ពី 0។ index ​ទី​មួយ​នៃ​ string គឺ​សូន្យ ហើយ index ​ចុង​ក្រោយ​គឺ​ជា​ប្រវែង​នៃ​ខ្សែ​អក្សរ​ដក​មួយ។ + +![Accessing sting by index](../images/string_indexes.png) + +ឥឡូវ​នេះយើងចូលប្រើតួអក្សរផ្សេងគ្នានៅក្នុង string 'JavaScript' ។ + +```js +let string = "JavaScript"; +let firstLetter = string[0]; + +console.log(firstLetter); // J + +let secondLetter = string[1]; // a +let thirdLetter = string[2]; +let lastLetter = string[9]; + +console.log(lastLetter); // t + +let lastIndex = string.length - 1; + +console.log(lastIndex); // 9 +console.log(string[lastIndex]); // t +``` + +3. _toUpperCase()_: method នេះផ្លាស់ប្តូរ string ទៅជាអក្សរធំ។ + +```js +let string = "JavaScript"; + +console.log(string.toUpperCase()); // JAVASCRIPT + +let firstName = "Asabeneh"; + +console.log(firstName.toUpperCase()); // ASABENEH + +let country = "Finland"; + +console.log(country.toUpperCase()); // FINLAND +``` + +4. _toLowerCase()_: method នេះផ្លាស់ប្តូរ string ទៅជាអក្សរតូច។ + +```js +let string = "JavasCript"; + +console.log(string.toLowerCase()); // javascript + +let firstName = "Asabeneh"; + +console.log(firstName.toLowerCase()); // asabeneh + +let country = "Finland"; + +console.log(country.toLowerCase()); // finland +``` + +5. _substr()_: វាត្រូវការ arguments ពីរ គឺ index ចាប់ផ្តើម និងចំនួនតួអក្សរដើម្បីកាត់។ + +```js +let string = "JavaScript"; +console.log(string.substr(4, 6)); // Script + +let country = "Finland"; +console.log(country.substr(3, 4)); // land +``` + +6. _substring()_: វាត្រូវការ arugments ពីរ គឺ index ចាប់ផ្តើម និង index បញ្ឈប់ ប៉ុន្តែវាមិនរួមបញ្ចូលតួអក្សរនៅ index បញ្ឈប់នោះទេ។ + +```js +let string = "JavaScript"; + +console.log(string.substring(0, 4)); // Java +console.log(string.substring(4, 10)); // Script +console.log(string.substring(4)); // Script + +let country = "Finland"; + +console.log(country.substring(0, 3)); // Fin +console.log(country.substring(3, 7)); // land +console.log(country.substring(3)); // land +``` + +7. _split()_: method នេះបំបែកបំបែក string នៅកន្លែងជាក់លាក់មួយ។ + +```js +let string = "30 Days Of JavaScript"; + +console.log(string.split()); // ប្តូរទៅជា array -> ["30 ថ្ងៃនៃ JavaScript"] +console.log(string.split(" ")); // បំបែកទៅជា array នៅចន្លោះ -> ["30", "ថ្ងៃ", "នៃ", "JavaScript"] + +let firstName = "Asabeneh"; + +console.log(firstName.split()); // ប្តូរទៅជា array -> ["Asabeneh"] +console.log(firstName.split("")); // បំបែកទៅជា array នៅអក្សរនីមួយៗ -> ["A", "s", "a", "b", "e", "n", "e", "h"] + +let countries = "Finland, Sweden, Norway, Denmark, and Iceland"; + +console.log(countries.split(",")); // បំបែកទៅជា array នៅសញ្ញាក្បៀស -> ["ហ្វាំងឡង់", "ស៊ុយអែត", "ន័រវេស", "ដាណឺម៉ាក", "និងអ៊ីស្លង់"] +console.log(countries.split(", ")); //  ["Finland", "Sweden", "Norway", "Denmark", "and Iceland"] +``` + +8. _trim()_: ដក​ដកឃ្លា​នៅ​ខាង​ដើម​ឬ​ចុង​ string ​ចេញ។ + +```js +let string = " 30 Days Of JavaScript "; + +console.log(string); +console.log(string.trim(" ")); + +let firstName = " Asabeneh "; + +console.log(firstName); +console.log(firstName.trim()); // នៅ​តែ​ដក​ដក​ឃ្លា​នៅ​ខាង​ដើម និង​ចុង​ string +``` + +```sh + 30 Days Of JavasCript +30 Days Of JavasCript + Asabeneh +Asabeneh +``` + +9. _includes()_: វា​យក​ argument substring ហើយ​វា​ពិនិត្យ​មើល​ថា​តើ​មាន argument substring នៅក្នុង​ string ហ្នឹង​ឬ​អត់។ _includes()_ ឲវិញជា boolean។ ប្រសិនបើខ្សែអក្សររងមាននៅក្នុងខ្សែអក្សរ វាឲពិត បើមិនដូច្នេះទេ វាឲមិនពិត។ + +```js +let string = "30 Days Of JavaScript"; + +console.log(string.includes("Days")); // true +console.log(string.includes("days")); // false - it is case sensitive! +console.log(string.includes("Script")); // true +console.log(string.includes("script")); // false +console.log(string.includes("java")); // false +console.log(string.includes("Java")); // true + +let country = "Finland"; + +console.log(country.includes("fin")); // false +console.log(country.includes("Fin")); // true +console.log(country.includes("land")); // true +console.log(country.includes("Land")); // false +``` + +10. _replace()_: យកជាប៉ារ៉ាម៉ែត្រនៃ substring ចាស់ និង substring ថ្មី។ + +```js +string.replace(oldsubstring, newsubstring); +``` + +```js +let string = "30 Days Of JavaScript"; +console.log(string.replace("JavaScript", "Python")); // 30 Days Of Python + +let country = "Finland"; +console.log(country.replace("Fin", "Noman")); // Nomanland +``` + +11. _charAt()_: យក index ហើយវាឲតម្លៃនៅ index នោះ។ + +```js +string.charAt(index); +``` + +```js +let string = "30 Days Of JavaScript"; +console.log(string.charAt(0)); // 3 + +let lastIndex = string.length - 1; +console.log(string.charAt(lastIndex)); // t +``` + +12. _charCodeAt()_: យក index ហើយវាត្រឡប់ char code (លេខ ASCII) នៃតម្លៃនៅ index នោះ។ + +```js +string.charCodeAt(index); +``` + +```js +let string = "30 Days Of JavaScript"; +console.log(string.charCodeAt(3)); // លេខ ASCII របស់ D គឺ 68 + +let lastIndex = string.length - 1; +console.log(string.charCodeAt(lastIndex)); // លេខ ASCII របស់ T គឺ 116 +``` + +13. _indexOf()_: យក​ substring ​មួយ ហើយ​ប្រសិនបើ​ substring ​មាន​ក្នុង​ string វា​ឲទីតាំង​ទីមួយ​នៃ​ substring ប្រសិនបើ​មិនមាន វា​នឹង​ឲ -1 + +```js +string.indexOf(substring); +``` + +```js +let string = "30 Days Of JavaScript"; + +console.log(string.indexOf("D")); // 3 +console.log(string.indexOf("Days")); // 3 +console.log(string.indexOf("days")); // -1 +console.log(string.indexOf("a")); // 4 +console.log(string.indexOf("JavaScript")); // 11 +console.log(string.indexOf("Script")); //15 +console.log(string.indexOf("script")); // -1 +``` + +14. _lastIndexOf()_: យក substring ​មួយ ហើយ​ប្រសិនបើ substring ​មាន​ក្នុង​ខ្សែ​អក្សរ វា​ត្រឡប់​ទីតាំង​ចុងក្រោយ​នៃ​ substring ប្រសិនបើ​វា​មិនមាន វា​ឲ​ -1 + +```js +//syntax +string.lastIndexOf(substring); +``` + +```js +let string = + "I love JavaScript. If you do not love JavaScript what else can you love."; + +console.log(string.lastIndexOf("love")); // 67 +console.log(string.lastIndexOf("you")); // 63 +console.log(string.lastIndexOf("JavaScript")); // 38 +``` + +15. _concat()_: វាយក substring ជាច្រើន ហើយភ្ជាប់ពួកវា។ + +```js +string.concat(substring, substring, substring); +``` + +```js +let string = "30"; +console.log(string.concat("Days", "Of", "JavaScript")); // 30DaysOfJavaScript + +let country = "Fin"; +console.log(country.concat("land")); // Finland +``` + +16. វា​យក​ substring ​ជា​ argument ហើយ​វា​ពិនិត្យ​មើល​ថាតើ​ string នេះ​ចាប់ផ្តើម​ដោយ​ substring ដែល​បាន​បញ្ជាក់​នោះ​ឬ​អត់។ វាត្រឡប់ boolean (ពិតឬមិនពិត) ។ + +```js +//syntax +string.startsWith(substring); +``` + +```js +let string = "Love is the best to in this world"; + +console.log(string.startsWith("Love")); // true +console.log(string.startsWith("love")); // false +console.log(string.startsWith("world")); // false + +let country = "Finland"; + +console.log(country.startsWith("Fin")); // true +console.log(country.startsWith("fin")); // false +console.log(country.startsWith("land")); // false +``` + +17. _endsWith_: វា​យក substring ​ជា argument ហើយ​វា​ពិនិត្យ​មើល​ថា​តើ​ string ​បញ្ចប់​ដោយ​ substring ​ដែល​បាន​បញ្ជាក់​នោះ​ឬ​អត់។ វាឲ boolean (ពិតឬមិនពិត) ។ + +```js +string.endsWith(substring); +``` + +```js +let string = "Love is the most powerful feeling in the world"; + +console.log(string.endsWith("world")); // true +console.log(string.endsWith("love")); // false +console.log(string.endsWith("in the world")); // true + +let country = "Finland"; + +console.log(country.endsWith("land")); // true +console.log(country.endsWith("fin")); // false +console.log(country.endsWith("Fin")); // false +``` + +18. _search_: វា​យក substring ​ជា​ argument ហើយ​វា​ឲ​ index ​នៃតម្លៃដែលត្រូវដំបូង​។ តម្លៃស្វែងរកអាចជា string ឬ regular expression។ + +```js +string.search(substring); +``` + +```js +let string = + "I love JavaScript. If you do not love JavaScript what else can you love."; +console.log(string.search("love")); // 2 +console.log(string.search(/javascript/gi)); // 7 +``` + +19. _match_: + វាយក substring ឬ regular expression ជា argument ហើយវាឲ array មួយ ប្រសិនបើមានការផ្គូផ្គង ហើយបើមិនមាន វាឲ null។ យើងមកមើលពីរបៀបរបស់ regular expression។ វាចាប់ផ្តើមដោយ/ និងបញ្ចប់ដោយ/ + +```js +let string = "love"; +let patternOne = /love/; // ដោយគ្មាន flag ណាមួយ +let patternTwo = /love/gi; // g-មានន័យថាស្វែងរកក្នុងអត្ថបទទាំងមូល i មានន័យថា case insensitive +``` + +Syntax សម្រាប់ការផ្គូផ្គង + +```js +// syntax +string.match(substring); +``` + +```js +let string = + "I love JavaScript. If you do not love JavaScript what else can you love."; +console.log(string.match("love")); +``` + +```sh +["love", index: 2, input: "I love JavaScript. If you do not love JavaScript what else can you love.", groups: undefined] +``` + +```js +let pattern = /love/gi; +console.log(string.match(pattern)); // ["love", "love", "love"] +``` + +ឥឡូវ​នេះយើងនឹងទាញយកលេខចេញពីអត្ថបទដោយប្រើ regular expression។ នេះមិនមែនជាផ្នែក regular expression ទេ កុំភ័យ! យើងនឹងបង្ហាញពី​ regular expression នៅពេលក្រោយ។ + +```js +let txt = + "In 2019, I ran 30 Days of Python. Now, in 2020 I am super exited to start this challenge"; +let regEx = /\d+/; + +// ជាមួួយ d នេះវាជំនួសឲ digit ជាជាងអក្សរ d +// + មានន័យថាលេខមួយខ្ទង់ ឬច្រើនខ្ទង់ +// ប្រសិនបើមាន g បន្ទាប់ពីនោះមានន័យថាជាសកល និងស្វែងរកគ្រប់ទីកន្លែង។ + +console.log(txt.match(regEx)); // ["2", "0", "1", "9", "3", "0", "2", "0", "2", "0"] +console.log(txt.match(/\d+/g)); // ["2019", "30", "2020"] +``` + +20. _repeat()_: វាយកលេខជា argument ហើយវាឲទម្រង់ដដែលៗរបស់ string នោះ។ + +```js +string.repeat(n); +``` + +```js +let string = "love"; +console.log(string.repeat(10)); // lovelovelovelovelovelovelovelovelovelove +``` + +## ការពិនិត្យមើលនិងផ្លាស់ប្តូរប្រភេទទិន្នន័យ + +### ការពិនិត្យមើលប្រភេទទិន្នន័យ + +ដើម្បីពិនិត្យមើលប្រភេទទិន្នន័យនៃ variable ណាមួយ យើងប្រើ method _typeof_ ។ + +**Example:** + +```js +// ប្រភេទទិន្នន័យ javascript ផ្សេងៗគ្នា +// ប្រកាសប្រភេទទិន្នន័យផ្សេងៗគ្នា + +let firstName = "Asabeneh"; // string +let lastName = "Yetayeh"; // string +let country = "Finland"; // string +let city = "Helsinki"; // string +let age = 250; // number វាមិនមែនជាអាយុពិតរបស់ខ្ញុំទេ កុំគិតអំពីវា។ +let job; // undefined, ដោយសារតែតម្លៃមិនត្រូវបានកំណត់ + +console.log(typeof "Asabeneh"); // string +console.log(typeof firstName); // string +console.log(typeof 10); // number +console.log(typeof 3.14); // number +console.log(typeof true); // boolean +console.log(typeof false); // boolean +console.log(typeof NaN); // number +console.log(typeof job); // undefined +console.log(typeof undefined); // undefined +console.log(typeof null); // object +``` + +### ការផ្លាស់ប្តូរប្រភេទទិន្នន័យ (Casting) + +- Casting៖ ការបំប្លែងប្រភេទទិន្នន័យមួយទៅប្រភេទទិន្នន័យមួយទៀត។ យើងប្រើ _parseInt()_, _parseFloat()_, _Number()_, _+ sign_, _str()_ + នៅពេលយើងធ្វើប្រតិបត្តិការនព្វន្ធលើ string numbers យើងគួរតែបំប្លែងវាជាចំនួនគត់ ឬចំនួនទសភាគ ប្រសិនបើវាមិនបង្កើត error។ + +#### String ទៅចំនួនគត់ + +យើងអាចបំប្លែង string number ទៅជាលេខមួយ។ លេខណាមួយនៅក្នុង quote គឺជា string number ឧទាហរណ៍នៃ string number៖ '10', '5' ។ល។ +យើង​អាច​បំប្លែង string ទៅ​ជា​លេខ​បាន​ដោយ​ប្រើ​វិធី​ដូច​ខាង​ក្រោម៖ + +- parseInt() +- Number() +- Plus sign(+) + +```js +let num = "10"; +let numInt = parseInt(num); +console.log(numInt); // 10 +``` + +```js +let num = "10"; +let numInt = Number(num); + +console.log(numInt); // 10 +``` + +```js +let num = "10"; +let numInt = +num; + +console.log(numInt); // 10 +``` + +#### String ទៅចំនួនទសភាគ + +យើងអាចបំប្លែង string float ទៅជាចំនួនទសភាគ។ ចំនួនទសភាគណាមួយនៅក្នុង quote គឺជា string float ឧទាហរណ៍នៃ string float៖ '9.81', '3.14', '1.44' ។ល។ +យើងអាចបំប្លែង string float ទៅជាលេខបានដោយប្រើវិធីខាងក្រោម៖ + +- parseFloat() +- Number() +- Plus sign(+) + +```js +let num = "9.81"; +let numFloat = parseFloat(num); + +console.log(numFloat); // 9.81 +``` + +```js +let num = "9.81"; +let numFloat = Number(num); + +console.log(numFloat); // 9.81 +``` + +```js +let num = "9.81"; +let numFloat = +num; + +console.log(numFloat); // 9.81 +``` + +#### ចំនួនទសភាគទៅចំនួនគត់ + +យើងអាចបំប្លែងលេខទសភាគទៅជាចំនួនគត់។ +យើងប្រើវិធីខាងក្រោមដើម្បីបំប្លែងចំនួនទសភាគទៅជាចំនួនគត់៖ + +- parseInt() + +```js +let num = 9.81; +let numInt = parseInt(num); + +console.log(numInt); // 9 +``` + +🌕 អ្នកពិតជាអស្ចារ្យមែន។ អ្នកទើបតែបានបញ្ចប់ challenge នេះនៅថ្ងៃទី 2 ហើយអ្នកកំពុងឈានទៅមុខពីរជំហានក្នុងដំណើរឆ្ពោះទៅរកភាពអស្ចារ្យ។ ឥឡូវធ្វើលំហាត់ខ្លះសម្រាប់ខួរក្បាល និងសាច់ដុំរបស់អ្នក។ + +## 💻 លំហាត់សម្រាប់ថ្ងៃទីពីរ + +### លំហាត់៖ កម្រិត ១ + + +1. ប្រកាស variable ដែលមានឈ្មោះ challenge ហើយកំណត់វាទៅជាតម្លៃ **'30 Days Of JavaScript'**។ +2. បង្ហាញ string នៅលើ browser console ដោយប្រើ **console.log()** +3. បង្ហាញ **ប្រវែង** នៃ string នៅលើ browser console ដោយប្រើ _console.log()_ +4. ផ្លាស់ប្តូរតួអក្សរ string ទាំងអស់ទៅជាអក្សរធំដោយប្រើវិធី **toUpperCase()** +5. ផ្លាស់ប្តូរតួអក្សរ string ទាំងអស់ទៅជាអក្សរតូចដោយប្រើវិធីសាស្រ្ត **toLowerCase()** +6. កាត់ (slice) ចេញពាក្យដំបូងនៃខ្សែអក្សរដោយប្រើ **substr()** ឬ **substring()** method +7. កាត់ឃ្លាថា Days_Of_JavaScript ចេញពី 30 Days Of JavaScript ។ +8. ពិនិត្យមើលថាតើ string មានពាក្យ **script** ដោយប្រើ **includes()** method +9. បំបែក string ទៅជា array ដោយប្រើវិធីសាស្ត្រ split() +10. បំបែក string 30 Days Of JavaScript នៅចន្លោះដោយប្រើវិធីសាស្ត្រ **split()** +11. 'Facebook, Google, Microsoft, Apple, IBM, Oracle, Amazon' **split** string ហ្នឹងនៅសញ្ញាក្បៀស ហើយប្តូរវាទៅជា array +12. ផ្លាស់ប្តូរ 30 Days Of JavaScript ទៅ 30 Days of Python ដោយប្រើវិធីសាស្រ្ត **replace()** ។ +13. តើអ្វីជាតួអក្សរនៅ index 15 ក្នុងខ្សែអក្សរ '30 Days Of JavaScript'? ប្រើវិធីសាស្រ្ត **charAt()**។ +14. តើអ្វីទៅជាកូដតួអក្សររបស់ J ក្នុងខ្សែអក្សរ '30 Days Of JavaScript' ដោយប្រើ **charCodeAt()** +15. ប្រើ **indexOf** ដើម្បីកំណត់ទីតាំងនៃការលេចឡើងដំបូងនៃ **a** ក្នុង 30 Days Of JavaScript +16. ប្រើ **lastIndexOf** ដើម្បីកំណត់ទីតាំងនៃលេខឡើងចុងក្រោយនៃ **a** ក្នុង 30 Days Of JavaScript ។ +17. ប្រើ **indexOf** ដើម្បីស្វែងរកទីតាំងនៃការកើតឡើងដំបូងនៃពាក្យ **because** ក្នុងប្រយោគខាងក្រោម៖**'You cannot end a sentence with because because because is a conjunction'** +18. ប្រើ **lastIndexOf** ដើម្បីស្វែងរកទីតាំងនៃការកើតឡើងចុងក្រោយនៃពាក្យ **because** ក្នុងប្រយោគខាងក្រោម៖**'You cannot end a sentence with because because because is a conjunction'** +19. ប្រើ **search** ដើម្បីស្វែងរកទីតាំងនៃការកើតឡើងដំបូងនៃពាក្យ **because** នៅក្នុងប្រយោគខាងក្រោម:**'You cannot end a sentence with because because because is a conjunction'** +20. ប្រើ **trim()** ដើម្បីលុបដកឃ្លាណាមួយនៅខាងដើម និងចុងបញ្ចប់នៃ string។ ឧទាហរណ៍ ' 30 Days Of JavaScript '។ +21. ប្រើវិធីសាស្រ្ត **startsWith()** ជាមួយ string _30 Days Of JavaScript_ ហើយធ្វើឱ្យលទ្ធផលពិត +22. ប្រើវិធីសាស្រ្ត **endsWith()** ជាមួយ string _30 Days Of JavaScript_ ហើយធ្វើឱ្យលទ្ធផលពិត +23. ប្រើវិធីសាស្រ្ត **match()** ដើម្បីស្វែងរក **a** ទាំងអស់ក្នុង 30 Days Of JavaScript +24. ប្រើ **concat()** ដើម្បីបញ្ចូល '30 Days of' និង 'JavaScript' ទៅ string តែមួយ '30 Days Of JavaScript' +25. ប្រើវិធីសាស្រ្ត **repeat()** ដើម្បបង្ហាញ 30 Days Of JavaScript 2 ដង + +### លំហាត់៖ កម្រិត ២ + +1. ដោយប្រើ console.log() បង្ហាញសេចក្តីថ្លែងខាងក្រោម៖ + + ```sh + The quote 'There is no exercise better for the heart than reaching down and lifting people up.' by John Holmes teaches us to help one another. + ``` + +2. ដោយប្រើ console.log() បង្ហាញសម្រង់ខាងក្រោមដោយ Mother Teresa: + + ```sh + "Love is not patronizing and charity isn't about pity, it is about love. Charity and love are the same -- with charity you give love, so don't just give money but reach out your hand instead." + ``` + +3. ពិនិត្យមើលថា typeof នៃ '10' គឺពិតជាស្មើនឹង 10។ ប្រសិនបើមិនធ្វើឱ្យវាស្មើគ្នាពិតប្រាកដ។ +4. ពិនិត្យមើលថាតើ parseFloat('9.8') ស្មើនឹង 10 ប្រសិនបើមិនធ្វើឱ្យវាពិតជាស្មើនឹង 10 ។ +5. ពិនិត្យមើលថាតើ 'on' ត្រូវបានរកឃើញនៅក្នុង python និង jargon ដែរឬទេ +6. _I hope this course is not full of jargon_. ពិនិត្យមើលថាតើ _jargon_ ស្ថិតនៅក្នុងប្រយោគដែររឺទេ +7. បង្កើតចំនួនចៃដន្យពី 0 ដល់ 100។ +8. បង្កើតលេខចៃដន្យរពី 50 ដល់ 100 រួមបញ្ចូល។ +8. បង្កើតលេខចៃដន្យរពី 0 ដល់ 255 រួមបញ្ចូល។ +10. ចូលតួអក្សរ string 'JavaScript' ដោយប្រើលេខចៃដន្យ។ +11. ប្រើ console.log() ហើយ escape character ដើម្បីបោះពុម្ពលំនាំខាងក្រោម។ + + ```js + 1 1 1 1 1 + 2 1 2 4 8 + 3 1 3 9 27 + 4 1 4 16 64 + 5 1 5 25 125 + ``` + +12. ប្រើ **substr** ដើម្បីកាត់ឃ្លា **because because because** ចេញពីប្រយោគខាងក្រោម៖**'You cannot end a sentence with because because because is a conjunction'** + +### លំហាត់៖ កម្រិត ៣ + +1. 'Love is the best thing in this world. Some found their love and some are still looking for their love.' រាប់ចំនួនពាក្យ **love** ក្នុងប្រយោគនេះ។ +2. ប្រើ **match()** ដើម្បីរាប់ចំនួន **because** ទាំងអស់ក្នុងប្រយោគខាងក្រោម:**'You cannot end a sentence with because because because is a conjunction'** +3. សម្អាតអត្ថបទខាងក្រោម ហើយស្វែងរកពាក្យញឹកញាប់បំផុត (ប្រើ replace និង regular expression)។ + + ```js + const sentence = + "%I $am@% a %tea@cher%, &and& I lo%#ve %te@a@ching%;. The@re $is no@th@ing; &as& mo@re rewarding as educa@ting &and& @emp%o@weri@ng peo@ple. ;I found tea@ching m%o@re interesting tha@n any ot#her %jo@bs. %Do@es thi%s mo@tiv#ate yo@u to be a tea@cher!? %Th#is 30#Days&OfJavaScript &is al@so $the $resu@lt of &love& of tea&ching"; + ``` + +4. គណនាប្រាក់ចំណូលប្រចាំឆ្នាំសរុបរបស់បុគ្គលដោយស្រង់លេខចេញពីអត្ថបទខាងក្រោម។ 'He earns 5000 euro from salary per month, 10000 euro annual bonus, 15000 euro online courses per month.' + +🎉 អបអរសាទរ ! 🎉 + +[<< ថ្ងៃទី 1](../readMe.md) | [ថ្ងៃទី 3 >>](../03_Day_Booleans_operators_date/03_booleans_operators_date.md) diff --git a/Khmer/03_Day_Booleans_operators_date/03_booleans_operators_date.md b/Khmer/03_Day_Booleans_operators_date/03_booleans_operators_date.md new file mode 100644 index 0000000..da05d31 --- /dev/null +++ b/Khmer/03_Day_Booleans_operators_date/03_booleans_operators_date.md @@ -0,0 +1,637 @@ +
+

30 ថ្ងៃនៃ JavaScript: Booleans, ប្រតិបត្តិករ, Date

+ + + + + Twitter Follow + + + អ្នកនិពន្ធ: + Asabeneh Yetayeh
+ ខែមករា ឆ្នាំ ២០២០ + +
+ +[<< ថ្ងៃទី 2](../02_Day_Data_types/02_day_data_types.md) | [ថ្ងៃទី 4 >>](../04_Day_Conditionals/04_day_conditionals.md) + +![សាមសិបថ្ងៃនៃ JavaScript](../images/banners/day_1_3.png) + +- [📔 ថ្ងៃទី 3](#-day-3) + - [Booleans](#booleans) + - [តម្លៃពិត](#truthy-values) + - [តម្លៃមិនពិត](#falsy-values) + - [Undefined](#undefined) + - [Null](#null) + - [ប្រតិបត្តិករ](#operators) + - [ប្រតិបត្តិករ Assignment](#assignment-operators) + - [ប្រតិបត្តិករ Arithmetic](#arithmetic-operators) + - [ប្រតិបត្តិករ Comparison](#comparison-operators) + - [ប្រតិបត្តិករ Logical](#logical-operators) + - [ប្រតិបត្តិករ Increment](#increment-operator) + - [ប្រតិបត្តិករ Decrement](#decrement-operator) + - [ប្រតិបត្តិករ Ternary](#ternary-operators) + - [អាទិភាពប្រតិបត្តិករ](#operator-precedence) + - [Window Methods](#window-methods) + - [Window alert() method](#window-alert-method) + - [Window prompt() method](#window-prompt-method) + - [Window confirm() method](#window-confirm-method) + - [Date Object](#date-object) + - [ការបង្កើត object ពេលវេលា](#creating-a-time-object) + - [ទាញយកឆ្នាំ](#getting-full-year) + - [ទាញយកខែ](#getting-month) + - [ទាញយកកាលបរិច្ឆេទ](#getting-date) + - [ទាញយកថ្ងៃ](#getting-day) + - [ទាញយកម៉ោង](#getting-hours) + - [ទាញយកនាទី](#getting-minutes) + - [ទាញយកវិនាទី](#getting-seconds) + - [ទាញយក​ពេល](#getting-time) + - [💻 លំហាត់សម្រាប់ថ្ងៃទី ៣](#-day-3-exercises) + - [លំហាត់៖ កម្រិត ១](#exercises-level-1) + - [លំហាត់៖ កម្រិត ២](#exercises-level-2) + - [លំហាត់៖ កម្រិត ៣](#exercises-level-3) + +# 📔 ថ្ងៃទី 3 + +## Booleans + +ប្រភេទទិន្នន័យ Boolean តំណាងឱ្យតម្លៃមួយក្នុងចំណោមតម្លៃទាំងពីរ៖ _true_ ឬ _false_ ។ តម្លៃ Boolean គឺពិតឬមិនពិត។ ការប្រើប្រាស់ប្រភេទទិន្នន័យទាំងនេះនឹងច្បាស់នៅពេលអ្នកចាប់ផ្តើមប្រតិបត្តិករប្រៀបធៀប។ ការប្រៀបធៀបណាមួយនឹងតឲតម្លៃ boolean ដែលពិតឬមិនពិត។ + +**ឧទាហរណ៍៖ តម្លៃ Boolean** + +```js +let isLightOn = true +let isRaining = false +let isHungry = false +let isMarried = true +let truValue = 4 > 3 // ពិត +let falseValue = 4 < 3 // មិនពិត +``` + +យើងបានយល់ព្រមថាតម្លៃ boolean គឺពិតឬមិនពិត។ + +### តម្លៃពិត + +- លេខទាំងអស់ (វិជ្ជមាន និងអវិជ្ជមាន) គឺជាតម្លៃពិត លើកលែងតែលេខសូន្យ +- string ទាំងអស់គឺជាការពិត លើកលែងតែ string ទទេ ('') +- boolean true + +### តម្លៃមិនពិត + +- 0 +- 0n +- null +- undefined +- NaN +- boolean false +- '', "", ``, string ទទេ + +វាជាការល្អក្នុងការចងចាំតម្លៃពិត និងតម្លៃមិនពិតទាំងនោះ។ នៅក្នុងផ្នែកបន្ទាប់ យើងនឹងប្រើប្រាស់ពួកវាជាមួយនិង conditional ដើម្បីធ្វើការសម្រេចចិត្ត។ + +## Undefined + +ប្រសិនបើយើងប្រកាស variable ហើយយើងមិនកំណត់តម្លៃទេ តម្លៃនឹង undefined។ បន្ថែមពីលើនេះ ប្រសិនបើ function មិនឲតម្លៃទេ វានឹងឲ undefined។ + +```js +let firstName +console.log(firstName) // undefined ព្រោះ​វា​មិន​ទាន់បាន​កំណត់​តម្លៃ​នៅ​ឡើយ​ទេ។ +``` + +## Null + +```js +let empty = null +console.log(empty) // -> null , មានន័យថាគ្មានតម្លៃ +``` + +## Operators + +### ប្រតិបត្តិករ Assignment + +សញ្ញាស្មើគ្នានៅក្នុង JavaScript គឺជាប្រតិបត្តិករ assignment។ វាប្រើដើម្បីកំណត់ variable។ + +```js +let firstName = 'Asabeneh' +let country = 'Finland' +``` + +ប្រតិបត្តិករ Assignment + +![Assignment operators](../images/assignment_operators.png) + +### ប្រតិបត្តិករ Arithmetic + +ប្រតិបត្តិករ Arithmetic គឺជា ប្រមាណវិធីគណិតវិទ្យា។ + +- ផលបូក(+): a + b +- ផលដក(-): a - b +- ផលគុណ(*): a * b +- ផលចែក(/): a / b +- ម៉ូឌុល(%): a % b +- ស្វ័យគុណ(**): a ** b + +```js +let numOne = 4 +let numTwo = 3 +let sum = numOne + numTwo +let diff = numOne - numTwo +let mult = numOne * numTwo +let div = numOne / numTwo +let remainder = numOne % numTwo +let powerOf = numOne ** numTwo + +console.log(sum, diff, mult, div, remainder, powerOf) // 7,1,12,1.33,1, 64 + +``` + +```js +const PI = 3.14 +let radius = 100 // ប្រវែងគិតជាម៉ែត្រ + +// គណនាផ្ទៃនៃរង្វង់មួយ +const areaOfCircle = PI * radius * radius +console.log(areaOfCircle) // 314 m + + +const gravity = 9.81 // គិតជា m/s2 +let mass = 72 // គិតជាគីឡូក្រាម + +// គណនាទម្ងន់របស់វត្ថុមួយ។ +const weight = mass * gravity +console.log(weight) // 706.32 N(Newton) + +const boilingPoint = 100 // សីតុណ្ហភាពក្នុង oC, ចំណុចរំពុះនៃទឹក +const bodyTemp = 37 // សីតុណ្ហភាពរាងកាយក្នុង oC + + +// ការភ្ជាប់ string ជាមួយលេខដោយប្រើ string interpolation +/* + The boiling point of water is 100 oC. + Human body temperature is 37 oC. + The gravity of earth is 9.81 m/s2. + */ +console.log( + `The boiling point of water is ${boilingPoint} oC.\nHuman body temperature is ${bodyTemp} oC.\nThe gravity of earth is ${gravity} m / s2.` +) +``` + +### ប្រតិបត្តិករ Comparison + +ក្នុង​ការ​សរសេរ​កម្មវិធី យើង​ប្រើ​ប្រតិបត្តិករ​ comparison ដើម្បី​ប្រៀបធៀប​តម្លៃ​ពីរ។ យើងពិនិត្យមើលថាតើតម្លៃមួយធំជាង ឬតិចជាង ឬស្មើនឹងតម្លៃផ្សេងទៀត។ + +![Comparison Operators](../images/comparison_operators.png) +**Example: Comparison Operators** + +```js +console.log(3 > 2) // ពិតព្រោះ 3 ធំជាង 2 +console.log(3 >= 2) // ពិតព្រោះ 3 ធំជាង 2 +console.log(3 < 2) // មិនពិត ពីព្រោះ 3 ធំជាង 2 +console.log(2 < 3) // ពិតព្រោះ 2 តិចជាង 3 +console.log(2 <= 3) // ពិតព្រោះ 2 តិចជាង 3 +console.log(3 == 2) // មិនពិត ព្រោះ ៣ មិនស្មើនឹង ២ +console.log(3 != 2) // ពិតព្រោះ ៣ មិនស្មើនឹង ២ +console.log(3 == '3') // ពិត ប្រៀបធៀបតម្លៃប៉ុណ្ណោះ។ +console.log(3 === '3') // មិនពិត ប្រៀបធៀបតម្លៃ និងប្រភេទទិន្នន័យ +console.log(3 !== '3') // ពិត ប្រៀបធៀបតម្លៃ និងប្រភេទទិន្នន័យ +console.log(3 != 3) // មិនពិត ប្រៀបធៀបតម្លៃប៉ុណ្ណោះ។ +console.log(3 !== 3) // មិនពិត ប្រៀបធៀបតម្លៃ និងប្រភេទទិន្នន័យ +console.log(0 == false) // ពិត, សមមូល +console.log(0 === false) // មិនពិត មិនដូចគ្នាទេ។ +console.log(0 == '') // ពិត, សមមូល +console.log(0 == ' ') // ពិត, សមមូល +console.log(0 === '') // មិនពិត មិនដូចគ្នាទេ។ +console.log(1 == true) // ពិត, សមមូល +console.log(1 === true) // មិនពិត មិនដូចគ្នាទេ។ +console.log(undefined == null) // ពិត +console.log(undefined === null) // មិនពិត +console.log(NaN == NaN) // មិនពិត, មិនស្មើគ្នាទេ +console.log(NaN === NaN) // មិនពិត +console.log(typeof NaN) // ចំនួន + +console.log('mango'.length == 'avocado'.length) // មិនពិត +console.log('mango'.length != 'avocado'.length) // ពិត +console.log('mango'.length < 'avocado'.length) // ពិត +console.log('milk'.length == 'meat'.length) // ពិត +console.log('milk'.length != 'meat'.length) // មិនពិត +console.log('tomato'.length == 'potato'.length) // ពិត +console.log('python'.length > 'dragon'.length) // មិនពិត +``` + +ព្យាយាមយល់ពីការប្រៀបធៀបខាងលើជាមួយនឹងតក្កវិជ្ជាមួយចំនួន។ ការចងចាំដោយគ្មានតក្កវិជ្ជាអាចពិបាក។ +JavaScript គឺជាប្រភេទភាសាសរសេរកម្មវិធីដែលចងគ្នា។ កូដ JavaScript ដំណើរការ និងផ្តល់ឱ្យអ្នកនូវលទ្ធផល ប៉ុន្តែលុះត្រាតែអ្នកពូកែវាប្រហែលជាមិនមែនជាលទ្ធផលដែលចង់បាននោះទេ។ + +តាមក្បួន ប្រសិនបើតម្លៃមិនពិតជាមួយ == វានឹងមិនស្មើនឹង === ។ ការប្រើប្រាស់ === មានសុវត្ថិភាពជាងការប្រើប្រាស់ == ។ [លំនាំ​](https://dorey.github.io/JavaScript-Equality-Table/) មានបញ្ជីពេញលេញនៃការប្រៀបធៀបប្រភេទទិន្នន័យ + +### ប្រតិបត្តិករ Logical + +និមិត្តសញ្ញាខាងក្រោមគឺជាសញ្ញាប្រមាណវិធីតក្កវិជ្ជាទូទៅ៖ +&&(ampersand), ||(pipe) និង !(negation)។ +ប្រតិបត្តិករ && ទទួលបានពិត លុះត្រាតែប្រតិបត្តិករទាំងពីរពិត។ +នេះ || ប្រតិបត្តិករទទួលបានពិត នៅពេលប្រតិបត្តិករមួយពិតរឺទាំងពីរ។ +នេះ! ប្រតិបត្តិករបដិសេធការពិតទៅមិនពិត និងមិនពិតទៅពិត។ + +```js +// ឧទាហរណ៍ ប្រតិបត្តិករ ampersand && + +const check = 4 > 3 && 10 > 5 // ពិត && ពិត -> ពិត +const check = 4 > 3 && 10 < 5 // ពិត && មិនពិត -> មិនពិត +const check = 4 < 3 && 10 < 5 // មិនពិត && មិនពិត -> មិនពិត + +// ឧទាហរណ៍នៃប្រតិបត្តិការ || pipe or + +const check = 4 > 3 || 10 > 5 // ពិត || ពិត -> ពិត +const check = 4 > 3 || 10 < 5 // ពិត || មិនពិត -> ពិត +const check = 4 < 3 || 10 < 5 // មិនពិត || false -> មិនពិត + +// ឧទាហរណ៍ ! Negation + +let check = 4 > 3 // ពិត +let check = !(4 > 3) // មិនពិត +let isLightOn = true +let isLightOff = !isLightOn // មិនពិត +let isMarried = !false // ពិត +``` + +### ប្រតិបត្តិករ Increment + +នៅក្នុង JavaScript យើងប្រើ increment operator ដើម្បីបង្កើនតម្លៃដែលរក្សាទុកក្នុង variable។ ការកើនឡើងអាចជា pre-increment រឺក៏ post-increment។ តោះមើលពួកគេមួយៗ៖ + +1. Pre-increment + +```js +let count = 0 +console.log(++count) // 1 +console.log(count) // 1 +``` + +1. Post-increment + +```js +let count = 0 +console.log(count++) // 0 +console.log(count) // 1 +``` + +យើងប្រើភាគច្រើនគឺ post-increment។ យ៉ាងហោចណាស់ អ្នកគួរចងចាំពីរបៀបប្រើ ប្រតិបត្តិករ post-increment + +### ប្រតិបត្តិករ Decrement + +នៅក្នុង JavaScript យើងប្រើ decrement operator ដើម្បីបន្ថយតម្លៃដែលរក្សាទុកក្នុងអថេរ។ ការថយចុះអាចជា pre-decrement រឺ post-decrement។ តោះមើលពួកវាមួយៗ៖ + +1. Pre-decrement + +```js +let count = 0 +console.log(--count) // -1 +console.log(count) // -1 +``` + +2. Post-decrement + +```js +let count = 0 +console.log(count--) // 0 +console.log(count) // -1 +``` + +### ប្រតិបត្តិករ Ternary + +ប្រតិបត្តិករ Ternary អនុញ្ញាតឱ្យយើងសរសេរលក្ខខណ្ឌ។ +វិធីមួយទៀតដើម្បីសរសេរលក្ខខណ្ឌគឺប្រើ ternary operators ។ សូមមើលឧទាហរណ៍ខាងក្រោម៖ + +```js +let isRaining = true +isRaining + ? console.log('You need a rain coat.') + : console.log('No need for a rain coat.') +isRaining = false + +isRaining + ? console.log('You need a rain coat.') + : console.log('No need for a rain coat.') +``` + +```sh +You need a rain coat. +No need for a rain coat. +``` + +```js +let number = 5 +number > 0 + ? console.log(`${number} is a positive number`) + : console.log(`${number} is a negative number`) +number = -5 + +number > 0 + ? console.log(`${number} is a positive number`) + : console.log(`${number} is a negative number`) +``` + +```sh +5 is a positive number +-5 is a negative number +``` + +### អាទិភាពប្រតិបត្តិករ + +ចង់ណែនាំអ្នកឱ្យអានអំពីអាទិភាពប្រតិបត្តិករពីនេះ។ [link](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence) + +## Window Methods + +### Window alert() method + +ដូចដែលអ្នកបានឃើញនៅដើមដំបូង method alert() បង្ហាញប្រអប់ជូនដំណឹងមួយដែលមានសារដែលបានបញ្ជាក់ និងប៊ូតុងយល់ព្រម។ វា​ជា​ method ដែល​មាន​ស្រាប់ ហើយ​វា​យក argument មួយ។ + +```js +alert(message) +``` + +```js +alert('Welcome to 30DaysOfJavaScript') +``` + + +កុំប្រើការ alert() ច្រើនពេកព្រោះវានឹងរំខាន ។ សូមប្រើវាដើម្បីតែសាកល្បង។ + +### Window prompt() method + +method prompt បង្ហាញប្រអប់បញ្ចូលជាមួយធាតុបញ្ចូលនៅលើ browser របស់អ្នកដើម្បីយកតម្លៃបញ្ចូល ហើយទិន្នន័យបញ្ចូលអាចត្រូវបានរក្សាទុកក្នុងអថេរមួយ។ វិធីសាស្ត្រ prompt() យក argument ពីរ។ អាគុយម៉ង់ទីពីរគឺស្រេចចិត្ត។ + +```js +prompt('required text', 'optional text') +``` + +```js +let number = prompt('Enter number', 'number goes here') +console.log(number) +``` + +### Window confirm() method + +method confirm() បង្ហាញប្រអប់ដែលមានសារដែលបានបញ្ជាក់ រួមជាមួយនឹងប៊ូតុង OK និងប៊ូតុង Cancel ។ +ប្រអប់ confirm ត្រូវបានប្រើជាញឹកញាប់ដើម្បីសុំការអនុញ្ញាតពីអ្នកប្រើប្រាស់ដើម្បីប្រតិបត្តិអ្វីមួយ។ Window confirm() យក string ជា argument។ +ការ​ចុច OK ផ្តល់​ផល​តម្លៃ​ពិត ចំណែក​ឯ​ការ​ចុច​ប៊ូតុង Cancel ផ្តល់​តម្លៃ​មិន​ពិត។ + +```js +const agree = confirm('Are you sure you like to delete? ') +console.log(agree) // លទ្ធផលនឹងពិត ឬមិនពិត ដោយផ្អែកលើអ្វីដែលអ្នកចុចលើប្រអប់ +``` + +ទាំង​នេះ​មិន​មែន​ជា window method ​ទាំង​អស់ទេ ​យើង​នឹង​មាន​ផ្នែក​ដាច់​ដោយ​ឡែក​ដើម្បី​ចូល​ជ្រៅ​ទៅ​ក្នុង​ window method​។ + +## Date Object + +ពេលវេលាគឺជារឿងសំខាន់។ យើងចង់ដឹងពីពេលវេលានៃសកម្មភាព ឬព្រឹត្តិការណ៍ជាក់លាក់មួយ។ នៅក្នុង JavaScript បច្ចុប្បន្ន និងកាលបរិច្ឆេទត្រូវបានបង្កើតដោយប្រើ JavaScript Date Object។ object ដែលយើងបង្កើតដោយប្រើ Date object ផ្តល់នូវវិធីសាស្រ្តជាច្រើនដើម្បីធ្វើការជាមួយកាលបរិច្ឆេទ និងពេលវេលា។ វិធីសាស្ត្រដែលយើងប្រើដើម្បីទទួលបានព័ត៌មានកាលបរិច្ឆេទ និងពេលវេលាពីតម្លៃវត្ថុកាលបរិច្ឆេទត្រូវបានចាប់ផ្តើមដោយពាក្យ _get_ ព្រោះវាផ្តល់ព័ត៌មាន។ +_getFullYear(), getMonth(), getDate(), getDay(), getHours(), getMinutes, getSeconds(), getMilliseconds(), getTime(), getDay()_ + +![Date time Object](../images/date_time_object.png) + +### ការបង្កើត object ពេលវេលា + +នៅពេលយើងបង្កើតobject ពេលវេលាវានឹងផ្តល់ព័ត៌មានអំពីពេលវេលា។ តោះយើងបង្កើត object ពេលវេលា + +```js +const now = new Date() +console.log(now) // Sat Jan 04 2020 00:56:41 GMT+0200 (Eastern European Standard Time) +``` + +យើងបានបង្កើត time object ហើយហើយយើងអាចចូលប្រើព័ត៌មានកាលបរិច្ឆេទណាមួយពី object ដោយប្រើ get method ដែលយើងបាននិយាយនៅលើតារាងខាងលើ។ + +### ទាញយកឆ្នាំ + +ចូរស្រង់ចេញ ឬទាញយកឆ្នាំពេញពី object ពេលវេលាមួយ។ + +```js +const now = new Date() +console.log(now.getFullYear()) // 2020 +``` + +### ទាញយកខែ + +ចូរស្រង់ចេញ ឬទាញយកខែពីវត្ថុពេលវេលាមួយ។ + +```js +const now = new Date() +console.log(now.getMonth()) // 0 ព្រោះ​ខែ​មករា​ ខែ (0-11) +``` + +### ទាញយកបរិច្ឆេទ + +ចូរស្រង់ចេញ ឬទាញយកកាលបរិច្ឆេទនៃខែពី object ពេលវេលាមួយ។ + +```js +const now = new Date() +console.log(now.getDate()) // ៤ ព្រោះ​ថ្ងៃ​នេះ​ជា​ថ្ងៃ​ទី ៤ គឺ​ថ្ងៃ (១-៣១) +``` + +### ទាញយកថ្ងៃ + +Let's extract or get the day of the week from a time object. + +ចូរស្រង់ចេញ ឬទាញយកថ្ងៃនៃសប្តាហ៍ពី object ពេលវេលាមួយ។ + +```js +const now = new Date() +console.log(now.getDay()) // ៦ ព្រោះ​ថ្ងៃ​សៅរ៍ ជា​ថ្ងៃ​ទី ៧ +// ថ្ងៃអាទិត្យគឺ 0 ថ្ងៃច័ន្ទគឺ 1 និងថ្ងៃសៅរ៍គឺ 6 +// ទទួលបានថ្ងៃធ្វើការជាលេខ (0-6) +``` + +### ទាញយកម៉ោង + +ចូរស្រង់ចេញ ឬទាញយកម៉ោងពី object ពេលវេលាមួយ។ + +```js +const now = new Date() +console.log(now.getHours()) // 0 ពីព្រោះពេលវេលាគឺ 00:56:41 +``` + +### ទាញយកនាទី + +ចូរស្រង់ចេញ ឬទាញយកនាទីពីវត្ថុពេលវេលាមួយ។ + +```js +const now = new Date() +console.log(now.getMinutes()) // 56, ដោយសារតែពេលវេលាគឺ 00:56:41 +``` + +### ទាញយកវិនាទី + +តោះស្រង់ ឬទាញយកវិនាទីពីវត្ថុពេលវេលា។ + +```js +const now = new Date() +console.log(now.getSeconds()) // 41, ដោយសារតែពេលវេលាគឺ 00:56:41 +``` + +### ទាញយកពេល + +វិធីសាស្រ្តនេះផ្តល់ពេលវេលាគិតជាមិល្លីវិនាទី ដែលចាប់ផ្តើមពីថ្ងៃទី 1 ខែមករា ឆ្នាំ 1970។ វាក៏ត្រូវបានគេស្គាល់ថាជាពេលវេលា Unix ផងដែរ។ យើងអាចទទួលបានពេលវេលា Unix តាមពីរវិធី៖ + +1. ដោយ _getTime()_ + +```js +const now = new Date() // +console.log(now.getTime()) // 1578092201341 នេះគឺជាចំនួនវិនាទីដែលបានឆ្លងកាត់ចាប់ពីថ្ងៃទី 1 ខែមករា ឆ្នាំ 1970 ដល់ថ្ងៃទី 4 ខែមករា ឆ្នាំ 2020 00:56:41 +``` + +1. ដោយ _Date.now()_ + +```js +const allSeconds = Date.now() // +console.log(allSeconds) // 1578092201341 នេះគឺជាចំនួនវិនាទីដែលបានឆ្លងកាត់ចាប់ពីថ្ងៃទី 1 ខែមករា ឆ្នាំ 1970 ដល់ថ្ងៃទី 4 ខែមករា ឆ្នាំ 2020 00:56:41 + +const timeInSeconds = new Date().getTime() +console.log(allSeconds == timeInSeconds) // ពិត +``` + +តោះយើងធ្វើទ្រង់ទ្រាយតម្លៃទាំងនេះទៅជាទម្រង់ពេលវេលាដែលអាចអានបាន។ +**Example:** + +```js +const now = new Date() +const year = now.getFullYear() // ឲឆ្នាំ +const month = now.getMonth() + 1 // ឲខែ (0 - 11) +const date = now.getDate() // ឲកាលបរិច្ឆេទ (1 - 31) +const hours = now.getHours() // ឲលេខ (0 - 23) +const minutes = now.getMinutes() // ឲលេខ (0 -59) + +console.log(`${date}/${month}/${year} ${hours}:${minutes}`) // 4/1/2020 0:56 +``` + +🌕 អ្នកមានថាមពលគ្មានដែនកំណត់។ អ្នកទើបតែបានបញ្ចប់ challenge នៅថ្ងៃទី 3 ហើយអ្នកគឺបានឈានជំហានបីឆ្ពោះទៅរកផ្លូវអស្ចារ្យ។ ឥឡូវធ្វើលំហាត់ខ្លះសម្រាប់ខួរក្បាល និងសាច់ដុំរបស់អ្នក។ + +## 💻 លំហាត់សម្រាប់ថ្ងៃទី ៣ + +### លំហាត់៖ កម្រិត ១ + +1. ប្រកាស firstName, lastName, country, city, age, isMarried, year variable ហើយកំណត់តម្លៃទៅវា ហើយប្រើ typeof ដើម្បីពិនិត្យមើលប្រភេទទិន្នន័យផ្សេងៗគ្នា។ +2. ពិនិត្យមើលថាតើប្រភេទនៃ '10' ស្មើនឹង 10 រឺទេ +3. ពិនិត្យមើលថាតើ parseInt ('9.8') ស្មើនឹង 10 រឺទេ +4. តម្លៃ boolean គឺពិតឬមិនពិត. + 1. សរសេរ JavaScript ចំនួនបី statement ដែលផ្តល់តម្លៃពិត. + 2. សរសេរ JavaScript ចំនួនបី statement ដែលផ្តល់តម្លៃមិនពិត. + +5. ស្វែងរកលទ្ធផលនៃកន្សោមប្រៀបធៀបខាងក្រោមជាមុនសិនដោយមិនប្រើ console.log()។ បន្ទាប់ពីអ្នកសម្រេចចិត្តលទ្ធផល បញ្ជាក់វាដោយប្រើ console.log() + 1. 4 > 3 + 2. 4 >= 3 + 3. 4 < 3 + 4. 4 <= 3 + 5. 4 == 4 + 6. 4 === 4 + 7. 4 != 4 + 8. 4 !== 4 + 9. 4 != '4' + 10. 4 == '4' + 11. 4 === '4' + 12. ស្វែងរកប្រវែងនៃ python និង jargon ហើយបង្កើត statement ប្រៀបធៀបដែលឲតម្លៃមិនពិត។ + +6. ស្វែងរកលទ្ធផលនៃកន្សោមប្រៀបធៀបខាងក្រោមជាមុនសិនដោយមិនប្រើ console.log()។ បន្ទាប់ពីអ្នកសម្រេចចិត្តលទ្ធផល បញ្ជាក់វាដោយប្រើ console.log() + 1. 4 > 3 && 10 < 12 + 2. 4 > 3 && 10 > 12 + 3. 4 > 3 || 10 < 12 + 4. 4 > 3 || 10 > 12 + 5. !(4 > 3) + 6. !(4 < 3) + 7. !(false) + 8. !(4 > 3 && 10 < 12) + 9. !(4 > 3 && 10 > 12) + 10. !(4 === '4') + 11. There is no 'on' in both dragon and python + +7. ប្រើ date object ដើម្បីធ្វើសកម្មភាពដូចខាងក្រោម + 1. តើពេលនេះជាឆ្នាំអ្វី? + 2. តើពេលនេះជាខែអ្វី? + 3. តើ​ថ្ងៃនេះ​ជា​ថ្ងៃ​អ្វី? + 4. តើថ្ងៃនេះជាថ្អៃអ្វីហើយជាលេខ? + 5. តើម៉ោងប៉ុន្មានឥឡូវនេះ? + 6. តើ​មាន​នាទី​អ្វី​ឥឡូវ​នេះ? + 7. រកមើលចំនួនវិនាទីដែលបានកន្លងផុតទៅចាប់ពីថ្ងៃទី 1 ខែមករាឆ្នាំ 1970 ដល់ឥឡូវនេះ + +### លំហាត់៖ កម្រិត ២ + +1.សរសេរស្គ្រីបដែលជំរុញឱ្យអ្នកប្រើប្រាស់បញ្ចូលមូលដ្ឋាន និងកម្ពស់នៃត្រីកោណ ហើយគណនាផ្ទៃដីនៃត្រីកោណមួយ (ផ្ទៃ = 0.5 x b x h) ។ + + ```sh + Enter base: 20 + Enter height: 10 + The area of the triangle is 100 + ``` + +1. សរសេរស្គ្រីបដែលជំរុញឱ្យអ្នកប្រើប្រាស់បញ្ចូលចំហៀង a ចំហៀង b និងចំហៀង c នៃត្រីកោណ ហើយនិងគណនាបរិវេណនៃត្រីកោណ (បរិមាត្រ = a + b + c) + + ```sh + Enter side a: 5 + Enter side b: 4 + Enter side c: 3 + The perimeter of the triangle is 12 + ``` + +1. ទទួលបានប្រវែង និងទទឹងដោយប្រើប្រអប់បញ្ចូល ហើយគណនាផ្ទៃដីនៃចតុកោណកែង (ផ្ទៃ = ប្រវែង x ទទឹង និងបរិមាត្រនៃចតុកោណកែង (បរិមាត្រ = 2 x (ប្រវែង + ទទឹង))) +1. ទទួលបានកាំដោយប្រើប្រអប់បញ្ចូល ហើយគណនាផ្ទៃរង្វង់មួយ (ផ្ទៃ = pi x r x r) និងបរិមាត្រនៃរង្វង់មួយ (c = 2 x pi x r) ដែល pi = 3.14 ។ +1. គណនាជម្រាល x-intercept និង y-intercept នៃ y = 2x −2 +1. ជម្រាលគឺ m = (y2-y1)/(x2-x1) ។ ស្វែងរកជម្រាលរវាងចំណុច (2, 2) និងចំណុច (6,10) +1. ប្រៀបធៀបជម្រាលនៃសំណួរទាំងពីរខាងលើ។ +1. គណនាតម្លៃ y (y = x2 + 6x + 9) ។ ព្យាយាមប្រើតម្លៃ x ផ្សេងគ្នា ហើយរកឱ្យឃើញនូវតម្លៃ x ដែល y គឺ 0 ។ +1. សរសេរស្គ្រីបដែលជំរុញឱ្យអ្នកប្រើប្រាស់បញ្ចូលម៉ោង និងអត្រាប្រាក់ឈ្នួលក្នុងមួយម៉ោង។ គណនាប្រាក់ឈ្នួលរបស់មនុស្ស? + + ```sh + Enter hours: 40 + Enter rate per hour: 28 + Your weekly earning is 1120 + ``` + +1. ប្រសិនបើប្រវែងនៃឈ្មោះរបស់អ្នកធំជាង 7 និយាយថាឈ្មោះរបស់អ្នកវែង ផ្សេងទៀតនិយាយថាឈ្មោះរបស់អ្នកខ្លី។ +1. ប្រៀបធៀបប្រវែងនាមខ្លួនរបស់អ្នក និងប្រវែងនាមត្រកូលរបស់អ្នក ហើយអ្នកគួរតែទទួលបានលទ្ធផលនេះ។ + + ```js + let firstName = 'Asabeneh' + let lastName = 'Yetayeh' + ``` + + ```sh + Your first name, Asabeneh is longer than your family name, Yetayeh + ``` + +1. ប្រកាសអថេរពីរ _myAge_ និង _yourAge_ ហើយកំណត់តម្លៃដំបូង + + ```js + let myAge = 250 + let yourAge = 25 + ``` + + ```sh + I am 225 years older than you. + ``` + +1. ដោយប្រើប្រអប់បញ្ចូល ទាញយកឆ្នាំដែលអ្នកប្រើប្រាស់កើត ហើយប្រសិនបើអ្នកប្រើមានអាយុ 18 ឆ្នាំឡើងទៅ អនុញ្ញាតឲ្យអ្នកប្រើប្រាស់បើកបរ ប្រសិនបើមិនទាន់គ្រប់អាយុទេ ប្រាប់អ្នកប្រើប្រាស់ឱ្យរង់ចាំចំនួនឆ្នាំជាក់លាក់ណាមួយ។ + + ```sh + + Enter birth year: 1995 + You are 25. You are old enough to drive + + Enter birth year: 2005 + You are 15. You will be allowed to drive after 3 years. + ``` + +1. សរសេរ​ស្គ្រីប​ដែល​ទាញយក​ឆ្នាំហើយគណនាចំនួននាទីដែលបានរស់នៅ + + ```sh + Enter number of years you live: 100 + You lived 3153600000 seconds. + ``` + +1. បង្កើតទម្រង់ពេលវេលាដែលអាចអានបានរបស់មនុស្សដោយប្រើ date object + 1. YYYY-MM-DD HH:mm + 2. DD-MM-YYYY HH:mm + 3. DD/MM/YYYY HH:mm + +### លំហាត់៖ កម្រិត ៣ + +1. Create a human readable time format using the Date time object. The hour and the minute should be all the time two digits(7 hours should be 07 and 5 minutes should be 05 ) +1. បង្កើតទម្រង់ពេលវេលាដែលអាចអានបានរបស់មនុស្សដោយប្រើ date obejct។ ម៉ោង និងនាទីគួរតែជាលេខពីរខ្ទង់ (៧ ម៉ោងគួរតែជា ០៧ និង ៥ នាទីគួរតែជា ០៥) + 1. YYY-MM-DD HH:mm eg. 20120-01-02 07:05 + +[<< ថ្ងៃទី 2](../02_Day_Data_types/02_day_data_types.md) | [ថ្ងៃទី 4 >>](../04_Day_Conditionals/04_day_conditionals.md) diff --git a/Khmer/04_Day_Conditionals/04_day_conditionals.md b/Khmer/04_Day_Conditionals/04_day_conditionals.md new file mode 100644 index 0000000..9e6d29a --- /dev/null +++ b/Khmer/04_Day_Conditionals/04_day_conditionals.md @@ -0,0 +1,377 @@ +
+

30 ថ្ងៃនៃ JavaScript៖ Conditionals

+ + + + + Twitter Follow + + + អ្នកនិពន្ធ: + Asabeneh Yetayeh
+ ខែមករា ឆ្នាំ ២០២០ + +
+ +[<< ថ្ងៃទី 3](../03_Day_Booleans_operators_date/03_booleans_operators_date.md) | [ថ្ងៃទី 5 >>](../05_Day_Arrays/05_day_arrays.md) + +![Thirty Days Of JavaScript](../images/banners/day_1_4.png) + +- [📔 ថ្ងៃទី 4](#-day-4) + - [Conditionals](#conditionals) + - [If](#if) + - [If Else](#if-else) + - [If Else if Else](#if--else-if-else) + - [Switch](#switch) + - [Ternary Operators](#ternary-operators) + - [💻 លំហាត់](#-exercises) + - [លំហាត់៖ កម្រិត 1](#exercises-level-1) + - [លំហាត់៖ កម្រិត 2](#exercises-level-2) + - [លំហាត់៖ កម្រិត 3](#exercises-level-3) + +# 📔 Day 4 + +## Conditionals + +conditional statement ត្រូវបានប្រើសម្រាប់ធ្វើការសម្រេចចិត្តដោយផ្អែកលើលក្ខខណ្ឌផ្សេងៗ។ +តាមលំនាំដើម statement នៅក្នុងស្គ្រីប JavaScript ត្រូវបានប្រតិបត្តិតាមលំដាប់ពីកំពូលទៅបាត។ ប្រសិនបើតក្កវិជ្ជាដំណើរការទាមទារដូច្នេះ លំហូរបន្តបន្ទាប់គ្នានៃការប្រតិបត្តិអាចត្រូវបានផ្លាស់ប្តូរតាមពីរវិធី៖ + +- conditional execution៖ ប្លុកនៃ statement មួយ ឬច្រើននឹងត្រូវបានប្រតិបត្តិប្រសិនបើកន្សោមជាក់លាក់មួយគឺពិត +- repetitive execution៖ ប្លុកនៃ statement មួយ ឬច្រើននឹងត្រូវបានប្រតិបត្តិដដែលៗ ដរាបណាកន្សោមជាក់លាក់មួយគឺពិត។ នៅក្នុងផ្នែកនេះ យើងនឹងនិយាយអំពី _if_, _else_ , _else if_ statements។ ប្រតិបត្តិករប្រៀបធៀប និង តក្កដែលយើងបានរៀននៅក្នុងផ្នែកមុនៗនឹងមានប្រយោជន៍នៅទីនេះ។ + +Conditoinals អាចត្រូវបានអនុវត្តដោយប្រើវិធីខាងក្រោម: + +- if +- if else +- if else if else +- switch +- ternary operator + +### If + +នៅក្នុង JavaScript និងភាសាសរសេរកម្មវិធីផ្សេងទៀត ពាក្យគន្លឹះ _if_ ត្រូវបានប្រើដើម្បីពិនិត្យមើលថាតើលក្ខខណ្ឌមួយគឺពិត និងដើម្បីប្រតិបត្តិកូដ។ ដើម្បីបង្កើតលក្ខខណ្ឌ if យើងត្រូវការពាក្យគន្លឹះ _if_ និងលក្ខខណ្ឌនៅខាងក្នុងវង់ក្រចក និងប្លុកកូដនៅខាងក្នុងតង្កៀបអង្កាញ់ ({})។ + +```js +// syntax +if (condition) { + //ផ្នែកនៃកូដនេះដំណើរការសម្រាប់លក្ខខណ្ឌដែលមានតម្លៃពិត +} +``` + +**ឧទាហរណ៍:** + +```js +let num = 3 +if (num > 0) { + console.log(`${num} is a positive number`) +} +// 3 គឺជាលេខវិជ្ជមាន +``` + +ដូចដែលអ្នកអាចឃើញនៅក្នុងឧទាហរណ៍លក្ខខណ្ឌខាងលើ 3 គឺធំជាង 0 ដូច្នេះវាគឺជាចំនួនវិជ្ជមាន។ លក្ខខណ្ឌគឺពិត ហើយប្លុកកូដត្រូវបានប្រតិបត្តិ។ យ៉ាងណាមិញ ប្រសិនបើលក្ខខណ្ឌមិនពិត យើងនឹងមិនឃើញលទ្ធផលណាមួយឡើយ។ + +```js +let isRaining = true +if (isRaining) { + console.log('Remember to take your rain coat.') +} +``` + + ដូចគ្នាទៅនឹងលក្ខខណ្ឌទីពីរ ប្រសិនបើ isRaining មិនពិត នោះ if block នឹងមិនត្រូវបានប្រតិបត្តិ ហើយយើងនឹងមិនឃើញលទ្ធផលណាមួយទេ។ ដើម្បី​មើល​ឃើញ​លទ្ធផល​នៃ​លក្ខខណ្ឌ​មិន​ពិត យើង​គួរ​តែ​មាន​ប្លុក​មួយ​ទៀត​ដែលជា _else_. + +### If Else + +ប្រសិនបើលក្ខខណ្ឌ if ពិត ប្លុកទីមួយនឹងត្រូវបានប្រតិបត្តិ ប្រសិនបើមិនចឹងទេ លក្ខខណ្ឌ else នឹងត្រូវបានប្រតិបត្តិ។ + +```js +// syntax +if (condition) { + // ផ្នែកនៃកូដនេះដំណើរការសម្រាប់លក្ខខណ្ឌពិត +} else { + // ផ្នែកនៃកូដនេះដំណើរការសម្រាប់លក្ខខណ្ឌមិនពិត +} +``` + +```js +let num = 3 +if (num > 0) { + console.log(`${num} is a positive number`) +} else { + console.log(`${num} is a negative number`) +} +// 3 is a positive number + +num = -3 +if (num > 0) { + console.log(`${num} is a positive number`) +} else { + console.log(`${num} is a negative number`) +} +// -3 is a negative number +``` + +```js +let isRaining = true +if (isRaining) { + console.log('You need a rain coat.') +} else { + console.log('No need for a rain coat.') +} +// You need a rain coat. + +isRaining = false +if (isRaining) { + console.log('You need a rain coat.') +} else { + console.log('No need for a rain coat.') +} +// No need for a rain coat. +``` + +លក្ខខណ្ឌចុងក្រោយគឺមិនពិត ដូច្នេះប្លុក else ត្រូវបានប្រតិបត្តិ។ ចុះបើយើងមានលក្ខខណ្ឌលើសពីពីរ? ក្នុងករណីនោះ យើងនឹងប្រើលក្ខខណ្ឌ *else if*។ + +### If Else if Else + +នៅក្នុងជីវិតប្រចាំថ្ងៃរបស់យើង យើងធ្វើការសម្រេចចិត្តជារៀងរាល់ថ្ងៃ។ យើងធ្វើការសម្រេចចិត្តមិនមែនដោយពិនិត្យមើលលក្ខខណ្ឌមួយ ឬពីរទេ យើងធ្វើការសម្រេចចិត្តដោយផ្អែកលើលក្ខខណ្ឌជាច្រើន។ ដូចទៅនឹងជីវិតប្រចាំថ្ងៃរបស់យើង ការសរសេរកម្មវិធីក៏ពោរពេញទៅដោយលក្ខខណ្ឌផងដែរ។ យើងប្រើ *else if* នៅពេលដែលយើងមានលក្ខខណ្ឌច្រើន។ + +```js +// syntax +if (condition) { + // code +} else if (condition) { + // code +} else { + // code + +} +``` + +**ឧទាហរណ៍:** + +```js +let a = 0 +if (a > 0) { + console.log(`${a} is a positive number`) +} else if (a < 0) { + console.log(`${a} is a negative number`) +} else if (a == 0) { + console.log(`${a} is zero`) +} else { + console.log(`${a} is not a number`) +} +``` + +```js +// if else if else +let weather = 'sunny' +if (weather === 'rainy') { + console.log('You need a rain coat.') +} else if (weather === 'cloudy') { + console.log('It might be cold, you need a jacket.') +} else if (weather === 'sunny') { + console.log('Go out freely.') +} else { + console.log('No need for rain coat.') +} +``` + +### Switch + +Switch គឺជាជម្រើសមួយសម្រាប់ **if else if else**។ +switch statement ចាប់ផ្តើមដោយពាក្យគន្លឹះ **switch** បន្តដោយវង់ក្រចក និងប្លុកកូដ។ នៅខាងក្នុងប្លុកកូដយើងនឹងមាន case ផ្សេងគ្នា។ ប្លុកដំណើរការប្រសិនបើតម្លៃនៅក្នុងវង់ក្រចក switch statement ត្រូវគ្នានឹងតម្លៃ case។ break statement គឺដើម្បីបញ្ចប់ការប្រតិបត្តិ ដូច្នេះការប្រតិបត្តិកូដមិនធ្លាក់ចុះបន្ទាប់។ ប្លុក default ដំណើរការប្រសិនបើ case ទាំងអស់មិនបំពេញលក្ខខណ្ឌ។ + +```js +switch(caseValue){ + case 1: + // code + break + case 2: + // code + break + case 3: + // code + break + default: + // code +} +``` + +```js +let weather = 'cloudy' +switch (weather) { + case 'rainy': + console.log('You need a rain coat.') + break + case 'cloudy': + console.log('It might be cold, you need a jacket.') + break + case 'sunny': + console.log('Go out freely.') + break + default: + console.log(' No need for rain coat.') +} + +// ឧទាហរណច្រើនទៀតពី​ switch +let dayUserInput = prompt('What day is today ?') +let day = dayUserInput.toLowerCase() + +switch (day) { + case 'monday': + console.log('Today is Monday') + break + case 'tuesday': + console.log('Today is Tuesday') + break + case 'wednesday': + console.log('Today is Wednesday') + break + case 'thursday': + console.log('Today is Thursday') + break + case 'friday': + console.log('Today is Friday') + break + case 'saturday': + console.log('Today is Saturday') + break + case 'sunday': + console.log('Today is Sunday') + break + default: + console.log('It is not a week day.') +} + +``` + +// ឧទាហរណ៍ដើម្បីប្រើ if នៅក្នុង case + +```js +let num = prompt('Enter number'); +switch (true) { + case num > 0: + console.log('Number is positive'); + break; + case num == 0: + console.log('Numbers is zero'); + break; + case num < 0: + console.log('Number is negative'); + break; + default: + console.log('Entered value was not a number'); +} +``` + +### Ternary Operators + +វិធីមួយទៀតដើម្បីសរសេរ conditionals គឺប្រើ ternary operators ។ យើងបានរៀបរាប់រឿងនេះនៅក្នុងផ្នែកផ្សេងទៀត ប៉ុន្តែយើងក៏គួរលើកឡើងវានៅទីនេះផងដែរ។ + +```js +let isRaining = true +isRaining + ? console.log('You need a rain coat.') + : console.log('No need for a rain coat.') +``` + +🌕 អ្នកពិតជាអស្ចារ្យ ហើយអ្នកមានសក្តានុពលគួរឱ្យកត់សម្គាល់។ អ្នកទើបតែបានបញ្ចប់ challenge ថ្ងៃទី 4 ហើយអ្នកនៅខាងមុខបួនជំហានឆ្ពោះទៅរកភាពអស្ចារ្យ។ ឥឡូវធ្វើលំហាត់ខ្លះសម្រាប់ខួរក្បាល និងសាច់ដុំរបស់អ្នក។ + +## 💻 លំហាត់ + +### លំហាត់៖ កម្រិត ១ + +1. ទទួលយកការបញ្ចូលរបស់អ្នកប្រើដោយប្រើប្រអប់បញ្ចូល ("បញ្ចូលអាយុរបស់អ្នក៖")។ ប្រសិនបើអ្នកប្រើមានអាយុ 18 ឆ្នាំ ឬចាស់ជាងនេះ សូមផ្តល់៖ 'អ្នកមានអាយុគ្រប់គ្រាន់ក្នុងការបើកបរ' ប៉ុន្តែប្រសិនបើមិនមែន 18 ឆ្នាំ សូមផ្តល់មតិផ្សេងទៀតដោយបញ្ជាក់ថា រង់ចាំចំនួនឆ្នាំដែលគាត់គ្រប់ 18 ឆ្នាំ។ + + ```sh + Enter your age: 30 + You are old enough to drive. + + Enter your age:15 + You are left with 3 years to drive. + ``` + +1. ប្រៀបធៀបតម្លៃនៃ myAge និង yourAge ដោយប្រើ if … else ។ ផ្អែកលើការប្រៀបធៀប បង្ហាញលទ្ធផលទៅកាន់ console ដែលបញ្ជាក់ថាអ្នកណាចាស់ជាង (ខ្ញុំឬអ្នក)។ ប្រើប្រអប់បញ្ចូល (“បញ្ចូលអាយុរបស់អ្នក៖”) ដើម្បីទទួលបានអាយុ។ + + ```sh + Enter your age: 30 + You are 5 years older than me. + ``` + +1. ប្រសិនបើ a ធំជាង b ឲ 'a គឺធំជាង b' បើមិចចឹងទេ 'a គឺតិចជាង b' ។ ព្យាយាមអនុវត្តវាតាមវិធី + + - ប្រើ if else + - ternary operator. + + ```js + let a = 4 + let b = 3 + ``` + + ```sh + 4 is greater than 3 + ``` + +1. លេខគូគឺចែកដាច់ដោយ 2 ហើយនៅសំណល់សូន្យ។ តើ​អ្នក​ពិនិត្យ​មើល​ដោយ​របៀប​ណាថាលេខ​មួយ​គឺ​គូ ឬ​មិន​គូ ដោយប្រើ JavaScript? + + ```sh + Enter a number: 2 + 2 is an even number + + Enter a number: 9 + 9 is is an odd number. + ``` + +### លំហាត់៖ កម្រិត ២ + +1. សរសេរកូដដែលអាចផ្តល់លំដាប់ពិន្ទុដល់សិស្សតាមពិន្ទុរបស់ពួកគេ៖ + - 80-100, A + - 70-89, B + - 60-69, C + - 50-59, D + - 0-49, F +1. ពិនិត្យមើលថាតើរដូវដែលបានបញ្ចូលគឺរដូវស្លឹកឈើជ្រុះ រដូវរងា និទាឃរដូវ ឬរដូវក្តៅ. + ប្រសិនបើអ្នកប្រើប្រាស់បញ្ចូល : + - ខែកញ្ញា តុលា ឬវិច្ឆិកា រដូវគឺរដូវស្លឹកឈើជ្រុះ. + - ខែធ្នូ មករា ឬកុម្ភៈ រដូវគឺរដូវរងា. + - ខែមីនា មេសា ឬឧសភា រដូវគឺនិទាឃរដូវ + - ខែមិថុនា កក្កដា ឬសីហា រដូវគឺរដូវក្តៅ +1. ពិនិត្យមើលថាតើថ្ងៃដែលបានបញ្ចូលជាថ្ងៃចុងសប្តាហ៍ ឬថ្ងៃធ្វើការ។ ស្គ្រីបរបស់អ្នកនឹងយកថ្ងៃជាតម្លៃបញ្ចូល. + +```sh + What is the day today? Saturday + Saturday is a weekend. + + What is the day today? saturDaY + Saturday is a weekend. + + What is the day today? Friday + Friday is a working day. + + What is the day today? FrIDAy + Friday is a working day. + ``` + +### លំហាត់៖ កម្រិត ៣ + +1. សរសេរកម្មវិធីដែលប្រាប់ចំនួនថ្ងៃក្នុងមួយខែ។ + + ```sh + Enter a month: January + January has 31 days. + + Enter a month: JANUARY + January has 31 day + + Enter a month: February + February has 28 days. + + Enter a month: FEbruary + February has 28 days. + ``` + +1. សរសេរកម្មវិធីដែលប្រាប់ចំនួនថ្ងៃក្នុង 1 ខែ ហើយពិចារណាឆ្នាំបង្គ្រប់។ + + +🎉 អបអរសាទរ ! 🎉 + +[<< ថ្ងៃទី 3](../03_Day_Booleans_operators_date/03_booleans_operators_date.md) | [ថ្ងៃទី 5 >>](../05_Day_Arrays/05_day_arrays.md) diff --git a/Khmer/05_Day_Arrays/05_day_arrays.md b/Khmer/05_Day_Arrays/05_day_arrays.md new file mode 100644 index 0000000..49655b2 --- /dev/null +++ b/Khmer/05_Day_Arrays/05_day_arrays.md @@ -0,0 +1,774 @@ +
+

30 ថ្ងៃនៃ JavaScript: Arrays

+ + + + + Twitter Follow + + + អ្នកនិពន្ធ: + Asabeneh Yetayeh
+ ខែមករា ឆ្នាំ ២០២០ + +
+ +[<< ថ្ងៃទី 4](../04_Day_Conditionals/04_day_conditionals.md) | [ថ្ងៃទី 6 >>](../06_Day_Loops/06_day_loops.md) + +![Day 5](../images/banners/day_1_5.png) + +- [📔 ថ្ងៃទី 5](#-day-5) + - [Arrays](#arrays) + - [របៀបបង្កើត array ទទេ](#how-to-create-an-empty-array) + - [របៀបបង្កើត array ដែលមានតម្លៃ](#how-to-create-an-array-with-values) + - [ការបង្កើត array ដោយប្រើ split](#creating-an-array-using-split) + - [ការចូលប្រើធាតុ array ដោយប្រើ index](#accessing-array-items-using-index) + - [ការកែប្រែធាតុ array](#modifying-array-element) + - [Methods ដើម្បីកែប្រែ array](#methods-to-manipulate-array) + - [Array Constructor](#array-constructor) + - [ការបង្កើតតម្លៃ static ជាមួយ fill](#creating-static-values-with-fill) + - [ការភ្ជាប់ array ដោយប្រើ concat](#concatenating-array-using-concat) + - [ការទាញយកប្រវែង array](#getting-array-length) + - [ទាញយក index ធាតុនៅក្នុង array](#getting-index-an-element-in-arr-array) + - [ទាញយក index ចុងក្រោយនៃធាតុនៅក្នុង array](#getting-last-index-of-an-element-in-array) + - [ពិនិត្យ array](#checking-array) + - [បំប្លែង array ទៅជា string](#converting-array-to-string) + - [ការភ្ជាប់ធាតុ array](#joining-array-elements) + - [Slice ធាតុ array](#slice-array-elements) + - [Splice method នៅក្នុង array](#splice-method-in-array) + - [បន្ថែមធាតុទៅ array ដោយប្រើ push](#adding-item-to-an-array-using-push) + - [ដកធាតុបញ្ចប់ដោយប្រើ pop](#removing-the-end-element-using-pop) + - [ដកធាតុចេញពីដើម array](#removing-an-element-from-the-beginning) + - [បន្ថែមធាតុពីដើម array](#add-an-element-from-the-beginning) + - [បញ្ច្រាសលំដាប់នៃ array](#reversing-array-order) + - [ការតម្រៀបធាតុនៅក្នុង array](#sorting-elements-in-array) + - [array នៃ array](#array-of-arrays) + - [💻 លំហាត់](#-exercise) + - [លំហាត់៖ កម្រិត 1](#exercise-level-1) + - [លំហាត់៖ កម្រិត 2](#exercise-level-2) + - [លំហាត់៖ កម្រិត 3](#exercise-level-3) + +# 📔 ថ្ងៃទី 5 + +## Arrays + +ផ្ទុយទៅនឹងអថេរ array មួយអាចរក្សាទុក តម្លៃច្រើន។ តម្លៃនីមួយៗក្នុង array មាន _index_ ហើយ index នីមួយៗមាន memory address។ តម្លៃនីមួយៗអាចចូលប្រើបានដោយប្រើ _indexes_ របស់ពួកគេ។ index នៃ array មួយចាប់ផ្តើមពី សូន្យហើយ index នៃធាតុចុងក្រោយគឺតិចជាងមួយពីប្រវែងនៃ array + +array គឺជាបណ្តុំនៃប្រភេទទិន្នន័យផ្សេងៗគ្នាដែលត្រូវបានដំរៀប និងអាចផ្លាស់ប្តូរបាន (កែប្រែបាន)។ array អនុញ្ញាតឱ្យរក្សាទុកធាតុស្ទួន និងប្រភេទទិន្នន័យផ្សេងៗគ្នា។ array អាចទទេ ឬវាអាចមានតម្លៃប្រភេទទិន្នន័យផ្សេងគ្នា។ + +### របៀបបង្កើត array ទទេ + +នៅក្នុង JavaScript យើងអាចបង្កើត array តាមវិធីផ្សេងៗគ្នា។ យើងនឹងមើលវិធីផ្សេងគ្នាដើម្បីបង្កើត array មួយ។ +វាជារឿងធម្មតាណាស់ក្នុងការប្រើ _const_ ជំនួសឱ្យ _let_ ដើម្បីប្រកាសអថេរ array។ ប្រសិនបើអ្នកកំពុងប្រើ const វាមានន័យថាអ្នកមិនប្រើឈ្មោះអថេរនោះម្តងទៀតទេ។ + +- ដោយ Array constructor + +```js +// syntax +const arr = Array() +// or +// let arr = new Array() +console.log(arr) // [] +``` + +- ដោយ square brackets([]) + +```js +// syntax +// នេះជាវិធីដែលបានណែនាំបំផុតដើម្បីបង្កើត ​array ទទេ +const arr = [] +console.log(arr) +``` + +### របៀបបង្កើត array ដែលមានតម្លៃ + +Array ជាមួយតម្លៃដំបូង។ យើងប្រើ _length_ property ដើម្បីស្វែងរកប្រវែងនៃ array មួយ។ + +```js +const numbers = [0, 3.14, 9.81, 37, 98.6, 100] // array នៃលេខ +const fruits = ['banana', 'orange', 'mango', 'lemon'] // array នៃ string, ផ្លែឈើ +const vegetables = ['Tomato', 'Potato', 'Cabbage', 'Onion', 'Carrot'] // array នៃ string, បន្លៃ +const animalProducts = ['milk', 'meat', 'butter', 'yoghurt'] // array នៃ string, ផលិតផល +const webTechs = ['HTML', 'CSS', 'JS', 'React', 'Redux', 'Node', 'MongDB'] // array នៃបច្ចេកវិទ្យា web +const countries = ['Finland', 'Denmark', 'Sweden', 'Norway', 'Iceland'] // array នៃ string, ប្រទេស + +// បង្ហាញ array និងប្រវែងរបស់វា។ + +console.log('Numbers:', numbers) +console.log('Number of numbers:', numbers.length) + +console.log('Fruits:', fruits) +console.log('Number of fruits:', fruits.length) + +console.log('Vegetables:', vegetables) +console.log('Number of vegetables:', vegetables.length) + +console.log('Animal products:', animalProducts) +console.log('Number of animal products:', animalProducts.length) + +console.log('Web technologies:', webTechs) +console.log('Number of web technologies:', webTechs.length) + +console.log('Countries:', countries) +console.log('Number of countries:', countries.length) +``` + +```sh +Numbers: [0, 3.14, 9.81, 37, 98.6, 100] +Number of numbers: 6 +Fruits: ['banana', 'orange', 'mango', 'lemon'] +Number of fruits: 4 +Vegetables: ['Tomato', 'Potato', 'Cabbage', 'Onion', 'Carrot'] +Number of vegetables: 5 +Animal products: ['milk', 'meat', 'butter', 'yoghurt'] +Number of animal products: 4 +Web technologies: ['HTML', 'CSS', 'JS', 'React', 'Redux', 'Node', 'MongDB'] +Number of web technologies: 7 +Countries: ['Finland', 'Estonia', 'Denmark', 'Sweden', 'Norway'] +Number of countries: 5 +``` + +- array អាចមានធាតុនៃប្រភេទទិន្នន័យផ្សេងៗគ្នា + +```js +const arr = [ + 'Asabeneh', + 250, + true, + { country: 'Finland', city: 'Helsinki' }, + { skills: ['HTML', 'CSS', 'JS', 'React', 'Python'] } +] // arr មានប្រភេទទិន្នន័យផ្សេងៗគ្នា +console.log(arr) +``` + +### ការបង្កើត array ដោយប្រើ split + +ដូចដែលយើងបានឃើញនៅក្នុងផ្នែកមុន យើងអាចបំបែក string នៅទីតាំងផ្សេងគ្នា ហើយយើងអាចប្តូរវាទៅជា array មួយ។ ចូរយើងមើលឧទាហរណ៍ខាងក្រោម។ + +```js +let js = 'JavaScript' +const charsInJavaScript = js.split('') + +console.log(charsInJavaScript) // ["J", "a", "v", "a", "S", "c", "r", "i", "p", "t"] + +let companiesString = 'Facebook, Google, Microsoft, Apple, IBM, Oracle, Amazon' +const companies = companiesString.split(',') + +console.log(companies) // ["Facebook", " Google", " Microsoft", " Apple", " IBM", " Oracle", " Amazon"] +let txt = + 'I love teaching and empowering people. I teach HTML, CSS, JS, React, Python.' +const words = txt.split(' ') + +console.log(words) +// អត្ថបទមានតួអក្សរពិសេស ចូរគិតពីរបៀបដែលអ្នកអាចទទួលបានតែពាក្យ +// ["I", "love", "teaching", "and", "empowering", "people.", "I", "teach", "HTML,", "CSS,", "JS,", "React,", "Python"] +``` + +### ការចូលប្រើធាតុ array ដោយប្រើ index + +យើងចូលប្រើធាតុនីមួយៗក្នុង array ដោយប្រើ index របស់វា។ index របស់ array ចាប់ផ្តើមពី 0។ រូបភាពខាងក្រោមបង្ហាញយ៉ាងច្បាស់អំពី index នៃធាតុនីមួយៗនៅក្នុង array ។ + +![arr index](../images/array_index.png) + +```js +const fruits = ['banana', 'orange', 'mango', 'lemon'] +let firstFruit = fruits[0] // យើងកំពុងចូលប្រើធាតុទីមួយដោយប្រើ index របស់វា។ + +console.log(firstFruit) // banana + +secondFruit = fruits[1] +console.log(secondFruit) // orange + +let lastFruit = fruits[3] +console.log(lastFruit) // lemon +// index ចុងក្រោយអាចត្រូវបានគណនាដូចខាងក្រោម + +let lastIndex = fruits.length - 1 +lastFruit = fruits[lastIndex] + +console.log(lastFruit) // lemon +``` + +```js +const numbers = [0, 3.14, 9.81, 37, 98.6, 100] // សំណុំនៃលេខ + +console.log(numbers.length) // => ដើម្បីដឹងពីទំហំនៃអារេដែលជា 6 +console.log(numbers) // -> [0, 3.14, 9.81, 37, 98.6, 100] +console.log(numbers[0]) // -> 0 +console.log(numbers[5]) // -> 100 + +let lastIndex = numbers.length - 1; +console.log(numbers[lastIndex]) // -> 100 +``` + +```js +const webTechs = [ + 'HTML', + 'CSS', + 'JavaScript', + 'React', + 'Redux', + 'Node', + 'MongoDB' +] // array នៃបច្ចេកវិទ្យាគេហទំព័រ + +console.log(webTechs) // ធាតុអារេទាំងអស់។ +console.log(webTechs.length) // => ដើម្បីដឹងពីទំហំនៃអារេដែលជា 7 +console.log(webTechs[0]) // -> HTML +console.log(webTechs[6]) // -> MongoDB + +let lastIndex = webTechs.length - 1 +console.log(webTechs[lastIndex]) // -> MongoDB +``` + +```js +const countries = [ + 'Albania', + 'Bolivia', + 'Canada', + 'Denmark', + 'Ethiopia', + 'Finland', + 'Germany', + 'Hungary', + 'Ireland', + 'Japan', + 'Kenya' +] // array នៃប្រទេស + +console.log(countries) // -> ប្រទេសទាំងអស់នៅក្នុងអារេ +console.log(countries[0]) // -> Albania +console.log(countries[10]) // -> Kenya + +let lastIndex = countries.length - 1; +console.log(countries[lastIndex]) // -> Kenya +``` + +```js +const shoppingCart = [ + 'Milk', + 'Mango', + 'Tomato', + 'Potato', + 'Avocado', + 'Meat', + 'Eggs', + 'Sugar' +] // array នៃផលិតផលអាហារ + +console.log(shoppingCart) // +console.log(shoppingCart[0]) // -> Milk +console.log(shoppingCart[7]) // -> Sugar + +let lastIndex = shoppingCart.length - 1; +console.log(shoppingCart[lastIndex]) // -> Sugar +``` + +### ការកែប្រែធាតុ array + +អារេអាចផ្លាស់ប្តូរបាន (កែប្រែបាន)។ នៅពេលដែលអារេមួយត្រូវបានបង្កើត យើងអាចកែប្រែតម្លៃនៃធាតុអារេ។ + +```js +const numbers = [1, 2, 3, 4, 5] +numbers[0] = 10 // ការផ្លាស់ប្តូរ 1 នៅ index 0 ទៅ 10 +numbers[1] = 20 // ការផ្លាស់ប្តូរ 2 នៅ index 1 ដល់ 20 + +console.log(numbers) // [10, 20, 3, 4, 5] + +const countries = [ + 'Albania', + 'Bolivia', + 'Canada', + 'Denmark', + 'Ethiopia', + 'Finland', + 'Germany', + 'Hungary', + 'Ireland', + 'Japan', + 'Kenya' +] + +countries[0] = 'Afghanistan' // ជំនួសអាល់បានីដោយអាហ្វហ្គានីស្ថាន +let lastIndex = countries.length - 1 +countries[lastIndex] = 'Korea' // ជំនួសប្រទេសកេនយ៉ាដោយកូរ៉េ + +console.log(countries) +``` + +```sh +["Afghanistan", "Bolivia", "Canada", "Denmark", "Ethiopia", "Finland", "Germany", "Hungary", "Ireland", "Japan", "Korea"] +``` + +### Methods ដើម្បីកែប្រែ array + +មាន method ផ្សេងគ្នាដើម្បីកែប្រែអារេមួយ។ ទាំងនេះគឺជា methods ដែលមានមួយចំនួនដើម្បីដោះស្រាយជាមួយអារេ៖_Array, length, concat, indexOf, slice, splice, join, toString, include, lastIndexOf, isArray, fill, push, pop, shift, unshift_ + +#### Array Constructor + +Array:ដើម្បីបង្កើតអារេ. + +```js +const arr = Array() // បង្កើតអារេទទេ +console.log(arr) + +const eightEmptyValues = Array(8) // វាបង្កើតតម្លៃទទេប្រាំបី +console.log(eightEmptyValues) // [empty x 8] +``` + +#### ការបង្កើត static values ជាមួយ fill + +fill:បំពេញធាតុអារេទាំងអស់ដោយតម្លៃ static + +```js +const arr = Array() // បង្កើតអារេទទេ +console.log(arr) + +const eightXvalues = Array(8).fill('X') // វាបង្កើតតម្លៃធាតុប្រាំបីដែលបំពេញដោយ 'X' +console.log(eightXvalues) // ['X', 'X','X','X','X','X','X','X'] + +const eight0values = Array(8).fill(0) // វាបង្កើតតម្លៃធាតុប្រាំបីដែលបំពេញដោយ '0' +console.log(eight0values) // [0, 0, 0, 0, 0, 0, 0, 0] + +const four4values = Array(4).fill(4) // វាបង្កើតតម្លៃធាតុ 4 ដែលបំពេញដោយ '4' +console.log(four4values) // [4, 4, 4, 4] +``` + +#### ការភ្ជាប់ array ដោយប្រើ concat + +concat:ដើម្បីភ្ជាប់អារេពីរ។ + +```js +const firstList = [1, 2, 3] +const secondList = [4, 5, 6] +const thirdList = firstList.concat(secondList) + +console.log(thirdList) // [1, 2, 3, 4, 5, 6] +``` + +```js +const fruits = ['banana', 'orange', 'mango', 'lemon'] // អារេនៃផ្លែឈើ +const vegetables = ['Tomato', 'Potato', 'Cabbage', 'Onion', 'Carrot'] // អារេនៃបន្លែ +const fruitsAndVegetables = fruits.concat(vegetables) // ភ្ជាប់អារេទាំងពីរ + +console.log(fruitsAndVegetables) +``` + +```sh +["banana", "orange", "mango", "lemon", "Tomato", "Potato", "Cabbage", "Onion", "Carrot"] +``` + +#### ការទាញយកប្រវែង array + +Length:ដើម្បីដឹងពីទំហំនៃអារេ + +```js +const numbers = [1, 2, 3, 4, 5] +console.log(numbers.length) // -> 5 គឺជាទំហំនៃអារេ +``` + +#### ទាញយក index ធាតុនៅក្នុង array + +indexOf: ដើម្បីពិនិត្យមើលថាតើធាតុមាននៅក្នុងអារេ។ ប្រសិនបើវាឲ index នោះធាតុនោះមាន តែបើវាឲ index ផ្សេង វាត្រឡប់ -1 ។ + +```js +const numbers = [1, 2, 3, 4, 5] + +console.log(numbers.indexOf(5)) // -> 4 +console.log(numbers.indexOf(0)) // -> -1 +console.log(numbers.indexOf(1)) // -> 0 +console.log(numbers.indexOf(6)) // -> -1 +``` + +ពិនិត្យធាតុមួយប្រសិនបើវាមាននៅក្នុងអារេ។ + +- ពិនិត្យធាតុនៅក្នុងបញ្ជីមួយ។ + +```js +// អនុញ្ញាតឱ្យយើងពិនិត្យមើលថាតើចេកមាននៅក្នុងអារេ + +const fruits = ['banana', 'orange', 'mango', 'lemon'] +let index = fruits.indexOf('banana') // 0 + +if(index === -1){ + console.log('This fruit does not exist in the array') +} else { + console.log('This fruit does exist in the array') +} +// ផ្លែឈើនេះមាននៅក្នុងអារេ + +// យើងអាចប្រើ ternary នៅទីនេះផងដែរ។ +index === -1 ? console.log('This fruit does not exist in the array'): console.log('This fruit does exist in the array') + +// យើងនឹងពិនិត្យមើលថាតើផ្លែបឺរមាននៅក្នុងអារេរឺទេ +let indexOfAvocado = fruits.indexOf('avocado') // ប្រសិនបើធាតុមិនបានរកឃើញ index គឺ -1 +if(indexOfAvocado === -1){ + console.log('This fruit does not exist in the array') +} else { + console.log('This fruit does exist in the array') +} +// This fruit does not exist in the array +``` + +#### ទាញយក index ចុងក្រោយនៃធាតុនៅក្នុង array + +LastIndexOf៖ វាផ្តល់ទីតាំងនៃធាតុចុងក្រោយក្នុងអារេ។ ប្រសិនបើវាមានវាឲindex បើមិនមានទេវាឲ -1 + +```js +const numbers = [1, 2, 3, 4, 5, 3, 1, 2] + +console.log(numbers.lastIndexOf(2)) // 7 +console.log(numbers.lastIndexOf(0)) // -1 +console.log(numbers.lastIndexOf(1)) // 6 +console.log(numbers.lastIndexOf(4)) // 3 +console.log(numbers.lastIndexOf(6)) // -1 +``` + +includes:ដើម្បីពិនិត្យមើលថាតើមានធាតុនៅក្នុងអារេ។ ប្រសិនបើវាមាន វាឲ true ផ្សេងទៀតវាឲ false។ + +```js +const numbers = [1, 2, 3, 4, 5] + +console.log(numbers.includes(5)) // true +console.log(numbers.includes(0)) // false +console.log(numbers.includes(1)) // true +console.log(numbers.includes(6)) // false + +const webTechs = [ + 'HTML', + 'CSS', + 'JavaScript', + 'React', + 'Redux', + 'Node', + 'MongoDB' +] // បញ្ជីនៃបច្ចេកវិទ្យាគេហទំព័រ + +console.log(webTechs.includes('Node')) // true +console.log(webTechs.includes('C')) // false +``` + +#### ពិនិត្យ array + +Array.isArray:ដើម្បីពិនិត្យមើលថាតើប្រភេទទិន្នន័យគឺជាអារេ + +```js +const numbers = [1, 2, 3, 4, 5] +console.log(Array.isArray(numbers)) // true + +const number = 100 +console.log(Array.isArray(number)) // false +``` + +#### ការបំប្លែង array ទៅជា string + +toString:បំប្លែងអារេទៅជាខ្សែអក្សរ + +```js +const numbers = [1, 2, 3, 4, 5] +console.log(numbers.toString()) // 1,2,3,4,5 + +const names = ['Asabeneh', 'Mathias', 'Elias', 'Brook'] +console.log(names.toString()) // Asabeneh,Mathias,Elias,Brook +``` + +#### ការភ្ជាប់ធាតុអារេ + +join: វា​ត្រូវ​បាន​ប្រើ​ដើម្បី​ភ្ជាប់​ធាតុ​នៃ​អារេ​ argument ដែលបានដាក់ក្នុង method នេះ​នឹង​ត្រូវ​បាន​ភ្ជាប់​ក្នុង​អារេ​ ហើយ​ឲជា string។ តាមលំនាំដើម វាភ្ជាប់ជាមួយសញ្ញាក្បៀស ប៉ុន្តែយើងអាចដាក់ parameter ផ្សេងគ្នាដែលអាចត្រូវបានភ្ជាប់រវាងធាតុ។ + +```js +const numbers = [1, 2, 3, 4, 5] +console.log(numbers.join()) // 1,2,3,4,5 + +const names = ['Asabeneh', 'Mathias', 'Elias', 'Brook'] + +console.log(names.join()) // Asabeneh,Mathias,Elias,Brook +console.log(names.join('')) //AsabenehMathiasEliasBrook +console.log(names.join(' ')) //Asabeneh Mathias Elias Brook +console.log(names.join(', ')) //Asabeneh, Mathias, Elias, Brook +console.log(names.join(' # ')) //Asabeneh # Mathias # Elias # Brook + +const webTechs = [ + 'HTML', + 'CSS', + 'JavaScript', + 'React', + 'Redux', + 'Node', + 'MongoDB' +] // បញ្ជីនៃបច្ចេកវិទ្យាគេហទំព័រ + +console.log(webTechs.join()) // "HTML,CSS,JavaScript,React,Redux,Node,MongoDB" +console.log(webTechs.join(' # ')) // "HTML # CSS # JavaScript # React # Redux # Node # MongoDB" +``` + +#### Slice ធាតុ array + +Slice: ដើម្បីកាត់ធាតុជាច្រើននៅក្នុងជួរ។ វាត្រូវការប៉ារ៉ាម៉ែត្រពីរ: ទីតាំងចាប់ផ្តើមនិងបញ្ចប់។ វាមិនរាប់បញ្ចូលទីតាំងបញ្ចប់នោះទេ។ + +```js + const numbers = [1,2,3,4,5] + + console.log(numbers.slice()) // -> វាចម្លងធាតុទាំងអស់។ + console.log(numbers.slice(0)) // -> វាចម្លងធាតុទាំងអស់។ + console.log(numbers.slice(0, numbers.length)) //វាចម្លងធាតុទាំងអស់។ + console.log(numbers.slice(1,4)) // -> [2,3,4] // វាមិនរាប់បញ្ចូលទីតាំងបញ្ចប់នោះទេ។ +``` + +#### Splice method ក្នុង array + +Splice: វាត្រូវការប៉ារ៉ាម៉ែត្របី៖ ទីតាំងចាប់ផ្តើម ចំនួនដងដែលត្រូវដកចេញ និងចំនួនធាតុដែលត្រូវបន្ថែម។ + +```js + const numbers = [1, 2, 3, 4, 5] + numbers.splice() + console.log(numbers) // -> លុបធាតុទាំងអស់។ + +``` + +```js + const numbers = [1, 2, 3, 4, 5] + numbers.splice(0,1) + console.log(numbers) // លុបធាតុទីមួយចេញ +``` + +```js + const numbers = [1, 2, 3, 4, 5, 6] + numbers.splice(3, 3, 7, 8, 9) + console.log(numbers.splice(3, 3, 7, 8, 9)) // -> [1, 2, 3, 7, 8, 9] //វាដកធាតុបីចេញ ហើយជំនួសធាតុបី +``` + +#### បន្ថែមធាតុទៅអារេដោយប្រើ push + +Push: ការបន្ថែមធាតុនៅចុងបញ្ចប់។ ដើម្បីបន្ថែមធាតុទៅចុងបញ្ចប់នៃអារេដែលមានស្រាប់ យើងប្រើ method push។ + +```js +// syntax +const arr = ['item1', 'item2','item3'] +arr.push('new item') +console.log(arr) +// ['item1', 'item2','item3','new item'] +``` + +```js +const numbers = [1, 2, 3, 4, 5] +numbers.push(6) +console.log(numbers) // -> [1,2,3,4,5,6] + +numbers.pop() // -> យកធាតុមួយចេញពីចុង +console.log(numbers) // -> [1,2,3,4,5] +``` + +```js +let fruits = ['banana', 'orange', 'mango', 'lemon'] +fruits.push('apple') +console.log(fruits) // ['banana', 'orange', 'mango', 'lemon', 'apple'] + +fruits.push('lime') +console.log(fruits) // ['banana', 'orange', 'mango', 'lemon', 'apple', 'lime'] +``` + +#### ការដកធាតុចុងដោយប្រើ pop + +pop: ការដកធាតុចេញនៅចុង + +```js +const numbers = [1, 2, 3, 4, 5] +numbers.pop() // -> យកធាតុមួយចេញពីចុង +console.log(numbers) // -> [1,2,3,4] +``` + +#### ការដកធាតុចេញពីដើម + +shift: ការដកធាតុអារេមួយចេញនៅដើមអារេ។ + +```js +const numbers = [1, 2, 3, 4, 5] +numbers.shift() // -> យកធាតុមួយចេញពីដើម +console.log(numbers) // -> [2,3,4,5] +``` + +#### បន្ថែមធាតុពីដើម + +unshift: ការបន្ថែមធាតុអារេនៅដើមអារេ។ + +```js +const numbers = [1, 2, 3, 4, 5] +numbers.unshift(0) // -> បន្ថែមធាតុមួយពីដំបូង +console.log(numbers) // -> [0,1,2,3,4,5] +``` + +#### បញ្ច្រាសលំដាប់អារេ + +reverse: បញ្ច្រាសលំដាប់នៃអារេមួយ។ + +```js +const numbers = [1, 2, 3, 4, 5] +numbers.reverse() // -> បញ្ច្រាសលំដាប់នៃអារេ +console.log(numbers) // [5, 4, 3, 2, 1] + +numbers.reverse() +console.log(numbers) // [1, 2, 3, 4, 5] +``` + +#### ការតម្រៀបធាតុនៅក្នុងអារេ + +sort: រៀបចំធាតុអារេតាមលំដាប់ឡើង។ តម្រៀបយក callback function យើងនឹងឃើញពីរបៀបដែលយើងប្រើការតម្រៀបជាមួយ callback function នៅក្នុងផ្នែកខាងមុខ។ + +```js +const webTechs = [ + 'HTML', + 'CSS', + 'JavaScript', + 'React', + 'Redux', + 'Node', + 'MongoDB' +] + +webTechs.sort() +console.log(webTechs) // ["CSS", "HTML", "JavaScript", "MongoDB", "Node", "React", "Redux"] + +webTechs.reverse() // បន្ទាប់​ពី​តម្រៀប​ហើយ យើង​អាច​បញ្ច្រាស​វា​បាន។ +console.log(webTechs) // ["Redux", "React", "Node", "MongoDB", "JavaScript", "HTML", "CSS"] +``` + +### Array នៃ arrays + +អារេអាចរក្សាទុកប្រភេទទិន្នន័យផ្សេងៗគ្នា រួមទាំងអារេខ្លួនឯងផងដែរ។ ចូរយើងបង្កើតអារេនៃអារេ + +```js +const firstNums = [1, 2, 3] +const secondNums = [1, 4, 9] + +const arrayOfArray = [[1, 2, 3], [1, 2, 3]] +console.log(arrayOfArray[0]) // [1, 2, 3] + + const frontEnd = ['HTML', 'CSS', 'JS', 'React', 'Redux'] + const backEnd = ['Node','Express', 'MongoDB'] + const fullStack = [frontEnd, backEnd] + console.log(fullStack) // [["HTML", "CSS", "JS", "React", "Redux"], ["Node", "Express", "MongoDB"]] + console.log(fullStack.length) // 2 + console.log(fullStack[0]) // ["HTML", "CSS", "JS", "React", "Redux"] + console.log(fullStack[1]) // ["Node", "Express", "MongoDB"] +``` + +🌕 អ្នក​ឧស្សាហ៍​ព្យាយាម ហើយ​អ្នក​បាន​សម្រេច​បាន​ច្រើន​ហើយ។ អ្នកទើបតែបានបញ្ចប់ challenge ថ្ងៃទី 5 ហើយអ្នកគឺជាជំហាន 5 ឆ្ពោះទៅរកផ្លូវរបស់អ្នកទៅកាន់ភាពអស្ចារ្យ។ ឥឡូវធ្វើលំហាត់ខ្លះសម្រាប់ខួរក្បាល និងសាច់ដុំរបស់អ្នក។ + +## 💻 លំហាត់ + +### លំហាត់៖ កម្រិត ១ + +```js +const countries = [ + 'Albania', + 'Bolivia', + 'Canada', + 'Denmark', + 'Ethiopia', + 'Finland', + 'Germany', + 'Hungary', + 'Ireland', + 'Japan', + 'Kenya' +] + +const webTechs = [ + 'HTML', + 'CSS', + 'JavaScript', + 'React', + 'Redux', + 'Node', + 'MongoDB' +] +``` + +1. ប្រកាសអារេទទេ +2. ប្រកាសអារេដែលមានធាតុច្រើនជាង 5 +3. ស្វែងរកប្រវែងនៃអារេរបស់អ្នក។ +4. ទាញយកធាតុទីមួយ ធាតុកណ្តាល និងធាតុចុងក្រោយនៃអារេ +5. ប្រកាសអារេមួយហៅថា _mixedDataTypes_ ហើយដាក់ប្រភេទទិន្នន័យផ្សេងៗគ្នាក្នុងអារេ និងស្វែងរកប្រវែងនៃអារេ។ ទំហំអារេគួរតែធំជាង 5 +6. ប្រកាសឈ្មោះអារេក្រុមហ៊ុន និងឲតម្លៃដំបូង Facebook, Google, Microsoft, Apple, IBM, Oracle និង Amazon +7. បង្ហាញដោយប្រើ _console.log()_ +8. បង្ហាញចំនួនក្រុមហ៊ុននៅក្នុងអារេ +9. បង្ហាញក្រុមហ៊ុនទីមួយ ក្រុមហ៊ុនកណ្តាល និងក្រុមហ៊ុនចុងក្រោយ +10. បង្ហាញក្រុមហ៊ុននីមួយៗ +11. ប្តូរឈ្មោះក្រុមហ៊ុននីមួយៗទៅជាអក្សរធំម្តងមួយ ហើយបង្ហាញវាចេញ +12. បង្ហាញអារេដូចជាប្រយោគ៖ Facebook, Google, Microsoft, Apple, IBM, Oracle និង Amazon គឺជាក្រុមហ៊ុន IT ធំ។ +13. ពិនិត្យមើលថាតើមានក្រុមហ៊ុនជាក់លាក់នៅក្នុងអារេ itCompanies ដែរឬទេ។ ប្រសិនបើវាមាន ឲក្រុមហ៊ុន បើទេ ឲ _Not found_ +14. ត្រងចេញក្រុមហ៊ុនដែលមានច្រើនជាងមួយ 'o' ដោយគ្មានវិធីសាស្ត្រតម្រង +15. តម្រៀបអារេដោយប្រើវិធីសាស្ត្រ _sort()_ +16. បញ្ច្រាសអារេដោយប្រើវិធីសាស្ត្រ _reverse()_ +17. កាត់ក្រុមហ៊ុន 3 ដំបូងចេញពីអារេ +18. កាត់ក្រុមហ៊ុន 3 ចុងក្រោយចេញពីអារេ +19. កាត់ក្រុមហ៊ុន IT កណ្តាល ឬក្រុមហ៊ុនចេញពីអារេ +20. យកក្រុមហ៊ុន IT ដំបូងចេញពីអារេ +21. ដកក្រុមហ៊ុន IT កណ្តាល ឬក្រុមហ៊ុនចេញពីអារេ +22. លុបក្រុមហ៊ុន IT ចុងក្រោយចេញពីអារេ +23. លុបក្រុមហ៊ុន IT ទាំងអស់។ + +### លំហាត់៖ កម្រិត ២ + +1. បង្កើតឯកសារ country.js ដាច់ដោយឡែក ហើយរក្សាទុកអារេប្រទេសទៅក្នុងឯកសារនេះ បង្កើតឯកសារដាច់ដោយឡែក web_techs.js និងរក្សាទុកអារេ webTechs ទៅក្នុងឯកសារនេះ។ ចូលប្រើឯកសារទាំងពីរនៅក្នុងឯកសារ main.js +1. ដំបូង​ត្រូវ​ដក​វណ្ណយុត្តិ​ទាំងអស់​ចេញ ហើយ​ប្តូរ​ខ្សែអក្សរ​ទៅជា​អារេ ហើយ​រាប់​ចំនួន​ពាក្យ​ក្នុង​អារេ + + ```js + let text = + 'I love teaching and empowering people. I teach HTML, CSS, JS, React, Python.' + console.log(words) + console.log(words.length) + ``` + + ```sh + ["I", "love", "teaching", "and", "empowering", "people", "I", "teach", "HTML", "CSS", "JS", "React", "Python"] + + 13 + ``` + +1. នៅ​ក្នុង​រទេះ​លក់​ទំនិញ​ដូច​ខាង​ក្រោម ចូរបន្ថែម លុប និងកែសម្រួល​ធាតុ + + ```js + const shoppingCart = ['Milk', 'Coffee', 'Tea', 'Honey'] + ``` + + - បន្ថែម 'Meat' នៅដើមរទេះទិញទំនិញរបស់អ្នក ប្រសិនបើវាមិនទាន់ត្រូវបានបន្ថែម + - បន្ថែម Sguar នៅចុងបញ្ចប់នៃរទេះទិញទំនិញរបស់អ្នកប្រសិនបើវាមិនទាន់ត្រូវបានបន្ថែម + - យក 'Honey' ចេញ ប្រសិនបើអ្នកមានប្រតិកម្មនឹងទឹកឃ្មុំ + - កែប្រែ Tea ទៅជា 'Green Tea' +1. នៅក្នុងប្រទេសនានា សូមពិនិត្យមើលថាតើ 'Ethiopia' មាននៅក្នុងអារេប្រសិនបើវាមានបោះពុម្ព 'ETHIOPIA' ។ ប្រសិនបើវាមិនមាន បន្ថែមទៅបញ្ជីប្រទេស។ +1. នៅក្នុងអារេ webTechs ពិនិត្យមើលថាតើ Sass មាននៅក្នុងអារេ ហើយប្រសិនបើវាមាន បោះពុម្ព 'Sass is a preprocess CSS'។ ប្រសិនបើវាមិនមានទេ បន្ថែម Sass ទៅអារេ ហើយបោះពុម្ពអារេ។ +1. ភ្ជាប់អថេរទាំងពីរខាងក្រោម ហើយរក្សាទុកវាក្នុងអថេរ fullStack ។ + + ```js + const frontEnd = ['HTML', 'CSS', 'JS', 'React', 'Redux'] + const backEnd = ['Node','Express', 'MongoDB'] + + console.log(fullStack) + ``` + + ```sh + ["HTML", "CSS", "JS", "React", "Redux", "Node", "Express", "MongoDB"] + ``` + +### លំហាត់៖ កម្រិត ៣ + +1. ខាង​ក្រោម​នេះ​គឺ​ជា​អារេ​នៃ​អាយុនៃសិស្ស​ទាំង​១០​ + + ```js + const ages = [19, 22, 19, 24, 20, 25, 26, 24, 25, 24] + ``` + + - តម្រៀបអារេ និងស្វែងរកអាយុអប្បបរមា និងអតិបរមា + - ស្វែងរកអាយុមធ្យម (ធាតុកណ្តាលមួយ ឬធាតុកណ្តាលពីរចែកនឹងពីរ) + - ស្វែងរកអាយុជាមធ្យម (ធាតុទាំងអស់បែងចែកដោយចំនួនធាតុ) + - ស្វែងរក range អាយុ (អតិបរមាដកអប្បបរមា) + - ប្រៀបធៀបតម្លៃនៃ (អប្បបរមា - មធ្យម) និង (អតិបរមា - មធ្យម) ប្រើវិធីសាស្ត្រ _abs()_ +1. Slice ប្រទេសដប់ដំបូងពី [countries array](https://github.com/Asabeneh/30DaysOfJavaScript/tree/master/data/countries.js) +1. ស្វែងរកប្រទេសកណ្តាលនៅក្នុង[countries array](https://github.com/Asabeneh/30DaysOfJavaScript/tree/master/data/countries.js) +2. ចែកអារេប្រទេសជាពីរអារេស្មើគ្នាប្រសិនបើវាគូ។ ប្រសិនបើអារេប្រទេសមិនគូ បន្ថែមទៀតសម្រាប់ពាក់កណ្តាលទីមួយ។ + +🎉 អបអរសាទរ ! 🎉 + +[<< ថ្ងៃទី 4](../04_Day_Conditionals/04_day_Conditionals.md) | [ថ្ងៃទី 6 >>](../06_Day_Loops/06_day_loops.md)