Hướng dẫn what are the data types in javascript? - các kiểu dữ liệu trong javascript là gì?

Gõ động và yếu

JavaScript là một ngôn ngữ động với các loại động. Các biến trong JavaScript không được liên kết trực tiếp với bất kỳ loại giá trị cụ thể nào và bất kỳ biến nào cũng có thể được gán (và được gán lại) của tất cả các loại:

let foo = 42; // foo is now a number foo = "bar"; // foo is now a string foo = true; // foo is now a boolean

JavaScript cũng là một ngôn ngữ được đánh máy yếu, có nghĩa là nó cho phép chuyển đổi loại ẩn khi một thao tác liên quan đến các loại không khớp, thay vì ném các lỗi loại.

const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421

Sự ép buộc ngầm rất thuận tiện, nhưng có thể là một bước chân tiềm năng nếu các nhà phát triển không có ý định thực hiện chuyển đổi hoặc có ý định chuyển đổi theo hướng khác (ví dụ: chuỗi thành số thay vì số thành chuỗi). Đối với các biểu tượng và lớn, JavaScript đã cố tình không cho phép chuyển đổi loại ngầm định.

Giá trị nguyên thủy

Tất cả các loại ngoại trừ đối tượng xác định các giá trị bất biến được biểu thị trực tiếp ở mức thấp nhất của ngôn ngữ. Chúng tôi đề cập đến các giá trị của các loại này là giá trị nguyên thủy.

Tất cả các loại nguyên thủy, ngoại trừ null, có thể được kiểm tra bởi toán tử typeof. typeof null Trả về "object", vì vậy người ta phải sử dụng === null để kiểm tra null.

Tất cả các loại nguyên thủy, ngoại trừ null và const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2, có các loại trình bao bọc đối tượng tương ứng của chúng, cung cấp các phương pháp hữu ích để làm việc với các giá trị nguyên thủy. Ví dụ: đối tượng const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 3 cung cấp các phương thức như const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 4. Khi một thuộc tính được truy cập trên một giá trị nguyên thủy, JavaScript sẽ tự động kết thúc giá trị vào đối tượng trình bao bọc tương ứng và thay vào đó truy cập vào thuộc tính trên đối tượng. Tuy nhiên, việc truy cập một thuộc tính trên null hoặc const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2 ném một ngoại lệ const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 7, đòi hỏi phải giới thiệu toán tử chuỗi tùy chọn.

console.log(42 / +0); // Infinity console.log(42 / -0); // -Infinity 9

// BigInt const x = BigInt(Number.MAX_SAFE_INTEGER); // 9007199254740991n x + 1n === x + 2n; // false because 9007199254740992n and 9007199254740993n are unequal // Number Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2; // true because both are 9007199254740992 0

Các trang tham chiếu của các lớp bao bọc đối tượng chứa nhiều thông tin hơn về các phương thức và thuộc tính có sẵn cho từng loại, cũng như các mô tả chi tiết cho ngữ nghĩa của chính các loại nguyên thủy.

Loại null

Loại NULL được sinh sống bởi chính xác một giá trị: null.

Loại không xác định

• Loại không xác định được sinh sống bởi chính xác một giá trị: const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2.
• Về mặt khái niệm, const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2 chỉ ra sự vắng mặt của một giá trị, trong khi null cho thấy sự vắng mặt của một đối tượng (cũng có thể tạo ra một cái cớ cho // BigInt const x = BigInt(Number.MAX_SAFE_INTEGER); // 9007199254740991n x + 1n === x + 2n; // false because 9007199254740992n and 9007199254740993n are unequal // Number Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2; // true because both are 9007199254740992 5). Ngôn ngữ thường mặc định là const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2 khi một cái gì đó không có giá trị:
• Một câu lệnh // BigInt const x = BigInt(Number.MAX_SAFE_INTEGER); // 9007199254740991n x + 1n === x + 2n; // false because 9007199254740992n and 9007199254740993n are unequal // Number Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2; // true because both are 9007199254740992 7 không có giá trị (// BigInt const x = BigInt(Number.MAX_SAFE_INTEGER); // 9007199254740991n x + 1n === x + 2n; // false because 9007199254740992n and 9007199254740993n are unequal // Number Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2; // true because both are 9007199254740992 8) ngầm trả về const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2.
• Truy cập thuộc tính đối tượng không tồn tại (console.log({} + []); // "[object Object]" 0) trả về const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2.

Một khai báo biến mà không cần khởi tạo (console.log({} + []); // "[object Object]" 2) hoàn toàn khởi tạo biến thành const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2.

Nhiều phương pháp, chẳng hạn như console.log({} + []); // "[object Object]" 4 và console.log({} + []); // "[object Object]" 5, trả về const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2 khi không tìm thấy phần tử nào.

null được sử dụng ít thường xuyên hơn trong ngôn ngữ cốt lõi. Nơi quan trọng nhất là kết thúc của chuỗi nguyên mẫu - sau đó, các phương pháp tương tác với các nguyên mẫu, chẳng hạn như console.log({} + []); // "[object Object]" 8, console.log({} + []); // "[object Object]" 9, v.v., chấp nhận hoặc trả lại null thay vì const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2.

null là một từ khóa, nhưng const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2 là một định danh bình thường xảy ra là một tài sản toàn cầu. Trong thực tế, sự khác biệt là nhỏ, vì const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2 không nên được xác định lại hoặc bị che mờ.

Loại boolean

Loại console.log(42 / +0); // Infinity console.log(42 / -0); // -Infinity 2 đại diện cho một thực thể logic và được sinh sống bởi hai giá trị: null6 và null7.

Các giá trị Boolean thường được sử dụng cho các hoạt động có điều kiện, bao gồm các toán tử ternary, null8, null9, v.v.

Các giá trị bên ngoài phạm vi ± (2-1074 đến 21024) được tự động chuyển đổi:

• Các giá trị dương lớn hơn typeof2 được chuyển đổi thành typeof7.
• Các giá trị dương nhỏ hơn typeof1 được chuyển đổi thành typeof9.
• Các giá trị âm nhỏ hơn -____ ____ 62 được chuyển đổi thành typeof null1.
• Các giá trị âm lớn hơn -____ ____ 61 được chuyển đổi thành typeof null3.

typeof7 và typeof null1 hành xử tương tự như vô cùng toán học, nhưng với một số khác biệt nhỏ; Xem typeof null6 và typeof null7 để biết chi tiết.

Loại số chỉ có một giá trị có nhiều biểu diễn: typeof null8 được biểu diễn dưới dạng cả typeof null3 và typeof9 (trong đó typeof null8 là bí danh đối với typeof9). Trong thực tế, hầu như không có sự khác biệt giữa các đại diện khác nhau; Ví dụ, "object"3 là null6. Tuy nhiên, bạn có thể nhận thấy điều này khi bạn chia cho 0:

console.log(42 / +0); // Infinity console.log(42 / -0); // -Infinity

"object"5 ("Không phải anumber") là một loại giá trị số đặc biệt thường gặp khi kết quả của một hoạt động số học không thể được biểu thị dưới dạng một số. Nó cũng là giá trị duy nhất trong JavaScript không bằng chính nó.Not a Number") is a special kind of number value that's typically encountered when the result of an arithmetic operation cannot be expressed as a number. It is also the only value in JavaScript that is not equal to itself.

Mặc dù một số về mặt khái niệm là "giá trị toán học" và luôn được mã hóa theo điểm nổi, JavaScript cung cấp các toán tử bitwise. Khi áp dụng các toán tử bitwise, số lần đầu tiên được chuyển đổi thành số nguyên 32 bit.

Lưu ý: Mặc dù các toán tử bitwise có thể được sử dụng để biểu thị một số giá trị boolean trong một số sử dụng mặt nạ bit, nhưng đây thường được coi là một thực tế xấu. JavaScript cung cấp các phương tiện khác để đại diện cho một bộ booleans (như một mảng booleans hoặc một đối tượng có giá trị boolean được gán cho các thuộc tính được đặt tên). Mặt nạ bit cũng có xu hướng làm cho mã khó đọc, hiểu và duy trì hơn. Although bitwise operators can be used to represent several Boolean values within a single number using bit masking, this is usually considered a bad practice. JavaScript offers other means to represent a set of Booleans (like an array of Booleans, or an object with Boolean values assigned to named properties). Bit masking also tends to make the code more difficult to read, understand, and maintain.

Có thể cần phải sử dụng các kỹ thuật như vậy trong các môi trường rất hạn chế, như khi cố gắng đối phó với các hạn chế của lưu trữ cục bộ hoặc trong các trường hợp cực đoan (chẳng hạn như khi mỗi bit trên số lượng mạng). Kỹ thuật này chỉ nên được xem xét khi đó là biện pháp cuối cùng có thể được thực hiện để tối ưu hóa kích thước.

Loại lớn

Loại console.log(42 / +0); // Infinity console.log(42 / -0); // -Infinity 6 là một nguyên thủy số trong JavaScript có thể đại diện cho các số nguyên có cường độ tùy ý. Với Bigint, bạn có thể lưu trữ và vận hành một cách an toàn trên các số nguyên lớn thậm chí vượt quá giới hạn số nguyên an toàn (typeof4) cho các số.

Một bigint được tạo ra bằng cách nối thêm "object"8 đến cuối số nguyên hoặc bằng cách gọi hàm "object"9.

Ví dụ này cho thấy việc tăng typeof4 trả về kết quả dự kiến:

// BigInt const x = BigInt(Number.MAX_SAFE_INTEGER); // 9007199254740991n x + 1n === x + 2n; // false because 9007199254740992n and 9007199254740993n are unequal // Number Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2; // true because both are 9007199254740992

Bạn có thể sử dụng hầu hết các nhà khai thác để làm việc với Bigint, bao gồm === null1, === null2, === null3, === null4 và === null5 - người duy nhất bị cấm là === null6. Một bigint không hoàn toàn bằng với một số có cùng giá trị toán học, nhưng nó là như vậy.

Các giá trị lớn không phải lúc nào cũng chính xác hơn cũng như luôn luôn ít chính xác hơn các số, vì Bigint không thể đại diện cho các số phân số, nhưng có thể đại diện cho các số nguyên lớn chính xác hơn. Không loại đòi hỏi phải loại khác, và chúng không thể thay thế lẫn nhau. Một const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 7 được ném nếu các giá trị lớn được trộn với các số thông thường trong các biểu thức số học hoặc nếu chúng được chuyển đổi hoàn toàn với nhau.

Loại chuỗi

Loại console.log(42 / +0); // Infinity console.log(42 / -0); // -Infinity 8 đại diện cho dữ liệu văn bản và được mã hóa dưới dạng một chuỗi các giá trị số nguyên không dấu 16 bit đại diện cho các đơn vị mã UTF-16. Mỗi phần tử trong chuỗi chiếm một vị trí trong chuỗi. Phần tử đầu tiên là tại Index typeof null8, phần tiếp theo tại Index const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 00, v.v. Độ dài của một chuỗi là số lượng đơn vị mã UTF-16 trong đó, có thể không tương ứng với số lượng ký tự unicode thực tế; Xem trang tham chiếu console.log(42 / +0); // Infinity console.log(42 / -0); // -Infinity 8 để biết thêm chi tiết.

Chuỗi JavaScript là bất biến. Điều này có nghĩa là một khi một chuỗi được tạo ra, không thể sửa đổi nó. Các phương thức chuỗi Tạo chuỗi mới dựa trên nội dung của chuỗi hiện tại - ví dụ::

• Một nền tảng của bản gốc bằng cách sử dụng const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 02.
• Một sự kết hợp của hai chuỗi sử dụng toán tử nối (=== null1) hoặc const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 04.

Coi chừng "Tách gõ" mã của bạn!

Nó có thể hấp dẫn để sử dụng các chuỗi để thể hiện dữ liệu phức tạp. Làm điều này đi kèm với lợi ích ngắn hạn:

• Thật dễ dàng để xây dựng các chuỗi phức tạp với sự kết hợp.
• Chuỗi rất dễ gỡ lỗi (những gì bạn thấy in luôn là những gì có trong chuỗi).
• Các chuỗi là mẫu số chung của rất nhiều API (trường đầu vào, giá trị lưu trữ cục bộ, phản hồi const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 05 khi sử dụng const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 06, v.v.) và nó có thể hấp dẫn chỉ hoạt động với các chuỗi.

Với các quy ước, có thể đại diện cho bất kỳ cấu trúc dữ liệu nào trong một chuỗi. Điều này không làm cho nó một ý tưởng tốt. Chẳng hạn, với một dấu phân cách, người ta có thể mô phỏng một danh sách (trong khi một mảng JavaScript sẽ phù hợp hơn). Thật không may, khi dấu phân cách được sử dụng trong một trong các yếu tố "danh sách", thì danh sách bị phá vỡ. Một nhân vật thoát có thể được chọn, v.v ... Tất cả điều này đòi hỏi các quy ước và tạo ra gánh nặng bảo trì không cần thiết.

Sử dụng chuỗi cho dữ liệu văn bản. Khi đại diện cho dữ liệu phức tạp, các chuỗi phân tích cú pháp và sử dụng sự trừu tượng phù hợp.

Loại ký hiệu

// BigInt const x = BigInt(Number.MAX_SAFE_INTEGER); // 9007199254740991n x + 1n === x + 2n; // false because 9007199254740992n and 9007199254740993n are unequal // Number Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2; // true because both are 9007199254740992 0 là một giá trị nguyên thủy độc đáo và bất biến và có thể được sử dụng làm khóa của thuộc tính đối tượng (xem bên dưới). Trong một số ngôn ngữ lập trình, các biểu tượng được gọi là "nguyên tử". Mục đích của các biểu tượng là tạo các khóa thuộc tính độc đáo được đảm bảo không đụng độ với các khóa từ mã khác.unique and immutable primitive value and may be used as the key of an Object property (see below). In some programming languages, Symbols are called "atoms". The purpose of symbols is to create unique property keys that are guaranteed not to clash with keys from other code.

Các đối tượng

Trong khoa học máy tính, một đối tượng là một giá trị trong bộ nhớ có thể được tham chiếu bởi một định danh. Trong JavaScript, các đối tượng là các giá trị có thể thay đổi duy nhất. Trên thực tế, các chức năng cũng là đối tượng với khả năng bổ sung có thể gọi được.

Đặc tính

Trong JavaScript, các đối tượng có thể được coi là một tập hợp các thuộc tính. Với cú pháp theo nghĩa đen của đối tượng, một tập hợp các thuộc tính giới hạn được khởi tạo; sau đó các thuộc tính có thể được thêm và loại bỏ. Thuộc tính đối tượng tương đương với các cặp giá trị khóa. Khóa tài sản là chuỗi hoặc ký hiệu. Giá trị thuộc tính có thể là giá trị của bất kỳ loại nào, bao gồm các đối tượng khác, cho phép xây dựng các cấu trúc dữ liệu phức tạp.

Có hai loại thuộc tính đối tượng: thuộc tính dữ liệu và thuộc tính của người truy cập. Mỗi thuộc tính có các thuộc tính tương ứng. Mỗi thuộc tính được truy cập nội bộ bởi công cụ JavaScript, nhưng bạn có thể đặt chúng thông qua const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 08 hoặc đọc chúng thông qua const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 09. Bạn có thể đọc thêm về các sắc thái khác nhau trên trang const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 08.

Thuộc tính dữ liệu

Thuộc tính dữ liệu liên kết một khóa với một giá trị. Nó có thể được mô tả bằng các thuộc tính sau:

Giá trị được lấy bằng cách truy cập tài sản. Có thể là bất kỳ giá trị JavaScript.

Một giá trị boolean cho biết nếu thuộc tính có thể được thay đổi với một gán.

Một giá trị boolean cho biết nếu thuộc tính có thể được liệt kê bằng vòng lặp const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 14. Xem thêm Khả năng và quyền sở hữu các thuộc tính để biết cách tính khả năng tương tác với các chức năng và cú pháp khác.

Một giá trị boolean cho biết nếu thuộc tính có thể bị xóa, có thể được thay đổi thành thuộc tính accessor và có thể thay đổi thuộc tính của nó.

Tài sản của người truy cập

Liên kết một khóa với một trong hai hàm truy cập (const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 16 và const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 17) để truy xuất hoặc lưu trữ một giá trị.

Lưu ý: Điều quan trọng là phải nhận ra thuộc tính của nó - không phải phương thức excessor. Chúng ta có thể cung cấp cho một trình truy cập giống như lớp đối tượng JavaScript bằng cách sử dụng hàm làm giá trị-nhưng điều đó không làm cho đối tượng trở thành một lớp. It's important to recognize it's accessor property — not accessor method. We can give a JavaScript object class-like accessors by using a function as a value — but that doesn't make the object a class.

Thuộc tính Accessor có các thuộc tính sau:

Một hàm được gọi với một danh sách đối số trống để truy xuất giá trị thuộc tính bất cứ khi nào nhận được quyền truy cập vào giá trị được thực hiện. Xem thêm Getters. Có thể là const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2.

Một hàm được gọi với một đối số chứa giá trị được gán. Được thực hiện bất cứ khi nào một thuộc tính được chỉ định được cố gắng thay đổi. Xem thêm Setters. Có thể là const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2.

Một giá trị boolean cho biết nếu thuộc tính có thể được liệt kê bằng vòng lặp const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 14. Xem thêm Khả năng và quyền sở hữu các thuộc tính để biết cách tính khả năng tương tác với các chức năng và cú pháp khác.

Tài sản của người truy cập

Liên kết một khóa với một trong hai hàm truy cập (const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 16 và const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 17) để truy xuất hoặc lưu trữ một giá trị.

Lưu ý: Điều quan trọng là phải nhận ra thuộc tính của nó - không phải phương thức excessor. Chúng ta có thể cung cấp cho một trình truy cập giống như lớp đối tượng JavaScript bằng cách sử dụng hàm làm giá trị-nhưng điều đó không làm cho đối tượng trở thành một lớp.

Thuộc tính Accessor có các thuộc tính sau:

Một hàm được gọi với một danh sách đối số trống để truy xuất giá trị thuộc tính bất cứ khi nào nhận được quyền truy cập vào giá trị được thực hiện. Xem thêm Getters. Có thể là const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2.

Một hàm được gọi với một đối số chứa giá trị được gán. Được thực hiện bất cứ khi nào một thuộc tính được chỉ định được cố gắng thay đổi. Xem thêm Setters. Có thể là const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 2.

const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 13

const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 15

Giá trị boolean cho biết nếu thuộc tính có thể bị xóa, có thể được thay đổi thành thuộc tính dữ liệu và có thể thay đổi thuộc tính của nó.

Bộ sưu tập khóa: Bản đồ, bộ, yếu, yếu

Các cấu trúc dữ liệu này lấy tài liệu tham khảo đối tượng làm khóa. const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 39 và const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 40 đại diện cho một tập hợp các giá trị duy nhất, trong khi const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 28 và const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 42 đại diện cho một bộ sưu tập các hiệp hội giá trị khóa.

Bạn có thể tự mình thực hiện const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 28S và const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 39s. Tuy nhiên, vì các đối tượng không thể được so sánh (theo nghĩa của const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 45 "ít hơn", ví dụ), thì động cơ cũng không làm lộ hàm băm của nó cho các đối tượng, hiệu suất tra cứu sẽ nhất thiết phải là tuyến tính. Các triển khai bản địa của chúng (bao gồm const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 42) có thể có hiệu suất tra cứu xấp xỉ logarit đến không đổi.

Thông thường, để liên kết dữ liệu với một nút DOM, người ta có thể đặt các thuộc tính trực tiếp trên đối tượng hoặc sử dụng các thuộc tính const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 47. Điều này có nhược điểm là dữ liệu có sẵn cho bất kỳ tập lệnh nào chạy trong cùng một bối cảnh. const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 28S và const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 42S giúp dễ dàng liên kết dữ liệu với một đối tượng.

const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 42 và const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 40 chỉ cho phép các phím đối tượng và các phím được phép thu thập rác ngay cả khi chúng vẫn còn trong bộ sưu tập. Chúng được sử dụng cụ thể để tối ưu hóa sử dụng bộ nhớ.

Dữ liệu có cấu trúc: JSON

JSON (ký hiệu đối tượng JavaScript) là một định dạng giữa các dữ liệu nhẹ, có nguồn gốc từ JavaScript, nhưng được sử dụng bởi nhiều ngôn ngữ lập trình. JSON xây dựng các cấu trúc dữ liệu phổ quát có thể được chuyển giữa các môi trường khác nhau và thậm chí trên các ngôn ngữ. Xem const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 52 để biết thêm chi tiết.JavaScript Object Notation) is a lightweight data-interchange format, derived from JavaScript, but used by many programming languages. JSON builds universal data structures that can be transferred between different environments and even across languages. See const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 52 for more details.

Nhiều đối tượng hơn trong thư viện tiêu chuẩn

JavaScript có một thư viện tiêu chuẩn của các đối tượng tích hợp. Đọc tham chiếu để tìm hiểu thêm về các đối tượng tích hợp.

Loại cưỡng chế

Như đã đề cập ở trên, JavaScript là một ngôn ngữ được đánh máy yếu. Điều này có nghĩa là bạn thường có thể sử dụng một giá trị của một loại trong đó loại khác được mong đợi và ngôn ngữ sẽ chuyển đổi nó thành đúng loại cho bạn. Để làm như vậy, JavaScript xác định một số quy tắc cưỡng chế.

Cưỡng chế nguyên thủy

Quá trình ép buộc nguyên thủy được sử dụng khi dự kiến ​​giá trị nguyên thủy, nhưng không có ưu tiên mạnh mẽ nào cho loại thực tế nên là gì. Điều này thường là khi một chuỗi, một số hoặc một bigint có thể chấp nhận như nhau. Ví dụ:

• Chất xây dựng const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 53, khi nhận được một đối số không phải là một ví dụ const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 30 - chuỗi đại diện cho các chuỗi ngày, trong khi các số đại diện cho dấu thời gian.
• Toán tử === null1 - nếu một toán hạng là một chuỗi, kết nối chuỗi được thực hiện; Nếu không, bổ sung số được thực hiện.
• Toán tử const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 56 - Nếu một toán hạng là nguyên thủy trong khi phần còn lại là đối tượng, đối tượng được chuyển đổi thành giá trị nguyên thủy không có loại ưu tiên.

Hoạt động này không thực hiện bất kỳ chuyển đổi nào nếu giá trị đã là nguyên thủy. Các đối tượng được chuyển đổi thành nguyên thủy bằng cách gọi const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 57 của nó (với const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 58 là gợi ý), const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 59 và const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 60, theo thứ tự đó. Lưu ý rằng chuyển đổi nguyên thủy gọi const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 59 trước const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 60, tương tự như hành vi ép buộc số nhưng khác với ép buộc chuỗi.

Phương pháp const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 57, nếu có, phải trả về nguyên thủy - trả về một đối tượng dẫn đến const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 7. Đối với const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 59 và const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 60, nếu một người trả về một đối tượng, giá trị trả về bị bỏ qua và giá trị trả về của kia được sử dụng thay thế; Nếu không có mặt, hoặc không trả lại nguyên thủy, một const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 7 sẽ bị ném. Ví dụ: trong mã sau:

console.log({} + []); // "[object Object]"

Cả const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 68 và const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 69 đều không có phương pháp const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 57. Cả const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 68 và const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 69 kế thừa const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 59 từ const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 74, trả về chính đối tượng. Vì giá trị trả về là một đối tượng, nó bị bỏ qua. Do đó, const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 60 được gọi thay thế. const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 76 Trả về const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 77, trong khi const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 78 trả về const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 79, vì vậy kết quả là sự kết hợp của chúng: const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 77.

Phương pháp const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 57 luôn được ưu tiên khi chuyển đổi sang bất kỳ loại nguyên thủy nào. Chuyển đổi nguyên thủy thường hoạt động như chuyển đổi số, bởi vì const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 59 được gọi là ưu tiên; Tuy nhiên, các đối tượng có các phương thức tùy chỉnh const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 57 có thể chọn trả về bất kỳ nguyên thủy nào. Các đối tượng const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 30 và // BigInt const x = BigInt(Number.MAX_SAFE_INTEGER); // 9007199254740991n x + 1n === x + 2n; // false because 9007199254740992n and 9007199254740993n are unequal // Number Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2; // true because both are 9007199254740992 0 là các đối tượng duy nhất tích hợp ghi đè phương thức const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 57. const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 87 đối xử với gợi ý const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 58 như thể đó là console.log(42 / +0); // Infinity console.log(42 / -0); // -Infinity 7, trong khi const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 90 bỏ qua gợi ý và luôn trả về một biểu tượng.

Cưỡng chế số

Có hai loại số: số và lớn. Đôi khi ngôn ngữ cụ thể mong đợi một số hoặc một bigint (chẳng hạn như const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 91, trong đó chỉ mục phải là một số); Những lần khác, nó có thể chịu đựng được và thực hiện các hoạt động khác nhau tùy thuộc vào loại của toán hạng. Đối với các quy trình ép buộc nghiêm ngặt không cho phép chuyển đổi ngầm từ loại khác, hãy xem sự ép buộc số và cưỡng chế Bigint.

Sự ép buộc số gần giống với sự ép buộc số, ngoại trừ việc Bigint được trả lại như-là thay vì gây ra const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 7. Sự ép buộc số được sử dụng bởi tất cả các toán tử số học, vì chúng bị quá tải cho cả số và bigint. Ngoại lệ duy nhất là Unary Plus, luôn luôn ép buộc số lượng.

Cưỡng chế khác

Tất cả các loại dữ liệu, ngoại trừ NULL, không xác định và biểu tượng, có quá trình ép buộc tương ứng của chúng. Xem Chuỗi ép buộc, ép buộc Boolean và ép buộc đối tượng để biết thêm chi tiết.

Như bạn có thể nhận thấy, có ba đường dẫn riêng biệt mà qua đó các đối tượng có thể được chuyển đổi thành nguyên thủy:

• Sự ép buộc nguyên thủy: const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 93 → const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 59 → const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 60
• Cưỡng chế số, ép buộc số, ép buộc Bigint: const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 96 → const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 59 → const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 60
• Chuỗi ép buộc: const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 99 → const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 60 → const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 59

Trong mọi trường hợp, const foo = 42; // foo is a number const result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operand console.log(result); // 421 57, nếu có, phải được gọi và trả lại nguyên thủy, trong khi console.log(42 / +0); // Infinity console.log(42 / -0); // -Infinity 03 hoặc console.log(42 / +0); // Infinity console.log(42 / -0); // -Infinity 04 sẽ bị bỏ qua nếu chúng không thể gọi được hoặc trả về một đối tượng. Vào cuối quá trình, nếu thành công, kết quả được đảm bảo là nguyên thủy. Kết quả nguyên thủy sau đó phải chịu sự ép buộc hơn nữa tùy thuộc vào bối cảnh.

Xem thêm