Có lm phép toán với kiểu string đc ko

Chúng ta đã cùng nhau tìm hiểu các kiểu dữ liệu có trong JavaScript ở bài trước, tuy nhiên chúng ta vẫn chưa biết cách thao tác với chúng như thế nào trong JavaScript, nó có hổ trợ các phương thức nào hay không? Vấn đề đó, chúng ta sẽ cùng nhau tìm hiểu trong bài này nhé 😉.

I. Number.

JavaScript không giống như nhiều ngôn ngữ lập trình khác, nó không có kiểu dữ liệu dành cho số như:

let num = 4 / 0;
//--> Output: -Infinity

1,

let num = 4 / 0;
//--> Output: -Infinity

2,

let num = 4 / 0;
//--> Output: -Infinity

3,

let num = 4 / 0;
//--> Output: -Infinity

4,

let num = 4 / 0;
//--> Output: -Infinity

5, ... mà nó chỉ có mỗi kiểu

let num = 4 / 0;
//--> Output: -Infinity

6.

Đối với số nguyên trong JavaScript nó có độ chính xác đến 15 con số, cụ thể như sau:

let a = 999999999999999; // Giá trị của a lúc này là à 999999999999999
let b = 9999999999999999;
// Đối với giá trị vượt quá 15 số thì b lúc này là 10000000000000000

Ngoài ra, số thập phân cũng có giới hạn của nó là 17 số. Tuy nhiên việc tính toán với số thập phân trong JavaScript không phải lúc nào cũng chính xác, cụ thể như sau:

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

Để biết nguyên nhân tại sao bạn tìm hiểu khái niệm floating-point nhé 😉.

Để khắc phục vấn đề này ta có thể nhân số thập phân với số nguyên rồi mới thực hiện phép tính, cụ thể như sau:

let total = (0.1 * 10 + 0.2 * 10)/10
//-->Output: total = 0.3

Lưu ý: Trong JavaScript, việc cộng 2 số với nhau tất nhiên sẽ cho kết quả là số, tuy nhiên cộng số với chuỗi thì JavaScript sẽ tự động convert số thành chuỗi và cộng 2 chuỗi với nhau, kết quả cuối cùng sẽ là một chuỗi đó nhé 🤭. Do đó trước khi tính toán, chúng ta cần convert hết qua thành số rồi làm gì thì làm nhé 😁.

1. Convert number to string.

Nếu muốn chuyển đổi từ kiểu

let num = 4 / 0;
//--> Output: -Infinity

6 sang

let num = 4 / 0;
//--> Output: -Infinity

8, ta có thể sử dụng phương thức

let num = 4 / 0;
//--> Output: -Infinity

9, cụ thể như sau:

let num = 2021;
num.toString();
//-->Output: "2021"

Ngoài ra ta còn có thể convert từ

let num = 4 / 0;
//--> Output: -Infinity

6 sang

let num = 4 / 0;
//--> Output: -Infinity

8 ở dạng nhị phân, bát phân, thập phân và thập lục phân đó 😉

let num = 240;
//Nhị phân
num.toString(2); //-->Output: "11110000"
//Bát phân
num.toString(8); //-->Output: "360"
//Thập phân
num.toString(10); //-->Output: "240"
//Thập lục phân
num.toString(16); //-->Output: "f0"

2. Infinity - Dương vô cực.

let total = 200 / "Hai trăm";
//-->Output: NaN
typeof NaN; //--> Output: "number"

2 hay dương vô cực cũng thuộc kiểu dữ liệu

let num = 4 / 0;
//--> Output: -Infinity

6. Khi một biến chứa giá trị mà vượt mức lưu trữ cho phép thì biến đó có giá trị là

let total = 200 / "Hai trăm";
//-->Output: NaN
typeof NaN; //--> Output: "number"

2. Nó cũng là một giá trị nên ta có đem đi so sánh được.

typeof Infinity; //--> Output: "number"
let a = 5/ 0;
//--> Output a = Infinity
let num = 5;
while(num != Infinity) {
  num = num * num;
    console.log(num);
}
//--> Output:
/*
25
625
390625
152587890625
2.3283064365386964e+22
5.421010862427523e+44
2.9387358770557196e+89
8.636168555094449e+178
Infinity
*/

Vậy âm vô cực thì sao??? Thì là

let total = 200 / "Hai trăm";
//-->Output: NaN
typeof NaN; //--> Output: "number"

5 đó 😁

let num = 4 / 0;
//--> Output: -Infinity

3. NaN - Not a Number.

let total = 200 / "Hai trăm";
//-->Output: NaN
typeof NaN; //--> Output: "number"

6 là một giá trị có trong JavaScript, nó dùng để xác định một số không phải là số hợp lệ. Nếu bạn thực hiện các phép tính với

let num = 4 / 0;
//--> Output: -Infinity

6 mà bằng cách nào đó nó vi phạm quy tắc tính toán của JavaScript thì nó sẽ trả về kết quả là

let total = 200 / "Hai trăm";
//-->Output: NaN
typeof NaN; //--> Output: "number"

6.

Ví dụ ta chia một số cho một chuỗi chẳng hạn 🤭.

let total = 200 / "Hai trăm";
//-->Output: NaN
typeof NaN; //--> Output: "number"

Để kiểm tra một biến có phải là

let total = 200 / "Hai trăm";
//-->Output: NaN
typeof NaN; //--> Output: "number"

6 hay không ta sử dụng phương thức

let x = 199 / "Not a number";
isNaN(x); //--> Output: true

0, nếu đúng thì return

let x = 199 / "Not a number";
isNaN(x); //--> Output: true

1 ngược lại return

let x = 199 / "Not a number";
isNaN(x); //--> Output: true

2.

let x = 199 / "Not a number";
isNaN(x); //--> Output: true

4. Ép kiểu sang number.

Khi làm việc với JavaScript chắc chắn sẽ có lúc có data bạn cần phải convert từ kiểu

let num = 4 / 0;
//--> Output: -Infinity

8 sang kiểu

let num = 4 / 0;
//--> Output: -Infinity

6, lúc này ta có 3 cách để ép kiểu:

• let x = 199 / "Not a number"; isNaN(x); //--> Output: true

  5: Chuyển đổi giá trị về kiểu number.

• let x = 199 / "Not a number"; isNaN(x); //--> Output: true

  6: Chuyển đổi giá trị sang số nguyên.

• let x = 199 / "Not a number"; isNaN(x); //--> Output: true

  7: Chuyển đổi giá trị sang số thập phân.

Number("200"); //--> 200
Number(2.2);   //--> 2.2
Number(2,2);   //--> NaN
Number(2 2);   //--> NaN
Number("Alice"); //--> NaN
Number(true);  //--> 1
Number(false); //--> 0

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

0

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

1

5. Làm tròn số.

Đôi khi những tính toán cho kết quả không mong muốn như cho ra kết quả dạng tập phân và bạn muốn làm tròn con số đó lên, trong JavaScript bạn có thể sử dụng phương thức

let x = 199 / "Not a number";
isNaN(x); //--> Output: true

8 để làm tròn các con số đó.

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

2

II. String.

let x = 199 / "Not a number";
isNaN(x); //--> Output: true

9 là một loại dữ liệu khá phổ biến trong JavaScript, một biến chứa các giá trị là các ký tự và được đặt trong dấu nhấy đơn

Number("200"); //--> 200
Number(2.2);   //--> 2.2
Number(2,2);   //--> NaN
Number(2 2);   //--> NaN
Number("Alice"); //--> NaN
Number(true);  //--> 1
Number(false); //--> 0

0 hay dấu nháy kép

Number("200"); //--> 200
Number(2.2);   //--> 2.2
Number(2,2);   //--> NaN
Number(2 2);   //--> NaN
Number("Alice"); //--> NaN
Number(true);  //--> 1
Number(false); //--> 0

1.

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

3

Một lưu ý cho các bạn, khi trong chuỗi bắt buộc có dấu nhấy đơn hoặc nhấy kép thì bạn phải thêm ký tự

Number("200"); //--> 200
Number(2.2);   //--> 2.2
Number(2,2);   //--> NaN
Number(2 2);   //--> NaN
Number("Alice"); //--> NaN
Number(true);  //--> 1
Number(false); //--> 0

2 ở trước dấu nhấy đó, như ví dụ bên dưới.

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

4

Ngoài ra trong chuỗi còn có các dấu, support cho các vấn đề khác mà bạn có thể quan tâm như:

Code Kết quả ' single quote - Dấu nhấy đơn \" double quote - Dấu nhấy kép \\ backslash - Dấu chéo ngược \n new line - Xuống dòng mới \r carriage return \t tab \b backspace - Tạo khoảng trống \f form feed

1. Lấy độ dài của chuỗi.

Ta có thể lấy độ dài của một chuỗi bằng phương thức

Number("200"); //--> 200
Number(2.2);   //--> 2.2
Number(2,2);   //--> NaN
Number(2 2);   //--> NaN
Number("Alice"); //--> NaN
Number(true);  //--> 1
Number(false); //--> 0

3.

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

5

2. Tìm kiếm chuỗi con trong một chuỗi.

Ta có thể sử dụng hàm

Number("200"); //--> 200
Number(2.2);   //--> 2.2
Number(2,2);   //--> NaN
Number(2 2);   //--> NaN
Number("Alice"); //--> NaN
Number(true);  //--> 1
Number(false); //--> 0

4 để tìm một chuỗi con trong một chuỗi lớn.

• Nếu tìm thấy, nó sẽ trả về vị trí đầu tiên của ký tự có trong chuỗi con.
• Nếu không tìm thấy, nó sẽ trả về Number("200"); //> 200 Number(2.2); //> 2.2 Number(2,2); //> NaN Number(2 2); //> NaN Number("Alice"); //> NaN Number(true); //> 1

  Number(false); //--> 0

  5

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

6

Ngoài ra, nếu bạn muốn tìm vị trí cuối cùng của chuỗi con thì bạ có thể sử dụng

Number("200"); //--> 200
Number(2.2);   //--> 2.2
Number(2,2);   //--> NaN
Number(2 2);   //--> NaN
Number("Alice"); //--> NaN
Number(true);  //--> 1
Number(false); //--> 0

6

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

7

À vị trí bắt đầu trong chuỗi là

Number("200"); //--> 200
Number(2.2);   //--> 2.2
Number(2,2);   //--> NaN
Number(2 2);   //--> NaN
Number("Alice"); //--> NaN
Number(true);  //--> 1
Number(false); //--> 0

7 nha 😁.

3. Tách chuỗi.

Làm việc với chuỗi thì chắc chắn bạn sẽ phải không ít thì nhiều lần phải tách một chuỗi thành nhiều chuỗi theo mục đích của mình. Trong JavaScript, nó có 3 cách để tách chuỗi.

• Sử dụng hàm Number("200"); //> 200 Number(2.2); //> 2.2 Number(2,2); //> NaN Number(2 2); //> NaN Number("Alice"); //> NaN Number(true); //> 1

  Number(false); //--> 0

  8, nó sẽ tách chuỗi từ vị trí

  Number("200"); //> 200 Number(2.2); //> 2.2 Number(2,2); //> NaN Number(2 2); //> NaN Number("Alice"); //> NaN Number(true); //> 1

  Number(false); //--> 0

  9 đến

  let a = 0.1 + 0.2; //> Bạn nghĩ rằng a = 0.3 //> Output: a = 0.30000000000000004 00

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

8

• Sử dụng let a = 0.1 + 0.2; //> Bạn nghĩ rằng a = 0.3 //> Output: a = 0.30000000000000004

  01, nó giống với

  let a = 0.1 + 0.2; //> Bạn nghĩ rằng a = 0.3 //> Output: a = 0.30000000000000004 02, tuy nhiên lại không chơi với giá trị âm.

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

9

• let a = 0.1 + 0.2; //> Bạn nghĩ rằng a = 0.3 //> Output: a = 0.30000000000000004

  03 cũng tương tự như

  let a = 0.1 + 0.2; //> Bạn nghĩ rằng a = 0.3 //> Output: a = 0.30000000000000004

  02 nhưng không có tham số

  let a = 0.1 + 0.2; //> Bạn nghĩ rằng a = 0.3 //> Output: a = 0.30000000000000004 05, tham số thứ hai là độ dài của chuỗi bạn muốn cắt. Nó cũng nhận tham số bắt đầu là số âm, nếu không xác định độ dài chuỗi muốn cắt thì nó sẽ tính từ vị trí bắt đầu ta truyền vào cho đến hết chuỗi.

let total = (0.1 * 10 + 0.2 * 10)/10
//-->Output: total = 0.3

0

4. Thay thế chuỗi.

Trong quá trình taho tác với chuỗi, nếu muốn thay thế một đoạn chuỗi nhỏ nào đó trong một chuỗi lớn thì ta có thể dùng hàm

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

06.

let total = (0.1 * 10 + 0.2 * 10)/10
//-->Output: total = 0.3

1

5. Chuyển sang chuỗi hoa hoặc chuỗi thường.

Để chuyển đoạn chuỗi sang chuỗi in hoa ta sử dụng phương thức

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

07, in thường dùng

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

08.

let total = (0.1 * 10 + 0.2 * 10)/10
//-->Output: total = 0.3

2

6. Nối chuỗi.

Để nối chuỗi ta sử dụng hàm

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

09:

let total = (0.1 * 10 + 0.2 * 10)/10
//-->Output: total = 0.3

3

Ngoài ra còn một cách đơn giản là ta sử dụng dấu

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

10 😁.

let total = (0.1 * 10 + 0.2 * 10)/10
//-->Output: total = 0.3

4

7. Xóa khoảng trắng hai bên chuỗi.

Để xóa khoảng trắng hai bên chuỗi ta dùng hàm

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

11. Thường ta có thể dùng phương thức để xóa các khoảng trống mà người dùng nhập thừa đấy 😉.

let total = (0.1 * 10 + 0.2 * 10)/10
//-->Output: total = 0.3

5

8. Cách lấy từng giá trị trong chuỗi.

Một chuỗi thì chung quy lại nó cũng chỉ là một mảng chứa các ký tự, do đó để lấy các giá trị trong chuỗi ta dùng

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

12 hoặc hàm

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

13.

let total = (0.1 * 10 + 0.2 * 10)/10
//-->Output: total = 0.3

6

9. Lấy UTF-16 code tại vị trí bất kì trong chuỗi.

Để lấy bất kỳ các code UTF-16 tại các vị trí bất kỳ trong chuỗi ta dùng hàm

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

14.

let total = (0.1 * 10 + 0.2 * 10)/10
//-->Output: total = 0.3

7

10. Chuyển chuỗi sang mảng.

Để chuyển một chuỗi sang dạng mảng ta sử dụng hàm

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

15, tham số đầu vào của hàm là một chuỗi để ngăn cách.

let total = (0.1 * 10 + 0.2 * 10)/10
//-->Output: total = 0.3

8

III. Array.

Array hay mảng là một tập hợp các phần tử, mỗi phần tử sẽ được đánh dấu thứ tự bằng chỉ mục hay index và index bắt đầu từ

Number("200"); //--> 200
Number(2.2);   //--> 2.2
Number(2,2);   //--> NaN
Number(2 2);   //--> NaN
Number("Alice"); //--> NaN
Number(true);  //--> 1
Number(false); //--> 0

7.

1. Lấy độ dài của mảng.

Tương tự chuỗi, để lấy độ dài của mảng ta dùng phương thức

Number("200"); //--> 200
Number(2.2);   //--> 2.2
Number(2,2);   //--> NaN
Number(2 2);   //--> NaN
Number("Alice"); //--> NaN
Number(true);  //--> 1
Number(false); //--> 0

3.

let total = (0.1 * 10 + 0.2 * 10)/10
//-->Output: total = 0.3

9

2. Kiểm tra biến có chứa dữ liệu dạng mảng hay không.

Để check xem một biến có chứa data dạng mảng hay không, ta dùng hàm

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

18 hoặc

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

19.

let num = 2021;
num.toString();
//-->Output: "2021"

0

3. Chuyển mảng sang chuỗi.

Để chuyển một mảng sang một chuỗi ta dùng hàm

let num = 4 / 0;
//--> Output: -Infinity

9 hoặc

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

21

let num = 2021;
num.toString();
//-->Output: "2021"

1

4. Thêm phần tử vào cuối mảng.

Add một phần tử mới vào mảng ta sử dụng hàm

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

22, ngoài add thêm phần tử vào mảng nó còn

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

23 lại độ dài của mảng mới.

let num = 2021;
num.toString();
//-->Output: "2021"

2

5. Xóa phần tử ở cuối mảng.

Để xóa một phần tử ở cuối mảng, ta dùng hàm

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

24 và nó return lại giá trị mà nó vừa xóa.

let num = 2021;
num.toString();
//-->Output: "2021"

3

6. Thêm phần tử vào đầu mảng.

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

25 cho phép ta thêm 1 phần tử mới vào đầu mảng và

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

23 lại chiều dài mảng mới.

let num = 2021;
num.toString();
//-->Output: "2021"

4

7. Xóa phần tử ở đầu mảng.

Với hàm

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

27 ta có thể xóa phần tử đầu tiên của mảng và đồng thời

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

23 lại phần tử vừa xóa.

let num = 2021;
num.toString();
//-->Output: "2021"

5

Lưu ý: ta cũng có thể dùng

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

29 operator để xóa bất kỳ phần tử nào có trong mảng. Tuy nhiên chỉ giá trị của phần tử được xóa nên lại để lại một khoảng trống trong mảng. Khi ta truy xuất đến khoảng trống này, ta nhận được giá trị của nó là

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

30.

let num = 2021;
num.toString();
//-->Output: "2021"

6

8. Thêm hoặc xóa nhiều phần tử trong 1 mảng.

Với hàm

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

31, ta có thể thêm hoặc xóa nhiều phần tử trong mảng và return lại mảng với các phần tử mà ta đã xóa.

cú pháp của nó như sau:

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

32

let num = 2021;
num.toString();
//-->Output: "2021"

7

let num = 2021;
num.toString();
//-->Output: "2021"

8

9. Ghép mảng.

Hàm

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

09 cũng có thể ghép 2 mảng lại với nhau.

let num = 2021;
num.toString();
//-->Output: "2021"

9

10. Tách mảng

Muốn tách mảng thì ta sử dụng hàm

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

02, với cú pháp:

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

35

let num = 240;
//Nhị phân
num.toString(2); //-->Output: "11110000"
//Bát phân
num.toString(8); //-->Output: "360"
//Thập phân
num.toString(10); //-->Output: "240"
//Thập lục phân
num.toString(16); //-->Output: "f0"

0

11. Spread operator.

Đây là một khái niệm mới đây, được ra mắt từ ES6 (ES2015), nó phân rã mảng (object) thành từng phần tử nhỏ ( ví dụ: [1,2,3] => 1,2,3).

let num = 240;
//Nhị phân
num.toString(2); //-->Output: "11110000"
//Bát phân
num.toString(8); //-->Output: "360"
//Thập phân
num.toString(10); //-->Output: "240"
//Thập lục phân
num.toString(16); //-->Output: "f0"

1

Hiện nay Spread operator được sử dụng thương xuyên trong lập trình và thao tác với mảng đấy 😉.

12. Lặp mảng.

Lặp mảng hay duyệt mảng thì đây là cách thức ta thường phải sử dụng để thao tác với mảng, ngoài

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

36 thông thường, ta còn có

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

37,

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

38,

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

39,

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

40,

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

41,

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

42,

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

43. Cùng nhau tìm hiểu từng loại một nhé 😁.

forEach(): Lặp qua từng phần tử có trong mảng. Tham số truyền vào

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

44 là một callback function với 3 đối số gồm:

• Giá trị phần tử.
• Index của phần tử.
• Mảng đang thực hiện.

let num = 240;
//Nhị phân
num.toString(2); //-->Output: "11110000"
//Bát phân
num.toString(8); //-->Output: "360"
//Thập phân
num.toString(10); //-->Output: "240"
//Thập lục phân
num.toString(16); //-->Output: "f0"

2

map(): cho phép tạo một mảng mới bằng cách thực hiện tính toán trên mỗi phần tử,

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

38 không làm thay đổi mảng cũ.

let num = 240;
//Nhị phân
num.toString(2); //-->Output: "11110000"
//Bát phân
num.toString(8); //-->Output: "360"
//Thập phân
num.toString(10); //-->Output: "240"
//Thập lục phân
num.toString(16); //-->Output: "f0"

3

filter(): cho phép tạo một mảng mới với những phần tử nào thỏa điều kiện ta đặt ra. Hàm này thường được dùng để tìm kiếm phần tử trong mảng.

let num = 240;
//Nhị phân
num.toString(2); //-->Output: "11110000"
//Bát phân
num.toString(8); //-->Output: "360"
//Thập phân
num.toString(10); //-->Output: "240"
//Thập lục phân
num.toString(16); //-->Output: "f0"

4

find(): Hàm này trả về phần tử thỏa điều kiện đầu tiên, nếu không có sẽ

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

46. Thường dùng hàm này để tìm kiếm phần tử trong mảng.

let num = 240;
//Nhị phân
num.toString(2); //-->Output: "11110000"
//Bát phân
num.toString(8); //-->Output: "360"
//Thập phân
num.toString(10); //-->Output: "240"
//Thập lục phân
num.toString(16); //-->Output: "f0"

5

findIndex(): Hàm này trả về index của phần tử thỏa điều kiện đầu tiên, nếu không có sẽ

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

47

let num = 240;
//Nhị phân
num.toString(2); //-->Output: "11110000"
//Bát phân
num.toString(8); //-->Output: "360"
//Thập phân
num.toString(10); //-->Output: "240"
//Thập lục phân
num.toString(16); //-->Output: "f0"

6

every(): Nếu mọi phần tử thỏa điều kiện sẽ

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

48, còn không sẽ

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

49, đơn giản vậy thôi 😁.

let num = 240;
//Nhị phân
num.toString(2); //-->Output: "11110000"
//Bát phân
num.toString(8); //-->Output: "360"
//Thập phân
num.toString(10); //-->Output: "240"
//Thập lục phân
num.toString(16); //-->Output: "f0"

7

some(): Nếu có một phần tử bất kỳ nào thỏa điều kiện thì sẽ

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

48, còn không thì sẽ

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

49.

let num = 240;
//Nhị phân
num.toString(2); //-->Output: "11110000"
//Bát phân
num.toString(8); //-->Output: "360"
//Thập phân
num.toString(10); //-->Output: "240"
//Thập lục phân
num.toString(16); //-->Output: "f0"

8

13. Lấy index của phần tử mảng.

Để lấy giá trị

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

52 của phần tử có trong mảng ta dùng hàm

Number("200"); //--> 200
Number(2.2);   //--> 2.2
Number(2,2);   //--> NaN
Number(2 2);   //--> NaN
Number("Alice"); //--> NaN
Number(true);  //--> 1
Number(false); //--> 0

4 và truyền vào giá trị mà bạn muốn lấy index.

let num = 240;
//Nhị phân
num.toString(2); //-->Output: "11110000"
//Bát phân
num.toString(8); //-->Output: "360"
//Thập phân
num.toString(10); //-->Output: "240"
//Thập lục phân
num.toString(16); //-->Output: "f0"

9

14. Kiểm tra phần tử có trong mảng hay không.

Để check xem phần tử nào đó có trong mảng hay không ta dùng hàm

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

54 và truyền vào giá trị bạn muốn tìm. Nếu có nó sẽ

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

48 không thì

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

49

typeof Infinity; //--> Output: "number"
let a = 5/ 0;
//--> Output a = Infinity
let num = 5;
while(num != Infinity) {
  num = num * num;
    console.log(num);
}
//--> Output:
/*
25
625
390625
152587890625
2.3283064365386964e+22
5.421010862427523e+44
2.9387358770557196e+89
8.636168555094449e+178
Infinity
*/

0

IV. Object.

Entry của object là cặp

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

57,

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

58 tương ứng, entry còn được coi như là property (thuộc tính) của object.

Key của object luôn là

let num = 4 / 0;
//--> Output: -Infinity

8 hoặc

let num = 4 / 0;
//--> Output: -Infinity

6.

Value của object thì có thể thuộc bất cứ kiểu dữ liệu nào kể cả là function.

Method hay phương thức là những thuộc tính mà value của nó là function

1. prototype object

Prototype là một cơ chế của JavaScript, giúp object thừa kế các tính năng của object khác.

Ngoài các kiểu dữ liệu trong JavaScript mà ta đã biết thì nó cũng như bao ngôn ngữ lập trình khá còn có các object kiểu dữ liệu như

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

61,

let x = 199 / "Not a number";
isNaN(x); //--> Output: true

9,

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

63. Mảng là một object dạng

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

64 còn function là một object

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

65.

Để dễ hiểu hơn, chúng ta cùng xem ví dụ và giải thích nhé 😉.

typeof Infinity; //--> Output: "number"
let a = 5/ 0;
//--> Output a = Infinity
let num = 5;
while(num != Infinity) {
  num = num * num;
    console.log(num);
}
//--> Output:
/*
25
625
390625
152587890625
2.3283064365386964e+22
5.421010862427523e+44
2.9387358770557196e+89
8.636168555094449e+178
Infinity
*/

1

typeof Infinity; //--> Output: "number"
let a = 5/ 0;
//--> Output a = Infinity
let num = 5;
while(num != Infinity) {
  num = num * num;
    console.log(num);
}
//--> Output:
/*
25
625
390625
152587890625
2.3283064365386964e+22
5.421010862427523e+44
2.9387358770557196e+89
8.636168555094449e+178
Infinity
*/

2

typeof Infinity; //--> Output: "number"
let a = 5/ 0;
//--> Output a = Infinity
let num = 5;
while(num != Infinity) {
  num = num * num;
    console.log(num);
}
//--> Output:
/*
25
625
390625
152587890625
2.3283064365386964e+22
5.421010862427523e+44
2.9387358770557196e+89
8.636168555094449e+178
Infinity
*/

3

Thử thêm một phương thức vào object được tạo từ một constructor function

typeof Infinity; //--> Output: "number"
let a = 5/ 0;
//--> Output a = Infinity
let num = 5;
while(num != Infinity) {
  num = num * num;
    console.log(num);
}
//--> Output:
/*
25
625
390625
152587890625
2.3283064365386964e+22
5.421010862427523e+44
2.9387358770557196e+89
8.636168555094449e+178
Infinity
*/

4

Ta có thể edit prototype của một function thông qua object được tạo từ function đó bằng

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

66 như sau:

typeof Infinity; //--> Output: "number"
let a = 5/ 0;
//--> Output a = Infinity
let num = 5;
while(num != Infinity) {
  num = num * num;
    console.log(num);
}
//--> Output:
/*
25
625
390625
152587890625
2.3283064365386964e+22
5.421010862427523e+44
2.9387358770557196e+89
8.636168555094449e+178
Infinity
*/

5

2. Truy xuất, thêm, xóa, sửa thuộc tính của object.

typeof Infinity; //--> Output: "number"
let a = 5/ 0;
//--> Output a = Infinity
let num = 5;
while(num != Infinity) {
  num = num * num;
    console.log(num);
}
//--> Output:
/*
25
625
390625
152587890625
2.3283064365386964e+22
5.421010862427523e+44
2.9387358770557196e+89
8.636168555094449e+178
Infinity
*/

6

3. Merge object.

Để merge 2 object lại với nhau ta dùng phương thức

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

67.

typeof Infinity; //--> Output: "number"
let a = 5/ 0;
//--> Output a = Infinity
let num = 5;
while(num != Infinity) {
  num = num * num;
    console.log(num);
}
//--> Output:
/*
25
625
390625
152587890625
2.3283064365386964e+22
5.421010862427523e+44
2.9387358770557196e+89
8.636168555094449e+178
Infinity
*/

7

Spread operator cũng có thể dùng để shallow copy hoặc merge object lại nhé 😁

typeof Infinity; //--> Output: "number"
let a = 5/ 0;
//--> Output a = Infinity
let num = 5;
while(num != Infinity) {
  num = num * num;
    console.log(num);
}
//--> Output:
/*
25
625
390625
152587890625
2.3283064365386964e+22
5.421010862427523e+44
2.9387358770557196e+89
8.636168555094449e+178
Infinity
*/

8

4. Lấy các key của object.

Để lấy tất cả các key của một object ta dùng phương thức

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

68, nó sẽ return một mảng chứa tất cả các key của object đó.

typeof Infinity; //--> Output: "number"
let a = 5/ 0;
//--> Output a = Infinity
let num = 5;
while(num != Infinity) {
  num = num * num;
    console.log(num);
}
//--> Output:
/*
25
625
390625
152587890625
2.3283064365386964e+22
5.421010862427523e+44
2.9387358770557196e+89
8.636168555094449e+178
Infinity
*/

9

5. Lấy các value của object.

Để lấy tất cả các value của một object ta dùng phương thức

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

69, nó sẽ return một mảng chứa tất cả các value của object đó.

let num = 4 / 0;
//--> Output: -Infinity

0

V. Tổng kết.

Bài viết tuy hơi dài, nhưng mình đã cố gắng giới thiệu cho các bạn những phương thức thừng hay sử dụng để thao tác với các data là

let num = 4 / 0;
//--> Output: -Infinity

6,

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

71,

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

72 hay

let a = 0.1 + 0.2;
//--> Bạn nghĩ rằng a = 0.3
//--> Output: a = 0.30000000000000004

73 trong khi học hay làm việc với ngôn ngữ JavaScript, ngoài ra còn nhiều phương thức khác nữa đó nha, bấy nhiêu đó chưa có hết đâu 😁. Tuy vậy, mình hy vọng bài viết này sẽ có ích cho các bạn, cảm ơn các bạn đã đọc 🤗.