原型扩展 String.prototype.trim = function String$trim() {
if (arguments.length !== 0 ) throw Error.parameterCount(); return this .replace( / ^\s+|\s+$ / g, '' ); }
function Person(firstName, lastName, age)
{ // 私有变量: var _firstName = firstName; var _lastName = lastName; // 公共变量: this .age = age; // 方法: this .getName = function () { return (firstName + " " + lastName); }; this .SayHello = function () { alert( " Hello, I'm " + firstName + " " + lastName); }; }; var BillGates = new Person( " Bill " , " Gates " , 53 ); var SteveJobs = new Person( " Steve " , " Jobs " , 53 ); BillGates.SayHello(); SteveJobs.SayHello(); alert(BillGates.getName() + " " + BillGates.age); alert(BillGates.firstName); // 这里不能访问到私有变量
// 定义构造函数
function Person(name) { this .name = name; // 在构造函数中定义成员 }; // 方法定义到构造函数的prototype上 Person.prototype.SayHello = function () { alert( " Hello, I'm " + this .name); }; // 子类构造函数 function Employee(name, salary) { Person.call( this , name); // 调用上层构造函数 this .salary = salary; // 扩展的成员 }; // 子类构造函数首先需要用上层构造函数来建立prototype对象,实现继承的概念 Employee.prototype = new Person() // 只需要其prototype的方法,此对象的成员没有任何意义! // 子类方法也定义到构造函数之上 Employee.prototype.ShowMeTheMoney = function () { alert( this .name + " $ " + this .salary); }; var BillGates = new Person( " Bill Gates " ); BillGates.SayHello(); var SteveJobs = new Employee( " Steve Jobs " , 1234 ); SteveJobs.SayHello(); SteveJobs.ShowMeTheMoney(); 原型类模型虽然不能模拟真正的私有变量,而且也要分两部分来定义类,显得不怎么“优雅”。不过,对象间的方法是共享的,不会遇到垃圾回收问题,而且性能优于“闭包”模型。正所谓“有失必有得”嘛。 在原型模型中,为了实现类继承,必须首先将子类构造函数的prototype设置为一个父类的对象实例。创建这个父类对象实例的目的就是为了构成原型链,以起到共享上层原型方法作用。但创建这个实例对象时,上层构造函数也会给它设置对象成员,这些对象成员对于继承来说是没有意义的。虽然,我们也没有给构造函数传递参数,但确实创建了若干没有用的成员,尽管其值是undefined,这也是一种浪费啊。 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. " ); } }; 这个JSON形式的写法多么象一个C#的类啊!既有构造函数,又有各种方法。如果可以用某种形式来创建对象,并将对象的内置的原型设置为上面这个“类”对象,不就相当于创建该类的对象了吗? function anyfunc(){}; // 定义一个函数躯壳
anyfunc.prototype = Person; // 将原型对象放到中转站prototype var BillGates = new anyfunc(); // 新建对象的内置原型将是我们期望的原型对象 不过,这个anyfunc函数只是一个躯壳,在使用过这个躯壳之后它就成了多余的东西了,而且这和直接使用构造函数来创建对象也没啥不同,有点不爽。 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(); alert(BillGates.constructor == Object); // 输出:true 这里的通用函数New()就是一个“语法甘露”!这个语法甘露不但中转了原型对象,还中转了构造函数逻辑及构造参数。 // 语法甘露:
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(); 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 “语法甘露”不用太多,只要那么一点点,就能改观整个代码的易读性和流畅性,从而让代码显得更优雅。有了这些语法甘露,JavaScript就很像一般对象语言了,写起代码了感觉也就爽多了!
原著:李战(leadzen) http://www.cnblogs.com/leadzen/archive/2008/02/25/1073404.html |
|