Class降级

class Product {
    static count = 0;
    constructor(name, unitPrice, number) {
        this.name = name;
        this.unitPrice = unitPrice;
        this.number = number;
        Product.count++;
    }
    get totalPrice() { // ES6访问器,注意：会同时存在原型和实例上，而且不可枚举(控制台打印即灰色)，不能被for-of、for-in等遍历到
        return this.number * this.unitPrice;
    }
    increase() { // 注意：不可枚举，且只能当作普通方法调用，不能通过new形式(new product.increase(),只能product.increase()来使用)来调用
        this.number++;
    }
}
const product = new Product();

var Product = (function (_Parent) {
    _Parent && _inherits(Product, _Parent);
    function Product(name, unitPrice, number) {
        if (Object.getPrototypeOf(this) !== Product.prototype) { // 当然也是可以绕开，如：var p = Product(); Product.call(p);
            // if (this.__protyo__ !== Product.prototype) { // ES不推荐使用__proto__
            // if (!new.target) { // ES6写法
            throw new TypeError('不能不使用new来调用');
        }
        this.name = name;
        this.unitPrice = unitPrice;
        this.number = number;
        Product.count++;
    }
    Object.defineProperty(Product.prototype, 'totalPrice', {
        get() {
            this.number * this.unitPrice;
        },
        enumerable: false,
    });
    Object.defineProperty(this, 'totalPrice', {
        get() {
            this.number * this.unitPrice;
        },
        enumerable: false,
    });
    Object.defineProperty(Product.prototype, 'increase', {
        value: function () {
            if (Object.getPrototypeOf(this) !== Product.prototype.increase.prototype) { // 当然也是可以绕开，如：var p = Product(); Product.call(p);
                /*
                new product.increase(); increase的this指向了increase的实例
                product.increase(); // increase的this指向了product
                通过以上，判断this指向是不是相同即可
                */
                throw new TypeError('不能不使用new来调用');
            }
            this.number++;
        },
        enumerable: false,
    });
    Product.count = 0;
    // Product.prototype.increase = function () { // 不能这么创建，不然increase会被枚举
    //     this.number++;
    // }
    return Product;
})();

function _inherits(subClass, superClass) {
    if (typeof superClass !== 'function' && superClass !== null) {
        throw new TypeError('superClass expression must either be null or a function, not ' + typeof superClass);
    }
    // 利用寄生继承继承父类原型
    superClass.prototype = Object.create(superClass && superClass.prototype, {
        constructor: {
            value: subClass,
            enumerable: false,
        }
    })
    // 将子构造函数的__proto__指向父类构造函数，这里的setPrototypeOf方法和create类似，可以看出class继承同时存在两条继承链：子类构造函数的__proto__指向父类，子类原型的__proto__指向父类原型
    if (superClass) {
        Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
}