Hướng dẫn is javascript reference based? - là dựa trên tham chiếu javascript?

Tổng quan đối tượng

Các đối tượng trong JavaScript, giống như trong nhiều ngôn ngữ lập trình khác, có thể được so sánh với các đối tượng trong cuộc sống thực. Khái niệm về các đối tượng trong JavaScript có thể được hiểu với cuộc sống thực, các đối tượng hữu hình.

Trong JavaScript, một đối tượng là một thực thể độc lập, với các thuộc tính và loại. So sánh nó với một cốc, ví dụ. Một cốc là một đối tượng, với các thuộc tính. Một cốc có màu, thiết kế, trọng lượng, một vật liệu được làm bằng, v.v ... Theo cùng một cách, các đối tượng JavaScript có thể có các thuộc tính, xác định các đặc điểm của chúng.

Đối tượng và thuộc tính

Một đối tượng JavaScript có các thuộc tính liên quan đến nó. Một thuộc tính của một đối tượng có thể được giải thích là một biến được gắn vào đối tượng. Các thuộc tính đối tượng về cơ bản giống như các biến JavaScript thông thường, ngoại trừ phần đính kèm với các đối tượng. Các thuộc tính của một đối tượng xác định các đặc điểm của đối tượng. Bạn truy cập các thuộc tính của một đối tượng với một ghi chú dấu chấm đơn giản:

Giống như tất cả các biến JavaScript, cả tên đối tượng (có thể là biến bình thường) và tên thuộc tính đều nhạy cảm. Bạn có thể xác định một thuộc tính bằng cách gán nó một giá trị. Ví dụ: chúng ta hãy tạo một đối tượng có tên

myCar['make'] = 'Ford';
myCar['model'] = 'Mustang';
myCar['year'] = 1969;

myCar['make'] = 'Ford';
myCar['model'] = 'Mustang';
myCar['year'] = 1969;

myCar['make'] = 'Ford';
myCar['model'] = 'Mustang';
myCar['year'] = 1969;

myCar['make'] = 'Ford';
myCar['model'] = 'Mustang';
myCar['year'] = 1969;

const myCar = new Object();
myCar.make = 'Ford';
myCar.model = 'Mustang';
myCar.year = 1969;

Ví dụ trên cũng có thể được viết bằng trình khởi tạo đối tượng, là danh sách được phân phối bằng dấu phẩy bằng 0 hoặc nhiều cặp tên thuộc tính và các giá trị liên quan của một đối tượng, được đặt trong niềng răng xoăn (

myCar['make'] = 'Ford';
myCar['model'] = 'Mustang';
myCar['year'] = 1969;

myCar['make'] = 'Ford';
myCar['model'] = 'Mustang';
myCar['year'] = 1969;

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

Các thuộc tính không được chỉ định của một đối tượng là

// four variables are created and assigned in a single go,
// separated by commas
const myObj = {},
      str = 'myString',
      rand = Math.random(),
      anotherObj = {};

// Now, creating additional properties.
myObj.type              = 'Dot syntax for a key named type';
myObj['date created']   = 'This key has a space';
myObj[str]              = 'This key is in variable str';
myObj[rand]             = 'A random number is the key here';
myObj[anotherObj]       = 'This key is object anotherObj';
myObj['']               = 'This key is an empty string';

console.log(myObj);
console.log(myObj.myString);

/*
[Log] Object
    : "This key is an empty string"
    0.8916485437228595: "A random number is the key here"
    [object Object]: "This key is object anotherObj"
    date created: "This key has a space"
    myString: "This key is in variable str"
    type: "Dot syntax for a key named type"
*/
// notice that in the log, the order of the properties listed is not the same as the order they were created.

// [Log] This key is in variable str

// four variables are created and assigned in a single go,
// separated by commas
const myObj = {},
      str = 'myString',
      rand = Math.random(),
      anotherObj = {};

// Now, creating additional properties.
myObj.type              = 'Dot syntax for a key named type';
myObj['date created']   = 'This key has a space';
myObj[str]              = 'This key is in variable str';
myObj[rand]             = 'A random number is the key here';
myObj[anotherObj]       = 'This key is object anotherObj';
myObj['']               = 'This key is an empty string';

console.log(myObj);
console.log(myObj.myString);

/*
[Log] Object
    : "This key is an empty string"
    0.8916485437228595: "A random number is the key here"
    [object Object]: "This key is object anotherObj"
    date created: "This key has a space"
    myString: "This key is in variable str"
    type: "Dot syntax for a key named type"
*/
// notice that in the log, the order of the properties listed is not the same as the order they were created.

// [Log] This key is in variable str

myCar.color; // undefined

Thuộc tính của các đối tượng JavaScript cũng có thể được truy cập hoặc đặt bằng ký hiệu khung (để biết thêm chi tiết, hãy xem Trình truy cập thuộc tính). Các đối tượng đôi khi được gọi là mảng liên kết, vì mỗi thuộc tính được liên kết với giá trị chuỗi có thể được sử dụng để truy cập nó. Vì vậy, ví dụ, bạn có thể truy cập các thuộc tính của đối tượng

myCar['make'] = 'Ford';
myCar['model'] = 'Mustang';
myCar['year'] = 1969;

myCar['make'] = 'Ford';
myCar['model'] = 'Mustang';
myCar['year'] = 1969;

Tên thuộc tính đối tượng có thể là bất kỳ chuỗi JavaScript hợp lệ nào hoặc bất cứ thứ gì có thể được chuyển đổi thành một chuỗi, bao gồm một chuỗi trống. Tuy nhiên, bất kỳ tên thuộc tính nào không phải là định danh JavaScript hợp lệ đều không thể sử dụng ký hiệu DOT. Ví dụ: tên thuộc tính có không gian hoặc dấu gạch nối, bắt đầu bằng một số hoặc được giữ bên trong một biến chỉ có thể được truy cập bằng ký hiệu khung vuông. Ký hiệu này cũng rất hữu ích khi tên thuộc tính được xác định động, tức là không thể xác định cho đến khi chạy. Ví dụ như sau:

// four variables are created and assigned in a single go,
// separated by commas
const myObj = {},
      str = 'myString',
      rand = Math.random(),
      anotherObj = {};

// Now, creating additional properties.
myObj.type              = 'Dot syntax for a key named type';
myObj['date created']   = 'This key has a space';
myObj[str]              = 'This key is in variable str';
myObj[rand]             = 'A random number is the key here';
myObj[anotherObj]       = 'This key is object anotherObj';
myObj['']               = 'This key is an empty string';

console.log(myObj);
console.log(myObj.myString);

/*
[Log] Object
    : "This key is an empty string"
    0.8916485437228595: "A random number is the key here"
    [object Object]: "This key is object anotherObj"
    date created: "This key has a space"
    myString: "This key is in variable str"
    type: "Dot syntax for a key named type"
*/
// notice that in the log, the order of the properties listed is not the same as the order they were created.

// [Log] This key is in variable str

Tên thuộc tính đối tượng JavaScript (khóa) chỉ có thể là các chuỗi hoặc ký hiệu - tất cả các khóa trong ký hiệu khung vuông được chuyển đổi thành chuỗi trừ khi chúng là ký hiệu. Ví dụ: trong mã trên, khi khóa

// four variables are created and assigned in a single go,
// separated by commas
const myObj = {},
      str = 'myString',
      rand = Math.random(),
      anotherObj = {};

// Now, creating additional properties.
myObj.type              = 'Dot syntax for a key named type';
myObj['date created']   = 'This key has a space';
myObj[str]              = 'This key is in variable str';
myObj[rand]             = 'A random number is the key here';
myObj[anotherObj]       = 'This key is object anotherObj';
myObj['']               = 'This key is an empty string';

console.log(myObj);
console.log(myObj.myString);

/*
[Log] Object
    : "This key is an empty string"
    0.8916485437228595: "A random number is the key here"
    [object Object]: "This key is object anotherObj"
    date created: "This key has a space"
    myString: "This key is in variable str"
    type: "Dot syntax for a key named type"
*/
// notice that in the log, the order of the properties listed is not the same as the order they were created.

// [Log] This key is in variable str

// four variables are created and assigned in a single go,
// separated by commas
const myObj = {},
      str = 'myString',
      rand = Math.random(),
      anotherObj = {};

// Now, creating additional properties.
myObj.type              = 'Dot syntax for a key named type';
myObj['date created']   = 'This key has a space';
myObj[str]              = 'This key is in variable str';
myObj[rand]             = 'A random number is the key here';
myObj[anotherObj]       = 'This key is object anotherObj';
myObj['']               = 'This key is an empty string';

console.log(myObj);
console.log(myObj.myString);

/*
[Log] Object
    : "This key is an empty string"
    0.8916485437228595: "A random number is the key here"
    [object Object]: "This key is object anotherObj"
    date created: "This key has a space"
    myString: "This key is in variable str"
    type: "Dot syntax for a key named type"
*/
// notice that in the log, the order of the properties listed is not the same as the order they were created.

// [Log] This key is in variable str

// four variables are created and assigned in a single go,
// separated by commas
const myObj = {},
      str = 'myString',
      rand = Math.random(),
      anotherObj = {};

// Now, creating additional properties.
myObj.type              = 'Dot syntax for a key named type';
myObj['date created']   = 'This key has a space';
myObj[str]              = 'This key is in variable str';
myObj[rand]             = 'A random number is the key here';
myObj[anotherObj]       = 'This key is object anotherObj';
myObj['']               = 'This key is an empty string';

console.log(myObj);
console.log(myObj.myString);

/*
[Log] Object
    : "This key is an empty string"
    0.8916485437228595: "A random number is the key here"
    [object Object]: "This key is object anotherObj"
    date created: "This key has a space"
    myString: "This key is in variable str"
    type: "Dot syntax for a key named type"
*/
// notice that in the log, the order of the properties listed is not the same as the order they were created.

// [Log] This key is in variable str

// four variables are created and assigned in a single go,
// separated by commas
const myObj = {},
      str = 'myString',
      rand = Math.random(),
      anotherObj = {};

// Now, creating additional properties.
myObj.type              = 'Dot syntax for a key named type';
myObj['date created']   = 'This key has a space';
myObj[str]              = 'This key is in variable str';
myObj[rand]             = 'A random number is the key here';
myObj[anotherObj]       = 'This key is object anotherObj';
myObj['']               = 'This key is an empty string';

console.log(myObj);
console.log(myObj.myString);

/*
[Log] Object
    : "This key is an empty string"
    0.8916485437228595: "A random number is the key here"
    [object Object]: "This key is object anotherObj"
    date created: "This key has a space"
    myString: "This key is in variable str"
    type: "Dot syntax for a key named type"
*/
// notice that in the log, the order of the properties listed is not the same as the order they were created.

// [Log] This key is in variable str

Bạn cũng có thể truy cập các thuộc tính với giá trị chuỗi được lưu trữ trong một biến. Biến phải được truyền trong ký hiệu khung. Trong ví dụ trên, biến

// four variables are created and assigned in a single go,
// separated by commas
const myObj = {},
      str = 'myString',
      rand = Math.random(),
      anotherObj = {};

// Now, creating additional properties.
myObj.type              = 'Dot syntax for a key named type';
myObj['date created']   = 'This key has a space';
myObj[str]              = 'This key is in variable str';
myObj[rand]             = 'A random number is the key here';
myObj[anotherObj]       = 'This key is object anotherObj';
myObj['']               = 'This key is an empty string';

console.log(myObj);
console.log(myObj.myString);

/*
[Log] Object
    : "This key is an empty string"
    0.8916485437228595: "A random number is the key here"
    [object Object]: "This key is object anotherObj"
    date created: "This key has a space"
    myString: "This key is in variable str"
    type: "Dot syntax for a key named type"
*/
// notice that in the log, the order of the properties listed is not the same as the order they were created.

// [Log] This key is in variable str

// four variables are created and assigned in a single go,
// separated by commas
const myObj = {},
      str = 'myString',
      rand = Math.random(),
      anotherObj = {};

// Now, creating additional properties.
myObj.type              = 'Dot syntax for a key named type';
myObj['date created']   = 'This key has a space';
myObj[str]              = 'This key is in variable str';
myObj[rand]             = 'A random number is the key here';
myObj[anotherObj]       = 'This key is object anotherObj';
myObj['']               = 'This key is an empty string';

console.log(myObj);
console.log(myObj.myString);

/*
[Log] Object
    : "This key is an empty string"
    0.8916485437228595: "A random number is the key here"
    [object Object]: "This key is object anotherObj"
    date created: "This key has a space"
    myString: "This key is in variable str"
    type: "Dot syntax for a key named type"
*/
// notice that in the log, the order of the properties listed is not the same as the order they were created.

// [Log] This key is in variable str

// four variables are created and assigned in a single go,
// separated by commas
const myObj = {},
      str = 'myString',
      rand = Math.random(),
      anotherObj = {};

// Now, creating additional properties.
myObj.type              = 'Dot syntax for a key named type';
myObj['date created']   = 'This key has a space';
myObj[str]              = 'This key is in variable str';
myObj[rand]             = 'A random number is the key here';
myObj[anotherObj]       = 'This key is object anotherObj';
myObj['']               = 'This key is an empty string';

console.log(myObj);
console.log(myObj.myString);

/*
[Log] Object
    : "This key is an empty string"
    0.8916485437228595: "A random number is the key here"
    [object Object]: "This key is object anotherObj"
    date created: "This key has a space"
    myString: "This key is in variable str"
    type: "Dot syntax for a key named type"
*/
// notice that in the log, the order of the properties listed is not the same as the order they were created.

// [Log] This key is in variable str

str = 'myString';
myObj[str] = 'This key is in variable str';

console.log(myObj.str); //[Log] undefined

console.log(myObj[str]); //[Log] This key is in variable str
console.log(myObj.myString); //[Log] This key is in variable str

str = 'myString';
myObj[str] = 'This key is in variable str';

console.log(myObj.str); //[Log] undefined

console.log(myObj[str]); //[Log] This key is in variable str
console.log(myObj.myString); //[Log] This key is in variable str

Điều này cho phép truy cập bất kỳ thuộc tính nào như được xác định trong thời gian chạy:

let propertyName = 'make';
myCar[propertyName] = 'Ford';

// access different properties by changing the contents of the variable
propertyName = 'model';
myCar[propertyName] = 'Mustang';

console.log(myCar);

// [Log] {make: 'Ford', model: 'Mustang'}

Bạn có thể sử dụng ký hiệu khung với

str = 'myString';
myObj[str] = 'This key is in variable str';

console.log(myObj.str); //[Log] undefined

console.log(myObj[str]); //[Log] This key is in variable str
console.log(myObj.myString); //[Log] This key is in variable str

function showProps(obj, objName) {
  let result = '';
  for (const i in obj) {
    // obj.hasOwn is used to exclude properties from the object's prototype chain and only show "own properties"
    if (Object.hasOwn(obj, i)) {
      result += `${objName}.${i} = ${obj[i]}\n`;
    }
  }
  console.log(result);
}

Thuật ngữ "thuộc tính riêng" đề cập đến các thuộc tính của đối tượng, nhưng không bao gồm các thuộc tính của chuỗi nguyên mẫu. Vì vậy, chức năng gọi

str = 'myString';
myObj[str] = 'This key is in variable str';

console.log(myObj.str); //[Log] undefined

console.log(myObj[str]); //[Log] This key is in variable str
console.log(myObj.myString); //[Log] This key is in variable str

myCar.make = Ford
myCar.model = Mustang
myCar.year = 1969

Liệt kê các thuộc tính của một đối tượng

Có ba cách gốc để liệt kê/Traverse Object Properties:

• str = 'myString';
  myObj[str] = 'This key is in variable str';
  
  console.log(myObj.str); //[Log] undefined
  
  console.log(myObj[str]); //[Log] This key is in variable str
  console.log(myObj.myString); //[Log] This key is in variable str
  

  1 vòng lặp. Phương pháp này đi qua tất cả các thuộc tính chuỗi có thể suy giảm của một đối tượng cũng như chuỗi nguyên mẫu của nó.

• str = 'myString';
  myObj[str] = 'This key is in variable str';
  
  console.log(myObj.str); //[Log] undefined
  
  console.log(myObj[str]); //[Log] This key is in variable str
  console.log(myObj.myString); //[Log] This key is in variable str
  

  4. Phương thức này trả về một mảng chỉ có tên thuộc tính chuỗi riêng ("phím") trong đối tượng

  // four variables are created and assigned in a single go,
  // separated by commas
  const myObj = {},
        str = 'myString',
        rand = Math.random(),
        anotherObj = {};
  
  // Now, creating additional properties.
  myObj.type              = 'Dot syntax for a key named type';
  myObj['date created']   = 'This key has a space';
  myObj[str]              = 'This key is in variable str';
  myObj[rand]             = 'A random number is the key here';
  myObj[anotherObj]       = 'This key is object anotherObj';
  myObj['']               = 'This key is an empty string';
  
  console.log(myObj);
  console.log(myObj.myString);
  
  /*
  [Log] Object
      : "This key is an empty string"
      0.8916485437228595: "A random number is the key here"
      [object Object]: "This key is object anotherObj"
      date created: "This key has a space"
      myString: "This key is in variable str"
      type: "Dot syntax for a key named type"
  */
  // notice that in the log, the order of the properties listed is not the same as the order they were created.
  
  // [Log] This key is in variable str
  

  4, nhưng không phải là trong chuỗi nguyên mẫu.

• str = 'myString';
  myObj[str] = 'This key is in variable str';
  
  console.log(myObj.str); //[Log] undefined
  
  console.log(myObj[str]); //[Log] This key is in variable str
  console.log(myObj.myString); //[Log] This key is in variable str
  

  6. Phương thức này trả về một mảng chứa tất cả các tên thuộc tính chuỗi riêng trong đối tượng

  // four variables are created and assigned in a single go,
  // separated by commas
  const myObj = {},
        str = 'myString',
        rand = Math.random(),
        anotherObj = {};
  
  // Now, creating additional properties.
  myObj.type              = 'Dot syntax for a key named type';
  myObj['date created']   = 'This key has a space';
  myObj[str]              = 'This key is in variable str';
  myObj[rand]             = 'A random number is the key here';
  myObj[anotherObj]       = 'This key is object anotherObj';
  myObj['']               = 'This key is an empty string';
  
  console.log(myObj);
  console.log(myObj.myString);
  
  /*
  [Log] Object
      : "This key is an empty string"
      0.8916485437228595: "A random number is the key here"
      [object Object]: "This key is object anotherObj"
      date created: "This key has a space"
      myString: "This key is in variable str"
      type: "Dot syntax for a key named type"
  */
  // notice that in the log, the order of the properties listed is not the same as the order they were created.
  
  // [Log] This key is in variable str
  

  4, bất kể chúng có thể không có được hay không.

Không có cách tự nhiên để liệt kê các thuộc tính "ẩn" (thuộc tính trong chuỗi nguyên mẫu không thể truy cập được thông qua đối tượng, bởi vì một thuộc tính khác có cùng tên trước đó trong chuỗi nguyên mẫu). Tuy nhiên, điều này có thể đạt được với chức năng sau:

function listAllProperties(myObj) {
  let objectToInspect = myObj;
  let result = [];

  while(objectToInspect !== null) {
    result = result.concat(Object.getOwnPropertyNames(objectToInspect));
    objectToInspect = Object.getPrototypeOf(objectToInspect)
  }

  return result;
}

Tạo các đối tượng mới

JavaScript có một số đối tượng được xác định trước. Ngoài ra, bạn có thể tạo các đối tượng của riêng bạn. Bạn có thể tạo một đối tượng bằng Trình khởi tạo đối tượng. Ngoài ra, trước tiên bạn có thể tạo hàm tạo hàm và sau đó khởi tạo một đối tượng gọi hàm đó kết hợp với toán tử

str = 'myString';
myObj[str] = 'This key is in variable str';

console.log(myObj.str); //[Log] undefined

console.log(myObj[str]); //[Log] This key is in variable str
console.log(myObj.myString); //[Log] This key is in variable str

Sử dụng các bộ khởi tạo đối tượng

Sử dụng các bộ khởi tạo đối tượng đôi khi được gọi là tạo các đối tượng có ký hiệu theo nghĩa đen. "Bộ khởi tạo đối tượng" phù hợp với thuật ngữ được sử dụng bởi C ++.

Cú pháp cho một đối tượng sử dụng Trình khởi tạo đối tượng là:

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

Trong đó

str = 'myString';
myObj[str] = 'This key is in variable str';

console.log(myObj.str); //[Log] undefined

console.log(myObj[str]); //[Log] This key is in variable str
console.log(myObj.myString); //[Log] This key is in variable str

let propertyName = 'make';
myCar[propertyName] = 'Ford';

// access different properties by changing the contents of the variable
propertyName = 'model';
myCar[propertyName] = 'Mustang';

console.log(myCar);

// [Log] {make: 'Ford', model: 'Mustang'}

str = 'myString';
myObj[str] = 'This key is in variable str';

console.log(myObj.str); //[Log] undefined

console.log(myObj[str]); //[Log] This key is in variable str
console.log(myObj.myString); //[Log] This key is in variable str

Bộ khởi tạo đối tượng là các biểu thức và mỗi trình khởi tạo đối tượng dẫn đến một đối tượng mới được tạo bất cứ khi nào câu lệnh xuất hiện được thực thi. Bộ khởi tạo đối tượng giống hệt nhau tạo ra các đối tượng riêng biệt sẽ không so sánh với nhau như nhau. Các đối tượng được tạo như thể một cuộc gọi đến

let propertyName = 'make';
myCar[propertyName] = 'Ford';

// access different properties by changing the contents of the variable
propertyName = 'model';
myCar[propertyName] = 'Mustang';

console.log(myCar);

// [Log] {make: 'Ford', model: 'Mustang'}

let propertyName = 'make';
myCar[propertyName] = 'Ford';

// access different properties by changing the contents of the variable
propertyName = 'model';
myCar[propertyName] = 'Mustang';

console.log(myCar);

// [Log] {make: 'Ford', model: 'Mustang'}

Câu lệnh sau đây tạo một đối tượng và gán nó cho biến

let propertyName = 'make';
myCar[propertyName] = 'Ford';

// access different properties by changing the contents of the variable
propertyName = 'model';
myCar[propertyName] = 'Mustang';

console.log(myCar);

// [Log] {make: 'Ford', model: 'Mustang'}

let propertyName = 'make';
myCar[propertyName] = 'Ford';

// access different properties by changing the contents of the variable
propertyName = 'model';
myCar[propertyName] = 'Mustang';

console.log(myCar);

// [Log] {make: 'Ford', model: 'Mustang'}

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

Ví dụ sau đây tạo ra

let propertyName = 'make';
myCar[propertyName] = 'Ford';

// access different properties by changing the contents of the variable
propertyName = 'model';
myCar[propertyName] = 'Mustang';

console.log(myCar);

// [Log] {make: 'Ford', model: 'Mustang'}

let propertyName = 'make';
myCar[propertyName] = 'Ford';

// access different properties by changing the contents of the variable
propertyName = 'model';
myCar[propertyName] = 'Mustang';

console.log(myCar);

// [Log] {make: 'Ford', model: 'Mustang'}

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

Bạn cũng có thể sử dụng bộ khởi tạo đối tượng để tạo mảng. Xem văn bản mảng.

Sử dụng hàm tạo hàm

Ngoài ra, bạn có thể tạo một đối tượng với hai bước sau:

1. Xác định loại đối tượng bằng cách viết hàm tạo hàm. Có một quy ước mạnh mẽ, với lý do chính đáng, để sử dụng một lá thư ban đầu vốn.
2. Tạo một thể hiện của đối tượng với

   str = 'myString';
   myObj[str] = 'This key is in variable str';
   
   console.log(myObj.str); //[Log] undefined
   
   console.log(myObj[str]); //[Log] This key is in variable str
   console.log(myObj.myString); //[Log] This key is in variable str
   

   8.

Để xác định loại đối tượng, hãy tạo một hàm cho loại đối tượng chỉ định tên, thuộc tính và phương thức của nó. Ví dụ: giả sử bạn muốn tạo một loại đối tượng cho xe hơi. Bạn muốn loại đối tượng này được gọi là

let propertyName = 'make';
myCar[propertyName] = 'Ford';

// access different properties by changing the contents of the variable
propertyName = 'model';
myCar[propertyName] = 'Mustang';

console.log(myCar);

// [Log] {make: 'Ford', model: 'Mustang'}

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

Lưu ý rằng việc sử dụng

function showProps(obj, objName) {
  let result = '';
  for (const i in obj) {
    // obj.hasOwn is used to exclude properties from the object's prototype chain and only show "own properties"
    if (Object.hasOwn(obj, i)) {
      result += `${objName}.${i} = ${obj[i]}\n`;
    }
  }
  console.log(result);
}

Bây giờ bạn có thể tạo một đối tượng được gọi là

myCar['make'] = 'Ford';
myCar['model'] = 'Mustang';
myCar['year'] = 1969;

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

Câu lệnh này tạo ra

myCar['make'] = 'Ford';
myCar['model'] = 'Mustang';
myCar['year'] = 1969;

function showProps(obj, objName) {
  let result = '';
  for (const i in obj) {
    // obj.hasOwn is used to exclude properties from the object's prototype chain and only show "own properties"
    if (Object.hasOwn(obj, i)) {
      result += `${objName}.${i} = ${obj[i]}\n`;
    }
  }
  console.log(result);
}

function showProps(obj, objName) {
  let result = '';
  for (const i in obj) {
    // obj.hasOwn is used to exclude properties from the object's prototype chain and only show "own properties"
    if (Object.hasOwn(obj, i)) {
      result += `${objName}.${i} = ${obj[i]}\n`;
    }
  }
  console.log(result);
}

function showProps(obj, objName) {
  let result = '';
  for (const i in obj) {
    // obj.hasOwn is used to exclude properties from the object's prototype chain and only show "own properties"
    if (Object.hasOwn(obj, i)) {
      result += `${objName}.${i} = ${obj[i]}\n`;
    }
  }
  console.log(result);
}

Bạn có thể tạo bất kỳ số lượng đối tượng

let propertyName = 'make';
myCar[propertyName] = 'Ford';

// access different properties by changing the contents of the variable
propertyName = 'model';
myCar[propertyName] = 'Mustang';

console.log(myCar);

// [Log] {make: 'Ford', model: 'Mustang'}

str = 'myString';
myObj[str] = 'This key is in variable str';

console.log(myObj.str); //[Log] undefined

console.log(myObj[str]); //[Log] This key is in variable str
console.log(myObj.myString); //[Log] This key is in variable str

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

Một đối tượng có thể có một thuộc tính tự nó là một đối tượng khác. Ví dụ: giả sử bạn xác định một đối tượng được gọi là

function showProps(obj, objName) {
  let result = '';
  for (const i in obj) {
    // obj.hasOwn is used to exclude properties from the object's prototype chain and only show "own properties"
    if (Object.hasOwn(obj, i)) {
      result += `${objName}.${i} = ${obj[i]}\n`;
    }
  }
  console.log(result);
}

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

và sau đó khởi tạo hai đối tượng

function showProps(obj, objName) {
  let result = '';
  for (const i in obj) {
    // obj.hasOwn is used to exclude properties from the object's prototype chain and only show "own properties"
    if (Object.hasOwn(obj, i)) {
      result += `${objName}.${i} = ${obj[i]}\n`;
    }
  }
  console.log(result);
}

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

Sau đó, bạn có thể viết lại định nghĩa của

let propertyName = 'make';
myCar[propertyName] = 'Ford';

// access different properties by changing the contents of the variable
propertyName = 'model';
myCar[propertyName] = 'Mustang';

console.log(myCar);

// [Log] {make: 'Ford', model: 'Mustang'}

myCar.make = Ford
myCar.model = Mustang
myCar.year = 1969

function showProps(obj, objName) {
  let result = '';
  for (const i in obj) {
    // obj.hasOwn is used to exclude properties from the object's prototype chain and only show "own properties"
    if (Object.hasOwn(obj, i)) {
      result += `${objName}.${i} = ${obj[i]}\n`;
    }
  }
  console.log(result);
}

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

Để khởi tạo các đối tượng mới, sau đó bạn sử dụng các đối tượng sau:

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

Lưu ý rằng thay vì truyền một chuỗi theo nghĩa đen hoặc giá trị số nguyên khi tạo các đối tượng mới, các câu lệnh trên truyền các đối tượng

myCar.make = Ford
myCar.model = Mustang
myCar.year = 1969

myCar.make = Ford
myCar.model = Mustang
myCar.year = 1969

myCar.make = Ford
myCar.model = Mustang
myCar.year = 1969

Lưu ý rằng bạn luôn có thể thêm một thuộc tính vào một đối tượng được xác định trước đó. Ví dụ: tuyên bố

Thêm một thuộc tính

myCar.make = Ford
myCar.model = Mustang
myCar.year = 1969

myCar.make = Ford
myCar.model = Mustang
myCar.year = 1969

myCar.make = Ford
myCar.model = Mustang
myCar.year = 1969

let propertyName = 'make';
myCar[propertyName] = 'Ford';

// access different properties by changing the contents of the variable
propertyName = 'model';
myCar[propertyName] = 'Mustang';

console.log(myCar);

// [Log] {make: 'Ford', model: 'Mustang'}

Sử dụng phương pháp function listAllProperties(myObj) { let objectToInspect = myObj; let result = []; while(objectToInspect !== null) { result = result.concat(Object.getOwnPropertyNames(objectToInspect)); objectToInspect = Object.getPrototypeOf(objectToInspect) } return result; } 0

Các đối tượng cũng có thể được tạo bằng phương thức

function listAllProperties(myObj) {
  let objectToInspect = myObj;
  let result = [];

  while(objectToInspect !== null) {
    result = result.concat(Object.getOwnPropertyNames(objectToInspect));
    objectToInspect = Object.getPrototypeOf(objectToInspect)
  }

  return result;
}

myCar.color; // undefined

Di sản

Tất cả các đối tượng trong JavaScript kế thừa từ ít nhất một đối tượng khác. Đối tượng được di truyền từ được gọi là nguyên mẫu và các thuộc tính được di truyền có thể được tìm thấy trong đối tượng

function listAllProperties(myObj) {
  let objectToInspect = myObj;
  let result = [];

  while(objectToInspect !== null) {
    result = result.concat(Object.getOwnPropertyNames(objectToInspect));
    objectToInspect = Object.getPrototypeOf(objectToInspect)
  }

  return result;
}

Lập chỉ mục các thuộc tính đối tượng

Bạn có thể tham khảo một thuộc tính của một đối tượng bằng tên thuộc tính của nó hoặc theo chỉ số thứ tự của nó. Nếu ban đầu bạn xác định một thuộc tính bằng tên của nó, bạn phải luôn tham khảo nó bằng tên của nó và nếu ban đầu bạn xác định một thuộc tính theo chỉ mục, bạn phải luôn luôn tham khảo nó bằng chỉ mục của nó.

Hạn chế này áp dụng khi bạn tạo một đối tượng và các thuộc tính của nó với hàm tạo hàm (như chúng tôi đã làm trước đây với loại đối tượng

let propertyName = 'make';
myCar[propertyName] = 'Ford';

// access different properties by changing the contents of the variable
propertyName = 'model';
myCar[propertyName] = 'Mustang';

console.log(myCar);

// [Log] {make: 'Ford', model: 'Mustang'}

function listAllProperties(myObj) {
  let objectToInspect = myObj;
  let result = [];

  while(objectToInspect !== null) {
    result = result.concat(Object.getOwnPropertyNames(objectToInspect));
    objectToInspect = Object.getPrototypeOf(objectToInspect)
  }

  return result;
}

function listAllProperties(myObj) {
  let objectToInspect = myObj;
  let result = [];

  while(objectToInspect !== null) {
    result = result.concat(Object.getOwnPropertyNames(objectToInspect));
    objectToInspect = Object.getPrototypeOf(objectToInspect)
  }

  return result;
}

function listAllProperties(myObj) {
  let objectToInspect = myObj;
  let result = [];

  while(objectToInspect !== null) {
    result = result.concat(Object.getOwnPropertyNames(objectToInspect));
    objectToInspect = Object.getPrototypeOf(objectToInspect)
  }

  return result;
}

Ngoại lệ cho quy tắc này là các đối tượng giống như mảng được phản ánh từ HTML, chẳng hạn như đối tượng giống như mảng

function listAllProperties(myObj) {
  let objectToInspect = myObj;
  let result = [];

  while(objectToInspect !== null) {
    result = result.concat(Object.getOwnPropertyNames(objectToInspect));
    objectToInspect = Object.getPrototypeOf(objectToInspect)
  }

  return result;
}

function listAllProperties(myObj) {
  let objectToInspect = myObj;
  let result = [];

  while(objectToInspect !== null) {
    result = result.concat(Object.getOwnPropertyNames(objectToInspect));
    objectToInspect = Object.getPrototypeOf(objectToInspect)
  }

  return result;
}

function listAllProperties(myObj) {
  let objectToInspect = myObj;
  let result = [];

  while(objectToInspect !== null) {
    result = result.concat(Object.getOwnPropertyNames(objectToInspect));
    objectToInspect = Object.getPrototypeOf(objectToInspect)
  }

  return result;
}

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

Xác định thuộc tính cho loại đối tượng

Bạn có thể thêm thuộc tính vào loại đối tượng được xác định trước đó bằng cách sử dụng thuộc tính

function listAllProperties(myObj) {
  let objectToInspect = myObj;
  let result = [];

  while(objectToInspect !== null) {
    result = result.concat(Object.getOwnPropertyNames(objectToInspect));
    objectToInspect = Object.getPrototypeOf(objectToInspect)
  }

  return result;
}

myCar.make = Ford
myCar.model = Mustang
myCar.year = 1969

let propertyName = 'make';
myCar[propertyName] = 'Ford';

// access different properties by changing the contents of the variable
propertyName = 'model';
myCar[propertyName] = 'Mustang';

console.log(myCar);

// [Log] {make: 'Ford', model: 'Mustang'}

myCar.make = Ford
myCar.model = Mustang
myCar.year = 1969

myCar.make = Ford
myCar.model = Mustang
myCar.year = 1969

myCar.color; // undefined

Xem kế thừa_and_the_prototype_chain để biết thêm thông tin.

Xác định phương pháp

Phương pháp là một hàm được liên kết với một đối tượng, hoặc, khác nhau, một phương thức là một thuộc tính của một đối tượng là một hàm. Các phương thức được xác định theo cách xác định các hàm bình thường, ngoại trừ việc chúng phải được gán là thuộc tính của một đối tượng. Xem thêm Định nghĩa phương pháp để biết thêm chi tiết. Một ví dụ là:

myCar.color; // undefined

Trong đó

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

Sau đó, bạn có thể gọi phương thức trong bối cảnh của đối tượng như sau:

myCar.color; // undefined

Bạn có thể xác định các phương thức cho một loại đối tượng bằng cách bao gồm một định nghĩa phương thức trong hàm xây dựng đối tượng. Bạn có thể xác định một hàm sẽ định dạng và hiển thị các thuộc tính của các đối tượng

let propertyName = 'make';
myCar[propertyName] = 'Ford';

// access different properties by changing the contents of the variable
propertyName = 'model';
myCar[propertyName] = 'Mustang';

console.log(myCar);

// [Log] {make: 'Ford', model: 'Mustang'}

myCar.color; // undefined

trong đó

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

function showProps(obj, objName) {
  let result = '';
  for (const i in obj) {
    // obj.hasOwn is used to exclude properties from the object's prototype chain and only show "own properties"
    if (Object.hasOwn(obj, i)) {
      result += `${objName}.${i} = ${obj[i]}\n`;
    }
  }
  console.log(result);
}

Bạn có thể biến hàm này thành một phương thức của

let propertyName = 'make';
myCar[propertyName] = 'Ford';

// access different properties by changing the contents of the variable
propertyName = 'model';
myCar[propertyName] = 'Mustang';

console.log(myCar);

// [Log] {make: 'Ford', model: 'Mustang'}

myCar.color; // undefined

đến định nghĩa đối tượng. Vì vậy, định nghĩa đầy đủ của

let propertyName = 'make';
myCar[propertyName] = 'Ford';

// access different properties by changing the contents of the variable
propertyName = 'model';
myCar[propertyName] = 'Mustang';

console.log(myCar);

// [Log] {make: 'Ford', model: 'Mustang'}

myCar.color; // undefined

Sau đó, bạn có thể gọi phương thức

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

myCar.color; // undefined

Sử dụng function showProps(obj, objName) { let result = ''; for (const i in obj) { // obj.hasOwn is used to exclude properties from the object's prototype chain and only show "own properties" if (Object.hasOwn(obj, i)) { result += `${objName}.${i} = ${obj[i]}\n`; } } console.log(result); } 0 cho các tài liệu tham khảo đối tượng

JavaScript có một từ khóa đặc biệt,

function showProps(obj, objName) {
  let result = '';
  for (const i in obj) {
    // obj.hasOwn is used to exclude properties from the object's prototype chain and only show "own properties"
    if (Object.hasOwn(obj, i)) {
      result += `${objName}.${i} = ${obj[i]}\n`;
    }
  }
  console.log(result);
}

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

myCar.color; // undefined

function showProps(obj, objName) {
  let result = '';
  for (const i in obj) {
    // obj.hasOwn is used to exclude properties from the object's prototype chain and only show "own properties"
    if (Object.hasOwn(obj, i)) {
      result += `${objName}.${i} = ${obj[i]}\n`;
    }
  }
  console.log(result);
}

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

myCar.color; // undefined

Xác định getters và setters

Getter là một phương pháp nhận được giá trị của một thuộc tính cụ thể. Một setter là một phương thức đặt giá trị của một thuộc tính cụ thể. Bạn có thể xác định getters và setters trên bất kỳ đối tượng lõi được xác định trước hoặc đối tượng do người dùng xác định hỗ trợ bổ sung các thuộc tính mới.

Getters và setters có thể là

• được xác định bằng cách sử dụng khởi tạo đối tượng hoặc
• Đã thêm sau vào bất kỳ đối tượng nào bất cứ lúc nào bằng phương thức thêm getter hoặc setter.

Khi xác định getters và setters sử dụng bộ khởi tạo đối tượng, tất cả những gì bạn cần làm là tiền tố phương thức getter với

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

myCar['make'] = 'Ford';
myCar['model'] = 'Mustang';
myCar['year'] = 1969;

Các thuộc tính của đối tượng

// four variables are created and assigned in a single go,
// separated by commas
const myObj = {},
      str = 'myString',
      rand = Math.random(),
      anotherObj = {};

// Now, creating additional properties.
myObj.type              = 'Dot syntax for a key named type';
myObj['date created']   = 'This key has a space';
myObj[str]              = 'This key is in variable str';
myObj[rand]             = 'A random number is the key here';
myObj[anotherObj]       = 'This key is object anotherObj';
myObj['']               = 'This key is an empty string';

console.log(myObj);
console.log(myObj.myString);

/*
[Log] Object
    : "This key is an empty string"
    0.8916485437228595: "A random number is the key here"
    [object Object]: "This key is object anotherObj"
    date created: "This key has a space"
    myString: "This key is in variable str"
    type: "Dot syntax for a key named type"
*/
// notice that in the log, the order of the properties listed is not the same as the order they were created.

// [Log] This key is in variable str

• const myCar = {
    make: 'Ford',
    model: 'Mustang',
    year: 1969
  };
  

  33 - một số

• const myCar = {
    make: 'Ford',
    model: 'Mustang',
    year: 1969
  };
  

  34 - một người nhận trả về

  const myCar = {
    make: 'Ford',
    model: 'Mustang',
    year: 1969
  };
  

  33 cộng với 1

• const myCar = {
    make: 'Ford',
    model: 'Mustang',
    year: 1969
  };
  

  36 - Một setter đặt giá trị của

  const myCar = {
    make: 'Ford',
    model: 'Mustang',
    year: 1969
  };
  

  33 thành một nửa giá trị

  const myCar = {
    make: 'Ford',
    model: 'Mustang',
    year: 1969
  };
  

  36 đang được đặt thành

Xin lưu ý rằng tên hàm của getters và setters được xác định trong một đối tượng theo nghĩa đen bằng cách sử dụng "[gs] et property ()" không phải là tên của chính các getters, mặc dù cú pháp

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

Getters và setters cũng có thể được thêm vào một đối tượng bất cứ lúc nào sau khi tạo bằng phương thức

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

myCar['make'] = 'Ford';
myCar['model'] = 'Mustang';
myCar['year'] = 1969;

Những hình thức nào trong hai hình thức để chọn phụ thuộc vào phong cách lập trình và nhiệm vụ của bạn trong tay. Nếu bạn đã sử dụng trình khởi tạo đối tượng khi xác định nguyên mẫu, bạn có thể sẽ chọn biểu mẫu đầu tiên. Hình thức này nhỏ gọn và tự nhiên hơn. Tuy nhiên, nếu bạn cần thêm getters và setters sau - vì bạn không viết nguyên mẫu hoặc đối tượng cụ thể - thì biểu mẫu thứ hai là biểu mẫu duy nhất có thể. Hình thức thứ hai có thể thể hiện tốt nhất bản chất năng động của JavaScript - nhưng nó có thể làm cho mã khó đọc và hiểu.

Xóa thuộc tính

Bạn có thể xóa một thuộc tính không được inher bằng cách sử dụng toán tử

const myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
};

myCar['make'] = 'Ford';
myCar['model'] = 'Mustang';
myCar['year'] = 1969;

So sánh các đối tượng

Trong JavaScript, các đối tượng là một loại tham chiếu. Hai đối tượng riêng biệt không bao giờ bằng nhau, ngay cả khi chúng có cùng thuộc tính. Chỉ so sánh cùng một tham chiếu đối tượng với chính nó mang lại đúng.

myCar['make'] = 'Ford';
myCar['model'] = 'Mustang';
myCar['year'] = 1969;

myCar['make'] = 'Ford';
myCar['model'] = 'Mustang';
myCar['year'] = 1969;

Để biết thêm thông tin về các nhà khai thác so sánh, hãy xem các nhà khai thác bình đẳng.

Xem thêm

• Để lặn sâu hơn, hãy đọc về kế thừa và chuỗi nguyên mẫu.
• Để tìm hiểu về các lớp (một cách khác để tạo các đối tượng), hãy đọc tham chiếu của các lớp JavaScript.

• " Trước
• Tiếp theo "