javascript的继承,JavaScript的继承

如何理解javascript中寄生组合式继承

寄生组合式继承

成都创新互联企业建站,十多年网站建设经验,专注于网站建设技术,精于网页设计,有多年建站和网站代运营经验,设计师为客户打造网络企业风格,提供周到的建站售前咨询和贴心的售后服务。对于网站设计制作、做网站中不同领域进行深入了解和探索,创新互联在网站建设中充分了解客户行业的需求,以灵动的思维在网页中充分展现,通过对客户行业精准市场调研,为客户提供的解决方案。

组合继承是js最常用的继承模式,组合继承最大的问题就是无论在什么情况下,都会调用两次构造函数:一次是在创建子类型原型时,另一次是在子类型构造函数内部。

function SuperType(name){

this.name = name;

this.colors = ["red", "blue", "green"];

}

SuperType.prototype.sayName = function(){

alert(this.name);

}

function SubType(name, age){

SuperType.call(this, name);//第二次调用SuperType()

this.age = age;

}

SubType.prototype = new SuperType();//第一次调用SuperType()

SubType.prototype.sayAge = function(){

alert(this.age);

}

js中继承的几种用法总结

一,js中对象继承

js中有三种继承方式

1.js原型(prototype)实现继承

复制代码 代码如下:

SPAN style="BACKGROUND-COLOR: #ffffff"SPAN style="FONT-SIZE: 18px"html

body

script type="text/javascript"

function Person(name,age){

this.name=name;

this.age=age;

}

Person.prototype.sayHello=function(){

alert("使用原型得到Name:"+this.name);

}

var per=new Person("马小倩",21);

per.sayHello(); //输出:使用原型得到Name:马小倩

function Student(){}

Student.prototype=new Person("洪如彤",21);

var stu=new Student();

Student.prototype.grade=5;

Student.prototype.intr=function(){

alert(this.grade);

}

stu.sayHello();//输出:使用原型得到Name:洪如彤

stu.intr();//输出:5

/script

/body

/html/SPAN/SPAN

2.构造函数实现继承

复制代码 代码如下:

SPAN style="FONT-SIZE: 18px"html

body

script type="text/javascript"

function Parent(name){

this.name=name;

this.sayParent=function(){

alert("Parent:"+this.name);

}

}

function Child(name,age){

this.tempMethod=Parent;

this.tempMethod(name);

this.age=age;

this.sayChild=function(){

alert("Child:"+this.name+"age:"+this.age);

}

}

var parent=new Parent("江剑臣");

parent.sayParent(); //输出:“Parent:江剑臣”

var child=new Child("李鸣",24); //输出:“Child:李鸣 age:24”

child.sayChild();

/script

/body

/html/SPAN

3.call , apply实现继承

复制代码 代码如下:

SPAN style="FONT-SIZE: 18px"html

body

script type="text/javascript"

function Person(name,age,love){

this.name=name;

this.age=age;

this.love=love;

this.say=function say(){

alert("姓名:"+name);

}

}

//call方式

function student(name,age){

Person.call(this,name,age);

}

//apply方式

function teacher(name,love){

Person.apply(this,[name,love]);

//Person.apply(this,arguments); //跟上句一样的效果,arguments

}

//call与aplly的异同:

//1,第一个参数this都一样,指当前对象

//2,第二个参数不一样:call的是一个个的参数列表;apply的是一个数组(arguments也可以)

var per=new Person("武凤楼",25,"魏荧屏"); //输出:“武凤楼”

per.say();

var stu=new student("曹玉",18);//输出:“曹玉”

stu.say();

var tea=new teacher("秦杰",16);//输出:“秦杰”

tea.say();

/script

/body

/html/SPAN

二、call和apply的用法(详细介绍)

js中call和apply都可以实现继承,唯一的一点参数不同,func.call(func1,var1,var2,var3)对应的apply写法为:func.apply(func1,[var1,var2,var3])。

JS手册中对call的解释:

复制代码 代码如下:

SPAN style="FONT-SIZE: 18px"call 方法

调用一个对象的一个方法,以另一个对象替换当前对象。

call([thisObj[,arg1[, arg2[, [,.argN]]]]])

参数

thisObj

可选项。将被用作当前对象的对象。

arg1, arg2, , argN

可选项。将被传递方法参数序列。

说明

call 方法可以用来代替另一个对象调用一个方法。call 方法可将一个函数的对象上下文从初始的上下文改变为由 thisObj 指定的新对象。

如果没有提供 thisObj 参数,那么 Global 对象被用作 thisObj。/SPAN

说简单一点,这两函数的作用其实就是更改对象的内部指针,即改变对象的this指向的内容。这在面向对象的js编程过程中有时是很有用的。下面以apply为例,说说这两个函数在 js中的重要作用。如:

复制代码 代码如下:

SPAN style="FONT-SIZE: 18px" function Person(name,age){ //定义一个类

this.name=name; //名字

this.age=age; //年龄

this.sayhello=function(){alert(this.name)};

}

function Print(){ //显示类的属性

this.funcName="Print";

this.show=function(){

var msg=[];

for(var key in this){

if(typeof(this[key])!="function"){

msg.push([key,":",this[key]].join(""));

}

}

alert(msg.join(" "));

};

}

function Student(name,age,grade,school){ //学生类

Person.apply(this,arguments);//比call优越的地方

Print.apply(this,arguments);

this.grade=grade; //年级

this.school=school; //学校

}

var p1=new Person("卜开化",80);

p1.sayhello();

var s1=new Student("白云飞",40,9,"岳麓书院");

s1.show();

s1.sayhello();

alert(s1.funcName);/SPAN

另外,Function.apply()在提升程序性能方面有着突出的作用:

我们先从Math.max()函数说起,Math.max后面可以接任意个参数,最后返回所有参数中的最大值。

比如

复制代码 代码如下:

SPAN style="FONT-SIZE: 18px"alert(Math.max(5,8)); //8

alert(Math.max(5,7,9,3,1,6)); //9

//但是在很多情况下,我们需要找出数组中最大的元素。

var arr=[5,7,9,1];

//alert(Math.max(arr)); // 这样却是不行的。NaN

//要这样写

function getMax(arr){

var arrLen=arr.length;

for(var i=0,ret=arr[0];iarrLen;i++){

ret=Math.max(ret,arr[i]);

}

return ret;

}

alert(getMax(arr)); //9

//换用apply,可以这样写

function getMax2(arr){

return Math.max.apply(null,arr);

}

alert(getMax2(arr)); //9

//两段代码达到了同样的目的,但是getMax2却优雅,高效,简洁得多。

//再比如数组的push方法。

var arr1=[1,3,4];

var arr2=[3,4,5];

//如果我们要把 arr2展开,然后一个一个追加到arr1中去,最后让arr1=[1,3,4,3,4,5]

//arr1.push(arr2)显然是不行的。 因为这样做会得到[1,3,4,[3,4,5]]

//我们只能用一个循环去一个一个的push(当然也可以用arr1.concat(arr2),但是concat方法并不改变arr1本身)

var arrLen=arr2.length;

for(var i=0;iarrLen;i++){

arr1.push(arr2[i]);

}

//自从有了Apply,事情就变得如此简单

Array.prototype.push.apply(arr1,arr2); //现在arr1就是想要的结果/SPAN

JavaScript 中原型继承(prototype-based inheritance)的原理是怎样的?

构造函数=function(){};

原型对象={属性甲:1,属性乙:2};

构造函数.prototype=原型对象;

新建对象=new 构造函数();

新建对象.属性甲=0;

这样新建对象就继承了原型对象,并在自身内覆盖了一层私有属性,但并不改变原型对象的任何属性。

此时新建对象本身相当于{属性甲:0}(算上隐藏的不可枚举属性是{属性甲:0,constructor:构造函数}),但是如果访问新建对象.属性乙这个自身不存在的属性,则会上溯到其原型对象的同名属性。

原型对象的属性改变会对所有包括之前创建的新建对象统一有效。方便管理且节省空间。

原型对象亦可层层继承(原型对象本身也可以是基于更上层原型的对象构造的)。而没有继承任何对象的最顶层对象(也即是={}这种最常见的定义形式,等同于=new Object())的constructor就是Object这个原生超级根对象构造器。

js对象是怎样继承另一个对象的?

这几个连接不错,给你分享一下:

第二个:。

原理很简单:总结就是利用对象冒充机制的call方法把父类的属性给抓取下来,而成员方法尽量写进被所有对象实例共享的prototype域中,以防止方法副本重复创建。然后子类继承父类prototype域来抓取下来所有的方法。如想彻底理清这些调用链的关系,推荐大家多关注Js中prototype的constructor和对象的constructor属性,

怎么体现javascript的继承关系

js继承的概念

js里常用的如下两种继承方式:

原型链继承(对象间的继承)

类式继承(a href=";tn=44039180_cprfenlei=mv6quAkxTZn0IZRqIHckPjm4nH00T1YYn10zuADLujP9nAczPyFb0ZwV5Hcvrjm3rH6sPfKWUMw85HfYnjn4nH6sgvPsT6KdThsqpZwYTjCEQLGCpyw9Uz4Bmy-bIi4WUvYETgN-TLwGUv3EPHnLPH03nHDd"target="_blank" class="baidu-highlight"构造函数/a间的继承)

由于js不像java那样是真正a href=";tn=44039180_cprfenlei=mv6quAkxTZn0IZRqIHckPjm4nH00T1YYn10zuADLujP9nAczPyFb0ZwV5Hcvrjm3rH6sPfKWUMw85HfYnjn4nH6sgvPsT6KdThsqpZwYTjCEQLGCpyw9Uz4Bmy-bIi4WUvYETgN-TLwGUv3EPHnLPH03nHDd" target="_blank" class="baidu-highlight"面向对象/a的语言,js是基于对象的,它没有类的概念。所以,要想实现继承,可以用js的原型prototype机制或者用apply和call方法去实现

在a href=";tn=44039180_cprfenlei=mv6quAkxTZn0IZRqIHckPjm4nH00T1YYn10zuADLujP9nAczPyFb0ZwV5Hcvrjm3rH6sPfKWUMw85HfYnjn4nH6sgvPsT6KdThsqpZwYTjCEQLGCpyw9Uz4Bmy-bIi4WUvYETgN-TLwGUv3EPHnLPH03nHDd" target="_blank" class="baidu-highlight"面向对象/a的语言中,我们使用类来创建一个自定义对象。然而js中所有事物都是对象,那么用什么办法来创建自定义对象呢?这就需要用到js的原型:

我们可以简单的把prototype看做是一个模版,新创建的自定义对象都是这个模版(prototype)的一个拷贝 (实际上不是拷贝而是链接,只不过这种链接是不可见,新实例化的对象内部有一个看不见的__Proto__指针,指向原型对象)。

js可以通过a href=";tn=44039180_cprfenlei=mv6quAkxTZn0IZRqIHckPjm4nH00T1YYn10zuADLujP9nAczPyFb0ZwV5Hcvrjm3rH6sPfKWUMw85HfYnjn4nH6sgvPsT6KdThsqpZwYTjCEQLGCpyw9Uz4Bmy-bIi4WUvYETgN-TLwGUv3EPHnLPH03nHDd"target="_blank" class="baidu-highlight"构造函数/a和原型的方式模拟实现类的功能。 另外,js类式继承的实现也是依靠原型链来实现的。

原型式继承与类式继承

类式继承是在子类型a href=";tn=44039180_cprfenlei=mv6quAkxTZn0IZRqIHckPjm4nH00T1YYn10zuADLujP9nAczPyFb0ZwV5Hcvrjm3rH6sPfKWUMw85HfYnjn4nH6sgvPsT6KdThsqpZwYTjCEQLGCpyw9Uz4Bmy-bIi4WUvYETgN-TLwGUv3EPHnLPH03nHDd" target="_blank" class="baidu-highlight"构造函数/a的内部调用超类型的构造函数。

严格的类式继承并不是很常见,一般都是组合着用:

function Super(){

this.colors=["red","blue"];

}

function Sub(){

Super.call(this);

}

原型式继承是借助已有的对象创建新的对象,将子类的原型指向父类,就相当于加入了父类这条原型链

原型链继承

为了让子类继承父类的属性(也包括方法),首先需要定义一个构造函数。然后,将父类的新实例赋值给构造函数的原型。代码如下:

script

function Parent(){

this.name = 'mike';

}

function Child(){

this.age = 12;

}

Child.prototype = new Parent();//Child继承Parent,通过原型,形成链条

var test = new Child();

alert(test.age);

alert(test.name);//得到被继承的属性

//继续原型链继承

function Brother(){ //brother构造

this.weight = 60;

}

Brother.prototype = new Child();//继续原型链继承

var brother = new Brother();

alert(brother.name);//继承了Parent和Child,弹出mike

alert(brother.age);//弹出12

/script

以上原型链继承还缺少一环,那就是Object,所有的构造函数都继承自Object。而继承Object是自动完成的,并不需要我们自己手动继承,那么他们的a href=";tn=44039180_cprfenlei=mv6quAkxTZn0IZRqIHckPjm4nH00T1YYn10zuADLujP9nAczPyFb0ZwV5Hcvrjm3rH6sPfKWUMw85HfYnjn4nH6sgvPsT6KdThsqpZwYTjCEQLGCpyw9Uz4Bmy-bIi4WUvYETgN-TLwGUv3EPHnLPH03nHDd" target="_blank" class="baidu-highlight"从属关系/a是怎样的呢?

确定原型和实例的关系

可以通过两种方式来确定原型和实例之间的关系。操作符instanceof和isPrototypeof()方法:

alert(brother instanceof Object)//true

alert(test instanceof Brother);//false,test 是brother的超类

alert(brother instanceof Child);//true

alert(brother instanceof Parent);//true

只要是原型链中出现过的原型,都可以说是该原型链派生的实例的原型,因此,isPrototypeof()方法也会返回true

在js中,被继承的函数称为超类型(父类,基类也行),继承的函数称为子类型(子类,派生类)。使用原型继承主要由两个问题:

一是字面量重写原型会中断关系,使用引用类型的原型,并且子类型还无法给超类型传递参数。

伪类解决引用共享和超类型无法传参的问题,我们可以采用“借用构造函数”技术

借用构造函数(类式继承)

script

function Parent(age){

this.name = ['mike','jack','smith'];

this.age = age;

}

function Child(age){

Parent.call(this,age);

}

var test = new Child(21);

alert(test.age);//21

alert(test.name);//mike,jack,smith

test.name.push('bill');

alert(test.name);//mike,jack,smith,bill

/script

借用构造函数虽然解决了刚才两种问题,但没有原型,则复用无从谈起,所以我们需要原型链+借用构造函数的模式,这种模式称为组合继承

组合继承

script

function Parent(age){

this.name = ['mike','jack','smith'];

this.age = age;

}

Parent.prototype.run = function () {

return this.name + ' are both' + this.age;

};

function Child(age){

Parent.call(this,age);//对象冒充,给超类型传参

}

Child.prototype = new Parent();//原型链继承

var test = new Child(21);//写new Parent(21)也行

alert(test.run());//mike,jack,smith are both21

/script

组合式继承是比较常用的一种继承方法,其背后的思路是 使用原型链实现对原型属性和方法的继承,而通过借用构造函数来实现对实例属性的继承。这样,既通过在原型上定义方法实现了函数复用,又保证每个实例都有它自己的属性。

call()的用法:调用一个对象的一个方法,以另一个对象替换当前对象。

call([thisObj[,arg1[, arg2[, [,.argN]]]]])

原型式继承

这种继承借助原型并基于已有的对象创建新对象,同时还不用创建自定义类型的方式称为原型式继承

script

function obj(o){

function F(){}

F.prototype = o;

return new F();

}

var box = {

name : 'trigkit4',

arr : ['brother','sister','baba']

};

var b1 = obj(box);

alert(b1.name);//trigkit4

b1.name = 'mike';

alert(b1.name);//mike

alert(b1.arr);//brother,sister,baba

b1.arr.push('parents');

alert(b1.arr);//brother,sister,baba,parents

var b2 = obj(box);

alert(b2.name);//trigkit4

alert(b2.arr);//brother,sister,baba,parents

/script

原型式继承首先在obj()函数内部创建一个临时性的构造函数 ,然后将传入的对象作为这个构造函数的原型,最后返回这个临时类型的一个新实例。

寄生式继承

这种继承方式是把原型式+a href=";tn=44039180_cprfenlei=mv6quAkxTZn0IZRqIHckPjm4nH00T1YYn10zuADLujP9nAczPyFb0ZwV5Hcvrjm3rH6sPfKWUMw85HfYnjn4nH6sgvPsT6KdThsqpZwYTjCEQLGCpyw9Uz4Bmy-bIi4WUvYETgN-TLwGUv3EPHnLPH03nHDd" target="_blank" class="baidu-highlight"工厂模式/a结合起来,目的是为了封装创建的过程。

script

function create(o){

var f= obj(o);

f.run = function () {

return this.arr;//同样,会共享引用

};

return f;

}

/script

组合式继承的小问题

组合式继承是js最常用的继承模式,但组合继承的超类型在使用过程中会被调用两次;一次是创建子类型的时候,另一次是在子类型构造函数的内部

script

function Parent(name){

this.name = name;

this.arr = ['哥哥','妹妹','父母'];

}

Parent.prototype.run = function () {

return this.name;

};

function Child(name,age){

Parent.call(this,age);//第二次调用

this.age = age;

}

Child.prototype = new Parent();//第一次调用

/script

以上代码是之前的组合继承,那么寄生组合继承,解决了两次调用的问题。

寄生组合式继承

script

function obj(o){

function F(){}

F.prototype = o;

return new F();

}

function create(parent,test){

var f = obj(parent.prototype);//创建对象

f.constructor = test;//增强对象

}

function Parent(name){

this.name = name;

this.arr = ['brother','sister','parents'];

}

Parent.prototype.run = function () {

return this.name;

};

function Child(name,age){

Parent.call(this,name);

this.age =age;

}

inheritPrototype(Parent,Child);//通过这里实现继承

var test = new Child('trigkit4',21);

test.arr.push('nephew');

alert(test.arr);//

alert(test.run());//只共享了方法

var test2 = new Child('jack',22);

alert(test2.arr);//引用问题解决

/script

call和apply

全局函数apply和call可以用来改变函数中this的指向,如下:

// 定义一个全局函数

function foo() {

console.log(this.fruit);

}

// 定义一个全局变量

var fruit = "apple";

// 自定义一个对象

var pack = {

fruit: "orange"

};

// 等价于window.foo();

foo.apply(window); // "apple",此时this等于window

// 此时foo中的this === pack

foo.apply(pack); // "orange"


分享题目:javascript的继承,JavaScript的继承
本文路径:http://ybzwz.com/article/dsdgjso.html