Các loại nguyên thủy so với các loại tham chiếu JavaScript

JavaScript là một ngôn ngữ động với. 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à gán lại] giá trị 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 gõ yếu, có nghĩa là nó cho phép chuyển đổi kiểu ẩn khi một thao tác liên quan đến các kiểu không khớp, thay vì đưa ra các lỗi kiểu

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

Ép buộc ngầm rất thuận tiện, nhưng có thể là một khẩu súng ngắn tiềm năng nếu 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 và , JavaScript đã cố tình không cho phép một số chuyển đổi loại ngầm định

Tất cả các loại ngoại trừ 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 coi các giá trị của các loại này là giá trị nguyên thủy

Tất cả các kiểu 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

const foo = 42; // foo is a 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

Các trang tham khảo của các lớp trình 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 về ngữ nghĩa của chính các loại nguyên thủy.

Loại Null có chính xác một giá trị. null

Loại Không xác định là nơi sinh sống của 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

const foo = 42; // foo is a 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â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ị [_______17_______8] hoàn toàn 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 không có khởi tạo [_______24_______2] ngầm định 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 thức, 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 ít được sử dụng hơn trong ngôn ngữ chính. Vị trí quan trọng nhất là phần cuối của chuỗi nguyên mẫu — sau đó là các phương thức tương tác với nguyên mẫu, 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 là một , 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

console.log[42 / +0]; // Infinity
console.log[42 / -0]; // -Infinity

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ử bậc ba, null8, null9, v.v.

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

Các giá trị nằm ngoài phạm vi ±[2-1074 tới 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 -typeof2 được chuyển đổi thành typeof null1
• Các giá trị âm lớn hơn -typeof1 được chuyển đổi thành typeof null3

typeof7 và typeof null1 hoạt động tương tự như toán học vô hạn, nhưng với một số khác biệt nhỏ;

Kiểu Number chỉ có một giá trị với nhiều cách biểu diễn. typeof null8 được thể hiện dưới dạng cả typeof null3 và typeof9 [trong đó typeof null8 là bí danh của typeof9]. Trong thực tế, hầu như không có sự khác biệt giữa các cách biểu diễn khác nhau; . 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 là số"] là một loại giá trị số đặc biệt thường gặp khi kết quả của phép toán số học không thể được biểu thị dưới dạng số. Nó cũng là giá trị duy nhất trong JavaScript không bằng chính nó

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

Ghi chú. Mặc dù các toán tử bitwise có thể được sử dụng để biểu diễn một số giá trị Boolean trong một số duy nhất bằng cách sử dụng mặt nạ bit, nhưng điều này thường được coi là một cách làm không tốt. JavaScript cung cấp các phương tiện khác để biểu diễn một tập hợp các Boolean [chẳng hạn như một mảng Boolean 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, khó hiểu và khó bảo trì hơn

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ế, chẳng hạn như khi cố gắng đối phó với các hạn chế của bộ nhớ 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 mạng được tính]. Kỹ thuật này chỉ nên được xem xét khi nó 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

console.log[42 / +0]; // Infinity
console.log[42 / -0]; // -Infinity

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

Ví dụ này chứng minh nơi tăng typeof4 trả về kết quả mong đợi

// 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 toán tử để làm việc với BigInt, bao gồm === null1, === null2, === null3, === null4 và === null5 — toán tử duy nhất bị cấm là === null6. Một BigInt không hoàn toàn bằng một Số có cùng giá trị toán học, nhưng nó đại khái là như vậy

Các giá trị BigInt không phải lúc nào cũng chính xác hơn và cũng không phải lúc nào cũng kém chính xác hơn các số, vì BigInt không thể biểu thị các số phân số, nhưng có thể biểu thị các số nguyên lớn chính xác hơn. Không loại nào kéo theo loại kia 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

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

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

• Một chuỗi con 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
• Nối hai chuỗi bằ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

Cẩn thận với việc "gõ chuỗi" mã của bạn

Việc sử dụng các chuỗi để biểu diễn dữ liệu phức tạp có thể rất hấp dẫn. 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 phép nối
• Các chuỗi rất dễ gỡ lỗi [những gì bạn thấy được in ra luôn là những gì có trong chuỗi]
• 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à có thể chỉ hoạt động với các chuỗi

Với các quy ước, có thể biểu diễn 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 thành phần "danh sách", thì danh sách đó bị hỏng. Một ký tự thoát có thể được chọn, v.v. Tất cả điều này yêu cầu 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 biểu diễn dữ liệu phức tạp, hãy phân tích chuỗi và sử dụng phép trừu tượng thích hợp

Một

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

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 mã định danh. Trong JavaScript, đối tượng là giá trị duy nhất có thể thay đổi. Trên thực tế, các chức năng cũng là các đối tượng có khả năng bổ sung có thể gọi được

Trong JavaScript, các đối tượng có thể được xem như một tập hợp các thuộc tính. Với , một bộ thuộc tính giới hạn được khởi tạo; . Thuộc tính đối tượng tương đương với cặp khóa-giá trị. Các khóa thuộc tính là hoặc. Giá trị thuộc tính có thể là giá trị của bất kỳ loại nào, kể cả các đối tượng khác, cho phép xây dựng cấu trúc dữ liệu phức tạp

Có hai loại thuộc tính đối tượng. các và. Mỗi thuộc tính có các thuộc tính tương ứng. Mỗi thuộc tính được công cụ JavaScript truy cập nội bộ, nhưng bạn có thể đặt chú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ởi 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 truy xuất bởi quyền truy cập của thuộc tính. Có thể là bất kỳ giá trị JavaScript nào

const foo = 42; // foo is a 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 liệu thuộc tính có thể được thay đổi bằng một phép gán hay khô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

Giá trị boolean cho biết liệ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

Giá trị boolean cho biết liệu thuộc tính có thể bị xóa hay không, có thể thay đổi thành thuộc tính trình truy cập và có thể thay đổi thuộc tính của nó hay không

Thuộc tính truy cập

Liên kế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

Ghi chú. Điều quan trọng là phải nhận ra thuộc tính của trình truy cập - không phải phương thức của trình truy cập. 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 một hàm làm giá trị — nhưng điều đó không biến đối tượng thành một lớp

Một thuộc tính truy cập 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 thực hiện truy cập vào giá trị. 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 thi bất cứ khi nào một thuộc tính được chỉ định 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

Giá trị boolean cho biết liệ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

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

Nguyên mẫu của một đối tượng trỏ tới một đối tượng khác hoặc tới null — về mặt khái niệm, đó là một thuộc tính ẩn của đối tượng, thường được biểu diễn dưới 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

const foo = 42; // foo is a 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 đối tượng là các cặp khóa-giá trị đặc biệt, vì vậy chúng thường được sử dụng làm bản đồ. Tuy nhiên, có thể có các vấn đề về công thái học, bảo mật và hiệu suất. Thay vào đó, hãy 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

Khi biểu thị ngày tháng, lựa chọn tốt nhất là sử dụng tiện ích

const foo = 42; // foo is a 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ảng là các đối tượng thông thường có mối quan hệ cụ thể giữa các thuộc tính có khóa số nguyên và 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

Ngoài ra, mảng kế thừa 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

const foo = 42; // foo is a 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ảng đã nhập trình bày dạng xem giống như mảng của bộ đệm dữ liệu nhị phân cơ bản và cung cấp nhiều phương thức có ngữ nghĩa tương tự với các đối tác mảng. "Mảng đã nhập" là một thuật ngữ chung cho một loạt các cấu trúc dữ liệu, 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

const foo = 42; // foo is a 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 cấu trúc dữ liệu này lấy tham chiếu đố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ự 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 nút DOM, người ta có thể đặt thuộc tính trực tiếp trên đối tượng hoặc sử dụng 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

JSON [Ký hiệu đối tượng JavaScript] là một định dạng trao đổi dữ liệu nhẹ, bắt nguồn 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í giữa 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

JavaScript có một thư viện tiêu chuẩn gồm các đối tượng tích hợp sẵn. Đọc tài liệu tham khảo để tìm hiểu thêm về các đối tượng tích hợp

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

Quá trình này được sử dụng khi một giá trị nguyên thủy được mong đợi, nhưng không có sự ưu tiên mạnh mẽ nào cho loại thực tế sẽ là gì. Điều này thường xảy ra khi a , an hoặc a đều được chấp nhận như nhau. Ví dụ

• Hàm tạo

  const foo = 42; // foo is a 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 nó nhận được một đối số không phải là đố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 — chuỗi đại diện cho chuỗi ngày, trong khi 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, phép nối chuỗi đượ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 toán hạng kia là đối tượng, thì đối tượng được chuyển đổi thành giá trị nguyên thủy không có loại ưu tiên

Thao tác 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 các 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

const foo = 42; // foo is a 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 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

const foo = 42; // foo is a 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 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

const foo = 42; // foo is a 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ó hai loại số. và. Đô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 như , ngoại trừ việc BigInts được trả về nguyên trạng 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

Tất cả các loại dữ liệu, ngoại trừ Null, Undefined và Symbol, đều có quy trình cưỡng chế tương ứng. Xem , , và để 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 qua đó các đối tượng có thể được chuyển đổi thành 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
• , ,.

  const foo = 42; // foo is a 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

• const foo = 42; // foo is a 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

Sự khác biệt giữa kiểu nguyên thủy và kiểu tham chiếu là gì?

Các loại tham chiếu trong JavaScript là gì?

Chuỗi là kiểu nguyên thủy hay kiểu tham chiếu?

Sự khác biệt giữa các kiểu dữ liệu nguyên thủy và không nguyên thủy trong JavaScript là gì?