Javascript 学习总结 3
arguments [function.]arguments[n] 正在执行的函数和调用它的函数参数。function正在执行的Function名字。 n,要传递给Function的从0开始的参数值索引。
caller functionName.caller 返回一个函数的引用，该函数调用了当前函数。caller只在函数执行时才有定义,函数是顶层调用的，caller的值为null。
callee 返回正被执行的Function对象，[functionname.]arguments.callee 属性的初始值就是正被执行的function对象，是arguments对象的一个成员。arguments.length是实参长度，arguments.callee.length是形参长度。
apply 和 call
apply(thisArg,argArray)
call(thisArg[,arg1,arg2...])
他们的作用都是将函数绑定到另外一个对象上去运行。即所有函数内部的this会被赋值为thisArg，如果没有提供thisArg,Global对象将被用作thisArg,且无法传递参数。
用call和Apply应用另一个函数后，当前函数（类）就具备了另一个函数（类）的方法或属性。
通过apply创建一个定义类的模式。
var Class = {
create:function() {
return function() {
this.initialize.apply(this,arguments);
}
}
}
该对象仅包含一个方法：create，其返回一个函数，即类，这也同时是类的构造函数，其中调用initialize,这个方法是类创建时的初始化函数，这样规定，让类的初始化函数名一定是initialize,而this.initialize.apply(this,arguments)则保证initialize一定会在类实例创建后调用。
用函数作为构造函数操作this对象创建的每一个对象不但具有各自的成员数据，还具有各自的方法数据。
如：function person(name)
{
this.name=name;
this.Say=function(){alert("hi!,this.name);}
}
var BillGates = new person("Bill Gates");
var SteveJobs=new person("steve jobs");
Billgates 和SteveJobs两个对象没别有自己的数据和方法，他们的方法Say是两个名字内容一样的方法，不是共享一个方法。
function类型的对象都有一个prototype的属性，在构造函数（对象）的prototype上定义属性和方法可以被这个构造函数生成的对象共享。并可以通过将prototype设为基类对象的构造函数实现继承。
function Employee(name,salary)
{
person.call(this,name);
this.salary = salary;
}
Employee.prototype= new person() //通过Employee构造函数建立的对象会继承person的prototype的属性和方法。
通过原形模型构建类和对象，首先需要一个构造函数来定义对象的成员，其次通过构造函数的prototype定义方法及属于类的静态属性。
var anObject = new aFunction() 创建对象分为以下几步：
1、建立一个新对象
2、将该对象内置的原型对象设置为构造函数prototype引用的那个原型对象
3、将该对象作为this参数调用构造函数，完成成员设置等初始化工作。
通过建立一个通用函数，将通过原形来建立对象的躯壳函数变为通用函数的内部函数，将原形对象作为通用函数的参数，让通用函数返回创建的对象。
function New(aClass, aParams) //通用创建函数
{
function new_() //定义临时的中转函数壳
{
aClass.Create.apply(this, aParams); //调用原型中定义的的构造函数，中转构造逻辑及构造参数
};
new_.prototype = aClass; //准备中转原型对象
return new new_(); //返回建立最终建立的对象
};
var Person = //定义的类
{
Create: function(name, age)
{
this.name = name;
this.age = age;
},
SayHello: function()
{
alert("Hello, I'm " + this.name);
},
HowOld: function()
{
alert(this.name + " is " + this.age + " years old.");
}
};
var BillGates = New(Person, ["Bill Gates", 53]); //调用通用函数创建对象，并以数组形式传递构造参数
BillGates.SayHello();
BillGates.HowOld();
支持继承及对向类型的定义方式。
var object = //定义小写的object基本类，用于实现最基础的方法等
{
isA: function(aType) //一个判断类与类之间以及对象与类之间关系的基础方法
{
var self = this;
while(self)
{
if (self == aType)
return true;
self = self.Type;
};
return false;
}
};
function Class(aBaseClass, aClassDefine) //创建类的函数，用于声明类及继承关系
{
function class_() //创建类的临时函数壳
{
this.Type = aBaseClass; //我们给每一个类约定一个Type属性，引用其继承的类
for(var member in aClassDefine)
this[member] = aClassDefine[member]; //复制类的全部定义到当前创建的类
};
class_.prototype = aBaseClass;
return new class_();
};
function New(aClass, aParams) //创建对象的函数，用于任意类的对象创建
{
function new_() //创建对象的临时函数壳
{
this.Type = aClass; //我们也给每一个对象约定一个Type属性，据此可以访问到对象所属的类
if (aClass.Create)
aClass.Create.apply(this, aParams); //我们约定所有类的构造函数都叫Create，这和DELPHI比较相似
};
new_.prototype = aClass;
return new new_();
};
//语法甘露的应用效果：
var Person = Class(object, //派生至object基本类
{
Create: function(name, age)
{
this.name = name;
this.age = age;
},
SayHello: function()
{
alert("Hello, I'm " + this.name + ", " + this.age + " years old.");
}
});
var Employee = Class(Person, //派生至Person类，是不是和一般对象语言很相似？
{
Create: function(name, age, salary)
{
Person.Create.call(this, name, age); //调用基类的构造函数
this.salary = salary;
},
ShowMeTheMoney: function()
{
alert(this.name + " $" + this.salary);
}
});
var BillGates = New(Person, ["Bill Gates", 53]);
var SteveJobs = New(Employee, ["Steve Jobs", 53, 1234]);
BillGates.SayHello();
SteveJobs.SayHello();
SteveJobs.ShowMeTheMoney();
var LittleBill = New(BillGates.Type, ["Little Bill", 6]); //根据BillGate的类型创建LittleBill
LittleBill.SayHello();
