silverna-packs.js

《JavaScript王者归来》examples.rar

/*******************************************************
 *                                                     *
 *******************************************************/
//一些异常
function ImplementationException(msg){
	msg = msg || "接口未正确实现！";
	var _e = new Error(msg);
	_e.number = "0x101001";
	return _e;
}
function EnvironmentException(msg){
	msg = msg || "运行环境错误！";
	var _e = new Error(msg);
	_e.number = "0x101002";
	return _e;
}
function TypeNotFoundException(msg){
	msg = msg || "指定类型不存在或无法实例化！";
	var _e = new Error(msg);
	_e.number = "0x101004";
	return _e;
}
//空函数
var $void = function(){
}
//$pack函数当参数个数为1的时侯返回该参数，否则返回一个参数表
var $pack = function(){
	if(arguments.length == 1)
		return arguments[0];
	else
		return Array.apply(null, arguments);
}
//抽象函数，定义接口时使用，如果被调用，则抛出异常
//Silverna中所有未实现的接口也调用此函数
var $abstract = function(){
	throw new ImplementationException();
}
var Silverna = {
	version : "2.0.0.1.20070726",
	author : "akira",
	implementation : $abstract
}
//获得浏览器屏幕窗口的大小
window.clientRect = function() 
{     
	var w = (window.innerWidth) ? window.innerWidth : 
		(document.documentElement && document.documentElement.clientWidth) 
			? document.documentElement.clientWidth : document.body.offsetWidth;     
	var h = (window.innerHeight) ? window.innerHeight : 
		(document.documentElement && document.documentElement.clientHeight) 
			? document.documentElement.clientHeight : document.body.offsetHeight;     
	return {width:w,height:h}; 
} 
//获得页面文档的大小
window.pageRect = function() 
{     
	var w = (window.innerWidth) ? window.innerWidth : document.body.offsetWidth;     
	var h = (window.innerHeight) ? window.innerHeight : document.body.offsetHeight;     
	return {width:w,height:h}; 
}
//判断是否是IE浏览器
function $isIE()
{
	return /msie/i.test(navigator.userAgent);
}
//判断是否是Firefox浏览器
function $isFF()
{
    return /firefox/i.test(navigator.userAgent);
}
//判断是否是IE7.0浏览器
function $isIE7()
{
	return /msie 7/i.test(navigator.userAgent);
}
//获得文档的head，如果有的话
function $head(){
	var heads = document.getElementsByTagName("head"); 
	return heads ? heads[0] : null;
}
//获得文档的body，如果有的话
function $body(){
	var bodys = document.getElementsByTagName("body");
	return bodys ? bodys[0] : null;
}
//获得Silverna核心脚本所在的script DOM对象
var $script = (function(){
	var scripts = document.getElementsByTagName("script");
	return scripts.length ? scripts[scripts.length - 1] : null;
})();
//获得Silverna核心脚本的运行路径
function $root()
{
	return $script.getAttribute("src").replace(/[^\/]+$/g,'');
}
//检测一个包或者对象是否存在，不存在则抛出异常
function $require(packs)
{
	try{
		var obj = eval(packs);
		if(obj == null) throw new Error();
		return obj;
	}
	catch(ex)
	{
		throw new EnvironmentException("包或对象" + packs + "加载失败，是否未包含必要的文件？");
	}
}
//用指定参数依次检测一组closure的执行结果，如果正常执行，则返回该执行结果，否则检测下一个
//最后一个参数可以是一个参数列表
function $try(){
	var _args = arguments[arguments.length - 1];
	var len = arguments.length - 1;
	if(_args instanceof Function){
		_args = [];
		len++;
	}
	
	for(var i = 0; i < len; i++)
	{
		try{
			return arguments[i].apply(this, _args);
		}
		catch(ex){
		}
	}
}

//Iterator 迭代器原型
function Iterator(){}
Iterator.prototype.next = $abstract;
Iterator.prototype.hasNext = $abstract;
Iterator.prototype.toArray = function(){
	var _set = [this.item()];
	while(this.hasNext())
	{
		_set.push(this.item());
		this.next();
	}
	return _set;
}
//Serializer 序列化原型
function Serializer(){}
Serializer.prototype.serialize = function(encoder)
{
	var ret = [];
	encoder = encoder || 
		function(s){
			s = s || '';
			return s.replace(/\'/g,"\\'").replace(/([:{},])/g,function(s){s=s.charCodeAt(0).toString(16); while(s.length<4) s="0"+s; return "\\u"+s});
		}
	
	for(var each in this)
	{
		var o = this[each]
		if(!(o instanceof Function))
		{
			if(o.serialize instanceof Function)
			{
				o = o.serialize(encoder);
				ret.push("'"+encoder(each)+"'" + ":" + o);
			}
			else
				ret.push("'"+encoder(each)+"'" + ":" + "'" + encoder(o) + "'");
		}
	}

	return "{" + ret.join() + "}";
}

//Array 数组扩展
//any是一个集合迭代函数，它接受一个闭包作为参数
//当集合中的任何一个元素调用闭包的结果返回非false时，any()返回计算结果，否则返回false
Array.prototype.any = function(closure, _set){	
	_set = _set || false;

	if(typeof closure == 'undefined')
		closure = function(x){return x};
	if(typeof closure != 'function')
	{
		var c = closure;
		closure = function(x){return x == c}
	}
	
	var args = Array.apply(this, arguments).slice(2);

	for(var i = 0; i < this.length; i++)
	{
		var rval = closure.apply(this, [this[i]].concat(args).concat(i))
		if(rval || rval === 0)
		{
			if(_set && _set.put)
				_set.put(rval);
			else
				return rval;
		}
	}

	return _set;
}
//each是一个集合迭代函数，它接受一个闭包作为参数和一组可选的参数
//这个迭代函数依次将集合的每一个元素和可选参数用闭包进行计算，并将计算得的结果集返回
Array.prototype.each = function(closure){
    closure = closure || undefined;
	var _set = [];
	_set.put = _set.push;
	return this.any.apply(this, [closure, _set].concat(Array.apply(this, arguments).slice(1)));
}
//all是一个集合迭代函数，它接受一个闭包作为参数
//当且仅当集合中的每一个元素调用闭包的返回结果为true时，它才返回true
Array.prototype.all = function(closure){
	return this.each.apply(this, arguments).length == this.length;
}

//除去数组中的null、false元素
Array.prototype.trim = function(){
    return this.each();
}

//判断数组中是否包含某个元素
Array.prototype.contains = function(el){
	return this.any(function(x){return x == el});
}

//获得数组中值等于el的第一个索引，若不存在返回-1
Array.prototype.indexOf = function(el){
	return this.any(function(x, i){return el == x?i:-1});
}
//删除数组中第一个等于o的元素，返回被删除元素的位置
//如果删除的元素不存在，返回-1
Array.prototype.remove = function(o){
	var idx = this.indexOf(o);
	if(idx != -1)
	{
		this.splice(idx,1);
	}
	return idx;
}

//获得从start到end的子数组
Array.prototype.subarr = function(start, end){
	end = end || Math.Infinity;
	return this.each(function(x, i){return i >= start && i < end ? x : null});
}
//这是一个集合迭代函数，它接受一个list和一个闭包
//返回这个闭包对于集合和list元素的一组匹配
Array.prototype.map = function(list, closure){
	if (typeof list == 'function' && typeof closure != 'function')
	{
		var li = closure;
		closure = list;
		list = li;
	}
	closure = closure || Array;

	return this.each(function(x, i){return closure(x, list[i])});
};
Array.prototype.iterator = function(){
	
	var _it = new Iterator();
	var _cursor = 0;
	var _arr = this;

	_it.next = function(){
		_cursor++;
		return _it;
	}

	_it.item = function(){
		return _arr[_cursor];
	}

	_it.hasNext = function(){
		return _cursor < _arr.length - 1;
	}

	return _it;
}
// 除去左边空白
String.prototype.leftTrim = function()
{
	return this.replace(/^\s+/g,""); 
} 
// 除去右边空白
String.prototype.rightTrim = function()
{
	return this.replace(/\s+$/g,""); 
}
// 除去两边空白
String.prototype.trim = function()
{
	return this.replace(/(^\s+)|(\s+$)/g,""); 
}
// 得到字节长度
String.prototype.bytes = function()
{
	return this.replace(/[^\x00-\xff]/g,"--").length;
}
//根据字符串返回javascript日期类型对象,如果不是合法的日期字符串返回null
Date.parseDate = function(date)
{
	if (date == null)
	{
		return new Date();
	}
	if (date instanceof Date)
	{
		return date;
	}
	else
	{
		date = new Date(date.replace(/-/g,"/"));
	}
	if (isNaN(date.getTime()))
	{
		return null;
	}
	else
		return date;
}
//返回当前日期对象所在月份的天数
Date.prototype.getDaysOfMonth = function(date)
{
	return this.getLastDayOfMonth().getDate();
}
//获得当前月的第一天
Date.prototype.getFirstDayOfMonth = function()
{
	var year = this.getFullYear();
	var month = this.getMonth();

	return new Date(year,month,1);
}
//获得当前月的最后一天
Date.prototype.getLastDayOfMonth = function()
{
	var year = this.getFullYear();
	var month = this.getMonth();

	return new Date(year,month+1,0);
}
//获得下个月的第一天
Date.prototype.getFirstDayOfNextMonth = function()
{
	var year = this.getFullYear();
	var month = this.getMonth();

	return new Date(year,month+1,1);
}
//获得上个月的第一天
Date.prototype.getLastDayOfLastMonth = function()
{
	var year = this.getFullYear();
	var month = this.getMonth();

	return new Date(year,month-1,0);
}
//返回距离当前日期若干天之前/之后的日期
Date.prototype.getDateFrom = function(days)
{
	if (isNaN(this.getTime()))
		return new Date();
	else 
		return new Date(this.getTime() + 3600 * 24 * 1000 * days);
}
//格式化日期： var date = new Date(); var dateStr = date.toFormattedDateString("YYYY-MM-DD");
Date.prototype.toFormattedDateString = function(patternString)
{
	if(patternString == null)
	return this.toLocaleString();	 

	var ret = patternString;
	var year = this.getFullYear();
	var month = this.getMonth() + 1;
	var date = this.getDate();
	var hour = this.getHours();
	var minute = this.getMinutes();
	var second = this.getSeconds();

	month = month > 9 ? "" + month : "0" + month;
	date = date > 9 ? "" + date : "0" + date;

	ret = ret.replace(/YYYY/gi,year);
	ret = ret.replace(/MM/g,month);
	ret = ret.replace(/DD/gi,date);

	ret = ret.replace(/HH/gi,hour);
	ret = ret.replace(/mm/g,minute);
	ret = ret.replace(/ss/gi,second);

	return ret;
}
Date.prototype.datePart = function()
{
	return new Date(this.getFullYear(), this.getMonth(), this.getDate());
}
Date.now = function()
{
	return new Date();
}
Function.prototype.bind = function(owner)
{
	var $pointer = this;
	return function()
	{
		return $pointer.apply(owner, arguments);
	}
}
//这个函数有两个版本，一是它能够让一个对象在一定时间之后调用某个方法，例如：a.__defer__(b,100);
//另一个是能够让一个方法延迟一段时间被调用，例如a.defer(100);
//还有一个可选的参数是args，它表示调用的参数
Function.prototype.defer = function(delay, args){
	var $pointer = this;
	if(!(args instanceof Array))
		args = [args];
    window.setTimeout(function(){
		return $pointer.apply(this, args);
	}, delay);
}
Object.prototype.__getByNS__ = function(s)
{
	var n = s.split(".");
	var o = this;
	try{
		for(var i = 0; i < n.length; i++)
		{
			var t = n[i];
			if(parseInt(t).toString() == t)
			{
				o = o[t - 0];
			}
			else
				o = o[t];
		}
		return o;