Từ khóa siêu được sử dụng để truy cập các thuộc tính trên một đối tượng theo nghĩa đen hoặc [[nguyên mẫu]] của lớp hoặc gọi hàm tạo của siêu lớp.super keyword is used to access properties on an object literal or class's [[Prototype]], or invoke a superclass's constructor. Các biểu thức
4 và const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
5 có giá trị trong bất kỳ định nghĩa phương thức nào trong cả hai lớp và chữ cái. Biểu thức const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
6 là hợp lệ trong các hàm tạo lớp.const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
Cú pháp
super[[arguments]] // calls the parent constructor.
super.propertyOnParent
super[expression]
Sự mô tả
Từ khóa
const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
7 có thể được sử dụng theo hai cách: như một "cuộc gọi chức năng" [const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
6] hoặc như một "tra cứu thuộc tính" [const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
4 và const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
5].Lưu ý:
7 là một từ khóa và đây là các cấu trúc cú pháp đặc biệt. const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
7 không phải là một biến chỉ vào đối tượng nguyên mẫu. Cố gắng đọc const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
7 là một const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
4. class Rectangle {
constructor[height, width] {
this.name = 'Rectangle';
this.height = height;
this.width = width;
}
sayName[] {
console.log[`Hi, I am a ${this.name}.`];
}
get area[] {
return this.height * this.width;
}
set area[value] {
this._area = value;
}
}
class Square extends Rectangle {
constructor[length] {
this.height; // ReferenceError, super needs to be called first!
// Here, it calls the parent class's constructor with lengths
// provided for the Rectangle's width and height
super[length, length];
// Note: In derived classes, super[] must be called before you
// can use 'this'. Leaving this out will cause a reference error.
this.name = 'Square';
}
}
const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
7 is a keyword and these are special syntactic constructs. const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
7 is not a variable that points to the prototype object. Attempting to read const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
7 itself is a class Rectangle {
constructor[height, width] {
this.name = 'Rectangle';
this.height = height;
this.width = width;
}
sayName[] {
console.log[`Hi, I am a ${this.name}.`];
}
get area[] {
return this.height * this.width;
}
set area[value] {
this._area = value;
}
}
class Square extends Rectangle {
constructor[length] {
this.height; // ReferenceError, super needs to be called first!
// Here, it calls the parent class's constructor with lengths
// provided for the Rectangle's width and height
super[length, length];
// Note: In derived classes, super[] must be called before you
// can use 'this'. Leaving this out will cause a reference error.
this.name = 'Square';
}
}
4.const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
Trong thân hàm xây dựng của một lớp dẫn xuất [với
class Rectangle {
constructor[height, width] {
this.name = 'Rectangle';
this.height = height;
this.width = width;
}
sayName[] {
console.log[`Hi, I am a ${this.name}.`];
}
get area[] {
return this.height * this.width;
}
set area[value] {
this._area = value;
}
}
class Square extends Rectangle {
constructor[length] {
this.height; // ReferenceError, super needs to be called first!
// Here, it calls the parent class's constructor with lengths
// provided for the Rectangle's width and height
super[length, length];
// Note: In derived classes, super[] must be called before you
// can use 'this'. Leaving this out will cause a reference error.
this.name = 'Square';
}
}
5], từ khóa const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
7 có thể xuất hiện dưới dạng "gọi chức năng" [const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
6], phải được gọi trước từ khóa class Rectangle {
constructor[height, width] {
this.name = 'Rectangle';
this.height = height;
this.width = width;
}
sayName[] {
console.log[`Hi, I am a ${this.name}.`];
}
get area[] {
return this.height * this.width;
}
set area[value] {
this._area = value;
}
}
class Square extends Rectangle {
constructor[length] {
this.height; // ReferenceError, super needs to be called first!
// Here, it calls the parent class's constructor with lengths
// provided for the Rectangle's width and height
super[length, length];
// Note: In derived classes, super[] must be called before you
// can use 'this'. Leaving this out will cause a reference error.
this.name = 'Square';
}
}
8 được sử dụng và trước khi trở lại của hàm tạo. Nó gọi hàm tạo của lớp cha và liên kết các trường công khai của lớp cha, sau đó hàm tạo của lớp dẫn xuất có thể truy cập và sửa đổi class Rectangle {
constructor[height, width] {
this.name = 'Rectangle';
this.height = height;
this.width = width;
}
sayName[] {
console.log[`Hi, I am a ${this.name}.`];
}
get area[] {
return this.height * this.width;
}
set area[value] {
this._area = value;
}
}
class Square extends Rectangle {
constructor[length] {
this.height; // ReferenceError, super needs to be called first!
// Here, it calls the parent class's constructor with lengths
// provided for the Rectangle's width and height
super[length, length];
// Note: In derived classes, super[] must be called before you
// can use 'this'. Leaving this out will cause a reference error.
this.name = 'Square';
}
}
8.Mẫu "Tra cứu thuộc tính" có thể được sử dụng để truy cập các phương thức và thuộc tính của một đối tượng theo nghĩa đen hoặc lớp [[nguyên mẫu]]. Trong cơ thể của một lớp, tham chiếu của
const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
7 có thể là chính hàm tạo của siêu lớp hoặc class Rectangle {
static logNbSides[] {
return 'I have 4 sides';
}
}
class Square extends Rectangle {
static logDescription[] {
return `${super.logNbSides[]} which are all equal`;
}
}
Square.logDescription[]; // 'I have 4 sides which are all equal'
1 của nhà xây dựng, tùy thuộc vào bối cảnh thực thi là tạo thể hiện hay khởi tạo lớp. Xem phần ví dụ để biết thêm chi tiết.Lưu ý rằng tham chiếu của
const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
7 được xác định bởi lớp hoặc đối tượng theo nghĩa đen const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
7 được khai báo, không phải đối tượng mà phương thức được gọi. Do đó, không liên kết hoặc gắn lại một phương thức không thay đổi tham chiếu của const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
7 trong đó [mặc dù chúng thay đổi tham chiếu của class Rectangle {
constructor[height, width] {
this.name = 'Rectangle';
this.height = height;
this.width = width;
}
sayName[] {
console.log[`Hi, I am a ${this.name}.`];
}
get area[] {
return this.height * this.width;
}
set area[value] {
this._area = value;
}
}
class Square extends Rectangle {
constructor[length] {
this.height; // ReferenceError, super needs to be called first!
// Here, it calls the parent class's constructor with lengths
// provided for the Rectangle's width and height
super[length, length];
// Note: In derived classes, super[] must be called before you
// can use 'this'. Leaving this out will cause a reference error.
this.name = 'Square';
}
}
8]. Bạn có thể thấy const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
7 là một biến trong phạm vi theo nghĩa đen của lớp hoặc đối tượng, mà các phương thức tạo ra đóng cửa. [Nhưng cũng cẩn thận rằng nó không thực sự không phải là một biến, như đã giải thích ở trên.]Khi cài đặt thuộc tính thông qua
const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
7, thuộc tính được đặt trên class Rectangle {
constructor[height, width] {
this.name = 'Rectangle';
this.height = height;
this.width = width;
}
sayName[] {
console.log[`Hi, I am a ${this.name}.`];
}
get area[] {
return this.height * this.width;
}
set area[value] {
this._area = value;
}
}
class Square extends Rectangle {
constructor[length] {
this.height; // ReferenceError, super needs to be called first!
// Here, it calls the parent class's constructor with lengths
// provided for the Rectangle's width and height
super[length, length];
// Note: In derived classes, super[] must be called before you
// can use 'this'. Leaving this out will cause a reference error.
this.name = 'Square';
}
}
8 thay thế.Ví dụ
Sử dụng siêu trong các lớp học
Đoạn mã này được lấy từ mẫu lớp [bản demo trực tiếp]. Ở đây
class Rectangle {
static logNbSides[] {
return 'I have 4 sides';
}
}
class Square extends Rectangle {
static logDescription[] {
return `${super.logNbSides[]} which are all equal`;
}
}
Square.logDescription[]; // 'I have 4 sides which are all equal'
9 được gọi để tránh sao chép các bộ phận xây dựng 'phổ biến giữa class Base {
static baseStaticField = 90;
baseMethod[] {
return 10;
}
}
class Extended extends Base {
extendedField = super.baseMethod[]; // 10
static extendedStaticField = super.baseStaticField; // 90
}
0 và class Base {
static baseStaticField = 90;
baseMethod[] {
return 10;
}
}
class Extended extends Base {
extendedField = super.baseMethod[]; // 10
static extendedStaticField = super.baseStaticField; // 90
}
1.class Rectangle {
constructor[height, width] {
this.name = 'Rectangle';
this.height = height;
this.width = width;
}
sayName[] {
console.log[`Hi, I am a ${this.name}.`];
}
get area[] {
return this.height * this.width;
}
set area[value] {
this._area = value;
}
}
class Square extends Rectangle {
constructor[length] {
this.height; // ReferenceError, super needs to be called first!
// Here, it calls the parent class's constructor with lengths
// provided for the Rectangle's width and height
super[length, length];
// Note: In derived classes, super[] must be called before you
// can use 'this'. Leaving this out will cause a reference error.
this.name = 'Square';
}
}
Phương pháp tĩnh siêu
Bạn cũng có thể gọi Super trên các phương thức tĩnh.
class Rectangle {
static logNbSides[] {
return 'I have 4 sides';
}
}
class Square extends Rectangle {
static logDescription[] {
return `${super.logNbSides[]} which are all equal`;
}
}
Square.logDescription[]; // 'I have 4 sides which are all equal'
Truy cập Super in Class Field Tuyên bố
const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
7 cũng có thể được truy cập trong quá trình khởi tạo trường lớp. Tham chiếu của const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
7 phụ thuộc vào trường hiện tại là trường thể hiện hay trường tĩnh.class Base {
static baseStaticField = 90;
baseMethod[] {
return 10;
}
}
class Extended extends Base {
extendedField = super.baseMethod[]; // 10
static extendedStaticField = super.baseStaticField; // 90
}
Lưu ý rằng các trường thể hiện được đặt trên thể hiện thay vì
class Rectangle {
static logNbSides[] {
return 'I have 4 sides';
}
}
class Square extends Rectangle {
static logDescription[] {
return `${super.logNbSides[]} which are all equal`;
}
}
Square.logDescription[]; // 'I have 4 sides which are all equal'
1 của Constructor, do đó bạn không thể sử dụng const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
7 để truy cập trường thể hiện của siêu lớp.class Base {
baseField = 10;
}
class Extended extends Base {
extendedField = super.baseField; // undefined
}
Ở đây,
class Base {
static baseStaticField = 90;
baseMethod[] {
return 10;
}
}
class Extended extends Base {
extendedField = super.baseMethod[]; // 10
static extendedStaticField = super.baseStaticField; // 90
}
6 là class Base {
static baseStaticField = 90;
baseMethod[] {
return 10;
}
}
class Extended extends Base {
extendedField = super.baseMethod[]; // 10
static extendedStaticField = super.baseStaticField; // 90
}
7 thay vì 10, vì class Base {
static baseStaticField = 90;
baseMethod[] {
return 10;
}
}
class Extended extends Base {
extendedField = super.baseMethod[]; // 10
static extendedStaticField = super.baseStaticField; // 90
}
8 được định nghĩa là một thuộc tính riêng của ví dụ class Base {
static baseStaticField = 90;
baseMethod[] {
return 10;
}
}
class Extended extends Base {
extendedField = super.baseMethod[]; // 10
static extendedStaticField = super.baseStaticField; // 90
}
9, thay vì class Base {
baseField = 10;
}
class Extended extends Base {
extendedField = super.baseField; // undefined
}
0. const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
7, trong bối cảnh này, chỉ tìm kiếm các thuộc tính trên class Base {
baseField = 10;
}
class Extended extends Base {
extendedField = super.baseField; // undefined
}
0, bởi vì đó là [[nguyên mẫu]] của class Base {
baseField = 10;
}
class Extended extends Base {
extendedField = super.baseField; // undefined
}
3.Xóa siêu thuộc tính sẽ ném lỗi
Bạn không thể sử dụng toán tử xóa và
const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
4 hoặc const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
5 để xóa thuộc tính của lớp cha, nó sẽ ném class Base {
baseField = 10;
}
class Extended extends Base {
extendedField = super.baseField; // undefined
}
6.class Base {
foo[] {}
}
class Derived extends Base {
delete[] {
delete super.foo; // this is bad
}
}
new Derived[].delete[]; // ReferenceError: invalid delete involving 'super'.
Sử dụng Super.Prop trong các chữ cái đối tượng
Super cũng có thể được sử dụng trong bộ khởi tạo đối tượng / ký hiệu nghĩa đen. Trong ví dụ này, hai đối tượng xác định một phương thức. Trong đối tượng thứ hai,
const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
7 gọi phương thức của đối tượng đầu tiên. Điều này hoạt động với sự trợ giúp của class Base {
baseField = 10;
}
class Extended extends Base {
extendedField = super.baseField; // undefined
}
8 mà chúng tôi có thể đặt nguyên mẫu của class Base {
baseField = 10;
}
class Extended extends Base {
extendedField = super.baseField; // undefined
}
9 thành class Base {
foo[] {}
}
class Derived extends Base {
delete[] {
delete super.foo; // this is bad
}
}
new Derived[].delete[]; // ReferenceError: invalid delete involving 'super'.
0, do đó const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
7 có thể tìm thấy class Base {
foo[] {}
}
class Derived extends Base {
delete[] {
delete super.foo; // this is bad
}
}
new Derived[].delete[]; // ReferenceError: invalid delete involving 'super'.
2 trên class Base {
foo[] {}
}
class Derived extends Base {
delete[] {
delete super.foo; // this is bad
}
}
new Derived[].delete[]; // ReferenceError: invalid delete involving 'super'.
0.const obj1 = {
method1[] {
console.log['method 1'];
}
}
const obj2 = {
method2[] {
super.method1[];
}
}
Object.setPrototypeOf[obj2, obj1];
obj2.method2[]; // Logs "method 1"
Các phương thức đọc Super.Prop không hoạt động khác khi bị ràng buộc với các đối tượng khác
Truy cập
class Base {
foo[] {}
}
class Derived extends Base {
delete[] {
delete super.foo; // this is bad
}
}
new Derived[].delete[]; // ReferenceError: invalid delete involving 'super'.
4 hoạt động như class Base {
foo[] {}
}
class Derived extends Base {
delete[] {
delete super.foo; // this is bad
}
}
new Derived[].delete[]; // ReferenceError: invalid delete involving 'super'.
5, có nghĩa là tài sản luôn được tìm kiếm trên nguyên mẫu của đối tượng/lớp học, và không liên kết và gắn lại một phương thức sẽ không thay đổi tham chiếu của const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
7.class Base {
baseGetX[] {
return 1;
}
}
class Extended extends Base {
getX[] {
return super.baseGetX[];
}
}
const e = new Extended[];
console.log[e.getX[]]; // 1
const { getX } = e;
console.log[getX[]]; // 1
Điều tương tự xảy ra trong các chữ cái.
const parent1 = { prop: 1 };
const parent2 = { prop: 2 };
const child = {
myParent[] {
console.log[super.prop];
},
};
Object.setPrototypeOf[child, parent1];
child.myParent[]; // Logs "1"
const myParent = child.myParent;
myParent[]; // Still logs "1"
const anotherChild = { __proto__: parent2, myParent };
anotherChild.myParent[]; // Still logs "1"
Chỉ đặt lại toàn bộ chuỗi kế thừa sẽ thay đổi tham chiếu của
const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
7.const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
0Thay vào đó, cài đặt Super.Prop sẽ đặt thuộc tính này
Đặt thuộc tính của
const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
7, chẳng hạn như class Base {
foo[] {}
}
class Derived extends Base {
delete[] {
delete super.foo; // this is bad
}
}
new Derived[].delete[]; // ReferenceError: invalid delete involving 'super'.
9, hoạt động như const obj1 = {
method1[] {
console.log['method 1'];
}
}
const obj2 = {
method2[] {
super.method1[];
}
}
Object.setPrototypeOf[obj2, obj1];
obj2.method2[]; // Logs "method 1"
0. Đây là một trong những trường hợp mà sự hiểu biết const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
7 chỉ đơn giản là "tham chiếu của đối tượng nguyên mẫu" bị ngắn, bởi vì nó thực sự đặt thuộc tính trên class Rectangle {
constructor[height, width] {
this.name = 'Rectangle';
this.height = height;
this.width = width;
}
sayName[] {
console.log[`Hi, I am a ${this.name}.`];
}
get area[] {
return this.height * this.width;
}
set area[value] {
this._area = value;
}
}
class Square extends Rectangle {
constructor[length] {
this.height; // ReferenceError, super needs to be called first!
// Here, it calls the parent class's constructor with lengths
// provided for the Rectangle's width and height
super[length, length];
// Note: In derived classes, super[] must be called before you
// can use 'this'. Leaving this out will cause a reference error.
this.name = 'Square';
}
}
8 thay thế.const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
1class Base {
foo[] {}
}
class Derived extends Base {
delete[] {
delete super.foo; // this is bad
}
}
new Derived[].delete[]; // ReferenceError: invalid delete involving 'super'.
9 sẽ tìm kiếm bộ mô tả thuộc tính của const obj1 = {
method1[] {
console.log['method 1'];
}
}
const obj2 = {
method2[] {
super.method1[];
}
}
Object.setPrototypeOf[obj2, obj1];
obj2.method2[]; // Logs "method 1"
4 trên const obj1 = {
method1[] {
console.log['method 1'];
}
}
const obj2 = {
method2[] {
super.method1[];
}
}
Object.setPrototypeOf[obj2, obj1];
obj2.method2[]; // Logs "method 1"
5 [và gọi các setters được xác định ở đó], nhưng giá trị class Rectangle {
constructor[height, width] {
this.name = 'Rectangle';
this.height = height;
this.width = width;
}
sayName[] {
console.log[`Hi, I am a ${this.name}.`];
}
get area[] {
return this.height * this.width;
}
set area[value] {
this._area = value;
}
}
class Square extends Rectangle {
constructor[length] {
this.height; // ReferenceError, super needs to be called first!
// Here, it calls the parent class's constructor with lengths
// provided for the Rectangle's width and height
super[length, length];
// Note: In derived classes, super[] must be called before you
// can use 'this'. Leaving this out will cause a reference error.
this.name = 'Square';
}
}
8 sẽ được đặt thành class Rectangle {
constructor[height, width] {
this.name = 'Rectangle';
this.height = height;
this.width = width;
}
sayName[] {
console.log[`Hi, I am a ${this.name}.`];
}
get area[] {
return this.height * this.width;
}
set area[value] {
this._area = value;
}
}
class Square extends Rectangle {
constructor[length] {
this.height; // ReferenceError, super needs to be called first!
// Here, it calls the parent class's constructor with lengths
// provided for the Rectangle's width and height
super[length, length];
// Note: In derived classes, super[] must be called before you
// can use 'this'. Leaving this out will cause a reference error.
this.name = 'Square';
}
}
8, đó là const obj1 = {
method1[] {
console.log['method 1'];
}
}
const obj2 = {
method2[] {
super.method1[];
}
}
Object.setPrototypeOf[obj2, obj1];
obj2.method2[]; // Logs "method 1"
8 trong bối cảnh này. Bạn có thể đọc const obj1 = {
method1[] {
console.log['method 1'];
}
}
const obj2 = {
method2[] {
super.method1[];
}
}
Object.setPrototypeOf[obj2, obj1];
obj2.method2[]; // Logs "method 1"
9 để biết thêm chi tiết về vụ án khi class Base {
baseGetX[] {
return 1;
}
}
class Extended extends Base {
getX[] {
return super.baseGetX[];
}
}
const e = new Extended[];
console.log[e.getX[]]; // 1
const { getX } = e;
console.log[getX[]]; // 1
0 và class Base {
baseGetX[] {
return 1;
}
}
class Extended extends Base {
getX[] {
return super.baseGetX[];
}
}
const e = new Extended[];
console.log[e.getX[]]; // 1
const { getX } = e;
console.log[getX[]]; // 1
1 khác nhau.Điều này có nghĩa là trong khi các phương pháp nhận được
const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
4 thường không dễ bị thay đổi trong bối cảnh class Rectangle {
constructor[height, width] {
this.name = 'Rectangle';
this.height = height;
this.width = width;
}
sayName[] {
console.log[`Hi, I am a ${this.name}.`];
}
get area[] {
return this.height * this.width;
}
set area[value] {
this._area = value;
}
}
class Square extends Rectangle {
constructor[length] {
this.height; // ReferenceError, super needs to be called first!
// Here, it calls the parent class's constructor with lengths
// provided for the Rectangle's width and height
super[length, length];
// Note: In derived classes, super[] must be called before you
// can use 'this'. Leaving this out will cause a reference error.
this.name = 'Square';
}
}
8, những phương pháp đặt ra const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
4 là.const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
2Tuy nhiên,
class Base {
foo[] {}
}
class Derived extends Base {
delete[] {
delete super.foo; // this is bad
}
}
new Derived[].delete[]; // ReferenceError: invalid delete involving 'super'.
9 vẫn tư vấn cho bộ mô tả thuộc tính của đối tượng nguyên mẫu, điều đó có nghĩa là bạn không thể viết lại các thuộc tính không thuận lợi và các setters sẽ được gọi.const child = {
myParent[] {
console.log[super]; // SyntaxError: 'super' keyword unexpected here
},
};
3Thông số kỹ thuật
Đặc tả ngôn ngữ Ecmascript # Sec-Super-Keyword # sec-super-keyword |
Tính tương thích của trình duyệt web
Bảng BCD chỉ tải trong trình duyệt