Hướng dẫn what is value type in javascript? - loại giá trị 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

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

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

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

• Một câu lệnh

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

  4 không có giá trị (

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

  5) 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(42 / +0); // Infinity
  console.log(42 / -0); // -Infinity
  

  7) 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(42 / +0); // Infinity
  console.log(42 / -0); // -Infinity
  

  9) 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ư

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

  1 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
  

  2, 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ư

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

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

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({} + []); // "[object Object]"

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

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

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,

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

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

Loại số

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

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

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

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

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

  9 được chuyển đổi thành null4.
• Các giá trị dương nhỏ hơn

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

  8 được chuyển đổi thành null6.
• Các giá trị âm nhỏ hơn -____ 49 được chuyển đổi thành null8.
• Các giá trị âm lớn hơn -____ 48 được chuyển đổi thành typeof0.

null4 và null8 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 typeof3 và typeof4 để biết chi tiết.

Loại số chỉ có một giá trị có nhiều biểu diễn: typeof5 được biểu diễn dưới dạng cả typeof0 và null6 (trong đó typeof5 là bí danh đối với null6). 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ụ, typeof null0 là

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

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

typeof null2 ("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 typeof null3 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 (null1) cho các số.

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

Ví dụ này cho thấy việc tăng null1 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 typeof null8, typeof null9, "object"0, "object"1 và "object"2 - người duy nhất bị cấm là "object"3. 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 "object"5 đạ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 typeof5, phần tiếp theo tại Index "object"7, 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 "object"5 để 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 "object"9.
• Một sự kết hợp của hai chuỗi sử dụng toán tử nối (typeof null8) hoặc === null1.

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 === null2 khi sử dụng === null3, 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

=== null4 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 === null5 hoặc đọc chúng thông qua === null6. Bạn có thể đọc thêm về các sắc thái khác nhau trên trang === null5.

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.

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 các ____115s 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

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

• Trình 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
  

  40, 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
  

  17 - 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ử typeof null8 - 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
  

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

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

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
  

  80 →

  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
  

  46 →

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

  83 →

  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
  

  46 →

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

  86 →

  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 →

  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
  

  46

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

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

Xem thêm