周大侠啊——前端工程师

学海无涯苦作舟

进击的 JavaScript (八) 之 继承

前面讲完原型链,现在来讲继承,加深理解下。

一、对象的相关知识

什么是对象? 就是一些无序的 key : value 集合, 这个value 可以是 基本值,函数,对象。(注意 key 和 value 之间 是冒号 : ,每个 key : value 之间 是逗号 , )

var person = {
    name: 'zdx',
    age: 18,
    get: function(){
        return '名字:' + this.name + '年纪:' + this.age;
    }
}

这时的 person 就是一个对象

读取对象的属性,有两种方式:[‘ ‘],(使用中括号,里面是有引号的)

person.name   //'zdx'
person['age']    //18

之前说过,对象的创建 有三种 方式: 字面量,new,Object.create;

但是,这种简单的创建,并不能满足,我们实际开发的要求。

比如,每个人的名字,年纪不一样,我们不可能,每个人都写一个对象,那不得炸了。

var personA = {
    name: 'A',
    age: 28
}

var personB = {
    name: 'B',
    age: 22
}

所以,这时候,我们就需要一些创建模式。

(一)、工厂模式

工厂模式呢,就是我们写一个方法,然后通过这个方法复制出我们需要的对象。我们需要多少个,就复制多少个。(注意这里是用方法(函数) 来生成对象)

var createPerson = function(name,age){
    var obj = {},
    obj.name = name,
    obj.age = age
}

然后我们就可以这样使用了。

var personA = createPerson('A', 28);
var personB = createPerson('B', 22);

但是呢,这种模式,创建的对象,无法归类。也就是说,并不知道 personA,personB 等 是 属于哪个对象的(哪个构造函数或者类)。

具有相同特性的一类事物,把它总结成一个 ;比如,人类,有男人,女人,小孩。把他们总结成了人类。

比如:

var obj = {};
obj instanceof Object;    //true
//instanceof  方法 可以判断 前者是否是 后者的实例对象

var arr = [];
arr instanceof Array;    //true

于是,构造函数模式来了。

(二)、构造函数模式(类)

要想知道,男人,女人 属于什么类, 人类? 兽类? 这时候就需要 构造函数(类)了。

function Person(name, sex){     //注意,我们通常把构造函数(类)的首字母大写!
    this.name = name;
    this.sex = sex;
}
var personA = new Person('张三', '男');
var personB = new Person('李四', '女');

console.log( personA instanceof Person );    //true
console.log( personB instanceof Person );    //true

这时候 创建出来的对象, 就知道 它属于哪个构造函数(类)了。

这里为啥用了 this 呢?new 一个函数, 为啥会创建出 一个实例对象(我们把 new 出来的对象 称为 实例对象,简称实例)呢?

  • 这步,之前的原型链中说过,如果你懂了,可以简单过一眼,增强记忆。

这个呢,就要理解new 到底干了啥呢:

  1. 新建一个对象;
  2. 将该对象,即实例指向构造函数的原型;
  3. 将构造函数的this,指向该新建的对象;
  4. 返回该对象,即返回实例。下面,手写一个方法 实现new 的功能。
function New(func){    //func 指传进来的构造函数
    var obj = {};   //这里就直接新建一个空对象了,不用new Object了,效果一样的,因为我感觉这里讲实现new的功能   再用 new 就不太好。

    if(func.prototype != null){
        obj.__proto__ = func.prototype;
    }

    func.apply(obj,Array.prototype.slice.call(arguments, 1));
    //把func构造函数里的this 指向obj对象(你可以理解成func构造函数的this 替换成 obj对象);
    //Array.prototype.slice.call(arguments, 1);这个就是把New 函数,func 之后传进来的参数,转成数组。
   //把该参数数组,传入func构造函数里,并执行func构造函数,比如:属性赋值。

    return obj;

}

验证下:

function Person(name, sex){
    this.name = name;
    this.sex = sex;
    this.getName = function(){
        return this.name;
    }
}

var p = New(Person,"周大侠啊", "男");

console.log( p.getName() );   //"周大侠啊"

console.log( p instanceof Person );    //true

去掉new 的写法就是这样:

function Person(name, sex){
    var obj = {};
    obj.__proto__ = Person.prototype;
    obj.name = name;
    obj.sex = sex;
    obj.getName = function(){
        return obj.name;
    }
    return obj;
}

var p = Person("周大侠啊", "男");

console.log( p.getName() );   //"周大侠啊"

console.log( p instanceof Person );    //true

使用 new 就简化了步骤。

这种模式,也有弊端,你看出来了吗? 有木有发现,每个实例对象 都有 相同 的 getName 方法,这样,是不是就但占资源了呢,100个实例对象,就新建了 100 个 getName 方法。

原型模式开始!

(三)、原型模式

之前的原型链说过,属性、方法的读取是沿着原型链查找的,也就是说,在构造函数的原型对象上 创建的 属性、方法,它的实例对象都能够使用。

function Person(){};
Person.prototype.name = "周大侠啊";
Person.prototype.sex = "男";
Person.prototype.getName  = function(){
    return Person.prototype.name;
}

var p = new Person();
console.log( p.getName() );   //"周大侠啊"
console.log( p.hasOwnProperty("getName") );   //false   getName 不是 p实例的属性

这样,创建的实例对象 都能使用 getName ,并且,也不会给每个实例对象,添加该属性。

不过,你发现了吗,这样创建的实例对象,都是固定的属性值, 一更改,所有的实例对象获取的值,也都改变了。

那么说了半天,这都是啥呢,别急,正因为上面做的铺垫,才有更好的 方法。我觉得,眼尖的同学,可能已经知道了。

构造函数模式 与 原型模式 相结合的模式。

构造函数模式,可以创建 每个 实例对象 自己的属性, 而原型模式,可以共享,同一个方法。

所以,我们一般,把对象自己的属性、方法 ,用构造函数模式创建; 公共的方法,用原型模式 创建。

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

Person.prototype.getName = function(){
    return this.name;
}

var p = new Person("周大侠啊", 22);
p.getName();

这样就可以完美的创建对象了。

要是你有余力,可以想想,这里的 this.namethis 是怎么回事。

但是,上面这个还可以优化,要是 Person.prototype 上有很多方法, 这种写法就很不好,一般,我们用这种写法:

function Person(name, age){
    this.name = name;
    this.age = age;
}
//新建一个对象,给该对象添加 方法, 然后把该对象 赋值给Person.prototype ,该对象就成为 Person (构造函数)的原型对象了。

Person.prototype = {
    constructor : Person,   //给新建的对象,添加constructor 属性,建立与构造函数之间的联系。
    getName : function(){
        return this.name;
    },
    getAge : function(){
        return this.age;
    }
}

var p = new Person("周大侠啊", 22);

p.getName();

这里的 this 又看懂是怎么回事了吗? 那我就简单说一下 this 的知识吧。

关于 this 估计都听说过 谁调用它,this就指向谁,这种说法,不严谨,this 的指向,是 在函数调用(运行)时确定的

上面的:

Person.prototype = {
    constructor : Person, 
    getName : function(){
        return this.name;
    },
}
var p = new Person("周大侠啊", 22);
p.getName();

thisgetName 函数里,而getName 真正运行 的地方 是 p.getName,p 是调用者,所以, this 就指向 p(换句话说,这时的this 就是 p)。

你要理解 精髓, 函数调用(运行)时 确定的调用者 之间的关系。

看这个:

var a = 10;
var b = {
    a : 20,
    say : function(){
        console.log(this.a);
    }
}

var c = b.say;
c();    //10   非严格模式下,独立调用(无调用者)this 指向全局对象

包含 this 的函数 正在调用(运行) 的时候 是 c(); 此时,无调用者,指向全局对象。

二、继承

上面做了辣么多铺垫,终于要开始继承的讲解啦!什么是继承呢,其实呢,就是你 想要使用 别人的属性,或者方法; 这时候就要利用继承来实现。

既然是 得到别人的属性,方法,就是继承,那么不就是 除了 Object.prototype 其他都是继承了? dui ! 你说的没错…哈哈

所以,继承的一种就是基于 原型链的了 ,就是属性的查找,读取。

另一种就是 构造函数继承了。

首先来一个需要被继承的目标

//父类:
function Person(name) {
    this.name = name;
}

Person.prototype = {
    constructor: Person,
    getName : function() {
        return this.name;
    }
}

(一)、构造函数的继承


//子类: function Son(name, age) { Person.call(this, name); //call 方法,把前面函数的this 指向 给定的对象,第二个参数开始,传入 参数,并执行函数。 this.age = age; } //就相当于 function Son(name, age) { //Person(name); 此时 Person 里的 this 等于当前的this this.age = age; } //等同于 function Son(name, age) { this.name = name, this.age = age }

下面检验一下:


var s1 = new Son('周大侠啊', 22); console.log(s1.name); //'周大侠啊' console.log(s1.getName()); //报错,这是Person原型对象上的方法

(二)、原型链的继承

1、通过new一个父类实例

这种是,new 一个父类实例,然后把son.prototype 添加到原型链上去。

//new 一个 Person 实例 赋给 Son.prototype
Son.prototype = new Person();

//给子类的原型加方法:
Son.prototype.get = function() {
        return this.name + this.age;
}

上面的 Son.prototype = new Person() 实际上就是这样的

//内部就是
var obj = {};

obj.__proto__ = Person.prototype;

Son.prototype = obj

//把 obj 赋给 Son.prototype 。而obj 这个实例  又指向了Person的原型对象,
//这样,Son 就添加到了 Person 的原型链上了。

所以:

//给子类的原型加方法:
Son.prototype.get = function() {
        return this.name + this.age;
} 

//就是:
obj.get = function(){    //通过给obj添加方法 然后赋值给Son的原型对象
    return this.name + this.age;
};

验证:

var s2 = new Son('周大侠啊', 22);

console.log(s2.get());  //'周大侠啊22' 

console.log(s2.getName());   //'周大侠啊'

2、于是乎,我们就可以自己封装一个继承方法

function create(proto, options){     //proto表示父类的原型对象,options表示给子类添加的属性
    var obj = {};
    obj.__proto__ = proto;
    return Object.defineProperties(obj,options);    //Object.defineProperties方法直接在一个对象上定义新的属性或修改现有属性,并返回该对象。所以这里就直接return了
    }

//继承  就这样写了
Son.prototype = create(Person.prototype,{
    constructor: {    //这种格式的赋值写法, 是 defineProperties 方法规定的写法。
        value: Son
    },
    get: {
        value: function(){
            return this.name + this.age;
        }
    }
})

//验证一下
var s3 = new Son("zdx",22);

console.log(s3.getName());     //'zdx'

console.log(s3.get());         //'zdx22'

Object.defineProperties具体用法点这里

3、ES5中就有个Object.create 方法 它就实现了刚刚封装的create 方法

这里是它具体用法

可以直接使用它来完成继承:

Son.prototype = Object.create(Person.prototype,{
    constructor: {
        value: Son
    },
    get: {
        value: function(){
            return this.name + this.age;
        }
    }
})

//验证一下
var s4 = new Son("zdx",22);

console.log(s4.getName());     //zdx

console.log(s4.get());         //zdx22
点赞

发表评论

电子邮件地址不会被公开。