Added khmer translation for the first five days

pull/801/head
Hongsreng-P 2 years ago
parent 9c067ce30b
commit 1b9f1259f6

@ -0,0 +1,986 @@
<div align="center">
<h1> 30 ថ្ងៃនៃ JavaScript: ប្រភេទទិន្នន័យ </h1>
<a class="header-badge" target="_blank" href="https://www.linkedin.com/in/asabeneh/">
<img src="https://img.shields.io/badge/style--5eba00.svg?label=LinkedIn&logo=linkedin&style=social">
</a>
<a class="header-badge" target="_blank" href="https://twitter.com/Asabeneh">
<img alt="Twitter Follow" src="https://img.shields.io/twitter/follow/asabeneh?style=social">
</a>
<sub>អ្នកនិពន្ធ:
<a href="https://www.linkedin.com/in/asabeneh/" target="_blank">Asabeneh Yetayeh</a><br>
<small> មករា, 2020</small>
</sub>
</div>
</div>
[<< ថ្ងៃទី ១](../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)

@ -0,0 +1,637 @@
<div align="center">
<h1> 30 ថ្ងៃនៃ JavaScript: Booleans, ប្រតិបត្តិករ, Date</h1>
<a class="header-badge" target="_blank" href="https://www.linkedin.com/in/asabeneh/">
<img src="https://img.shields.io/badge/style--5eba00.svg?label=LinkedIn&logo=linkedin&style=social">
</a>
<a class="header-badge" target="_blank" href="https://twitter.com/Asabeneh">
<img alt="Twitter Follow" src="https://img.shields.io/twitter/follow/asabeneh?style=social">
</a>
<sub>អ្នកនិពន្ធ:
<a href="https://www.linkedin.com/in/asabeneh/" target="_blank">Asabeneh Yetayeh</a><br>
<small> ខែមករា ឆ្នាំ ២០២០</small>
</sub>
</div>
[<< ថ្ងៃទី 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 = (y<sub>2</sub>-y<sub>1</sub>)/(x<sub>2</sub>-x<sub>1</sub>) ។ ស្វែងរកជម្រាលរវាងចំណុច (2, 2) និងចំណុច (6,10)
1. ប្រៀបធៀបជម្រាលនៃសំណួរទាំងពីរខាងលើ។
1. គណនាតម្លៃ y (y = x<sup>2</sup> + 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)

@ -0,0 +1,377 @@
<div align="center">
<h1> 30 ថ្ងៃនៃ JavaScript៖ Conditionals</h1>
<a class="header-badge" target="_blank" href="https://www.linkedin.com/in/asabeneh/">
<img src="https://img.shields.io/badge/style--5eba00.svg?label=LinkedIn&logo=linkedin&style=social">
</a>
<a class="header-badge" target="_blank" href="https://twitter.com/Asabeneh">
<img alt="Twitter Follow" src="https://img.shields.io/twitter/follow/asabeneh?style=social">
</a>
<sub>អ្នកនិពន្ធ:
<a href="https://www.linkedin.com/in/asabeneh/" target="_blank">Asabeneh Yetayeh</a><br>
<small> ខែមករា ឆ្នាំ ២០២០</small>
</sub>
</div>
[<< ថ្ងៃទី 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)

@ -0,0 +1,774 @@
<div align="center">
<h1> 30 ថ្ងៃនៃ JavaScript: Arrays</h1>
<a class="header-badge" target="_blank" href="https://www.linkedin.com/in/asabeneh/">
<img src="https://img.shields.io/badge/style--5eba00.svg?label=LinkedIn&logo=linkedin&style=social">
</a>
<a class="header-badge" target="_blank" href="https://twitter.com/Asabeneh">
<img alt="Twitter Follow" src="https://img.shields.io/twitter/follow/asabeneh?style=social">
</a>
<sub>អ្នកនិពន្ធ:
<a href="https://www.linkedin.com/in/asabeneh/" target="_blank">Asabeneh Yetayeh</a><br>
<small> ខែមករា ឆ្នាំ ២០២០</small>
</sub>
</div>
[<< ថ្ងៃទី 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)
Loading…
Cancel
Save