资讯专栏INFORMATION COLUMN

JS基础篇--面向对象与原型

Pluser / 2665人阅读

摘要:判断一个对象是否指向该构造函数的原型对象,可以使用方法来测试。如何让指向呢直接强制指向即可运行中重写原型,不会保留之前原型的任何信息,把原来的原型对象和构造函数对象的实例切断了。

创建对象
var box = new Object();//创建对象
box.name = "Lee";      //添加属性
box.age = 100;
box.run = function(){
    return this.name + this.age + "运行中";  //this 表示当前作用域下对象
}

// this 表示new Object()实例出来的那个对象
alert(box.run());

这就是创建对象最基本的方法,但是有个缺点,想创建一个类似的对象,就会产生大量的代码。

工厂模式

为了解决多个类似对象声明的问题,我们可以使用一种叫做工厂模式的方法,这种方法就是为了解决实例化对象产生大量重复的问题。

function createObject(name,age){
    var obj = new Object();
    obj.name = name;
    obj.age = age;
    obj.run = function(){
        return this.name+this.age+"岁年龄";
    }
    return obj;
}

var box1 = createObject("Lee",20);
var box2 = createObject("Jack",30);
console.log(box1.run());
console.log(box2.run());

工厂模式解决了重复实例化的问题,但还有一个问题,那就是识别问题,因为根本无法搞清他们到底是哪个对象的实例。

alert(typeof box1); //Object
alert(box1 instanceof Object);//true
构造函数

ECAMScript中采用构造函数(构造方法)可用来创建特定的对象。类似于Object对象。

//构造函数
function Box(name,age){
    this.name = name;
    this.age = age;
    this.run = function(){
        return this.name + this.age +"运行中...";
    };
};

var box1 = new Box("Lee",100);
var box2 = new Box("Jack",200);

console.log(box1.run());
console.log(box2.run());

使用构造函数的方法,即解决了重复实例化的问题,又解决了对象识别的问题,但问题是,这里并没有new Object(),为什么可以实例化Box(),这个是哪里来的呢?

使用了构造函数的方法,和使用工厂模式的方法他们不同之处如下:
1.构造函数方法没有显示的创建对象(new Objectt()),但它在后台自动var obj = new Object();
2.直接将属性和方法赋值给this对象,this就相当于obj;
3.没有return语句,不需要返回对象引用,它是在后台自动返回的。

//构造函数
function Box(name,age){
    this.name = name;
    this.age = age;
    this.run = function(){
        return this.name + this.age +"运行中...";
    };
};

function Dack(name,age){
    this.name = name;
    this.age = age;
    this.run = function(){
        return this.name + this.age +"运行中...";
    };
};

var box1 = new Box("Lee",100);
var box2 = new Box("Jack",200);
var box3 = new Dack("MrLee",300);

console.log(box1.run());
console.log(box2.run());
console.log(box3.run());

//解决了对象识别问题
console.log(box1 instanceof Box); //true
console.log(box2 instanceof Box); //true
console.log(box3 instanceof Box); //false
console.log(box3 instanceof Dack);//true

对象冒充:使用call()方法

var o= new Object();
Box.call(o,"Lee",100);
console.log(o.run());

看下一个问题:

 var box1 = new Box("Lee",100); //实例化后地址为1
 var box2 = new Box("Lee",100); //实例化后地址为2

 console.log(box1.name == box2.name); //true
 console.log(box1.age == box2.age);      //true
 console.log(box1.run() == box2.run());//true //构造函数体内的方法的值是相当的
 console.log(box1.run == box2.run); //false //因为他们比较的是引用地址
 

上面的代码运行说明引用地址不一样,那么构造函数内的方法也可以这样写:

this.run = new Function("return this.name + this.age +"运行  

如何让他们的引用地址一样,下面代码:

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

function run(){
    return this.name +this.age+"运行中...";
}
 var box1 = new Box("Lee",100); //实例化后地址为1
 var box2 = new Box("Lee",100); //实例化后地址为2
 console.log(box1.run == box2.run); //true //因为他们比较的是引用地址  
 

把构造函数内部的方法通过全局来实现引用地址一致。
虽然使用了全局函数run()来解决了保证引用地址一致的问题,但是这种方式又带来了一个新的问题,全局中的this在对象调用的时候是Box本身,而当普通函数调用的时候,this又代表window。

原型
function Box(){
       //构造函数函数体内什么都没有,这里如有过,叫做实例属性,实例方法
} 

Box.prototype.name="Lee"; //原型属性
Box.prototype.age=100;
Box.prototype.run=function(){ //原型方法
    return this.name+this.age+"运行中...";
}

var box1=new Box();
var box2=new Box();
console.log(box1.run == box2.run); //true
console.log(box1.prototype);//这个属性是一个对象,访问不到
console.log(box1.__proto__);//这个属性是一个指针指向prototype原型对象。 

如果是实例方法,不同的实例化,他们的方法地址是不一样的,是唯一的。
如果是原型方法,那么他们的地址是共享的,大家都一样。

console.log(box1.constructor); //构造属性,可以获取构造函数  

PS:IE浏览器在脚本访问__proto__会不能识别,火狐和谷歌及其他某些浏览器能识别。虽然可以输出,但是无法获取内部信息。

判断一个对象是否指向该构造函数的原型对象,可以使用isPrototypeOf()方法来测试。

console.log(Box.prototype.isPrototypeOf(box1)); //true //只要实例化对象,即都会指向

原型模式的执行流程:
1.先查找构造函数实例里的属性或方法,如果有,立刻返回;
2.如果构造函数实例里没有,则去它的原型对象里找,如果有,就返回。

如何判断属性时构造函数的实例里,还是原型里?可以使用hasOwnProperty()函数来验证:

console.log(box1.hasOwnProperty("name"));//如果实例里有返回true,否则返回false  

如何判断属性是原型里的?

function Box(){
       
} 

Box.prototype.name="Lee"; //原型属性
Box.prototype.age=100;
Box.prototype.run=function(){ //原型方法
    return this.name+this.age+"运行中...";
}

function isProperty(object,property){
    return !object.hasOwnProperty(property) && (property in object);
}
var box1=new Box();
console.log(isProperty(box1,"name"));

为了让属性和方法更好的体现封装的效果,并且减少不必要的输入,原型的创建可以使用字面量的方式

使用字面量的方式创建原型对象,这里的{}就是对象,是object,new Object就相当于{}

function Box(){} 

Box.prototype={
    name:"Lee",
    age:100,
    run:function(){
        return this.name+this.age+"运行中...";
    }
}

var box = new Box();
console.log(box.constructor == Box); //false 

字面量创建的方式使用constructor属性不会指向实例,而会指向Object,构造函数创建的方式则相反。
这里的Box.prototype={}就相当于创建了一个新的对象,所以 box.constructor是Object。
如何让box.constructor指向Box呢?

function Box(){} 

Box.prototype={
    constructor:Box,//直接强制指向即可
    name:"Lee",
    age:100,
    run:function(){
        return this.name+this.age+"运行中...";
    }
}

var box = new Box();
console.log(box.constructor == Box); //true

重写原型,不会保留之前原型的任何信息,把原来的原型对象和构造函数对象的实例切断了。

function Box(){} 

Box.prototype={
    constructor:Box,
    name:"Lee",
    age:100,
    run:function(){
        return this.name+this.age+"运行中...";
    }
}

//重写原型
Box.prototype={
    age:200
}
var box = new Box();
console.log(box.name); //undefined

查看sort是否是Array原型对象里的方法
alert(Array.prototype.sort);

在如下 判断String原型对象里是否有substring方法
alert(String.prototype.substring);

给String 添加addstring方法:

String.prototype.addstring=function(){
    return this+",被添加了!";
}
var box="Lee";
console.log(box.addstring());

注:原型模式创建对象也有自己的缺点,它省略了构造函数传参初始化这一过程,带来的缺点就是初始化的值都是一致的。而原型最大的缺点就是它最大的优点,那就是共享。

原型中所有属性是被很多实例共享的,共享对于函数非常合适,对于包含基本值的属性也还可以。但如果属性包含引用类型,就存在一定的问题:

function Box(){}

Box.prototype={
    constructor:Box,
    name:"Lee",
    age:100,
    family:["哥哥","姐姐","妹妹"],
    run:function(){
        return this.name+this.age+"运行中...";
    }
};

var box1 = new Box();
console.log(box1.family); //"哥哥","姐姐","妹妹"
box1.family.push("弟弟");
console.log(box1.family);//"哥哥","姐姐","妹妹","弟弟"

var box2 = new Box();
console.log(box2.family);//"哥哥","姐姐","妹妹","弟弟"

从上面代码可以看出,在第一个实例修改后引用类型,保持了共享。box2.family共享了box1添加后的引用类型的原型。

为了解决构造传参和共享问题,可以组合构造函数+原型模式:

function Box(name,age){  //保持独立的用构造函数
    this.name=name;
    this.age=age;
    this.family=["哥哥","姐姐","妹妹"];
}

Box.prototype={ //保持共享的用原型
    constructor:Box,
    run:function(){
        return this.name+this.age+"运行中...";
    }
}

var box1 = new Box("Lee",100);
console.log(box1.family); //"哥哥","姐姐","妹妹"
box1.family.push("弟弟");
console.log(box1.family);//"哥哥","姐姐","妹妹","弟弟"



var box2 = new Box("Jack",200);
console.log(box2.family); //"哥哥","姐姐","妹妹" //引用类型没有使用原型,所以没有共享

动态原型模式

//把原型封装到构造函数里
function Box(name,age){
    this.name=name;
    this.age=age;
    this.family=["哥哥","姐姐","妹妹"];

    console.log("原型初始化开始");  //执行了两次
    Box.prototype.run=function(){
        return this.name+this.age+"运行中...";
    }
    console.log("原型初始化结束"); //执行了两次
}

//原型的初始化,只要第一次初始化就可以了,没必要每次构造函数实例化的时候都初始化
var box1 = new Box("Lee",100);
var box2 = new Box("Jack",200);

为了只让第一次初始化,那么就判断

function Box(name,age){
    this.name=name;
    this.age=age;
    this.family=["哥哥","姐姐","妹妹"];

    if(typeof this.run!="function"){
        console.log("原型初始化开始"); //执行了一次次
        Box.prototype.run=function(){
            return this.name+this.age+"运行中...";
        };
        console.log("原型初始化结束"); //执行了一次
    }
}

//原型的初始化,只要第一次初始化就可以了,没必要每次构造函数实例化的时候都初始化
var box1 = new Box("Lee",100);
var box2 = new Box("Jack",200);

寄生构造函数
如果以上都不能满足需要,可以使用一下寄生构造函数。
寄生构造函数=工厂模式+构造函数

function Box(name,age){
    var obj = new Object();
    obj.name=name;
    obj.age=age;
    obj.run=function(){
        return this.name+this.age+"运行中...";
    }
    return obj;
}

var box1 = new Box("Lee",100);
var box2 = new Box("Jack",200);

稳妥构造函数

在一些安全的环境中,比如禁止使用this和new,这里的this是构造函数里不使用的this,这里的new是在外部实例化构造函数时不使用new。这种创建方式叫做稳妥构造函数。

function Box(name,age){
    var obj = new Object();
    obj.name=name;
    obj.age=age;
    obj.run=function(){
        return this.name+this.age+"运行中...";
    }
    return obj;
}

var box1 = Box("Lee",100);
var box2 = Box("Jack",200);

继承

继承是面向对象中一个比较核心的概念。其它正统面向对象语言都会用两种方式实现继承:一个是接口实现,一个是继承。而ECMAScript只支持继承,不支持接口实现,而实现继承的方式依靠原型链完成。

function Box(){
    this.name="Lee";
}

function Jack(){
    this.age=100;
}

Jack.prototype = new Box();

var jack = new Jack();
console.log(jack.name); //Lee

为了解决引用共享和超类型无法传参的问题,我们采用一种叫借用构造函数的技术,或者成为对象冒充(伪造对象、经典继承)的技术解决这两个问题。

function Box(name){
    this.name=name;
}

Box.prototype.age=200;

function Jack(name){
    Box.call(this,name);
}

var jack = new Jack("Lee");

console.log(jack.name);//Lee
console.log(jack.age);//undefined   

但是上面的代码可以看出,对象冒充没有继承原型链上的age属性。所以要继承Box的原型,就出现下面的组合继承。
组合继承即是原型链+借用构造函数的模式

function Box(name){
    this.name=name;
}

Box.prototype.age=200;

function Jack(name){
    Box.call(this,name);
}

Jack.prototype = new Box();

var jack = new Jack("Lee");

console.log(jack.name);//Lee
console.log(jack.age);//200

原型式继承

//临时中转函数
function obj(o){
    function F(){};
    F.prototype = o;
    return new F();
}

//这是字面量的声明方式,相当于var box = new Box();
var box={
    name:"Lee",
    age:100,
    family:["哥哥","姐姐","妹妹"]
};

var box1 = obj(box);
console.log(box1.family);//"哥哥","姐姐","妹妹"
box1.family.push("弟弟");
console.log(box1.family);//"哥哥","姐姐","妹妹","弟弟"

var box2 = obj(box);
console.log(box2.family);//"哥哥","姐姐","妹妹","弟弟"

存在的问题就是引用类型共享了。

寄生式继承
把原型式与工厂模式结合起来。

//临时中转函数
function obj(o){
    function F(){};
    F.prototype = o;
    return new F();
}


//寄生函数
function create(o){
    var f=obj(o);
    f.run=function(){
        return this.name+"方法";
    }
    return f;
}


//这是字面量的声明方式,相当于var box = new Box();
var box={
    name:"Lee",
    age:100,
    family:["哥哥","姐姐","妹妹"]
};

var box1 = create(box);
console.log(box1.run());

寄生组合继承

//临时中转函数
function obj(o){
    function F(){};
    F.prototype = o;
    return new F();
}


//寄生函数
function create(box,desk){
    var f=obj(box.prototype);
    f.constructor=desk; //调整原型构造指针
    desk.prototype=f;
}


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

Box.prototype.run=function(){
    return this.name+this.age+"运行中...";
}

function Desk(name,age){
    Box.call(this,name,age); //对象冒充
}

//通过寄生组合继承来实现继承
create(Box,Desk); //这句话用来替代Desk.prototype = new Box();

var desk = new Desk("Lee",100);
console.log(desk.run());

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/78845.html

相关文章

  • 【连载】前端个人文章整理-从基础到入门

    摘要:个人前端文章整理从最开始萌生写文章的想法,到着手开始写,再到现在已经一年的时间了,由于工作比较忙,更新缓慢,后面还是会继更新,现将已经写好的文章整理一个目录,方便更多的小伙伴去学习。 showImg(https://segmentfault.com/img/remote/1460000017490740?w=1920&h=1080); 个人前端文章整理 从最开始萌生写文章的想法,到着手...

    madthumb 评论0 收藏0
  • SegmentFault 技术周刊 Vol.32 - 七夕将至,你的“对象”还好吗?

    摘要:很多情况下,通常一个人类,即创建了一个具体的对象。对象就是数据,对象本身不包含方法。类是相似对象的描述,称为类的定义,是该类对象的蓝图或原型。在中,对象通过对类的实体化形成的对象。一类的对象抽取出来。注意中,对象一定是通过类的实例化来的。 showImg(https://segmentfault.com/img/bVTJ3H?w=900&h=385); 马上就要到七夕了,离年底老妈老爸...

    李昌杰 评论0 收藏0
  • SegmentFault 技术周刊 Vol.32 - 七夕将至,你的“对象”还好吗?

    摘要:很多情况下,通常一个人类,即创建了一个具体的对象。对象就是数据,对象本身不包含方法。类是相似对象的描述,称为类的定义,是该类对象的蓝图或原型。在中,对象通过对类的实体化形成的对象。一类的对象抽取出来。注意中,对象一定是通过类的实例化来的。 showImg(https://segmentfault.com/img/bVTJ3H?w=900&h=385); 马上就要到七夕了,离年底老妈老爸...

    Lyux 评论0 收藏0
  • SegmentFault 技术周刊 Vol.32 - 七夕将至,你的“对象”还好吗?

    摘要:很多情况下,通常一个人类,即创建了一个具体的对象。对象就是数据,对象本身不包含方法。类是相似对象的描述,称为类的定义,是该类对象的蓝图或原型。在中,对象通过对类的实体化形成的对象。一类的对象抽取出来。注意中,对象一定是通过类的实例化来的。 showImg(https://segmentfault.com/img/bVTJ3H?w=900&h=385); 马上就要到七夕了,离年底老妈老爸...

    AaronYuan 评论0 收藏0
  • javascript基础:关于js面向对象的理解

    摘要:关于中面向对象的理解面向对象编程它是一种编程思想我们的编程或者学习其实是按照类实例来完成的学习类的继承封装多态封装把实现一个功能的代码封装到一个函数中一个类中以后再想实现这个功能,只需要执行这个函数方法即可,不需要再重复的编写代码。 关于js中面向对象的理解 面向对象编程(oop) 它是一种编程思想 (object-oriented programming ), 我们的编程或者学习其...

    roadtogeek 评论0 收藏0

发表评论

0条评论

Pluser

|高级讲师

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<