Hướng dẫn object to string javascript - đối tượng với chuỗi javascript

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

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

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

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

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

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

Đối với số nguyên trong JavaScript nó có độ chính xác đến 15 con số, cụ thể như sau: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: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é 😉.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é 😁.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

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

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

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

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

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

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

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"

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

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

typeof NaN; //--> Output: "number"

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

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"

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

3. NaN - Not a Number.

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

typeof NaN; //--> Output: "number"

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

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

typeof NaN; //--> Output: "number"

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"

let x = 199 / "Not a number";

isNaN(x); //--> Output: true

let x = 199 / "Not a number";

isNaN(x); //--> Output: true

let x = 199 / "Not a number";

isNaN(x); //--> Output: true

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

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

• 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

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

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

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

II. String.

let x = 199 / "Not a number";

isNaN(x); //--> Output: true

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

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

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

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

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ư:

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

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

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

• 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

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

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

À 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

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

• 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

• 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

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

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

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

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

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

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

let total = (0.1 * 10 + 0.2 * 10)/10
//-->Output: total = 0.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

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

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

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

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

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

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

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

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

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

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

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

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. 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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"

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).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"

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 😉.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

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

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

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

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

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

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

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

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

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

• 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"

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

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

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"

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.: 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"

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

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

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"

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

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

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"

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

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

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

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

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"

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

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

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

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

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"

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

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 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"

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

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

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

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

2.3283064365386964e+22
5.421010862427523e+44
2.9387358770557196e+89
8.636168555094449e+178
Infinity
*/

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

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

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

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

Key của object luôn là

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

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

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

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

Value của object thì có thể thuộc bất cứ kiểu dữ liệu nào kể cả là function. 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à functionhay 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

let x = 199 / "Not a number";

isNaN(x); //--> Output: true

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

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

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

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

let x = 199 / "Not a number";

isNaN(x); //--> Output: true

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

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

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

Để 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

2.3283064365386964e+22
5.421010862427523e+44
2.9387358770557196e+89
8.636168555094449e+178
Infinity
*/

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

2.3283064365386964e+22
5.421010862427523e+44
2.9387358770557196e+89
8.636168555094449e+178
Infinity
*/

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

2.3283064365386964e+22
5.421010862427523e+44
2.9387358770557196e+89
8.636168555094449e+178
Infinity
*/

Thử thêm một phương thức vào object được tạo từ một constructor functionconstructor 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

2.3283064365386964e+22
5.421010862427523e+44
2.9387358770557196e+89
8.636168555094449e+178
Infinity
*/

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

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

2.3283064365386964e+22
5.421010862427523e+44
2.9387358770557196e+89
8.636168555094449e+178
Infinity
*/

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

2.3283064365386964e+22
5.421010862427523e+44
2.9387358770557196e+89
8.636168555094449e+178
Infinity
*/

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

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

2.3283064365386964e+22
5.421010862427523e+44
2.9387358770557196e+89
8.636168555094449e+178
Infinity
*/

Spread operator cũng có thể dùng để  shallow copy hoặc merge object lại nhé 😁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

2.3283064365386964e+22
5.421010862427523e+44
2.9387358770557196e+89
8.636168555094449e+178
Infinity
*/

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

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

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

2.3283064365386964e+22
5.421010862427523e+44
2.9387358770557196e+89
8.636168555094449e+178
Infinity
*/

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

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

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

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

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

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

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