至于 ES6 中的 Class 的多少个性状和玩法

  1. 派生类的 constructor 必须显式定义:跟 C#、Java
    等语言会默许创设调用父类构造逻辑的 constructor 不一致,ES6 的 Class
    需求派生类明确写上 constructor 并在中间调用 super
    函数以确保父类构造逻辑运行

  2. ES6 的 Class 在宣称的时候,extends
    的父类可以是运算结果,于是乎,相比较起静态语言,可玩的事物重重,例如通过
    Higer-Order Components 的情势来促成类似 mixin 的功能:

‘use strict’;

function helloSayable(Class) {
    return class extends Class {
        sayHello() {
            console.log(‘hello’);
        }
    }
}

class A extends helloSayable(React.Component) {
}

const a = new A;
a.sayHello(); // hello

至于上边提到的 Higher-Order Components,推荐个篇章:
http://zhuanlan.zhihu.com/purerender/20361937
React Mixin 的前生今生(内含 Higher-Order Components 的牵线)

  1. ES 6 的 Class 上的 static 成员在其派生类中校被含有:

‘use strict’;

class A {
    static methodOnA() {
        console.log(‘methodOnA’);
    }
}

class B extends A {
}

class C extends A {
    static methodOnA() {
        console.log(‘methodOnA overrided by C’);
    }
}

B.methodOnA(); // prints: methodOnA
C.methodOnA(); // prints: methodOnA overrided by C

那点超越了昔日简短地经过 DerivedClass.prototype = new BaseClass()
的章程来落到实处持续完成的机能,实际上也的确更合乎我们关于继续行为的预料,那现实底层做了怎么着吧?把上述代码在
Babel 中跑一趟后,从编译得的代码可以见见端倪,请留意加粗那段:

‘use strict’;
function _inherits(subClass, superClass) {
    if (typeof superClass !== ‘function’ && superClass !== null) {
        throw new TypeError(‘Super expression must either be null or a
function, not ‘ + typeof superClass);
    }
    subClass.prototype = Object.create(superClass &&
superClass.prototype, {
        constructor: {
           value: subClass,
           enumerable: false,
            writable: true,
            configurable: true
        }
    });
    if (superClass)
        Object.setPrototypeOf ? Object.setPrototypeOf(subClass,
superClass) : subClass.__proto__ = superClass;

}
function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
        throw new TypeError(‘Cannot call a class as a function’);
    }
}
var A = function () {
    function A() {
        _classCallCheck(this, A);
    }
    A.methodOnA = function methodOnA() {
        console.log(‘methodOnA’);
    };
    return A;
}();
var B = function (_A) {
    _inherits(B, _A);
    function B() {
        _classCallCheck(this, B);
        _A.apply(this, arguments);
    }
    return B;
}(A);
var C = function (_A2) {
    _inherits(C, _A2);
    function C() {
        _classCallCheck(this, C);
        _A2.apply(this, arguments);
    }
    C.methodOnA = function methodOnA() {
        console.log(‘methodOnA overrided by C’);
    };
    return C;
}(A);
B.methodOnA();
C.methodOnA();

  1. 跟 React.createClass 的事态分歧,ES6 的 Class
    构造出来的对象上的法门默许不绑定到 this 上,所以传递时一旦预想 this
    不漂移,需求 bind(this) 一下再传,或者在 constructor
    中对章程举行四回替换,例如:

class A extends React.Component {
    constructor() {
        super(…arguments);
        for (let i in this) {
            const method = this[i];
            if (method instanceof Function) {
                this[i] = this[i].bind(this);
            }
        }
    }
}

相关文章