Toán tử
3 cho phép các nhà phát triển tạo một thể hiện của loại đối tượng do người dùng xác định hoặc của một trong các loại đối tượng tích hợp có hàm tạo hàm.function Foo[bar1, bar2] {
this.bar1 = bar1;
this.bar2 = bar2;
}
3 operator lets developers create an instance of a user-defined object type or of one of the built-in object types that has a constructor function.function Foo[bar1, bar2] {
this.bar1 = bar1;
this.bar2 = bar2;
}
Thử nó
Cú pháp
new constructor
new constructor[]
new constructor[arg1]
new constructor[arg1, arg2]
new constructor[arg1, arg2, /* …, */ argN]
Thông số
function Foo[bar1, bar2] {
this.bar1 = bar1;
this.bar2 = bar2;
}
4Một lớp hoặc hàm chỉ định loại thể hiện đối tượng.
function Foo[bar1, bar2] {
this.bar1 = bar1;
this.bar2 = bar2;
}
5, function Foo[bar1, bar2] {
this.bar1 = bar1;
this.bar2 = bar2;
}
6, xông, function Foo[bar1, bar2] {
this.bar1 = bar1;
this.bar2 = bar2;
}
7Một danh sách các giá trị mà
function Foo[bar1, bar2] {
this.bar1 = bar1;
this.bar2 = bar2;
}
4 sẽ được gọi với. function Foo[bar1, bar2] {
this.bar1 = bar1;
this.bar2 = bar2;
}
9 tương đương với const myFoo = new Foo['Bar 1', 2021];
0, tức là nếu không có danh sách đối số nào được chỉ định, const myFoo = new Foo['Bar 1', 2021];
1 được gọi mà không có đối số.Sự mô tả
Khi một hàm được gọi với từ khóa
function Foo[bar1, bar2] {
this.bar1 = bar1;
this.bar2 = bar2;
}
3, hàm sẽ được sử dụng làm hàm tạo. function Foo[bar1, bar2] {
this.bar1 = bar1;
this.bar2 = bar2;
}
3 sẽ làm những việc sau:function Foo[bar1, bar2] {
this.bar1 = bar1;
this.bar2 = bar2;
}
3 keyword, the function will be used as a constructor. function Foo[bar1, bar2] {
this.bar1 = bar1;
this.bar2 = bar2;
}
3 will do the following things:- Tạo một đối tượng JavaScript trống, đơn giản. Để thuận tiện, hãy gọi nó là
4.const myFoo = new Foo['Bar 1', 2021];
- Các điểm ________ 24 [[nguyên mẫu]] cho thuộc tính
6 của hàm xây dựng, nếuconst myFoo = new Foo['Bar 1', 2021];
6 làconst myFoo = new Foo['Bar 1', 2021];
8. Mặt khác,const myFoo = new Foo['Bar 1', 2021];
4 vẫn là một đối tượng đơn giản vớiconst myFoo = new Foo['Bar 1', 2021];
0 như [[nguyên mẫu]].function Car[] {} const car1 = new Car[]; const car2 = new Car[]; console.log[car1.color]; // undefined Car.prototype.color = 'original color'; console.log[car1.color]; // 'original color' car1.color = 'black'; console.log[car1.color]; // 'black' console.log[Object.getPrototypeOf[car1].color]; // 'original color' console.log[Object.getPrototypeOf[car2].color]; // 'original color' console.log[car1.color]; // 'black' console.log[car2.color]; // 'original color'
Lưu ý: Do đó, các thuộc tính/đối tượng được thêm vào thuộc tính
6 của hàm xây dựng có thể truy cập được cho tất cả các trường hợp được tạo từ hàm hàm tạo. Properties/objects added to the constructor function'sconst myFoo = new Foo['Bar 1', 2021];
6 property are therefore accessible to all instances created from the constructor function.const myFoo = new Foo['Bar 1', 2021];
- Thực thi hàm hàm tạo với các đối số đã cho, liên kết
4 là bối cảnhconst myFoo = new Foo['Bar 1', 2021];
3 [nghĩa là tất cả các tham chiếu đếnfunction Car[] {} const car1 = new Car[]; const car2 = new Car[]; console.log[car1.color]; // undefined Car.prototype.color = 'original color'; console.log[car1.color]; // 'original color' car1.color = 'black'; console.log[car1.color]; // 'black' console.log[Object.getPrototypeOf[car1].color]; // 'original color' console.log[Object.getPrototypeOf[car2].color]; // 'original color' console.log[car1.color]; // 'black' console.log[car2.color]; // 'original color'
3 trong hàm hàm tạo hiện tham khảofunction Car[] {} const car1 = new Car[]; const car2 = new Car[]; console.log[car1.color]; // undefined Car.prototype.color = 'original color'; console.log[car1.color]; // 'original color' car1.color = 'black'; console.log[car1.color]; // 'black' console.log[Object.getPrototypeOf[car1].color]; // 'original color' console.log[Object.getPrototypeOf[car2].color]; // 'original color' console.log[car1.color]; // 'black' console.log[car2.color]; // 'original color'
4].const myFoo = new Foo['Bar 1', 2021];
- Nếu hàm hàm tạo trả về không nguyên thủy, giá trị trả về này sẽ trở thành kết quả của toàn bộ biểu thức
3. Mặt khác, nếu hàm hàm tạo không trả về bất cứ điều gì hoặc trả về nguyên thủy, thay vào đó,function Foo[bar1, bar2] { this.bar1 = bar1; this.bar2 = bar2; }
4 sẽ được trả về. .const myFoo = new Foo['Bar 1', 2021];
Các lớp chỉ có thể được khởi tạo với toán tử
function Foo[bar1, bar2] {
this.bar1 = bar1;
this.bar2 = bar2;
}
3 - cố gắng gọi một lớp mà không có function Foo[bar1, bar2] {
this.bar1 = bar1;
this.bar2 = bar2;
}
3 sẽ ném function Car[color] {
if [!new.target] {
// Called as function.
return `${color} car`;
}
// Called with new.
this.color = color;
}
const a = Car["red"]; // a is "red car"
const b = new Car["red"]; // b is `Car { color: "red" }`
0.Tạo một đối tượng có chức năng xây dựng do người dùng xác định yêu cầu hai bước:
- Xác định loại đối tượng bằng cách viết một hàm chỉ định tên và thuộc tính của nó. Ví dụ: hàm tạo hàm để tạo đối tượng
1 có thể trông như thế này:const myFoo = new Foo['Bar 1', 2021];
function Foo[bar1, bar2] { this.bar1 = bar1; this.bar2 = bar2; }
- Tạo một thể hiện của đối tượng với
3.function Foo[bar1, bar2] { this.bar1 = bar1; this.bar2 = bar2; }
const myFoo = new Foo['Bar 1', 2021];
Lưu ý: Một đối tượng có thể có một thuộc tính tự nó là một đối tượng khác. Xem các ví dụ dưới đây. An object can have a property that is itself another object. See the examples below.
Bạn luôn có thể thêm một thuộc tính vào một thể hiện đối tượng được xác định trước đó. Ví dụ: câu lệnh
function Car[color] {
if [!new.target] {
// Called as function.
return `${color} car`;
}
// Called with new.
this.color = color;
}
const a = Car["red"]; // a is "red car"
const b = new Car["red"]; // b is `Car { color: "red" }`
3 thêm một thuộc tính function Car[color] {
if [!new.target] {
// Called as function.
return `${color} car`;
}
// Called with new.
this.color = color;
}
const a = Car["red"]; // a is "red car"
const b = new Car["red"]; // b is `Car { color: "red" }`
4 vào function Car[color] {
if [!new.target] {
// Called as function.
return `${color} car`;
}
// Called with new.
this.color = color;
}
const a = Car["red"]; // a is "red car"
const b = new Car["red"]; // b is `Car { color: "red" }`
5 và gán cho nó một giá trị là function Car[color] {
if [!new.target] {
// Called as function.
return `${color} car`;
}
// Called with new.
this.color = color;
}
const a = Car["red"]; // a is "red car"
const b = new Car["red"]; // b is `Car { color: "red" }`
6.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 thuộc tính
const myFoo = new Foo['Bar 1', 2021];
6 của hàm tạo. Đ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 được tạo với chức năng đó, thay vì chỉ bằng một thể hiện của loại đối tượng. Mã sau đây thêm thuộc tính function Car[color] {
if [!new.target] {
// Called as function.
return `${color} car`;
}
// Called with new.
this.color = color;
}
const a = Car["red"]; // a is "red car"
const b = new Car["red"]; // b is `Car { color: "red" }`
4 có giá trị function Car[color] {
if [!new.target] {
// Called as function.
return `${color} car`;
}
// Called with new.
this.color = color;
}
const a = Car["red"]; // a is "red car"
const b = new Car["red"]; // b is `Car { color: "red" }`
9 cho tất cả các đối tượng thuộc loại function Car[make, model, year] {
this.make = make;
this.model = model;
this.year = year;
}
0, sau đó ghi lại giá trị đó bằng chuỗi function Car[color] {
if [!new.target] {
// Called as function.
return `${color} car`;
}
// Called with new.
this.color = color;
}
const a = Car["red"]; // a is "red car"
const b = new Car["red"]; // b is `Car { color: "red" }`
6 chỉ trong đối tượng thể hiện function Car[color] {
if [!new.target] {
// Called as function.
return `${color} car`;
}
// Called with new.
this.color = color;
}
const a = Car["red"]; // a is "red car"
const b = new Car["red"]; // b is `Car { color: "red" }`
5. Để biết thêm thông tin, xem nguyên mẫu.function Car[] {}
const car1 = new Car[];
const car2 = new Car[];
console.log[car1.color]; // undefined
Car.prototype.color = 'original color';
console.log[car1.color]; // 'original color'
car1.color = 'black';
console.log[car1.color]; // 'black'
console.log[Object.getPrototypeOf[car1].color]; // 'original color'
console.log[Object.getPrototypeOf[car2].color]; // 'original color'
console.log[car1.color]; // 'black'
console.log[car2.color]; // 'original color'
Lưu ý: Mặc dù hàm hàm tạo có thể được gọi giống như bất kỳ hàm chính quy nào [nghĩa là không có toán tử
3], trong trường hợp này, một đối tượng mới không được tạo và giá trị của function Foo[bar1, bar2] {
this.bar1 = bar1;
this.bar2 = bar2;
}
3 cũng khác nhau. While the constructor function can be invoked like any regular function [i.e. without the function Car[] {}
const car1 = new Car[];
const car2 = new Car[];
console.log[car1.color]; // undefined
Car.prototype.color = 'original color';
console.log[car1.color]; // 'original color'
car1.color = 'black';
console.log[car1.color]; // 'black'
console.log[Object.getPrototypeOf[car1].color]; // 'original color'
console.log[Object.getPrototypeOf[car2].color]; // 'original color'
console.log[car1.color]; // 'black'
console.log[car2.color]; // 'original color'
function Foo[bar1, bar2] {
this.bar1 = bar1;
this.bar2 = bar2;
}
3 operator], in this case a new object is not created and the value of function Car[] {}
const car1 = new Car[];
const car2 = new Car[];
console.log[car1.color]; // undefined
Car.prototype.color = 'original color';
console.log[car1.color]; // 'original color'
car1.color = 'black';
console.log[car1.color]; // 'black'
console.log[Object.getPrototypeOf[car1].color]; // 'original color'
console.log[Object.getPrototypeOf[car2].color]; // 'original color'
console.log[car1.color]; // 'black'
console.log[car2.color]; // 'original color'
3 is also different. Một chức năng có thể biết liệu nó có được gọi bằng
function Foo[bar1, bar2] {
this.bar1 = bar1;
this.bar2 = bar2;
}
3 hay không bằng cách kiểm tra function Car[make, model, year] {
this.make = make;
this.model = model;
this.year = year;
}
6. function Car[make, model, year] {
this.make = make;
this.model = model;
this.year = year;
}
6 chỉ là function Car[make, model, year] {
this.make = make;
this.model = model;
this.year = year;
}
8 khi hàm được gọi mà không có function Foo[bar1, bar2] {
this.bar1 = bar1;
this.bar2 = bar2;
}
3. Ví dụ: bạn có thể có một chức năng hoạt động khác nhau khi nó được gọi là so với khi nó được xây dựng:function Car[color] {
if [!new.target] {
// Called as function.
return `${color} car`;
}
// Called with new.
this.color = color;
}
const a = Car["red"]; // a is "red car"
const b = new Car["red"]; // b is `Car { color: "red" }`
Trước ES6, trong đó giới thiệu các lớp, hầu hết các bản dựng JavaScript đều có thể gọi và có thể xây dựng, mặc dù nhiều trong số chúng thể hiện các hành vi khác nhau. Đến tên một vài:
0,const myCar = new Car['Eagle', 'Talon TSi', 1993];
1 vàconst myCar = new Car['Eagle', 'Talon TSi', 1993];
2 hoạt động giống nhau khi được gọi là hàm hoặc hàm tạo.const myCar = new Car['Eagle', 'Talon TSi', 1993];
3,const myCar = new Car['Eagle', 'Talon TSi', 1993];
4 vàconst myCar = new Car['Eagle', 'Talon TSi', 1993];
5 ép buộc đối số của họ với loại nguyên thủy tương ứng khi được gọi và trả về các đối tượng bao bọc khi được xây dựng.const myCar = new Car['Eagle', 'Talon TSi', 1993];
6 Trả về một chuỗi đại diện cho ngày hiện tại khi được gọi, tương đương vớiconst myCar = new Car['Eagle', 'Talon TSi', 1993];
7.const myCar = new Car['Eagle', 'Talon TSi', 1993];
Sau ES6, ngôn ngữ nghiêm ngặt hơn về các hàm tạo và là các chức năng. Ví dụ:
8 vàconst myCar = new Car['Eagle', 'Talon TSi', 1993];
9 chỉ có thể được gọi mà không cóconst myCar = new Car['Eagle', 'Talon TSi', 1993];
3. Cố gắng xây dựng chúng sẽ némfunction Foo[bar1, bar2] { this.bar1 = bar1; this.bar2 = bar2; }
0.function Car[color] { if [!new.target] { // Called as function. return `${color} car`; } // Called with new. this.color = color; } const a = Car["red"]; // a is "red car" const b = new Car["red"]; // b is `Car { color: "red" }`
2 vàconst kensCar = new Car['Nissan', '300ZX', 1992];
3 chỉ có thể được xây dựng vớiconst kensCar = new Car['Nissan', '300ZX', 1992];
3. Cố gắng gọi họ sẽ némfunction Foo[bar1, bar2] { this.bar1 = bar1; this.bar2 = bar2; }
0.function Car[color] { if [!new.target] { // Called as function. return `${color} car`; } // Called with new. this.color = color; } const a = Car["red"]; // a is "red car" const b = new Car["red"]; // b is `Car { color: "red" }`
Ví dụ
Loại đối tượng và thể hiện đối tượng
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à
function Car[make, model, year] {
this.make = make;
this.model = model;
this.year = year;
}
0 và bạn muốn nó có thuộc tính để tạo, mô hình và năm. Để làm điều này, bạn sẽ viết chức năng sau:function Car[make, model, year] {
this.make = make;
this.model = model;
this.year = year;
}
Bây giờ bạn có thể tạo một đối tượng được gọi là
const kensCar = new Car['Nissan', '300ZX', 1992];
7 như sau:const myCar = new Car['Eagle', 'Talon TSi', 1993];
Câu lệnh này tạo ra
const kensCar = new Car['Nissan', '300ZX', 1992];
7 và gán nó các giá trị được chỉ định cho các thuộc tính của nó. Sau đó, giá trị của const kensCar = new Car['Nissan', '300ZX', 1992];
9 là chuỗi "đại bàng", function Person[name, age, sex] {
this.name = name;
this.age = age;
this.sex = sex;
}
0 là số nguyên năm 1993, v.v.Bạn có thể tạo bất kỳ số lượng đối tượng
function Person[name, age, sex] {
this.name = name;
this.age = age;
this.sex = sex;
}
1 bằng các cuộc gọi đến function Foo[bar1, bar2] {
this.bar1 = bar1;
this.bar2 = bar2;
}
3. Ví dụ:const kensCar = new Car['Nissan', '300ZX', 1992];
Thuộc tính đối tượng tự nó là một đối tượng khác
Giả sử bạn xác định một đối tượng được gọi là
function Person[name, age, sex] {
this.name = name;
this.age = age;
this.sex = sex;
}
3 như sau:function Person[name, age, sex] {
this.name = name;
this.age = age;
this.sex = sex;
}
Và sau đó khởi tạo hai đối tượng
function Person[name, age, sex] {
this.name = name;
this.age = age;
this.sex = sex;
}
3 mới như sau:const rand = new Person['Rand McNally', 33, 'M'];
const ken = new Person['Ken Jones', 39, 'M'];
Sau đó, bạn có thể viết lại định nghĩa của
function Car[make, model, year] {
this.make = make;
this.model = model;
this.year = year;
}
0 để bao gồm một thuộc tính function Person[name, age, sex] {
this.name = name;
this.age = age;
this.sex = sex;
}
6 có đối tượng function Person[name, age, sex] {
this.name = name;
this.age = age;
this.sex = sex;
}
3, như sau:function Foo[bar1, bar2] {
this.bar1 = bar1;
this.bar2 = bar2;
}
0Để khởi tạo các đối tượng mới, sau đó bạn sử dụng các đối tượng sau:
function Foo[bar1, bar2] {
this.bar1 = bar1;
this.bar2 = bar2;
}
1Thay 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
function Person[name, age, sex] {
this.name = name;
this.age = age;
this.sex = sex;
}
8 và function Person[name, age, sex] {
this.name = name;
this.age = age;
this.sex = sex;
}
9 làm tham số cho chủ sở hữu. Để tìm ra tên của chủ sở hữu của const rand = new Person['Rand McNally', 33, 'M'];
const ken = new Person['Ken Jones', 39, 'M'];
0, bạn có thể truy cập thuộc tính sau:Sử dụng function Foo[bar1, bar2] {
this.bar1 = bar1;
this.bar2 = bar2;
}
3 với các lớp
function Foo[bar1, bar2] {
this.bar1 = bar1;
this.bar2 = bar2;
}
function Foo[bar1, bar2] {
this.bar1 = bar1;
this.bar2 = bar2;
}
2Thông số kỹ thuật
Đặc tả ngôn ngữ Ecmascript # Sec-New-Experator # sec-new-operator |
Tính tương thích của trình duyệt web
Bảng BCD chỉ tải trong trình duyệt