介绍
这篇文章将为大家详细讲解有关JavaScript原型和原型链的案例分析,小编觉得挺实用的,因此分享给大家做个参考,希望大家阅读完这篇文章后可以有所收获。
<强> 1,题目
如何准确判断一个变量是数组
写一个原型链继承的例子
继承实现的其他方式
es6实现继承的底层原理是什么
描述新一个对象的过程
zepto及其他源码中如何使用原型链
<强> 2。知识点
2.1构造函数
特点:以大写字母开头
函数Foo(姓名、年龄){//var obj={}//这个={}
this.name=名称;
这一点。年龄=年龄;
这一点。类=& # 39;class1 # 39;//返回这
}
var f1=new Foo(& # 39;石灰# 39;,19), 扩展
var o={}是var o=新对象()的语法糖
var=[]是var=new Array()的语法糖
函数Foo(){},相当于var Foo=新功能(){}
<强> 2.2原型规则
五条规则:
1。所有引用类型(对象、数组,函数)都具有对象特性,即可以自由扩展属性
2。所有引用类型(对象、数组,函数)都具有一个__proto__(隐式原型)属性,是一个普通对象
3。所有的函数都具有原型(显式原型)属性,也是一个普通对象
4。所有引用类型(对象、数组,函数)__proto__值指向它构造函数的原型
5。当试图得到一个对象的属性时,如果变量本身没有这个属性,则会去他的__proto__中去找
(var关键对象){//高级浏览器中已经屏蔽了来自原型的属性//建议加上判断保证程序的健壮性
如果(object.hasOwnProperty(关键)){
console.log(对象(例子));
}
} <强> 2.3原型链
obj。__原型<强>。<强> 原型。原型__…
对象。原型===null
运算符用于判断引用类型属于哪个构造函数
obj instanceob, Foo
实际意义:判断Foo。原型在不在obj的原型链上
<强> 3。题目解答
3.1如何准确判断一个变量是数组
arr数组运算符
3.2写一个原型链继承的例子
封装dom查询
函数Elem (id) {
这一点。elem=. getelementbyid (id);
}；
Elem.prototype。html=function (val) {
var elem=this.elem;
如果(val) {
初步的。innerHTML=val;
返回;
其他}{
返回elem.innerHTML;
}
}
Elem.prototype。=function(类型、有趣){
var elem=this.elem;
elem.addEventListener(类型、有趣的);
返回;
}
var p1=new Elem (& # 39; id1 # 39;);
p1.html (“test")内(& # 39;点击# 39;函数(){
console.log(& # 39;点击& # 39;);
}) <强> 3.3继承实现的其他方式
3.3.1原型继承
var obj={
0:& # 39;一个# 39;
1:& # 39;b # 39;
加勒比海盗:[1]
}
函数Foo (arr2) {
这一点。arr2=[1]
}
Foo。原型=obj;
var foo1=new Foo ();
var foo2=new Foo ();
foo1.arr.push (2);
foo1.arr2.push (2);
console.log (foo2.arr);//[1,2]
console.log (foo2.arr2);//[1] 优点:实现简单
缺点:
1。无法向父类构造函数传参
2。同时新的两个对象时改变一个对象的原型中的引用类型的属性时,另一个对象的该属性也会修改。因为来自原型对象的引用属性是所有实例共享的。
3.3.2构造继承
功能超级(b) {
这一点。b=b;
这一点。有趣=function () {}
}
函数Foo (a, b) {
这一点。一个=;
Super.call (b);
}
var foo1=new Foo (1、2);
console.log (foo1.b); 优点:可以向父类传参,子类不会共享父类的引用属性
缺点:无法实现函数复用,每个子类都有新的乐趣,太多了就会影响性能,不能继承父类的原型对象。
3.3.3组合继承
功能超级(){//只在此处声明基本属性和引用属性
这一点。val=1;
这一点。arr=[1];
}//在此处声明函数
Super.prototype。fun1=function () {};
Super.prototype。fun2=function () {};//Super.prototype.fun3……
函数子(){
Super.call(这个);//核心//?
}
Sub.prototype=new Super (); 优点:不存在引用属性共享问题,可传参,函数可复用
缺点:父类的属性会被实例化两次,获取不到真正实例父类(无法区分实例是父类创建还是父类创建的)
