JavaScript được thiết kế trên một mô hình dựa trên đối tượng đơn giản. Đối tượng là tập hợp các thuộc tính và thuộc tính là liên kết giữa tên [hoặc khóa] và giá trị. Giá trị của một thuộc tính có thể là một hàm, trong trường hợp đó, thuộc tính được gọi là một phương thức
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 đời thực. 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à kiểu. So sánh nó với một cái cốc chẳng hạn. Một cái cốc là một đối tượng, với các thuộc tính. Một chiếc cốc có màu sắc, kiểu dáng, trọng lượng, chất liệu làm ra nó, v.v. Theo cách tương tự, các đối tượng JavaScript có thể có các thuộc tính xác định đặc điểm của chúng
Ngoài các đối tượng được xác định trước trong trình duyệt, bạn có thể xác định các đối tượng của riêng mình. Chương này mô tả cách sử dụng các đối tượng, thuộc tính và phương thức cũng như cách tạo các đối tượng của riêng bạn
Bạn có thể tạo đố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 một hàm tạo và sau đó khởi tạo một đối tượng bằng cách gọi hàm đó bằng toán tử
function Car[make, model, year] {
this.make = make;
this.model = model;
this.year = year;
}
4Trình khởi tạo đối tượng còn được gọi là đối tượng chữ. "Trình 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 bộ khởi tạo đối tượng là
const obj = {
property1: value1, // property name may be an identifier
2: value2, // or a number
"property n": value3, // or a string
};
Mỗi tên thuộc tính trước dấu hai chấm là một mã định danh [tên, số hoặc chuỗi ký tự] và mỗi
function Car[make, model, year] {
this.make = make;
this.model = model;
this.year = year;
}
5 là một biểu thức có giá trị được gán cho tên thuộc tính. Tên thuộc tính cũng có thể là một biểu thức; . Tham chiếu trình khởi tạo đối tượng chứa giải thích chi tiết hơn về cú phápTrong ví dụ này, đối tượng mới tạo được gán cho một biến
function Car[make, model, year] {
this.make = make;
this.model = model;
this.year = year;
}
6 — đây là tùy chọn. Nếu bạn không cần tham khảo đối tượng này ở nơi khác, bạn không cần gán nó cho một biến. [Lưu ý rằng bạn có thể cần phải bọc đối tượng bằng chữ trong dấu ngoặc đơn nếu đối tượng xuất hiện ở vị trí mong đợi một câu lệnh, để không bị nhầm lẫn chữ với câu lệnh khối. ]Trình 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. Trình khởi tạo đối tượng giống hệt nhau tạo các đối tượng riêng biệt không so sánh với nhau bằng nhau
Câu lệnh sau đây tạo một đối tượng và gán nó cho biến
function Car[make, model, year] {
this.make = make;
this.model = model;
this.year = year;
}
7 khi và chỉ khi biểu thức function Car[make, model, year] {
this.make = make;
this.model = model;
this.year = year;
}
8 là đúnglet x;
if [cond] {
x = { greeting: "hi there" };
}
Ví dụ sau tạo
function Car[make, model, year] {
this.make = make;
this.model = model;
this.year = year;
}
9 với ba thuộc tính. Lưu ý rằng thuộc tính const myCar = new Car["Eagle", "Talon TSi", 1993];
0 cũng là một đối tượng có thuộc tính riêngconst myHonda = {
color: "red",
wheels: 4,
engine: { cylinders: 4, size: 2.2 },
};
Các đối tượng được tạo bằng bộ khởi tạo được gọi là các đối tượng đơn giản, bởi vì chúng là các thể hiện của
const myCar = new Car["Eagle", "Talon TSi", 1993];
1, chứ không phải bất kỳ loại đối tượng nào khác. Một số loại đối tượng có cú pháp khởi tạo đặc biệt - ví dụ: vàNgoài ra, bạn có thể tạo một đối tượng bằng hai bước sau
- Xác định loại đối tượng bằng cách viết hàm tạo. Có một quy ước mạnh mẽ, với lý do chính đáng, để sử dụng chữ cái đầu viết hoa
- Tạo một thể hiện của đối tượng với
4function Car[make, model, year] { this.make = make; this.model = model; this.year = year; }
Để xác định một 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 ô tô. Bạn muốn loại đối tượng này được gọi là
const myCar = new Car["Eagle", "Talon TSi", 1993];
3 và bạn muốn nó có các thuộc tính về kiểu dáng, kiểu dáng và năm. Để làm điều này, bạn sẽ viết chức năng saufunction Car[make, model, year] {
this.make = make;
this.model = model;
this.year = year;
}
Lưu ý việc sử dụng
const myCar = new Car["Eagle", "Talon TSi", 1993];
4 để gán giá trị cho các thuộc tính của đối tượng dựa trên các giá trị được truyền cho hàmBây giờ bạn có thể tạo một đối tượng có tên là
const myCar = new Car["Eagle", "Talon TSi", 1993];
5 như sau________số 8_______
Câu lệnh này tạo
const myCar = new Car["Eagle", "Talon TSi", 1993];
5 và gán cho nó các giá trị đã chỉ định cho các thuộc tính của nó. Sau đó, giá trị của const myCar = new Car["Eagle", "Talon TSi", 1993];
7 là chuỗi const myCar = new Car["Eagle", "Talon TSi", 1993];
8, const myCar = new Car["Eagle", "Talon TSi", 1993];
9 là chuỗi const kenscar = new Car["Nissan", "300ZX", 1992];
const vpgscar = new Car["Mazda", "Miata", 1990];
0, const kenscar = new Car["Nissan", "300ZX", 1992];
const vpgscar = new Car["Mazda", "Miata", 1990];
1 là số nguyên const kenscar = new Car["Nissan", "300ZX", 1992];
const vpgscar = new Car["Mazda", "Miata", 1990];
2, v.v. Thứ tự của các đối số và tham số phải giống nhauBạn có thể tạo bất kỳ số lượng đối tượng
const myCar = new Car["Eagle", "Talon TSi", 1993];
3 nào bằng cách gọi tới function Car[make, model, year] {
this.make = make;
this.model = model;
this.year = year;
}
4. Ví dụ,const kenscar = new Car["Nissan", "300ZX", 1992];
const vpgscar = new Car["Mazda", "Miata", 1990];
Một đối tượng có thể có một thuộc tính mà chính nó là một đối tượng khác. Ví dụ: giả sử bạn định nghĩa một đối tượng có tên là
const kenscar = new Car["Nissan", "300ZX", 1992];
const vpgscar = new Car["Mazda", "Miata", 1990];
5 như saufunction Person[name, age, sex] {
this.name = name;
this.age = age;
this.sex = sex;
}
và sau đó khởi tạo hai đối tượng
const kenscar = new Car["Nissan", "300ZX", 1992];
const vpgscar = new Car["Mazda", "Miata", 1990];
5 mới như sauconst rand = new Person["Rand McKinnon", 33, "M"];
const ken = new Person["Ken Jones", 39, "M"];
Sau đó, bạn có thể viết lại định nghĩa của
const myCar = new Car["Eagle", "Talon TSi", 1993];
3 để bao gồm thuộc tính const kenscar = new Car["Nissan", "300ZX", 1992];
const vpgscar = new Car["Mazda", "Miata", 1990];
8 nhận đối tượng const kenscar = new Car["Nissan", "300ZX", 1992];
const vpgscar = new Car["Mazda", "Miata", 1990];
5, như saufunction Car[make, model, year, owner] {
this.make = make;
this.model = model;
this.year = year;
this.owner = owner;
}
Để khởi tạo các đối tượng mới, sau đó bạn sử dụng như sau
const car1 = new Car["Eagle", "Talon TSi", 1993, rand];
const car2 = new Car["Nissan", "300ZX", 1992, ken];
Lưu ý rằng thay vì chuyển một chuỗi ký tự 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 chuyển các đối tượng
function Person[name, age, sex] {
this.name = name;
this.age = age;
this.sex = sex;
}
0 và function Person[name, age, sex] {
this.name = name;
this.age = age;
this.sex = sex;
}
1 làm đối số cho chủ sở hữu. Sau đó, nếu bạn muốn tìm tên chủ sở hữu của function Person[name, age, sex] {
this.name = name;
this.age = age;
this.sex = sex;
}
2, bạn có thể truy cập vào tài sản saulet x;
if [cond] {
x = { greeting: "hi there" };
}
0Bạn luôn có thể thêm thuộc tính vào đối tượng đã xác định trước đó. Ví dụ, tuyên bố
let x;
if [cond] {
x = { greeting: "hi there" };
}
1thêm một thuộc tính
function Person[name, age, sex] {
this.name = name;
this.age = age;
this.sex = sex;
}
3 vào function Person[name, age, sex] {
this.name = name;
this.age = age;
this.sex = sex;
}
4 và gán cho nó một giá trị là function Person[name, age, sex] {
this.name = name;
this.age = age;
this.sex = sex;
}
5. Tuy nhiên, điều này không ảnh hưởng đến bất kỳ đối tượng nào khác. Để thêm thuộc tính mới vào tất cả các đối tượng cùng loại, bạn phải thêm thuộc tính vào định nghĩa của loại đối tượng const myCar = new Car["Eagle", "Talon TSi", 1993];
3Bạn cũng có thể sử dụng cú pháp
function Person[name, age, sex] {
this.name = name;
this.age = age;
this.sex = sex;
}
7 thay vì cú pháp function Person[name, age, sex] {
this.name = name;
this.age = age;
this.sex = sex;
}
8 để xác định hàm tạo. Để biết thêm thông tin, hãy xem hướng dẫn lớp họcCác đối tượng cũng có thể được tạo bằng phương thức
function Person[name, age, sex] {
this.name = name;
this.age = age;
this.sex = sex;
}
9. Phương thức này có thể rất hữu ích vì nó cho phép bạn chọn đối tượng nguyên mẫu cho đối tượng bạn muốn tạo mà không cần phải xác định hàm tạolet x;
if [cond] {
x = { greeting: "hi there" };
}
2Một đối tượng JavaScript có các thuộc tính được liên kết với nó. Các thuộc tính đối tượng về cơ bản giống như các biến, ngoại trừ việc chúng được liên kết với các đối tượng, không phải phạm vi. Các thuộc tính của một đối tượng xác định các đặc tính của đối tượng
Ví dụ: ví dụ này tạo một đối tượng có tên là
const myCar = new Car["Eagle", "Talon TSi", 1993];
5, với các thuộc tính có tên là const rand = new Person["Rand McKinnon", 33, "M"];
const ken = new Person["Ken Jones", 39, "M"];
1, const rand = new Person["Rand McKinnon", 33, "M"];
const ken = new Person["Ken Jones", 39, "M"];
2 và const rand = new Person["Rand McKinnon", 33, "M"];
const ken = new Person["Ken Jones", 39, "M"];
3, với các giá trị của chúng được đặt thành const rand = new Person["Rand McKinnon", 33, "M"];
const ken = new Person["Ken Jones", 39, "M"];
4, const rand = new Person["Rand McKinnon", 33, "M"];
const ken = new Person["Ken Jones", 39, "M"];
5 và const rand = new Person["Rand McKinnon", 33, "M"];
const ken = new Person["Ken Jones", 39, "M"];
6let x;
if [cond] {
x = { greeting: "hi there" };
}
3Giống như các biến JavaScript, tên thuộc tính phân biệt chữ hoa chữ thường. Tên thuộc tính chỉ có thể là chuỗi hoặc Ký hiệu — tất cả các khóa đều như vậy trừ khi chúng là Ký hiệu. trên thực tế, là các thuộc tính có khóa chuỗi chứa số nguyên
Bạn có thể truy cập một thuộc tính của một đối tượng bằng tên thuộc tính của nó. Trình truy cập thuộc tính có hai cú pháp. ký hiệu dấu chấm và ký hiệu dấu ngoặc. Ví dụ: bạn có thể truy cập các thuộc tính của đối tượng
const myCar = new Car["Eagle", "Talon TSi", 1993];
5 như saulet x;
if [cond] {
x = { greeting: "hi there" };
}
4Tên thuộc tính đối tượng có thể là bất kỳ chuỗi hoặc ký hiệu JavaScript nào, kể cả chuỗi rỗng. Tuy nhiên, bạn không thể sử dụng ký hiệu dấu chấm để truy cập thuộc tính có tên không phải là mã định danh JavaScript hợp lệ. Ví dụ: tên thuộc tính có dấu cách hoặc dấu gạch ngang, bắt đầu bằng số hoặc thuộc tính được giữ bên trong biến chỉ có thể được truy cập bằng cách sử dụng ký hiệu dấu ngoặc. Ký hiệu này cũng rất hữu ích khi tên thuộc tính được xác định động. e. không thể xác định cho đến khi thời gian chạy. Ví dụ như sau
let x;
if [cond] {
x = { greeting: "hi there" };
}
5Trong đoạn mã trên, khóa
const rand = new Person["Rand McKinnon", 33, "M"];
const ken = new Person["Ken Jones", 39, "M"];
8 là một đối tượng, không phải là chuỗi cũng không phải ký hiệu. Khi nó được thêm vào const rand = new Person["Rand McKinnon", 33, "M"];
const ken = new Person["Ken Jones", 39, "M"];
9, JavaScript gọi phương thức function Car[make, model, year, owner] {
this.make = make;
this.model = model;
this.year = year;
this.owner = owner;
}
0 của const rand = new Person["Rand McKinnon", 33, "M"];
const ken = new Person["Ken Jones", 39, "M"];
8 và sử dụng chuỗi kết quả làm khóa mớiBạn cũng có thể truy cập các thuộc tính có giá trị chuỗi được lưu trữ trong một biến. Biến phải được truyền trong ký hiệu ngoặc. Trong ví dụ trên, biến
function Car[make, model, year, owner] {
this.make = make;
this.model = model;
this.year = year;
this.owner = owner;
}
2 được giữ _____34_______3 và _____34_______3 là tên thuộc tính. Do đó, function Car[make, model, year, owner] {
this.make = make;
this.model = model;
this.year = year;
this.owner = owner;
}
5 sẽ trả về là không xác địnhlet x;
if [cond] {
x = { greeting: "hi there" };
}
6Điều này cho phép truy cập bất kỳ thuộc tính nào được xác định trong thời gian chạy
let x;
if [cond] {
x = { greeting: "hi there" };
}
7Tuy nhiên, hãy cẩn thận khi sử dụng dấu ngoặc vuông để truy cập các thuộc tính có tên được cung cấp bởi đầu vào bên ngoài. Điều này có thể khiến mã của bạn dễ bị tấn công bằng cách tiêm đối tượng
Các thuộc tính không tồn tại của một đối tượng có giá trị
function Car[make, model, year, owner] {
this.make = make;
this.model = model;
this.year = year;
this.owner = owner;
}
6 [chứ không phải function Car[make, model, year, owner] {
this.make = make;
this.model = model;
this.year = year;
this.owner = owner;
}
7]let x;
if [cond] {
x = { greeting: "hi there" };
}
8Có ba cách riêng để liệt kê/duyệt các thuộc tính đối tượng
8 vòng. Phương thức này duyệt qua tất cả các thuộc tính chuỗi có thể đếm được của một đối tượng cũng như chuỗi nguyên mẫu của nófunction Car[make, model, year, owner] { this.make = make; this.model = model; this.year = year; this.owner = owner; }
9. Phương thức này trả về một mảng chỉ có vô số tên thuộc tính chuỗi riêng ["khóa"] trong đối tượngfunction Car[make, model, year, owner] { this.make = make; this.model = model; this.year = year; this.owner = owner; }
9, chứ không phải những tên trong chuỗi nguyên mẫuconst rand = new Person["Rand McKinnon", 33, "M"]; const ken = new Person["Ken Jones", 39, "M"];
1. 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ượngconst car1 = new Car["Eagle", "Talon TSi", 1993, rand]; const car2 = new Car["Nissan", "300ZX", 1992, ken];
9, bất kể chúng có đếm được hay khôngconst rand = new Person["Rand McKinnon", 33, "M"]; const ken = new Person["Ken Jones", 39, "M"];
Bạn có thể sử dụng ký hiệu ngoặc với
function Car[make, model, year, owner] {
this.make = make;
this.model = model;
this.year = year;
this.owner = owner;
}
8 để lặp qua tất cả các thuộc tính có thể đếm được của một đối tượng. Để minh họa cách thức hoạt động của tính năng này, hàm sau đây sẽ hiển thị các thuộc tính của đối tượng khi bạn chuyển đối tượng và tên của đối tượng làm đối số cho hàmlet x;
if [cond] {
x = { greeting: "hi there" };
}
9Thuật ngữ "tài sản riêng" dùng để chỉ 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, lệnh gọi hàm
const car1 = new Car["Eagle", "Talon TSi", 1993, rand];
const car2 = new Car["Nissan", "300ZX", 1992, ken];
4 sẽ in như sauconst myHonda = {
color: "red",
wheels: 4,
engine: { cylinders: 4, size: 2.2 },
};
0Ở trên là tương đương với
const myHonda = {
color: "red",
wheels: 4,
engine: { cylinders: 4, size: 2.2 },
};
1Không có cách riêng để liệt kê các thuộc tính không thể đếm được kế thừa. Tuy nhiên, điều này có thể đạt được với chức năng sau
const myHonda = {
color: "red",
wheels: 4,
engine: { cylinders: 4, size: 2.2 },
};
2Để biết thêm thông tin, hãy xem Tính đếm được và quyền sở hữu tài sản
Bạn có thể xóa thuộc tính không được kế thừa bằng cách sử dụng toán tử
const car1 = new Car["Eagle", "Talon TSi", 1993, rand];
const car2 = new Car["Nissan", "300ZX", 1992, ken];
5. Đoạn mã sau cho biết cách xóa một thuộc tínhconst myHonda = {
color: "red",
wheels: 4,
engine: { cylinders: 4, size: 2.2 },
};
3Tấ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 kế thừa từ đó được gọi là nguyên mẫu và các thuộc tính được kế thừa có thể được tìm thấy trong đối tượng
const car1 = new Car["Eagle", "Talon TSi", 1993, rand];
const car2 = new Car["Nissan", "300ZX", 1992, ken];
6 của hàm tạo. Xem Kế thừa và chuỗi nguyên mẫu để biết thêm thông tinBạn có thể thêm một thuộc tính cho tất cả các đối tượng được tạo thông qua một thuộc tính nhất định bằng cách sử dụng thuộc tính
const car1 = new Car["Eagle", "Talon TSi", 1993, rand];
const car2 = new Car["Nissan", "300ZX", 1992, ken];
6. Điều này xác định một thuộc tính được chia sẻ bởi tất cả các đối tượng thuộc loại đã chỉ định, thay vì chỉ bởi một phiên bản của đối tượng. Đoạn mã sau thêm thuộc tính function Person[name, age, sex] {
this.name = name;
this.age = age;
this.sex = sex;
}
3 vào tất cả các đối tượng thuộc loại const myCar = new Car["Eagle", "Talon TSi", 1993];
3, sau đó đọc giá trị của thuộc tính từ một thể hiện function Person[name, age, sex] {
this.name = name;
this.age = age;
this.sex = sex;
}
4const myHonda = {
color: "red",
wheels: 4,
engine: { cylinders: 4, size: 2.2 },
};
4Một phương thức là một hàm được liên kết với một đối tượng, hay nói cách khác, 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 định nghĩa theo cách định nghĩa các hàm thông thường, ngoại trừ việc chúng phải được gán làm 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à
const myHonda = {
color: "red",
wheels: 4,
engine: { cylinders: 4, size: 2.2 },
};
5trong đó
let x;
if [cond] {
x = { greeting: "hi there" };
}
01 là một đối tượng hiện có, let x;
if [cond] {
x = { greeting: "hi there" };
}
02 là tên bạn đang gán cho phương thức và let x;
if [cond] {
x = { greeting: "hi there" };
}
03 là tên của hàmSau đó, bạn có thể gọi phương thức trong ngữ cảnh của đối tượng như sau
const myHonda = {
color: "red",
wheels: 4,
engine: { cylinders: 4, size: 2.2 },
};
6Các phương thức thường được định nghĩa trên đối tượng
const car1 = new Car["Eagle", "Talon TSi", 1993, rand];
const car2 = new Car["Nissan", "300ZX", 1992, ken];
6 của hàm tạo, để tất cả các đối tượng cùng loại chia sẻ cùng một phương thức. Ví dụ: bạn có thể xác định một hàm định dạng và hiển thị các thuộc tính của đối tượng const myCar = new Car["Eagle", "Talon TSi", 1993];
3 đã xác định trước đóconst myHonda = {
color: "red",
wheels: 4,
engine: { cylinders: 4, size: 2.2 },
};
7Lưu ý việc sử dụng
const myCar = new Car["Eagle", "Talon TSi", 1993];
4 để chỉ đối tượng mà phương thức thuộc về. Sau đó, bạn có thể gọi phương thức let x;
if [cond] {
x = { greeting: "hi there" };
}
07 cho từng đối tượng như sauconst myHonda = {
color: "red",
wheels: 4,
engine: { cylinders: 4, size: 2.2 },
};
8JavaScript có một từ khóa đặc biệt,
const myCar = new Car["Eagle", "Talon TSi", 1993];
4, mà bạn có thể sử dụng trong một phương thức để tham chiếu đến đối tượng hiện tại. Ví dụ: giả sử bạn có 2 đối tượng, let x;
if [cond] {
x = { greeting: "hi there" };
}
09 và let x;
if [cond] {
x = { greeting: "hi there" };
}
10. Mỗi đối tượng có riêng của mình let x;
if [cond] {
x = { greeting: "hi there" };
}
11, let x;
if [cond] {
x = { greeting: "hi there" };
}
12 và let x;
if [cond] {
x = { greeting: "hi there" };
}
13. Trong hàm let x;
if [cond] {
x = { greeting: "hi there" };
}
14, lưu ý việc sử dụng let x;
if [cond] {
x = { greeting: "hi there" };
}
15. Khi được thêm vào 2 đối tượng, cùng một chức năng sẽ in thông báo có tên của đối tượng tương ứng mà nó được đính kèmconst myHonda = {
color: "red",
wheels: 4,
engine: { cylinders: 4, size: 2.2 },
};
9const myCar = new Car["Eagle", "Talon TSi", 1993];
4 là một "tham số ẩn" của lệnh gọi hàm được truyền vào bằng cách chỉ định đối tượng trước hàm được gọi. Ví dụ, trong let x;
if [cond] {
x = { greeting: "hi there" };
}
17, const myCar = new Car["Eagle", "Talon TSi", 1993];
4 là đối tượng let x;
if [cond] {
x = { greeting: "hi there" };
}
09, bởi vì let x;
if [cond] {
x = { greeting: "hi there" };
}
09 đứng trước hàm let x;
if [cond] {
x = { greeting: "hi there" };
}
14. Nếu bạn truy cập chức năng tương tự từ một đối tượng khác, thì const myCar = new Car["Eagle", "Talon TSi", 1993];
4 cũng sẽ thay đổi. Nếu bạn sử dụng các phương thức khác để gọi hàm, chẳng hạn như let x;
if [cond] {
x = { greeting: "hi there" };
}
23 hoặc let x;
if [cond] {
x = { greeting: "hi there" };
}
24, bạn có thể chuyển giá trị của const myCar = new Car["Eagle", "Talon TSi", 1993];
4 làm đối số một cách rõ ràngGetter là một hàm được liên kết với một thuộc tính nhận giá trị của một thuộc tính cụ thể. Một setter là một chức năng được liên kết với một thuộc tính đặt giá trị của một thuộc tính cụ thể. Cùng với nhau, chúng có thể gián tiếp đại diện cho giá trị của một tài sản
Getters và setters có thể là một trong hai
- được xác định trong phạm vi , hoặc
- được thêm sau vào bất kỳ đối tượng hiện có nào
Trong , getters và setters được định nghĩa giống như các phương thức thông thường, nhưng có tiền tố là các từ khóa
let x;
if [cond] {
x = { greeting: "hi there" };
}
26 hoặc let x;
if [cond] {
x = { greeting: "hi there" };
}
27. Phương thức getter không được mong đợi một tham số, trong khi phương thức setter mong đợi chính xác một tham số [giá trị mới được đặt]. Ví dụfunction Car[make, model, year] {
this.make = make;
this.model = model;
this.year = year;
}
0Các thuộc tính của đối tượng
const rand = new Person["Rand McKinnon", 33, "M"];
const ken = new Person["Ken Jones", 39, "M"];
9 là
29 — một con sốlet x; if [cond] { x = { greeting: "hi there" }; }
30 — một getter trả vềlet x; if [cond] { x = { greeting: "hi there" }; }
29 cộng 1let x; if [cond] { x = { greeting: "hi there" }; }
32 — một setter đặt giá trị củalet x; if [cond] { x = { greeting: "hi there" }; }
29 thành một nửa giá trịlet x; if [cond] { x = { greeting: "hi there" }; }
32 đang được đặt thànhlet x; if [cond] { x = { greeting: "hi there" }; }
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 cách sử dụng phương thức
let x;
if [cond] {
x = { greeting: "hi there" };
}
35. Tham số đầu tiên của phương thức này là đối tượng mà bạn muốn xác định getter hoặc setter. Tham số thứ hai là một đối tượng có tên thuộc tính là tên getter hoặc setter và giá trị thuộc tính của nó là đối tượng để xác định hàm getter hoặc setter. Đây là một ví dụ xác định cùng một getter và setter được sử dụng trong ví dụ trướcfunction Car[make, model, year] {
this.make = make;
this.model = model;
this.year = year;
}
1Lựa chọn hình thức nào trong hai hình thức tùy thuộc vào phong cách lập trình và nhiệm vụ của bạn. Nếu bạn có thể thay đổi định nghĩa của đối tượng ban đầu, bạn có thể sẽ xác định getters và setters thông qua trình khởi tạo ban đầu. 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 này — có thể do bạn không viết đối tượng cụ thể — thì biểu mẫu thứ hai là biểu mẫu khả thi duy nhất. Dạng thứ hai thể hiện tốt hơn bản chất động của JavaScript, nhưng nó có thể khiến mã khó đọc và khó hiểu
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ó mới mang lại kết quả đúng