Javascript面向对象扩展库代码分享

lang.js库提供了包和类的定义、类的继承与混合(mixin)、函数重载等功能,基本可满足大多数面向对象设计的需求。同时支持基于链式的定义方式,让库在使用时更加规范和便捷。下面首先通过简单的例子演示了lang.js的基本功能,之后给出了lang.js的源码及注释。
一.功能介绍
“lang”作为框架的全局定义,其中包括了四个方法:
lang.Package(string name) //用于定义包(默认会暴露到全局)
lang.Class(string name[, object config], object classBody) //用于定义类
lang.Object(string name | object body) //用于定义支持重载函数的普通对象
lang.Function(string name | object body) //用于定义重载函数


代码如下:

var lang = (function(){
/***********************************
Javascript面向对象扩展库(lang.js v1.0)
By: X!ao_f
QQ: 120000512
Mail: xiao_f.mail#163.com
************************************/
var customToString = function(){
return '[' + this.Type.type + ' ' + this.Type.name + ']';
}
//支持重载的方法定义
var createMethod = (function(){
//创建一个代理函数
var createMethodProxy = function(context, name){
//当调用重载的函数时,首先会执行该函数分析传入的参数,进行匹配和转发
var method = function(){
//在第一次调用时初始化,将映射信息缓存
if(!method.__initialized__){
initializeMethod(method);
}
//将参数类型拼接成函数签名
var signature;
if(arguments.length){
var list = [];
for(var i=0; i<arguments.length; i++){
var typename;
var argument = arguments[i];
if(argument === undefined || argument === null){
typename = 'object';
}else if(argument instanceof Array){
typename = 'array';
}else if(argument instanceof Date){
typename = 'date';
}else{
typename = typeof argument;
if(typename == 'object'){
if('Class' in argument){
typename = argument.Class.Type.name;
}else if('nodeType' in argument){
typename = 'element';
}
}
}
list.push(typename);
}
signature = list.join(',');
}else{
signature = '';
}
//如果常规缓存中存在匹配的签名,直接调用
if(method.__overloads__[signature]){
return method.__overloads__[signature].apply(this, arguments);
}else{
//缓存中不存在时,尝试利用正则进行模糊匹配
//首先判断模糊匹配缓存中是否存在记录,如存在直接调用
if(method.__overloadsCache__[signature]){
return method.__overloadsCache__[signature].apply(this, arguments);
}
//循环匹配
for(var i=0; i<method.__overloadsRegExp__.length; i++){
//如果匹配成功,将映射关系存入模糊匹配缓存,同时调用并返回
if(method.__overloadsRegExp__[i].regexp.test(signature)){
method.__overloadsCache__[signature] = method.__overloadsRegExp__[i].fn;
return method.__overloadsRegExp__[i].fn.apply(this, arguments);
}
}
//如果依然无法找到对应的函数,判断是否存在默认函数
if(method.__overloads__['default']){
return method.__overloads__['default'].apply(this, arguments);
}else if(method.__overloads__['']){
return method.__overloads__[''].apply(this, arguments);
}else{
alert('Error: '+method.Type.name+'('+signature+') is undefined.');
}
}
};
//内置对象
method.__context__ = context;
method.__functions__ = {};
method.toString = customToString;
//自描述信息
method.Type = {
name: name,
Method: method,
type: 'method'
};
return method;
}
//初始化
var initializeMethod = function(method){
//基础签名缓存
method.__overloads__ = {};
//模糊匹配正则缓存
method.__overloadsRegExp__ = [];
//模糊匹配结果缓存
method.__overloadsCache__ = {};
//例举所有定义的函数
for(var signature in method.__functions__){
var fn = method.__functions__[signature];
var params = signature.substring(signature.indexOf('(') + 1, signature.length - 1);
var pure = !/[\*\+\?\{]/.test(params);
//如果不存在通配符直接保存到基础签名缓存
if(pure){
method.__overloads__[params] = fn;
}else{
//生成模糊匹配正则
var regexp = '^' + params
.replace(/([\w\.]+)(\{.*?\})?/g, '($1(,|$))$2')
.replace(/\./g, '\\.')
.replace(/((\()var(\())/g, '$2\\w+$3')
.replace(/,\(/g, '(') + '$';
method.__overloadsRegExp__.push({ regexp: new RegExp(regexp), fn: fn });
}
}
method.__initialized__ = true;
}
//返回外部的定义函数
return function(signature, fn, comp){
//如果传入的为一个对象,视为定义匿名方法
if(typeof signature == 'object'){
var context = {};
var method;
for(var key in signature){
method = createMethod.call(context, 'anonymous'+key, signature[key]);
}
return method;
}
signature = signature.replace(/\s+/g, '');
var index = signature.indexOf('(');
var name = index > -1 ? signature.substring(0, signature.indexOf('(')) : signature;
var context = this;
var method = context[name];
//上下文中不存在函数定义,视为第一次定义
if(method === undefined){
context[name] = method = createMethodProxy(context, name);
}else if(!method.Type || method.Type.type!='method'){
//上下文存在的函数是原生函数,将这个函数作为默认函数存入列表
var temp = method;
context[name] = method = createMethodProxy(context, name);
method.__functions__[name + '()'] = temp;
}else{
//如果上下文不同,创建新的重载方法并将已经存在的函数复制,这里主要解决类继承中子类与父类冲突的问题
//如果上下文相同,直接将初始化标记设为false,待下次调用时重新初始化
if(method.__context__ !== context){
var temp = method;
context[name] = method = createMethodProxy(context);
for(var sign in temp.__functions__){
method.__functions__[sign] = temp.__functions__[sign];
}
}else{
method.__initialized__ = false;
}
}
//将本次定义的函数添加到函数列表
//先入为主策略
if(comp){
if(fn.__functions__){
for(var key in fn.__functions__){
if(key in method.__functions__){
method.__functions__[key].__overridden__ = fn;
}else{
method.__functions__[key] = fn;
}
}
}else{
if(signature in method.__functions__){
method.__functions__[signature].__overridden__ = fn;
}else{
method.__functions__[signature] = fn;
}
}
}else{
//后入为主策略
if(fn.__functions__){
for(var key in fn.__functions__){
if(key in method.__functions__){
fn.__functions__[key].__overridden__ = method;
}
method.__functions__[key] = fn.__functions__[key];
}
}else{
if(signature in method.__functions__){
fn.__overridden__ = method;
}
method.__functions__[signature] = fn;
}
}
if(this.Type && this.Type.type == 'package'){
return this;
}else{
return method;
}
};
})();
//类定义函数
var createClass = (function(){
var slice = Array.prototype.slice;
var emptyFn = function(){};
var createClass = function(name){
return function(){
this[name].apply(this, slice.call(arguments, 0));
};
}
//用于调用被重写函数
var baseCaller = function(){
if(arguments.length){
var args = slice.call(arguments, 0);
return baseCaller.caller.__overridden__.apply(this, args);
}else{
return baseCaller.caller.__overridden__.call(this);
}
}
//用于调用自身重载构造函数
var selfCaller = function(){
if(arguments.length){
var args = slice.call(arguments, 0);
return selfCaller.caller.__self__.apply(this, args);
}else{
return selfCaller.caller.__self__.call(this);
}
}
var filter = {prototype:true, Type:true};
//快速浅拷贝
function clone(a){
var fn = function(){};
fn.prototype = a;
return new fn;
}
//对象复制,替换存在的(后入为主)
function replace(base, self){
for(var key in self){
if(!(key in filter)){
if(typeof self[key] == 'function'){
//如果子类函数包含重载签名或父类函数已经重载
if(key.indexOf('(') > -1 || (base[key] && base[key].__functions__)){
createMethod.call(base, key, self[key]);
}else{
//常规函数定义
if(key in base){
//记录重写信息
self[key].__overridden__ = base[key];
}
base[key] = self[key];
}
}else{
base[key] = self[key];
}
}
}
}
//对象复制,只取补集(先入为主)
function complement(self, base){
for(var key in base){
if(!(key in filter)){
if(typeof base[key] == 'function'){
if(key.indexOf('(') > -1 || (self[key] && self[key].__functions__)){
createMethod.call(self, key, base[key], true);
}else{
if(key in self){
//记录重写信息
self[key].__overridden__ = base[key];
}else{
self[key] = base[key];
}
}
}else if(!(key in self)){
self[key] = base[key];
}
}
}
}
return function(){
//处理参数
if(this.Type && this.Type.type == 'package'){
if(arguments.length == 2){
var name = arguments[0];
var body = arguments[1];
}else{
var name = arguments[0];
var config = arguments[1];
var body = arguments[2];
}
}else{
if(arguments.length == 1){
var name = 'Anonymous';
var body = arguments[0];
}else{
var name = 'Anonymous';
var config = arguments[0];
var body = arguments[1];
}
}
//创建类的基础函数
var clazz = createClass(name);
//获取父类信息
var baseClass;
if(config && config.extend){
baseClass = config.extend;
}
//如果传入的主体为函数,取其返回值
if(typeof body == 'function'){
body = body(clazz);
}
//处理静态成员
if(body.Static){
complement(clazz, body.Static);
delete body.Static;
body = body.Public||body;
}else{
body = body.Public||body;
}
//处理继承
if(baseClass){
//通过快速浅拷贝复制父类成员
clazz.prototype = clone(baseClass.prototype);
//继承静态成员
complement(clazz, baseClass);
//继承类成员
complement(clazz.prototype, body);
}else{
//不存在继承
clazz.prototype = {};
complement(clazz.prototype, body);
}
//处理混合
if(config && config.mixin){
var mixin = config.mixin;
if(mixin instanceof Array){
for(var i=0; i<mixin.length; i++){
replace(clazz.prototype, mixin[i]);
}
}else{
replace(clazz.prototype, mixin);
}
}
//添加内置函数
clazz.prototype.base = baseCaller;
clazz.prototype.self = selfCaller;
clazz.prototype.constructor = clazz;
clazz.prototype.toString = customToString;
clazz.toString = customToString;
clazz.prototype.Class = clazz;
if(clazz.prototype[name]){
var constructor = clazz.prototype[name];
if(constructor.__functions__){
for(var key in constructor.__functions__){
//存在重载时,添加自身引用,用于通过this.self调用重载构造函数
constructor.__functions__[key].__self__ = constructor;
//存在继承时,将父类的构造函数作为被重写的函数,配置给当前类的构造函数
//用于通过base调用父类构造函数
if(baseClass){
constructor.__functions__[key].__overridden__ = baseClass.prototype[baseClass.Type.shortName];
}
}
}else if(baseClass){
clazz.prototype[name].__overridden__ = baseClass.prototype[baseClass.Type.shortName];
}
}else{
clazz.prototype[name] = emptyFn;
}
//类型自描述信息
//如果当前上下文是一个包,将类添加到包中
if(this.Type && this.Type.type == 'package'){
clazz.Type = {
type:'class',
name: this.Type.name+'.'+name,
shortName: name,
Package: this,
Class: clazz,
baseClass: baseClass
}
clazz.prototype.Type = {
type: 'object',
name: this.Type.name+'.'+name
}
//将类添加到包
this[name] = clazz;
//调用静态构造函数
if(name in clazz){
clazz[name].call(clazz);
}
//返回this用于链式调用
return this;
}else{
//上下文不是包则直接返回
clazz.Type = {
type:'class',
name: name,
shortName: name,
Class: clazz,
baseClass: baseClass
}
clazz.prototype.Type = {
type: 'object',
name: name,
baseClass: baseClass
}
if(name in clazz){
clazz[name].call(clazz);
}
return clazz;
}
};
})();
//用于创建支持重载的普通对象
var createObject = function(objects, config){
var target;
if(this.Type && this.Type.type == 'package'){
target = this;
}else{
target = {};
}
if(typeof objects == 'string'){
target = this[objects] = {};
objects = config;
}else if(typeof objects == 'function'){
objects = objects();
}
for(var key in objects){
if(typeof objects[key] == 'function' && (key.indexOf('(') > -1 || typeof target[key] == 'function')){
createMethod.call(target, key, objects[key]);
}else{
target[key] = objects[key];
}
}
if(this.Type && this.Type.type == 'package'){
return this;
}else{
return target;
}
};
//用于创建包
var createPackage = (function(){
var root = this;
return function(package){
var name = [];
var path = package.split('.');
var parent = root;
for(var i=0; i<path.length; i++){
name.push(path[i]);
if(parent[path[i]]){
parent = parent[path[i]];
}else{
var pack = {
Class: createClass,
Object: createObject,
Function: createMethod,
Package: createPackage,
toString: customToString
};
pack.Type = {
type: 'package',
Package: pack,
name: name.join('.')
}
parent = parent[path[i]] = pack;
}
}
return parent;
}
})();
//默认将Package暴露
window.Package = createPackage;
return {
Package: createPackage,
Class: createClass,
Function: createMethod,
Object: createObject
};
})();

结束语:
到这里,lang.js的应用和原理就介绍完毕了,该库在主流浏览器中均已测试通过,
如果想使用lang.js,可以在这里免费下载,如发现什么问题,或有好的建议可以反馈给我。

(0)

相关推荐

  • javascript Prototype 对象扩展

    Javascript当然也不例外,可是关于对象的引用问题,你考虑过么?通常的做法是一系列对象共享类的方法,而不是为每个对象复制一份函数.下面看看为每个对象复制一份函数的做法. 复制代码 代码如下: var myobject=function(param1,param2) { this.name=param1; this.age=param2; this.showmsg=function() { alert("name:"+this.name+"\n"+"a

  • JavaScript 三种创建对象的方法

    JavaScript中对象的创建有以下几种方式: (1)使用内置对象 (2)使用JSON符号 (3)自定义对象构造 一.使用内置对象 JavaScript可用的内置对象可分为两种: 1,JavaScript语言原生对象(语言级对象),如String.Object.Function等: 2,JavaScript运行期的宿主对象(环境宿主级对象),如window.document.body等. 我们所说的使用内置对象,是指通过JavaScript语言原生对象的构造方法,实例化出一个新的对象.如: 复

  • 原生js实现复制对象、扩展对象 类似jquery中的extend()方法

    jq的extend()方法能很方便的实现扩展对象方法,语法如下:$.extend(obj1,boj2,obj3); 现在要实现的是:原生js实现复制对象,扩展对象,类似jq中的extend()方法,具体实例如下: 现有3个对象字面量: var o1={hello:1,old:555}, o2 = { abc: 55555555, hello: 2, fun: function() { alert(111); } }, o3={third:9999}; 实现目标: 复制o1对象,把 o2,o3的对

  • js中判断对象是否为空的三种实现方法

    在写js脚本的时候经常遇到对象为空或者不是对象的情况,出现这种情况我们可以用if去判断它,然后去执行相应的处理方法,具体判断他们的方法有以下几种: 1.if   (typeOf(x)   ==   "undefined") 2.if   (typeOf(x)   !=   "object") 3.if(!x) 其中第三种是最简单的方法,但是第三种就不能用if(x)这种互斥的方法去判断,只能在对象前面加! java里面!x为true的时候x肯定为false了,但是这里

  • JavaScript中json对象和string对象之间相互转化

    json对象 复制代码 代码如下: var json = {aa:true,bb:true}; var json1 = {aa:'b',bb:{cc:true,dd:true}}; 1:js操作json对象 复制代码 代码如下: for(var item in json){ alert(item); //结果是 aa,bb, 类型是 string alert(typeof(item)); alert(eval("json."+item)); //结果是true,true类型是boole

  • 模仿JQuery.extend函数扩展自己对象的js代码

    但在写的过程中发现,如果要在之前写好的对象中添加新的静态方法或实例方法,要修改原有的对象结构,于是查看了jquery了extend方法,果然extend方法支持了jq的半边天,拿来主义,给自己的对象做扩张用. 下面进入正题: 假如有以下一个对象 复制代码 代码如下: var MyMath = { //加法 Add: function(a, b){ return a + b; }, //减法 Sub: function(a, b){ return a - b; } } 对象名MyMath,有两个静

  • JS 创建对象(常见的几种方法)

    贴个代码先: function O(user,pwd){ //use constructor this.user=user; this.pwd=pwd; this.get=get; return this; } function O2(user,pwd){ //use factory var obj=new Object(); obj.user=user; obj.pwd=pwd; obj.get=get; return obj; } function O3(){ //use prototype

  • js String对象中常用方法小结(字符串操作)

    1.charCodeAt方法返回一个整数,代表指定位置字符的Unicode编码. strObj.charCodeAt(index) 说明: index将被处理字符的从零开始计数的编号.有效值为0到字符串长度减1的数字. 如果指定位置没有字符,将返回NaN. 例如: var str = "ABC"; str.charCodeAt(0); 结果:65 2.fromCharCode方法从一些Unicode字符串中返回一个字符串. String.fromCharCode([code1[,cod

  • js将类数组对象转换成数组对象

    在标准浏览器中,好像只要对象存在length属性,就能把它转换为数组,但IE就不尽然. //※※※※※※※※※※※测试1※※※※※※※※※※※※※※ function test(){ alert(arguments) arguments = Array.prototype.slice.call(arguments); alert(arguments instanceof Array); alert(arguments) } test(1,2,3,4); //※※※※※※※※※※※测试2※※※※※

  • javascript防篡改对象实例详解

    本文实例讲述了javascript防篡改对象.分享给大家供大家参考,具体如下: JavaScript中对象内置有多个属性Configurable,Writable,Enumerable,Value,Get和Set,来控制属性的行为.同样的ES5也有几个方法,来指定对象的行为.我们知道,javascript中的对象是可以共享的,也是默认可拓展的: //一旦将对象设置防篡改,就不能撤销了 //众所周知,一般的对象是可以随意拓展的 var person = {name:'liufang'}; pers

  • js中获取事件对象的方法小结

    复制代码 代码如下: var evt = window.event || arguments[0]; 下面分三种添加事件的方式讨论,你也许会看到以前没有看到过的获取方式. 1,第一种添加事件的方式,直接在html的属性中写JS代码 复制代码 代码如下: <div onclick="alert(4);">Div1 Element</div> 大概这是上世纪90年代的写法,那时候直接把js代码写在网页中很普遍,也许那时候的js并不太重要,只是用来做做验证或一些花哨的

  • 基于jQuery的一个扩展form序列化到json对象

    复制代码 代码如下: $.fn.serializeObject = function() { var o = {}; var a = this.serializeArray(); $.each(a, function() { if (o[this.name]) { if (!o[this.name].push) { o[this.name] = [ o[this.name] ]; } o[this.name].push(this.value || ''); } else { o[this.nam

  • 用原生JS获取CLASS对象(很简单实用)

    听说是最常用....我是看了dom编程艺术想到的. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta

随机推荐