类

类
es5构造函数

    function Person(name) {
        this.name= name;
    }
    Person.prototype.sayName = function(){
        console.log(this.name)
    }

    let p1 = new Person('zs')
    p1.sayName()

es6类

        class Person {
            // 等价于Person 构造器(构造函数)
            constructor(name) {
                this.name=name;
            }
            // 等价于Person.prototype.sayName
            sayName() {
                console.log(this.name);
            }
        }

        let p1 = new Person('zs');
        p1.sayName()

    let Person = class {
        // 等价于Person  构造器
        constructor(name) {
            this.name= name;
        }

        // 等价于Person.prototype.sayName
        sayName(){
            console.log(this.name);
        }
    }

    let p1 = new Person('zs');
    p1.sayName()

作为参数传入函数：

    function createObject(classDef) {
        return new classDef();
    }

    let obj = createObject(
        class {
            sayHi() {
                console.log('Hi!')
            }
        }
    );
    obj.sayHi();

       let person = new class {
            constructor(name) {
                this.name= name;
            }
            sayName() {
                console.log(this.name)
            }
        }('zs')

        person.sayName()

直接在构造器上添加额外方法来模拟静态成员

function PersonType(name) {
    this.name = name;
}
// 静态方法 
PersonType.create = function(name) {
    return new PersonType(name);
};
// 实例方法 
PersonType.prototype.sayName = function() {
    console.log(this.name);
};
var person = PersonType.create("Nicholas");

ES6 之前，实现自定义类型的继承是个繁琐的过程。严格的继承要求有多个步骤。例如，研 究以下范例：

类让继承工作变得更轻易，使用熟悉的 extends 关键字来指定当前类所需要继承的函数，即 可生成的类的原型会被自动调整，而你还能调用 super() 方法来访问基类的构造器。此处 是与上个例子等价的 ES6 代码：

    class Person {
        constructor(name,age) {
            this.name= name;
            this.age = age;
        }
        sayHi(){
            console.log(this.name + this.age)
        }
    }
    
    class C extends Person {
        constructor(name,age,gender){
            super(name,age)
            this.gender = gender
        }
    }
    let c = new C('ls',20,'男')
    c.sayHi()

es6的继承

        class Rectangle {
            constructor(length, width) {
                this.length = length;
                this.width = width;
            }

            getArea() {
                return this.length * this.width;
            }
        }

        class Square extends Rectangle {
            constructor(length) {
                super(length, length);
            }
        }

        var square = new Square(2);
        console.log(square.getArea());
        console.log(square instanceof Square);
        console.log(square instanceof Rectangle)

使用 super() 时需牢记以下几点： 1. 你只能在派生类中使用 super() 。若尝试在非派生的类（即：没有使用 extends 关键字的类）或函数中使用它，就会抛出错误。 2. 在构造器中，你必须在访问 this 之前调用 super() 。由于 super() 负责初始化 this ，因此试图先访问 this 自然就会造成错误。 3. 唯一能避免调用 super() 的办法，是从类构造器中返回一个对象。

es5的仿类

        function PersonType(name) {
            this.name = name;
        }
        PersonType.prototype.sayName = function () {
            console.log(this.name);
        };
        let person = new PersonType("Nicholas");
        person.sayName(); // 输出 "Nicholas"
        console.log(person instanceof PersonType); // true 
        console.log(person instanceof Object); // true

类声明以 class 关键字开始，其后是类的名称；剩余部分的语法看起来就像对象字面量中的 方法简写，并且在方法之间不需要使用逗号。作为范例，此处有个简单的类声明：

        class PersonClass {
            //等价于PersonType 构造器
            constructor(name) {
                this.name = name;
            }

            //等价于PersonType.prtotype.sayName
            sayName() {
                console.log(this.name);
            }
        }

        let person = new PersonClass('zs');
        person.sayName(); //输出 'zs'

        console.log(person instanceof PersonClass); //true
        console.log(person instanceof Object);//true

        console.log(typeof PersonClass);//function
        console.log(typeof PersonClass.prototype.sayName)//function

这个 PersonClass 类声明的行为非常类似上个例子中的 PersonType 。类声明允许你在其中 使用特殊的 constructor 方法名称直接定义一个构造器，而不需要先定义一个函数再把它当 作构造器使用。由于类的方法使用了简写语法，于是就不再需要使用 function 关键字。 constructor 之外的方法名称则没有特别的含义，因此可以随你高兴自由添加方法。