首页 / JAVASCRIPT / Javascript面向对象扩展库代码分享

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

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Javascript面向对象扩展库代码分享，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含11716字，纯文字阅读大概需要17分钟。

内容图文

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，可以在这里免费下载，如发现什么问题，或有好的建议可以反馈给我。

内容总结

以上是互联网集市为您收集整理的Javascript面向对象扩展库代码分享全部内容，希望文章能够帮你解决Javascript面向对象扩展库代码分享所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/368321.html

来源：【匿名】

【上一篇】js 页面左右两侧居中广告代码【下一篇】javascript 怎么调用php方法

更多 ►

【Javascript面向对象扩展库代码分享】教程文章相关的互联网学习教程文章

《JavaScript》——面向对象与原型【图】

谈到面向对象，我们之前学过Vb和C#，从抽象到封装再到继承和多态，面向对象的世界真的很好玩，但是JavaScript中的面向对象有些特殊，因为里面没有类，而且对象的创建方式也不同。对象的创建大约有四种方式：使用new关键字创建、使用字面量创建、使用工厂方法创建、使用构造函数创建。 1、使用new关键字var box = new Object(); //创建一个 Object 对象 box.name = 'Lee'; //创建一个 name 属性并赋值 box.age = 100; //...

JavaScript面向对象编程（8）使用中间函数

上一讲我们提出一个很好的思路，将一个类的可复用部分全部定义在prototype中，这样子类继承的时候可以很方便地通过prototype来继承；但是也带来一个问题就是子类在重写prototype中的属性时会改变所有实例的属性，这是因为父类和子类实例都共享同一个prototype；怎么解决呢？思路就是利用一个中间函数，具体请看代码：<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-tra...

用javascript 面向对象制作坦克大战（二）【代码】【图】

2. 完善地图我们的地图中有空地，墙，钢，草丛，水，总部等障碍物。我们可以把这些全部设计为对象。2.1 创建障碍物对象群对象群保存各种地图上的对象，我们通过对象的属性来判断对象是否可以被穿过或被攻击。 Barrier.js: 1// 障碍物基类对象，继承自TankObject 2 Barrier = function () {3this.DefenVal = 1; // 防御力 4this.CanBeAttacked = true; // 是否可以被攻击 5}6 Barrier.prototype = new TankObject(...

JavaScript 中的面向对象编程【代码】

使用JSON 来定义一个对象: <script type="text/javascript">var xiaoming = { name : ‘xiaoming‘, age : 18, say : function(){ console.log(‘my name is ‘+this.name); }}xiaoming.say();xiaoming.name = ‘li xiao ming‘;xiaoming.say();</script> 原文：http://www.cnblogs.com/likewpp/p/6935684.html

javascript面向对象和原型【代码】

/* //工厂模式 function createObject(name,age){var obj = new Object();//新建一个对象obj.name=name;//新建对象的属性obj.age=age;obj.run=function(){//新建对象的方法return this.name+","+this.age+"...running.";}return obj;//返回新建的对象引用 }var box1 = createObject("Carl",20); var box2 = createObject("Zhang",25); alert(box1.run()); alert(box2.run());//构造函数 function Box(name,age){this.name=name;//新...

JavaScript学习日志（二）：面向对象的程序设计

1，ECMAScript不像其他面向对象的语言那样有类的概念，它的对象与其他不同。2，ECMAScript有两种属性：数据属性和访问器属性。（[[]]这种双中括号表示属性为内部属性，外部不可直接访问） 1.数据属性：[[ Configurable ]]：表示能否通过delete删除属性，能否修改属性的特性，能否将属性修改为访问器属性，默认为true。 [[ Enumerable ]]：表示能否通过for-in循环返回属性，默认为true。 [[ Writable ]]：表示能...

JavaScript【面向对象】-静态方法-私有方法-公有方法-特权方法【图】

JavaScript面向对象是近年来比较火的一个概念了，由于小弟才疏学浅，虽然做过不少的web项目，看了网上很多深奥的资料和教程，还是对他们深奥的理论一知半解，前段时间看了点书，总算有了自己的理解，今天也出来装一回，如果觉得很深奥，请直接鄙视我，如果觉得不对，请直接拍砖。先通俗了解下面一些东西。在JS代码中写入function fn(){}或者var fn=function(){}等等，你都可以将其理解为对象，当然还有数组等等。在理解面向对象...

Javascript基础示例：用JS写简易版贪吃蛇（面向对象）【代码】【图】

废话不多说，代码如下： 1 <!DOCTYPE html>2 <html>3 <head>4 <meta charset="UTF-8">5 <title>贪吃蛇</title>6 <script>7var map; //地图类对象 8var snake; //蛇类对象 9var food; //食物类对象 10var timer; //定时器对象 11var sum=0; //分数 12 13//地图类 14function Map()15 {16this.width=800; //地图宽度 17this.height=400; //地图高度 18this.position=‘absolute‘; //定位方式 19this.color=‘#cccccc‘; //地图...

JavaScript对象及初识面向对象【图】

JavaScript对象及初识面向对象：原文：http://www.cnblogs.com/s1297-lgy/p/7060692.html

js 面向对象

哈哈，面向对象的创建居然学了这么久，不废话。首先是创建面向的对象的方式。最常用的构造函数和原型模式混合。对于方法使用原型模式，对于属性使用构造函数的方式。。为什么要组合这两种方式呢，是因为通过原型模式创建引用类型的值的时候。创建实例时这个引用类型的值更改，会影响到其他实例。继承，es5使用原型链来继承。继承是通过创建一个对象的实例，并赋给另一个对象的prototype实现的。结果是原来存在于实例中的所有方法和...

js面向对象实现切换面板【代码】

js面向对象的特点：继承(inheritance)：对象方法和属性的继承多态(polymorphism)：组件开发抽象(abstract)：抓住核心问题封装(encapsulation)：把功能写出方法面向过程式切换面板实现：<!DOCTYPE HTML><html><head><meta charset="utf-8"><title>切换面板</title><style>#div1 input {background: white;}#div1 input.active {background: yellow;}#div1 div {width: 200px;height: 200px;background: #CCC;display: none;}</style...

面向对象的JS（一）【代码】

/*JavaScript和其他的语言类似，也是面向对象，自然也就是存在类和对象（对象是类的实例化）*///1、JS对象var empty = {}; //没有任何属性的对象var point = { x: 0, y: 0 }; //两个属性和值var point2 = { x: point.x, y: point.y } //复杂的属性和值var book = {"main title": "javascript", //属性名字中有空格，必须用字符串表示"sub-title": "The Definitive Guide", //属性名字里有连字符，必须用字...

什么是js面向对象？？

简单的来说就是键值对，写一个函数，然后传值进去， function Person(name,age){ this.name = name; this.age = age; } var p1 = new Person(‘Jack‘,20); console.log(p1.__proto__);原文：http://www.cnblogs.com/ZH1132672711/p/4098339.html

深入理解Javascript面向对象编程【代码】【图】

阅读目录一：理解构造函数原型(prototype)机制二：理解原型域链的概念三：理解原型继承机制四：理解使用类继承(继承的更好的方案)五：建议使用封装类实现继承六：理解使用复制继承回到顶部一：理解构造函数原型(prototype)机制 prototype是javascript实现与管理继承的一种机制，也是面向对象的设计思想.构造函数的原型存储着引用对象的一个指针，该指针指向与一个原型对象，对象内部存储着函数的原始属性和方法；我们可以借助pr...

面向对象的JavaScript-006-Function.prototype.bind() 的4种作用【代码】【图】

1. 1// Function.prototype.bind() 的作用 2 3// 1.Creating a bound function 4this.x = 9; 5var module = {6 x: 81,7 getX: function() { returnthis.x; }8 };9 10 console.log(module.getX()); // 81 11 12var retrieveX = module.getX;13 console.log(retrieveX()); 14// 9, because in this case, "this" refers 15// to the global object 16 17// Create a new function with ‘this‘ bound to ...

首页 / JAVASCRIPT / Javascript面向对象扩展库代码分享

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

内容导读

内容图文

内容总结

内容备注

内容手机端

【Javascript面向对象扩展库代码分享】教程文章相关的互联网学习教程文章

JAVASCRIPT - 相关标签

面向对象 - 相关标签

JAVASCRIPT - 技术教程分类

JAVASCRIPT - 最新教程

JAVASCRIPT - 最热教程