Hướng dẫn what is data types in javascript? - 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Nhiều phương pháp, chẳng hạn như

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

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

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

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

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

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

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

Loại chuỗi

Loại

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

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

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

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

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

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

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

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:

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

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.

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

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.

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

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

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

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

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

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:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Xem thêm