面向对象编程就是将你的需求抽象成一个对象，针对这个对象分析其特征（属性）和动作（方法），这个对象称为“类”。JavaScript 的核心是支持面向对象的，同时它也提供了强大灵活的 OOP 语言能力，遗憾的是对于JavaScript这种解释性的弱类型语言，没有强类型语言中那种通过class等关键字实现类的方式，但JavaScript可以通过一些特性模仿实现面向对象编程。

面向对象有三个基本特征：封装、继承、多态。

封装

封装，就是把客观事物封装成抽象的类，类中包含了事物的属性和方法，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
JavaScript创建一个类很容易，通过声明一个函数保存在一个变量里来实现，这个类的类名通常会采用首字母大写的形式来表示，然后在这个函数（类）的内部使用this关键字来定义类的属性和方法。例如：

var Person = function(name,sex,age){
    this.name = name;
    this.sex = sex;
    this.age = age;
}

也可以在类的原型上添加属性和方法。例如：

1
2
3

Person.prototype.say = function(){
    // Say something
}

或者

1
2
3

Person.prototype = {
    say: function(){ … }
}

这样就完成了Person类的封装，当我们要使用这个类时，需要通过new关键字来实例化（创建）一个新的对象，通过.操作符访问对象的属性和方法。例如：

1 2	var person = new Person('Scott','male',20); console.log(person.name); // Scott

通过this添加的属性和方法是在当前对象上添加的，而JavaScript是一种基于原型prototype的语言，每创建一种对象时，都有一个原型prototype用于指向其继承的属性和方法，通过prototype继承的属性和方法不是属于对象本身的，在使用这些方法时，会通过原型链进行查找。当创建一个对象时，会创建this指向的属性和方法，而通过prototype继承的属性或方法是该类的每个对象所共有的，不会再次创建。

当创建一个函数或者对象时都会为其创建一个prototype对象，原对象中的__proto__属性指向该原型对象，prototype对象中会有一个constructor属性指向拥有整个原型对象的函数或者类。

通过new关键字创建对象时实际上是对新对象中this的不断赋值，并将prototype指向类的原型对象，而在类外通过.操作符定义的属性和方法是不会添加到新建对象上的，通过对象进行访问的结果是undefined。例如：

Person.isChinese = true;
Person.eat = function(){ … }

var person = new Person("Alex","female",19);
console.log(person.name);    // Alex
console.log(person.isChinese);    // undefined
console.log(person.eat());    // undefined

如果你忽略了new关键字直接调用类，如：

person


要解决这个问题可以采用“**安全模式**”，例如：
``` javascript
var Person = function(name,sex,age){
    if(this instanceof Person){
        this.name = name;
        this.sex = sex;
        this.age = age;
    }else{    // 未使用 new
        return new Person(name,sex,age);
    }
}

var person = Person("Scott","male",20);

这样就不用当心创建对象时忘记使用new关键字了。

继承

继承可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。继承所涉及的对象不止一个，JavaScript并没有提供继承这一现有的机制，也正因为JavaScript少了这些显性的限制，使其更具有灵活性。在JavaScript中可以使用类式继承、构造函数继承、组合继承来达到继承的效果。

类式继承

// 声明父类
function Parent(){
    this.parentValue = true;
}
// 为父类添加共有方法
Parent.prototype.getParentValue = function(){
    return this.parentValue;
}

// 声明子类
function Child(){
    this.childValue = false;
}
// 继承父类
Child.prototype = new Parent();
// 为子类添加共有方法
Child.prototype.getChildValue = function(){
    return this.childValue;
}

类的原型对象的作用是为类的原型添加共有属性和方法，但类必须通过原型prototype来访问这些属性和方法。当实例化一个父类时，新建对象复制了父类构造函数内的属性和方法，并且将原型__proto__指向了父类的原型对象，这样就拥有了父类原型对象上的属性和方法，新建对象可以直接访问父类原型对象的属性和方法，接着将这个新建的对象赋值给子类的原型，那么子类的原型就可以访问父类的原型属性和方法。将这个对象赋值给子类的原型，那么这个子类就可以访问父类原型上的属性和方法，并且可以访问从父类构造函数中复制的属性和方法。我们可以来测试一下：

var child = new Child();
console.log(child.getParentValue());      // true
console.log(child.getChildValue());       // false
console.log(child instanceof Parent);     // true
console.log(child instanceof Child);      // true
console.log(Child instanceof Parent);     // false

但这种继承方式有2个缺点：

由于子类是通过其原型prototype对父类实例化，如果父类中的共有属性是引用类型，会被所有实例所共享，一个子类的实例修改了该属性会直接影响到所有实例。例如：

function Parent(){
    this.values = ['A','B','C'];
}
function Child(){}
Child.prototype = new Parent();
var child1 = new Child();
var child2 = new Child();
console.log(child2.values);    // ["A","B","C"]
child1.values.push('D');
console.log(child2.values);    // ["A","B","C","D"]

创建父类实例时，是无法向父类传递参数的，也就是无法对父类构造函数内的属性进行初始化。例如这种错误的继承方式：
1
2
3
4
5
function Parent(name){
this.name = name;
}
function Child(){}
Child.prototype = new Parent('name'); // 错误

构造函数继承

// 声明父类
function Parent(name){
    this.name = name;
    this.values = ['A','B','C'];
}
Parent.prototype.showName = function(){
    console.log(this.name);
}
// 声明子类
function Child(name){
    Parent.call(this,name);
}
var child1 = new Child('one');
var child2 = new Child('two');
child1.values.push('D');
console.log(child1.name);   // one
console.log(child1.values); // ["A","B","C","D"]
console.log(child2.name);   // two
console.log(child2.values); // ["A","B","C"]
child1.showName();          // TypeError

语句Parent.call(this,name);是构造函数继承的精华，call方法可以更改函数的作用环境，在子类中执行该方法相当于将子类的变量在父类中执行一遍，此时父类方法中的this属性指的是子类中的this，由于父类中是给this绑定属性的，所以子类也就继承了父类的属性和方法。构造函数继承并没有涉及原型prototype，所以父类的原型方法不会被子类继承，子类的每个实例会单独拥有一份父类的属性方法而不能共用，如果想被子类继承就必须放在构造函数中，要实现这样的效果可以采用组合继承的方式。

组合继承

类式继承是通过子类的原型prototype对父类实例化来实现的，构造函数继承是通过在子类的构造函数作用环境中执行一次父类的构造函数来实现的，而组合继承则同时做到这两点。

// 声明父类
function Parent(name){
    this.name = name;
    this.values = ['A','B','C'];
}
Parent.prototype.getName = function(){
    console.log(this.name);
}
// 声明子类
function Child(name,id){
    Parent.call(this, name);
    this.id = id;
}
Child.prototype = new Parent();
Child.prototype.getId = function(){
    console.log(this.id);
}

var child1 = new Child('child1', 1);
child1.values.push('D');
console.log(child1.values); // ["A", "B", "C", "D"]
child1.getName();           // child1
child1.getId();             // 1

var child2 = new Child('child2', 2);
console.log(child2.values);    // ["A", "B", "C"]
child2.getName();              // child2
child2.getId();                // 2

子类的实例中更改父类继承下来的引用类型属性，不会影响到其它实例，并且子类实例化过程中又能将参数传递到父类的构造函数中。

多态

多态就是同一个方法多种调用方式，JavaScript可以通过对传入的参数列表arguments进行判断来实现多种调用方式。例如：

function Add(){
    // 无参数
    function zero(){
        return 0;
    }
    // 一个参数
    function one(num){
        return num;
    }
    // 两个参数
    function two(num1, num2){
        return num1 + num2;
    }

    this.add = function(){
        // 获取参数列表及参数个数
        var arg = arguments,
            len = arg.length;
        switch(len){
            case 0:
                return zero();
            case 1:
                return one(arg[0]);
            case 2:
                return two(arg[0], arg[1]);
        }
    }
}

var A = new Add();
console.log(A.add());       // 0
console.log(A.add(1));      // 1
console.log(A.add(1,2));    // 3

当调用add进行运算时，会根据参数列表的不同做相应的运算，这就是JavaScript的多态实现方式。

总结

面向对象设计方法的应用解决了传统结构化开发方法中客观世界描述工具与软件结构的不一致性问题，缩短了开发周期，解决了从分析和设计到软件模块结构之间多次转换映射的繁杂过程，是一种高效率的软件开发方式，特别是在多人协作开发的情况下，可以提高代码的可复用性和维护性，使开发更有效率。

本文为作者kMacro原创，转载请注明来源：https://zkhdev.github.io/2017/04/21/js-object/