es6 对象后面直接加()调用
时间: 2023-08-19 11:05:07 浏览: 85
在ES6中,对象后面直接加()调用的语法是箭头函数语法。箭头函数是一种更简洁的函数定义方式,它可以直接在对象字面量中定义函数。例如:
```
const obj = {
name: 'John',
sayHello: () => {
console.log(`Hello, my name is ${this.name}.`);
}
};
obj.sayHello(); // 输出 "Hello, my name is undefined."
```
需要注意的是,箭头函数中的`this`指向的是定义时的上下文,而不是调用时的上下文。因此,在上面的例子中,`this.name`的值是`undefined`,而不是`John`。
相关问题
ES6 class基本使用
ES6 class是一种用于定义对象的语法糖,它可以更方便地定义类和继承。
1. 定义类
要定义一个类,可以使用class关键字,后面跟类名,类名通常首字母大写。
```javascript
class Person {
constructor(name, age) {
this.name = name;
this.age = age;
}
sayHello() {
console.log(`Hello, my name is ${this.name}.`);
}
}
```
上面的代码定义了一个名为Person的类,它有一个构造函数和一个方法sayHello。构造函数接受两个参数name和age,用于初始化对象的属性。sayHello方法用于输出对象的名字。
2. 创建对象
要创建一个类的对象,可以使用new关键字,并传入构造函数需要的参数。
```javascript
const person = new Person('Tom', 18);
console.log(person.name); // 'Tom'
console.log(person.age); // 18
person.sayHello(); // 'Hello, my name is Tom.'
```
上面的代码创建了一个名为person的对象,它的名字是Tom,年龄是18,然后调用了它的sayHello方法输出了自己的名字。
3. 继承
要继承一个类,可以使用extends关键字,并指定父类的名称。
```javascript
class Student extends Person {
constructor(name, age, grade) {
super(name, age);
this.grade = grade;
}
study() {
console.log(`I'm studying in grade ${this.grade}.`);
}
}
```
上面的代码定义了一个名为Student的类,它继承自Person类。Student类有一个构造函数和一个方法study。构造函数接受三个参数name、age和grade,其中前两个用于初始化父类的属性,后一个用于初始化自己的属性。study方法用于输出学生的年级。
4. 调用父类方法
在子类中,可以使用super关键字调用父类的方法或属性。
```javascript
class Student extends Person {
constructor(name, age, grade) {
super(name, age);
this.grade = grade;
}
sayHello() {
super.sayHello();
console.log(`I'm a student in grade ${this.grade}.`);
}
}
```
上面的代码重新定义了Student类的sayHello方法,并在其中调用了父类的sayHello方法。这样,每次调用子类的sayHello方法时,都会先输出父类的信息,然后再输出子类的信息。
5. 静态方法
类中可以定义静态方法,通过类名调用,而不是通过对象调用。
```javascript
class Calculator {
static add(a, b) {
return a + b;
}
static subtract(a, b) {
return a - b;
}
}
```
上面的代码定义了一个名为Calculator的类,它有两个静态方法add和subtract,用于执行加法和减法运算。这些方法可以直接通过类名调用,而不需要先创建对象。
```javascript
console.log(Calculator.add(1, 2)); // 3
console.log(Calculator.subtract(3, 2)); // 1
```
上面的代码分别调用了Calculator类的add和subtract方法,输出了它们的计算结果。
es6中的super方法
在ES6中,super方法用于在子类中调用父类的构造函数、静态方法或原型方法。它必须在使用this关键字之前调用,否则会抛出一个ReferenceError错误。
1. 调用父类构造函数
子类必须在构造函数中调用super方法来执行父类的构造函数,以便正确地设置子类的this对象。例如:
```
class Animal {
constructor(name) {
this.name = name;
}
}
class Dog extends Animal {
constructor(name, breed) {
super(name);
this.breed = breed;
}
}
const myDog = new Dog('Buddy', 'Golden Retriever');
console.log(myDog.name); // 'Buddy'
console.log(myDog.breed); // 'Golden Retriever'
```
在这个例子中,Dog类继承自Animal类,因此它必须调用Animal类的构造函数来设置this.name属性。通过调用super(name),Dog类将传递给Animal构造函数的参数name。
2. 调用父类静态方法
子类可以调用父类的静态方法,通过使用super关键字。例如:
```
class Animal {
static sayHi() {
console.log('Hi from Animal');
}
}
class Dog extends Animal {
static sayHi() {
super.sayHi();
console.log('Hi from Dog');
}
}
Dog.sayHi(); // 'Hi from Animal' 'Hi from Dog'
```
在这个例子中,Dog类继承自Animal类,并覆盖了Animal的sayHi静态方法。通过使用super关键字,Dog类调用了Animal的sayHi静态方法,并在后面添加了自己的输出。
3. 调用父类原型方法
子类可以调用父类的原型方法,通过使用super关键字。例如:
```
class Animal {
sayHi() {
console.log('Hi from Animal');
}
}
class Dog extends Animal {
sayHi() {
super.sayHi();
console.log('Hi from Dog');
}
}
const myDog = new Dog();
myDog.sayHi(); // 'Hi from Animal' 'Hi from Dog'
```
在这个例子中,Dog类继承自Animal类,并覆盖了Animal的sayHi原型方法。通过使用super关键字,Dog类调用了Animal的sayHi方法,并在后面添加了自己的输出。