js面向对象思想以及es6的“类”

一、面向对象

JavaScript 中的所有事物，例如字符串、数值、数组、函数等都是对象。

现在定义“对象a”和“对象b”输出两个不同的单词“hello”和“world”。

（1）采用“面向过程”的思想，需要定义两个函数来实现：

function a(data) {
  console.log(data);
}
a('hello');

function b(data) {
  console.log(data);
}
b('world');

“面向过程”最直白的解释就是“谁去做什么”，即先定义a和b这两个对象，然后再分别去设置这两个对象去做什么事。

（2）采用“面向对象”的思想，只需要定义一个函数即可实现：

var Public = function(data){
  this.word = data;
  this.say = function(){
    console.log(this.word);  
  };
}
var a = new Public('hello');
a.say();
var b = new Public('world');
b.say();

“面向对象”则是“这件事由谁来做”。即先设置“输出单词”这件事，然后再确定是由“对象a”、“对象b”来做这件事。

在函数“Public”中，“this”指代的是对象（即a和b），而“word”则是对象的属性，“say ”由于是一个函数，所以是对象的方法。而“Public”这种带有属性和方法的函数被称为“构造函数”。

构造函数需要用“new”进行实例化，使“对象a”和“对象b”成为Public的实例。可以理解为“对象a”和“对象b”将Public里的属性和方法全部克隆了一份，这样就会造成一个问题：如果把方法（例如上面的“say”）直接写在函数内部里，那么每次实例化一个对象，对象的方法都会复制一份（两个实例，就存在两个“say”方法），将会占用大量的内存，这时就需要用到prototype属性。

var Public = function(data){
  this.word = data;
 }
Public.prototype.say = function(){
   console.log(this.word);
}

var a = new Public('hello');
a.say();
var b = new Public('hello');
b.say();

将函数的方法添加到函数的prototype属性上，这样每次实例化对象就不会自己再复制一份这个方法，而是共享。

二、es6的“类”－－class

在java和c++等语言中，“面向对象”思想除了属性和方法外，还有一个非常重要的概念，就是“类”。

所谓“类”，就是定义对象的特征，也就是对象属性和方法的模板。

上面的Public函数就具有这样的功能，它为“对象a”和“对象b”规定了一个模版，就是这两个对象都有“word”属性和“say”方法。

所以es6之前虽然没有“类”这个概念，但也可以通过构造例如Public函数来模拟一个“类”。由此可知，es6引入的“类”并没有向js里加入什么本质性的新功能，主要也只是让代码更加清晰，风格向java等更靠拢。
将上面的Public函数改成class

class Public {
  constructor(data) {
    this.word = data;
    };
  }
  say() {
      console.log(this.word);
  }

var a = new Public('hello');
a.say();

使用 class 最明显的便利：一是不需要写function，二就是不需要写prototype，但这并不代表class内部的方法不是写在prototype上。

class Public(){
  say() {}
}
var a = new Public();
console.log(a.say === Public.prototype.say);

最终得到的结果为“true”，这表明类的所有方法都是被默认添加在类的prototype属性上。

通过 typeof a.constructor 得到的结果是“function”，由此可知constructor也是“类”的一个方法而不是属性，但这个方法很特殊，因为它是“类”必带的方法，即使不写，“类”也会默认自带这个方法：

class Public(){}
var a = new Public();
console.log(a.conconstructor);

但是如果想要正常使用“类”，那么就必须要写上constructor，因为“类”的 属性只能 写在constructor里，constructor的作用，就是初始化对象，比如给“类”的属性赋值。

"类"也可以通过表达式来定义，定义的类赋值给一个变量，这时候变量就为类名。class关键字之后的类名可有可无，如果存在，则只能在类内部使用，指代当前类，也就是相当于“this”。

var pub = class Public() {
  constructor(data) {
    Public.word = data;
   };

  say() {
      console.log(Public.word);
  }
}
var a = new pub('hello');
a.say();

使用表达式写法，就可以在“类”前面加上new进行实例化，这样就可以直接调用“类”的方法。

var words = new class {
  constructor(data) {
    this.word = data;
 }
say() {
    console.log(this.word);
  }
}('hello');
words.say(); 

直接使用类名即可访问的方法，称之为“静态方法”。

class Public {
    constructor(data){
        this.word = data;
    }

    static say(){
        console.log(this.word);
    }
}

var a = new Public('hello');
Public.say(a);

该方法不会被实例继承，而是直接通过类来调用。

当然，“类”最大的优点，还是“继承”功能。所谓“继承”，就是函数b把函数a的方法复制到自己身上。
es6之前，最常用的继承方式有三种，分别是：prototype，apply和call+prototype。

（1）prototype：

// 父级“类”
function Parent(data){  
   this.words = data;            
}; 
Parent.prototype.say = function(){
     console.log(this.words);
};

// 子级“类”
function Child(){}; 

Child.prototype = new Parent('hello');  
        
var a = new Child();  
        
 a.say();

使用prototype的缺点也是显而易见的，也是比较致命的，那就是子级“类”的对象在进行实例化时，传入的参数在父级“类”是无法使用的（即var a = new Child('hello')是无效的 ）。

（2）apply的方式:

function Parent(data){  
   this.word = data;    
  this.say = function() {  
    console.log(this.word);  
  }; 
}  

//子类  
function Child(data){  
   Parent.apply(this,arguments);  
}  

var a = new Child('hello');  
a.say();

然而如果用instance去进行判断，结果会发现a并不是Parent的实例化。

console.log(a instanceof Child);  // true
console.log(a instanceof Parent); // false

并且apply虽然能通过子级“类”对象的实例化向父级“类”传参，但是apply还是只能输出一个对象的值。

（2）call+prototype的方式:

//父级“类”  
function Parent(data){  
     this.word = data;
     this.say = function() {  
          console.log(this.word);  
     }; 
}  
        
//子级“类”
function Child(data){  
    Parent.call(this,arguments);  
}  
Child.prototype = new Parent();  
var a = new Child('hello');  
a.say();
var b = new Child('world');  
b.say();

通过call+prototype，就可以实例化两个带有不同参数的对象，只是输出的结果变成了数组，并且在Parent.call时调用了一次Parent函数，在Child.prototype = new Parent(); 时又调用一次Parent函数。

class则可以通过extends来实现继承：

//定义类父类
class Parent {
  constructor(data){
    this.word = data;
 }
  say(){
    console.log(this.word);
  }
}

class Child extends Parent {}
 
var a = new Child('hello');
a.say();
var b = new Child('world');
b.say();
console.log(a instanceof Parent);

可以说，上面三种继承方式的缺点在“类”里都可以避免。当然，如果在子级“类”里添加constructor方法：

class Child extends Parent 
  constructor() {
    super();
  }
 }

就必须再添加“super”，否则会报错，这是因为子级“类”没有自己的this对象，而是继承父级“类”的this对象。如果不调用super方法，子级“类”就获取不到this指代的对象。

最后一句话总结，就是用class这个关键字来创建一个类，constructor定义构造函数，用extends来实现继承。

“类”的注意事项：

1.一个类只能拥有一个名为 constructor的方法，否则出现异常。

2.类的调用必须使用new，否则会报错：

3.“类”没有提升作用，所以必须先定义类，再使对象进行实例化，否则会报错：

var a = new Public(); 
class Public{
  constructor(data) {
     this.word = data;
  }
}

得到的结果是：

4.“类”的方法与方法之间不能用逗号分隔，否则会报错，分号则没问题。
5.super()只能用在子级“类”的constructor方法中，如果用在其他方法里就会报错。

参考：

1.https://wwsun.github.io/2017/06/19/javascript-oop/ （面向对象的几个概念）
2.https://github.com/dreamapplehappy/hacking-with-javascript/blob/master/points/methods-within-constructor-vs-prototype-in-javascript.md?utm_source=caibaojian.com （很好的prototype的文章）
3.http://zxc0328.github.io/2015/10/22/learn-ES6-with-babel/
4.http://www.cnblogs.com/zmxmumu/p/5588431.html （“类”的实例）
6.https://www.kancloud.cn/kancloud/javascript-style-guide/43128 （“类”的实例）
7.http://es6.ruanyifeng.com/#docs/class （“类”的知识点）
8.http://itbilu.com/javascript/js/EkR85KsBW.html
9.http://www.jianshu.com/p/58075a9a35d8
10.http://www.jb51.net/article/97925.htm
11.http://www.jianshu.com/p/342966fdf816