JS之面向对象

JavaScript是基于原型（prototype）, 没有python中class 的概念。

   var Cartoon={
         name:'Micky Mouse',
         height:15,
         run:function () {
            console.log(this.name+'is quacking')
         }
     };

     function createCartoon(name) {
         var p = Object.create(Cartoon);
         p.name=name;
         return p
     }

     var p2 = createCartoon('Donald Duck');
     console.log(p2.name); //'Donald Duck'
    p2.run()   //'Donald Duck is running'

构造函数
在JavaScript中，可以用关键字new来调用这个函数，并返回一个对象：

function Cat(name) {
         this.name = name;
         this.hello=function () {
             console.log('hello'+this.name)
         }
     }
var k1 = new Cat('kitty'); // new 别忘了写
 k1.hello();

同上

function Cat(name) {   // 构造函数首字母要大写
        this.name=name
     }
     Cat.prototype.hello=function () {
         console.log('hello'+this.name)
     };
    var k1 = new Cat('kitty');
    k1.hello()

用Cat()创建的对象还从原型上获得了一个constructor属性，它指向函数Cat本身：

console.log(k1.constructor===Cat.prototype.constructor) //true

不写new时：

 function Robot(props) {
         this.name = props.name || 'John Doe';
         this.inventor = props.inventor || 'None'
     }
     Robot.prototype.sayHi = function () {
        console.log('hello,hello hello'+this.name + 'my inventor is '+ this.inventor)
             };
    function createNewRobot(props) {
        return new Robot(props || {})  // 在这里封装new的相关操作
    }

传参时：

var r1 = createNewRobot({
        name:'David',
        inventor:'Alice'
    });
    r1.sayHi()

动态原型创建对象

   function Factory(name,location) {
         this.name = name;
         this.location = location;
         if (typeof this.recruit !== 'function'){  //      判断this.recruit这个属性是不是function，如果不是function则证明是第一次创建对象
             Factory.prototype.recruit = function () {
         console.log(this.name+'starting'+ ' in ' + this.location )

     };
         }

     }

    let f1 = new Factory('NNL','Jilin');
    console.log(f1.name,f1.location);
    f1.recruit()

原型和原型链

proto 和 prototype

image.png

prototype是函数才有的属性
proto是每个对象都有的属性

在大多数情况下, proto可以理解成构造器原型， 即：

__proto__ === constructor.prototype

var a = {};
console.log(a.prototype);  //undefined
console.log(a.__proto__);  //Object {}

var b = function(){}
console.log(b.prototype);  //b {}
console.log(b.__proto__);  //function() {}

由于proto是任何对象都具有的属性，同python一样，JS中也是万物皆对象，所以会形成一条proto连接起来的链条，递归访问最终到头，返回值是null。

当JS引擎查找对象的属性时，会先查找对象本身是否具有该属性，如果不存在，会在原型链上查找。

JS实现继承的几种方式

先定义一个父类

// 定义一个动物类
function Animal (name) {
  // 属性
  this.name = name || 'Animal';
  // 实例方法
  this.sleep = function(){
    console.log(this.name + ' is sleeping now');
  }
}
// 原型方法
Animal.prototype.eat = function(food) {
  console.log(this.name + ' is having ' + food);
};

1、原型链继承（核心：将父类的实例作为子类的原型）

function Cat(){ 
}
Cat.prototype = new Animal();
Cat.prototype.name = 'cat';

//　Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.eat('fish'));
console.log(cat.sleep());
console.log(cat instanceof Animal); //true 
console.log(cat instanceof Cat); //true

这种方法缺点太多，例如，创建子类实例时，无法向父类构造函数传参，无法实现多继承等，不推荐。

2、构造函数继承（使用父类的构造函数来增强子类实例，等于是复制父类的实例属性给子类）

function Cat(name){
  Animal.call(this);
  this.name = name || 'Tom';
}

// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // false
console.log(cat instanceof Cat); // true

只能继承父类的实例属性和方法，不能继承原型属性/方法, 不推荐。

3、实例继承（为父类实例添加新特性，作为子类实例返回）

function Cat(name){
  var instance = new Animal();
  instance.name = name || 'Tom';
  return instance;
}

// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // true
console.log(cat instanceof Cat); // false

不支持多继承，不推荐。

4、拷贝继承

function Cat(name){
  var animal = new Animal();
  for(var p in animal){
    Cat.prototype[p] = animal[p];
  }
  Cat.prototype.name = name || 'Tom';
}

// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // false
console.log(cat instanceof Cat); // true

无法获取父类不可枚举的方法（不可枚举方法，不能使用for in 访问到）不推荐。

5、组合寄生继承