个人网站

# Class (重点)

# 简介

ES6新的class写法只是让对象原型的写法更加清晰、更像面向对象编程的语法而已,类和模块的内部，默认就是严格模式

//定义类
class Person {
    //构造方法，而this关键字则代表实例对象
  constructor(age, gender) {
    this.age = age;
    this.gender = gender;
  }
  //类的内部所有定义的方法，都是不可枚举的
    run(){
        return 'running'
    }
}
const p1=new Person(22,'male')
p1.run()//'running'

# constructor

一个类必须有constructor方法，如果没有显式定义，一个空的constructor方法会被默认添加
默认返回实例对象（即this）

# 不存在遍历提升

new Foo(); // ReferenceError
class Foo {}

# seter getter

在“类”的内部可以使用get和set关键字，对某个属性设置存值函数和取值函数，拦截该属性的存取行为。

class MyClass {
  constructor() {
    // ...
  }
  get prop() {
    return 'getter';
  }
  set prop(value) {
    console.log('setter: '+value);
  }
}

let inst = new MyClass();

inst.prop = 123;
// setter: 123

inst.prop
// 'getter'

# 静态方法

如果在一个方法前，加上static关键字，就表示该方法不会被实例继承，而是直接通过类来调用，这就称为“静态方法”。

class Foo {
  static classMethod() {
    return 'hello';
  }
}

Foo.classMethod() // 'hello'

var foo = new Foo();
foo.classMethod()
// TypeError: foo.classMethod is not a function
//父类的静态方法，可以被子类继承。可以从super对象上调用

# 继承

Class 可以通过extends关键字实现继承

class Point {
}
class ColorPoint extends Point {
    constructor(x, y, color) {
    super(x, y); // 调用父类的constructor(x, y)
    //子类必须在constructor方法中调用super方法
    this.color = color;
  }
}

# Object.getPrototypeOf

Object.getPrototypeOf(ColorPoint) === Point
// true 方法判断，一个类是否继承了另一个类。

# super

super这个关键字，既可以当作函数使用，也可以当作对象使用

  1. 作为函数
    作为函数时，super()只能用在子类的构造函数之中，用在其他地方就会报错。

    class A {}

class B extends A {
constructor() {
    super();
    }
}

  2. 作为对象
    super作为对象时，在普通方法中，指向父类的原型对象；在静态方法中，指向父类
    对象

    class A {
p() {
    return 2;
  }
}
class B extends A {
constructor() {
    super();
    console.log(super.p()); // 2   相当于A.prototype.p()
    }
}
let b = new B();

    静态方法中

    class Parent {
static myMethod(msg) {
    console.log('static', msg);
}

myMethod(msg) {
    console.log('instance', msg);
    }
}

class Child extends Parent {
static myMethod(msg) {
    super.myMethod(msg);
}

myMethod(msg) {
    super.myMethod(msg);
    }
}

Child.myMethod(1); // static 1

var child = new Child();
child.myMethod(2); // instance 2

# 原生构造函数

大概有这些

  • Boolean()
  • Number()
  • String()
  • Array()
  • Date()
  • Function()
  • RegExp()
  • Error()
  • Object()
class MyArray extends Array {
  constructor(...args) {
    super(...args);
  }
}

← Module →