ANSYSIcepak电⼦散热基础教程+ANSYSIcepak进阶应⽤导航案例.zip ANSYS Icepak电⼦散热基础教程+ANSYS Icepak进阶应⽤导航案例，两本pdf，全本⽆缺。
⽂件：
（访问密码：551685）
以下内容⽆关：
-------------------------------------------分割线---------------------------------------------
开篇之前，我想提出3个问题：
新建⼀个不添加任何属性的对象为何能调⽤toString⽅法?
如何让拥有相同构造函数的不同对象都具备相同的⾏为?
instanceof关键字判断对象类型的依据是什么?
要是这3个问题都能回答上来，那么接下来的内容不看也罢。但若是对这些问题还存在疑虑和不解，相信我，下⾯的内容将正是你所需要的。
正⽂
新建⼀个不添加任何属性的对象为何能调⽤toString⽅法?
我在深⼊了解JavaScript中基于原型（prototype）的继承机制⼀⽂中提到过，JavaScript使⽤的是基于原型的继承机制，它的引⽤类型与其对应的值将都存在着__proto__[1]属性，指向继承的原型对象[2]。当访问对象属性⽆果时，便会在其原型对象中继续查，倘若其原型对象中还是查询⽆果，那便接着去其原型对象的原型中去查，直到查成功或原型为null时[3]才会停⽌查。
let obj = {
}
这段代码就是在obj对象中查toString⽅法，查询⽆果，继⽽在其原型[4]中查toString⽅法，正好其原型中含有toString⽅法，故⽽得以输出"[object Object]"。
如何让拥有相同构造函数的不同对象都具备相同的⾏为?
下⾯是⼀段实现了发布订阅模式的代码：
let _indexOf = Array.prototype.indexOf;
let _push = Array.prototype.push;
let _slice = Array.prototype.slice;
let _concat = at;
let _forEach = Array.prototype.forEach;
function Publish(){
this.subList;
this.indexOf = function(sub){
let index = -1;
if(typeof this.subList === 'undefined' || this.subList === null){
this.subList = [];
}
if(typeof sub !== 'undefined' && sub !== null){
index = _indexOf.call(this.subList,sub);
}
return index;
}
this.addSub = function(sub){
let index = this.indexOf(sub);
index > -1 ?
'' :
_push.call(this.subList,sub);
};
let index = this.indexOf(sub);
index > -1 ?
index === 0 ?
this.subList = _slice.call(this.subList,1) :
this.subList = _concat.call(_slice.call(this.subList,0,index),_slice.call(this.subList,index + 1)) : '';
};
let index = this.indexOf(sub);
index > -1 ?
(Receive === 'function' ?
'') :
'';
};
if(typeof this.subList !== 'undefined' && this.subList !== null){
_forEach.call(this.subList,(sub)=>{
if(typeof sub !== 'undefined' && sub !== null){
Receive === 'function' ?
'';
}
})
}
};
}
function Subscription(name){
this.name = name;
console.log(this.name + ’ 收到消息 : ’ + msg);
};
}
let pub = new Publish();
let sub1 = new Subscription(‘sub1’);
let sub2 = new Subscription(‘sub2’);
let sub3 = new Subscription(‘sub3’);
let sub4 = new Subscription(‘sub4’);
pub.addSub(sub1);
pub.addSub(sub1);
pub.addSub(sub2);
pub.addSub(sub3);
pub.addSub(sub4);
// sub1 收到消息 : 这是⼀条全部推送的消息
// sub2 收到消息 : 这是⼀条全部推送的消息
// sub3 收到消息 : 这是⼀条全部推送的消息
// sub4 收到消息 : 这是⼀条全部推送的消息
// sub2 收到消息 : 这是⼀条单独推送的消息
// sub1 收到消息 : 这是⼀条全部推送的消息
// sub2 收到消息 : 这是⼀条全部推送的消息
/
/ sub4 收到消息 : 这是⼀条全部推送的消息
此代码中拥有同⼀构造函数的所有对象都含有不同的⽅法。
这样会导致:
1.浪费内存;
2.不易于对⽅法进⾏批量操作。
接下来是改进版本，使⽤原型达到代码复⽤的效果：
let _indexOf = Array.prototype.indexOf;
let _push = Array.prototype.push;
let _slice = Array.prototype.slice;
let _concat = at;
let _forEach = Array.prototype.forEach;
function Publish(){
this.subList;
}
Publish.prototype.indexOf = function(sub){
let index = -1;
if(typeof this.subList === ‘undefined’ || this.subList === null){ this.subList = [];
}
if(typeof sub !== ‘undefined’ && sub !== null){
index = _indexOf.call(this.subList,sub);
}
return index;
}
Publish.prototype.addSub = function(sub){
let index = this.indexOf(sub);
index > -1 ?
‘’ :
_push.call(this.subList,sub);
};
veSub = function(sub){
let index = this.indexOf(sub);
index > -1 ?
index === 0 ?
this.subList = _slice.call(this.subList,1) :
this.subList = _concat.call(_slice.call(this.subList,0,index),_slice.call(this.subList,index + 1)) :‘’;
};
ifySingle = function(sub,msg){
let index = this.indexOf(sub);
index > -1 ?
(Receive === ‘function’ ?
‘’) :
‘’;
};
ifyAll = function(msg){
if(typeof this.subList !== ‘undefined’ && this.subList !== null){
_forEach.call(this.subList,(sub)=>{
if(typeof sub !== ‘undefined’ && sub !== null){
Receive === ‘function’ ?
‘’;
}
})
}
};
function Subscription(name){
this.name = name;
}
Receive = function(msg){
console.log(this.name + ’ 收到消息 : ’ + msg);
};
let pub = new Publish();
let sub1 = new Subscription(‘sub1’);
let sub2 = new Subscription(‘sub2’);
let sub3 = new Subscription(‘sub3’);
let sub4 = new Subscription(‘sub4’);
pub.addSub(sub1);
pub.addSub(sub1);
pub.addSub(sub2);
pub.addSub(sub3);
pub.addSub(sub4);
// sub1 收到消息 : 这是⼀条全部推送的消息
// sub2 收到消息 : 这是⼀条全部推送的消息
// sub3 收到消息 : 这是⼀条全部推送的消息
// sub4 收到消息 : 这是⼀条全部推送的消息
// sub2 收到消息 : 这是⼀条单独推送的消息
// sub1 收到消息 : 这是⼀条全部推送的消息
// sub2 收到消息 : 这是⼀条全部推送的消息
/
/ sub4 收到消息 : 这是⼀条全部推送的消息
Receive === Receive;//true
改进版本与之前的版本相⽐有⼀个特点：拥有同⼀构造函数的对象，属性是唯⼀的，⾏为是⼀致的[5]。所有对象都拥有独⽴于其它对象的属性，却存在相同的⾏为。这正是因为在改进版本中，⽅法存在于构造函数的prototype属性值上，其将被其创建的对象所继承。也正是因为如此，尽管此时的sub1、sub2、sub3、sub4中都不包含onReceive⽅法，但也可以通过继承的原型对象Subscription.prototype去达到调⽤onReceive的⽬的。⽽且修改Subscription.prototype上的onReceive⽅法是可以马上作⽤到sub1、sub2、sub3、sub4上的。将⽅法定义到构造函数的prototype属性值上，就可以让拥有相同构造函数的不同对象都具备相同的⾏为以达到代码复⽤⽬的。
instanceof关键字判断对象类型的依据是什么?
我在深⼊了解JavaScript中基于原型（prototype）的继承机制中声明了函数Person，并以它为构造函数创建了person对象。
function Person(){
}
let person = new Person();
person对象的继承Person函数的prototype属性值，⽽Person函数的prototype属性值⼜继承Object函数的prototype属性值，这种⼀层⼀层继承的关系构成了原型链。
instanceof关键字判断对象类型的依据便是判断函数的prototype属性值是否存在于对象的原型链上。
正如Person函数的prototype属性值和Object函数的prototype属性值都存在于person对象的原型链上，所以使⽤instanceof判断两者都为true。
person instanceof Person;//true
person instanceof Object;//true
⽽Function函数的prototype属性值不存在于person对象的原型链上，所以使⽤instanceof判断Function函数为false。
person instanceof Function;//false
最后，完成⼀个instanceof。
/**
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论