es6学习笔记-class之一概念

前段时间复习了面向对象这一部分，其中提到在es6之前，Javasript是没有类的概念的，只从es6之后出现了类的概念和继承。于是乎，花时间学习一下class。

简介

JavaScript 语言中，生成实例对象的传统方法是通过构造函数来创建的。

function Person (name,age){
    this.name = name;
    this.age = age;
}
Person.prototype.say=function(){  // 不能使用箭头函数（我差点忘记）,因为 箭头函数没有prototype属性
    alert(this.name);
}
var peter = new Person('peter',25);

es6提出了一个关键字class，把上述例子中简化成了传统的面向对象语言java，c++等创建类的形式。 ps：Javascript 的保留关键字不可以用作变量、标签或者函数名。有些保留关键字是作为 Javascript 以后扩展使用。

class定义类简单方式：

class Person{
    constructor(name,age){
        this.name = name;
        this.age = age;
    }
    say(){
        alert(this.name)
    }
}
var peter = new Person('peter',25);

这几步骤中：
1. Person 这是类名，对应就是es5中构造函数名。
2. 里面创建的都是方法。
3. 其中有constructor方法，就叫构造方法，this关键字则代表实例对象，这个方法对应的就是es5的构造函数。
4. 还有个除了constructor方法的其他方法，say方法，对应的就是es5中挂载到其构造函数的prototype属性上的方法。

ps：1 定义“类”的方法的时候，前面不需要加上function这个关键字，直接把函数定义放进去就行，否则报错。 2 方法之间不需要逗号分隔，加了会报错。 3 class定义类名，虽然是对象形式，但不是对象，而是函数。

typeof Person  // "function"
Person.prototype.constructor == Person   // true

这说明了类的数据类型就是函数，类本身就指向构造函数。

  类和普通的构造函数的区别：

    * 类的调用必须用new来实例化。

    * 类的内部所有定义的方法是不可枚举的。

    * 类的内部已经采用的是严格模式。

    * 类的内部不存在变量提升。

class表达式

与函数一样，类也可以使用表达式的形式定义。

    const Person = class {
        constructor(){}
    }

也可以用这样的方式定义。

    const MyClass = class Me {
        getClassName() {
            return Me.name;
        }
    };

需要注意的是，这个类的名字是MyClass而不是Me，Me只在 Class 的内部代码可用，指代当前类。

    let inst = new MyClass();
    inst.getClassName() // 'Me'
    console.log(Me.name)  // Uncaught ReferenceError: Me is not defined

tip:
    name 属性
    由于本质上，ES6 的类只是 ES5 的构造函数的一层包装，所以函数的许多特性都被Class继承，包括name属性,name属性总是返回紧跟在class关键字后面的类名。
    class Point {}
    Point.name // "Point"

constuctor方法：

每个类中都有默认的construtor方法，通过new命令生成对象实例时，自动调用该方法。即使没有显式定义constructor方法，也会有默认的construtor方法。 constructor方法默认返回实例对象（即this）,也可以指定返回另外一个对象。

class Person{
    constructor(name,age){
        this.name = name;
        this.age = age
    }
}
var peter = new Person('peter',25);
peter instanceof Person   // true;
class Person{
    constructor(){
        var child = {
            name:'jerry',
            age:10
        }
        return child
    }
}
var peter = new Person();
peter instanceof Person   // false;

上面两个例子说明了，在没有指定返回的对象情况下，默认返回实例对象，有指定返回的对象，则返回该对象，但返回的对象就不是类的实例了。

另外：实例属性的新写法： // error

实例属性除了在constructor()方法里面定义，也可以直接写在类的最顶层。

class Person{
    name = 'peter';
    say(name){
        console.log(name)
    }
}

类的实例对象：

同es5的构造函数的实例一样：实例的属性除非显式定义在其本身（即定义在this对象上），否则都是定义在原型上（即定义在class上）。 大白话就是：实例的属性如果没有显式定义到constructor上，那么就是定义在除了constructor以外的方法中。

class Person{
    constructor(name,age){
        this.name = name;
        this.age = age;
        this.skill = function(){
            alert('running')
        }
    }
    say(){
        alert(this.name)
    }
}
var peter = new Person('peter',25);
console.log(peter.hasOwnProperty('name'));   // true
console.log(peter.hasOwnProperty('age'));    // true
console.log(peter.hasOwnProperty('skill'));  // true
console.log(peter.hasOwnProperty('say'));    // false
console.log(peter.__proto__.hasOwnProperty('say'))  // true

从上述可知：凡是在constructor方法里的属性都是实例对象中的都返回为true，不在constructor方法里的都是类的原型上的属性。

tip：

      object.hasOwnProperty(proName) 确定某个对象是否具有带指定名称的属性。

        参数解释：

        object

          必需。对象的实例。

        proName

          必需。一个属性名称的字符串值。（是个字符串!）

      说明：

        如果 object 具有带指定名称的属性，则 hasOwnProperty 方法返回 true，否则返回 false。

        此方法不会检查对象原型链中的属性；该属性必须是对象本身的一个成员。

同es5一样，类的所有实例共享一个原型对象。

var peter = new Person('peter',25);
var tom = new Person('tom',18);
console.log(tom.__proto__ == peter.__proto__)  // true

这说明了，peter，tom都是一个类的实例化对象，共享这一个类的所有属性和方法。

根据原型共享，如果在一个实例对象上更改原型上的值，会直接影响到其他实例，所以一般不建议使用这种方式更改原型的值。

tom.\__proto\__.skill = function(){
    alert('running');
}
tom.skill();  // running
peter.skill();  // running

因此最好不要通过实例去更改类的值。

this的指向 （不懂）

类的方法内部如果含有this，它默认指向类的实例，如果单独提取该方法调用this会报错

class Print{
    printName(name){
        this.print(name);
    }
    print(text){
        alert(text);
    }
}
var hello = new Print();
var {printName} = hello;    //对象的解构,printName == hello.printName,为何找不到this的指向？
printName('peter');  // Cannot read property 'print' of undefined

解决办法：

1 在constructor方法中绑定this。

  constructor(){
      this.printName = this.printName.bind(this);
  }

2 使用箭头函数。

printName(name)=>{this.print(name)};

3 使用proxy（待学习）

私有属性和私有方法

所谓的私有方法和私有属性，只能在类*其他方法使用。 有两种方式可以声明私有方法和私有属性

1 将要调用的方法放到类的外部，在类的内部，通过call，apply进行调用。

class Print{
   printName(name){
       print.call(this,name);
   }
}
function print(text){alert(text)}
var hello = new Print();
hello.printName('peter');  // peter

这种方式是把私有方法放到外部，不能被调用，这意思是说的在类的内部是访问不到print方法的。

2 使用sybmol类型。

var print = Symbol('print');
class Print{
    printName(name){
        this[print](name);
    }
    [print] (text){
        alert(text);
    }
}
var hello = new Print();
hello.printName('peter');  // peter

symbol类型保证了是独一无二的，导致第三方获取不到,达到了私有的效果。

class的取值函数和存值函数

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

class Person{
    constructor(){

    }
    get height(){
        return this._height
    }
    set height(value){
        this._height = value
    }
}
var peter = new Person();
peter.height = 12344;  // 设置身高
console.log(perter.height)   // 12344

当一个属性只有get没有set的时候，我们是无法进行赋值操作的,第一次初始化也不行。 如果把变量定义为私有的(定义在类的外面),就可以只使用get不使用set。

Class 的 Generator

在类的某个方法的前面加上星号，可以代表这是个generator函数。可以用generator的方式去运用这个方法。

class Person{
    *sum(x,y,z){
        yield x + y;
        yield y + z;
        yield x + y +z;
    }
}
var a = new Person();
for(let i of a.sum(1,2,3)){
    console.log(i);
} // 3  5  6

class的静态方法

类相当于实例的原型，所有在类中定义的方法，都会被实例继承。 如果在一个方法前，加上static关键字，就表示该方法不会被实例继承，而是直接通过类来调用，这就称为“静态方法”。

class Person{
    static print(text){
        alert(text);
    }
    printName(name){
        this.print(name);
    }
}
Person.print('peter')   // peter
var peter = new Person();
peter.print('peter');   //  peter.print is not a function

上面的代码表示：可以直接在Person类上调用（Person.print('peter')），而不是在Person类的实例上调用。如果在实例上调用静态方法，会抛出一个错误，表示不存在该方法。

  如果静态方法包含this关键字，这个this指的是类，而不是实例。

  静态方法可以与非静态方法重名。(就是static的方法是一个，非static的方法是一个，两者无关联)。

  父类的静态方法，可以被子类继承。

new.target属性

new是从构造函数生成实例对象的命令 ES6 为new命令引入了一个new.target属性，该属性一般用在构造函数之中，返回new命令作用于的那个构造函数。如果构造函数不是通过new命令调用的，new.target会返回undefined，因此这个属性可以用来确定构造函数是怎么调用的。

function Person(name) {
  if (new.target === Person) {
    this.name = name;
  } else {
    throw new Error('必须使用 new 命令生成实例');
  }
}
var peter = new Person('peter');
var notAPerson = Person.call(peter, 'peter');  // 报错 必须使用 new 命令生成实例

Class 内部调用new.target，返回当前 Class。

子类继承父类时，new.target会返回子类。

用处：可以写出不能独立使用、必须继承后才能使用的类。

继承

因篇幅过长，放到下一篇文章es6学习笔记-class之继承