《悟透javascript》笔记

//定义式

functionmyfunc(){};

//直接量

varmyfunc=function(){};

//考虑如下代码：

functionmyfunc(){alert(1)};

myfunc();//2

functionmyfunc(){alert(2)};

myfunc();//2

//javascript预编译会将定义式代码提前执行,所以在执行myfunc()之前，myfunc函数的内容已经被覆盖了。

//再考虑如下代码：

fn=function(){alert(1)};

fn();//1

fn=function(){alert(2)};

fn();//2

//函数从定义式变成了直接量式，于是，结果大不一样。

//第三段代码：

<script>

functionmyfunc(){alert(1)};

myfunc();//1

</script>

<script>

functionmyfunc(){alert(2)};

myfunc();//2

</script>

//这次使用的是定义式函数，但由于使用script标记将代码分成了两段，于是结果变成了1,2。原因是

javascript语言的分段预编译机制。

functionSing(){

varsinger=arguments.callee;//调用arguments对象的环境函数。

alert(singer.author+"\n"+singer.poem);//调用该函数的相关属性

}

Sing.author="李白";

Sing.poem="汉家秦地月，流影照明妃。一上玉关道，天涯去不归";

Sing();

functionSing(){

varsinger=arguments.callee;

//数组形式访问对象属性。

alert(singer["author"]+"\n"+singer["poem"]);

}

Sing.author="李白";

Sing.poem="汉家秦地月，流影照明妃。一上玉关道，天涯去不归";

Sing();

functionWhoAmI(){

alert(this.name)

}

//1：this指代匿名对象{name:"MrZhou",whoAmI:WhoAmI}

//({name:"MrZhou",whoAmI:WhoAmI}).whoAmI();//MrZhou

//2：this指代对象zhou

varzhou={name:"MrZhou",whoAmI:WhoAmI};

//zhou.whoAmI();//MrZhou

//3：通过函数从Function继承的call方法指定调用对象(zhou)。

WhoAmI.call(zhou);//MrZhou

//4：调用其他对象的函数

varsunny={name:"MrSunny"};

//zhou.whoAmI.call(sunny)//MrSunny

//5：通过函数自身就是对象的性质，使用函数自身呼出函数对象的属性。

WhoAmI.name="whoAmI";

WhoAmI.WhoAmI=WhoAmI;

WhoAmI.WhoAmI();//whoAmI

//这里的this是活动的，在代码执行过程中可以灵活的控制this的指向，this始终为当前调用对象，不过不能为this显式赋值。在这

里，对象就是函数，函数就是对象。

//方式1：对象冒充:只能继承函数内this关键字指定的属性和方法。

functionperson(name){

this.name=name;

this.say=function(){}

}

functionemployee(name,salary){

person.call(this,name);//调用基类构造函数

this.salary=salary;

this.showSalary=function(){}

}

//方式2：原型继承：通过复制对象实例为子类得prototype原型对象，从而得到父类构造函数内的this上的和prototype上的相关属性方法

functionperson(name){

this.name=name;//将基类属性设置在构造函数中

}

functionemployee(name,salary){

person.call(this,name);//调用基类构造函数，初始化相关属性

this.salary=salary;

}

person.prototype.say=function(){alert("hello")}//为基类的原型对象添加方法，该方法会通过原型链机制共享到employee对象上

employee.prototype=newperson();//使用原型链机制实现继承。

employee.prototype.showSalary=function(){alert(this.salary)}//为子类原型对象添加方法

varxiaoMing=newemployee("xiaoMing",10000);

xiaoMing.say();//hello

xiaoMing.showSalary()//10000

employee.prototype.say=function(){alert("hello,everyone")}//为子类employee添加say方法，掩盖父类person的say方法，借此实现

override方法重载

varxiaoGang=newemployee("xiaoGang",10000);

xiaoMing.say();//hello,everyone

xiaoGang.say();//hello,everyone

xiaoGang.say=function(){alert("hello,everyone.i`m"+this.name)}//为子类employee的对象实例添加say方法，掩盖子类和父类的

say方法

xiaoMing.say();//hello,everyone

xiaoGang.say();//hello,everyone.i`mXiaoGang这里说明各个实例的方法各自独立互不影响。

person.prototype.sleep=function(){alert("zzzz~")}//通过动态修改函数原型，从而达到动态扩展基类属性和方法的目的。注意此时

是在子类对象已经实例化了之后动态添加的。

xiaoGang.sleep();//zzzz~此时照样可以调用xiaoGang实例的sleep()方法。

//方式3：

/*我们知道varanObj=newaFunction();的方式创建对象实际上包括了以下三步：

1.建立一个新对象。

2.将该对象的内置原型对象设置为构造函数prototype引用的那个原型对象

3.将该对象作为this参数调用构造函数，完成对象成员属性的初始化工作。

在这里，new关键字用来分配内存，创建对象副本。而aFunction函数则用来关联函数的原型对象和初始化对象的内置属性、方法。我们

自己也可以模拟实现这种创建对象的方式

*/

varPerson={

create:function(name,age){

this.name=name;

this.age=age;

},

getName:function(){

returnthis.name;

},

getAge:function(){

returnthis.age;

}

}

/*《悟透javascript》作者说：“那么，我们能否自己定义一个对象来当作原型，并在这个原型上描述类，然后将这个原型设置给新创建

的对象，将其当作对象的类呢？我们又能否将这个原型中的一个方法当作构造函数，去初始化新建的对象呢？”当时我看了半天，不得其解，后来

又看了几遍，想起java中强面向对象的语法和实现方式，茅塞顿开。

我理解的是，如果我们能将Person对象当做Java或者C#里面的类，那么上面JSON的语法格式就跟java和C#的类非常相似了，但java的类写

好了之后，通过类创建的对象实例，必然具有其类内部实现的方法和属性。但是在这里，却无法通过对象实例访问类内部的属性和方法。或者必须

通过一些特殊渠道，如下例：*/

varnewFish=newPerson.create("zhou",123);

newFish.getName()//TypeError:Object[objectObject]hasnomethod'getName'

/*这时候我们可以使用一个函数还作为中转站，想将该函数的prototype指向JSON对象，再在这个函数中调用JSON对象的构造函数，之后将

生成的新对象返回，如下例*/

functionNEW(Class,aParams){

functiontransfer(){

Class.create.apply(this,aParams);

}

transfer.prototype=Class;

returnnewtransfer();

}

varxiaoA=NEW(Person,["a",12])

xiaoA.getAge();//12

xiaoA.getName()//"a"

xiaoA.constructor;//functionObject(){[nativecode]}

/*这里首先通过transfer函数中转JSON对象的create构造函数内部逻辑，之后又将transfer的原型指向Class，中转JSON对象，最后通过

new将修正后的对象返回。而此时由于已经将transfer函数的原型设置为新的原型，那么transfer对象的函数与原型之间的引用链被解开，于是

transfer函数和他之前的原型对象同时被正确回收。

而此时xiaoA的构造函数就已经不再是transfer了（因为已经被回收了，为什么会被回收呢？因为在这里xiaoA实际上并没有constructor

属性的，它自己会通过原型链(__proto__)去找constructor属性，而__proto__实际上就是transfer的prototype，当我将prototype销毁了之后，

这个原型指向__proto__当然也就不存在了，于是自动向上回朔，直到顶层的Object），而是Object。

这样的话，不论从语法角度还是继承机制，都和java、c#比较相似了*/

varobject=//定义小写的object基本类，用于实现最基础的方法等

{

isA:function(aType)//一个判断类与类之间以及对象与类之间关系的基础方法,在模式上类似于Object的toString,这样所有

继承了object基类的对象都将有isA方法。

{

varself=this;

while(self)

{

if(self==aType)

returntrue;

self=self.Type;//这个Type需要往下看才能明白

};

returnfalse;

}

};

functionClass(aBaseClass,aClassDefine)//创建类的函数，用于声明类及继承关系，ps：这里如果只是继承的话，一个

aBaseClass就够了，那么aClassDefine是干啥的？匿名对象，创建对象用的。

{

functionclass_()//创建类的临时函数壳，ps：用这个函数还中转原型链

{

this.Type=aBaseClass;//我们给每一个类约定一个Type属性，ps：引用其继承的类，实现显式访问原型链对象

for(varmemberinaClassDefine)

this[member]=aClassDefine[member];//复制类的全部定义到当前创建的类，ps：所有属性和对象，如果有私有的捏？

};

class_.prototype=aBaseClass;

returnnewclass_();

};

functionNew(aClass,aParams)//创建对象的函数，用于任意类的对象创建，ps：使用aClass类创建对象实例

{

functionnew_()//创建对象的临时函数壳ps：中转类构造函数逻辑和原型链

{

this.Type=aClass;//我们也给每一个对象约定一个Type属性，据此可以访问到对象所属的类ps：留个指针，以后

好找自己的类，跟反射有点儿像

if(aClass.Create)

aClass.Create.apply(this,aParams);//我们约定所有类的构造函数都叫Create，这和DELPHI比较相似ps：调用基类

构造函数，这里有疑问：如果基类有父类呢？

};

new_.prototype=aClass;//ps：中转原型链

returnnewnew_();//ps：构造实例对象，并将实例对象返回

};

//语法甘露的应用效果：

varPerson=Class(object,//派生至object基本类，ps：第二个实参是匿名对象

{

Create:function(name,age)

{

this.name=name;

this.age=age;

},

SayHello:function()

{

alert("Hello,I'm"+this.name+","+this.age+"yearsold.");

}

});

varEmployee=Class(Person,//派生至Person类，是不是和一般对象语言很相似？

{

Create:function(name,age,salary)

{

Person.Create.call(this,name,age);//调用基类的构造函数

this.salary=salary;

},

ShowMeTheMoney:function()

{

alert(this.name+"$"+this.salary);

}

});

varBillGates=New(Person,["BillGates",53]);

varSteveJobs=New(Employee,["SteveJobs",53,1234]);

BillGates.SayHello();

SteveJobs.SayHello();

SteveJobs.ShowMeTheMoney();

varLittleBill=New(BillGates.Type,["LittleBill",6]);//根据BillGate的类型创建LittleBill

LittleBill.SayHello();

alert(BillGates.isA(Person));//true

alert(BillGates.isA(Employee));//false

alert(SteveJobs.isA(Person));//true

alert(Person.isA(Employee));//false

alert(Employee.isA(Person));//true

Person={

name:"MrZhou",

getName:function(){

returnthis.name;}

}

varsomeOne={};

someOne.prototype=Person;

someOne.name;//undefined;

//但如果这样：

varsomeOne=(function(){

functiontransfer(){};

transfer.prototype=Person;

returnnewtransfer();

}())

someOne.name;//MrZhou

varsomeOne.__proto__=Person;

someOne.name;//MrZhou