prototype.js

JAVA +MySql小型用户管理系统 运用Strust+Spring+Hibernate 3框架 实现mvc jsp融合JavaScript+Ajax 技术 程序还有待完善

/*  Prototype JavaScript framework, version 1.4.0
 *  (c) 2005 Sam Stephenson <[e-mail]>
 *
 *  Prototype is freely distributable under the terms of an MIT-style license.
 *  For details, see the Prototype web site: http://prototype.conio.net/
 *
/*--------------------------------------------------------------------------*/

var Prototype = {
  Version: '1.4.0',
  ScriptFragment: '(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)',

  emptyFunction: function() {},
  K: function(x) {return x}
}


/******************************************************************************************/
/*
创建一个新类
*/
var Class = {
//创建一个新类
  create: function() {
    return function() {
      this.initialize.apply(this, arguments);
    }
  }
}
/********************************************************************************************/


var Abstract = new Object();

Object.extend = function(destination, source) {
  for (property in source) {
    destination[property] = source[property];
  }
  return destination;
}


Object.inspect = function(object) {
  try {
    if (object == undefined) return 'undefined';
    if (object == null) return 'null';
    return object.inspect ? object.inspect() : object.toString();
  } catch (e) {
    if (e instanceof RangeError) return '...';
    throw e;
  }
}

Function.prototype.bind = function() {
  var __method = this, args = $A(arguments), object = args.shift();
  return function() {
    return __method.apply(object, args.concat($A(arguments)));
  }
}

Function.prototype.bindAsEventListener = function(object) {
  var __method = this;
  return function(event) {
    return __method.call(object, event || window.event);
  }
}

Object.extend(Number.prototype, {
  toColorPart: function() {
    var digits = this.toString(16);
    if (this < 16) return '0' + digits;
    return digits;
  },

  succ: function() {
    return this + 1;
  },

  times: function(iterator) {
    $R(0, this, true).each(iterator);
    return this;
  }
});




/*****************************自动调用传入的系列函数********************************************/
/*
Try.these()允许传入一系列函数作为参数，如果这一系列函数都返回值，将有可能出现问题，该函数自动调用传入的系列函数，并找到第一个能成功返回值的函数，将该函数的返回值作为Try.these()的返回值
该函数的用途主要是满足JavaScript在不同浏览器上运行的需要
*/
var Try = {
  these: function() {
    var returnValue;

    for (var i = 0; i < arguments.length; i++) {
      var lambda = arguments[i];
      try {
        returnValue = lambda();
        break;
      } catch (e) {}
    }

    return returnValue;
  }
}

/***********************************自动调用传入的系列函数**********************************/




/*--------------------------------------------------------------------------*/

var PeriodicalExecuter = Class.create();
PeriodicalExecuter.prototype = {
  initialize: function(callback, frequency) {
    this.callback = callback;
    this.frequency = frequency;
    this.currentlyExecuting = false;

    this.registerCallback();
  },

  registerCallback: function() {
    setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
  },

  onTimerEvent: function() {
    if (!this.currentlyExecuting) {
      try {
        this.currentlyExecuting = true;
        this.callback();
      } finally {
        this.currentlyExecuting = false;
      }
    }
  }
}




/*********************对应于document对象getElementById（）方法*********************************/
/*
对应于document对象getElementById（）方法，但比其更强大，可以接受多个id值
*/
function $() {
  var elements = new Array();
//通过 arguments 属性，函数可以处理可变数量的参数
  for (var i = 0; i < arguments.length; i++) {
    var element = arguments[i];
	//判断element是否为string型，如是则获取其对应的对象
    if (typeof element == 'string')
      element = document.getElementById(element);

    if (arguments.length == 1)
      return element;

    elements.push(element);
  }

  return elements;
}
/******************************对应于document对象getElementById（）方法************************/


/*******************************String 扩展字符串类*********************************************/
Object.extend(String.prototype, {
			  
//返回删除了HTML和XML标记的新字符串，不会影响原字符串
  stripTags: function() {
    return this.replace(/<\/?[^>]+>/gi, '');
  },

//返回删除了JavaScript脚本的新字符串，不会影响原字符串
  stripScripts: function() {
    return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');
  },

//返回字符串中的所有的脚本片段，如果有多个脚本片段，则以数组的形似返回
  extractScripts: function() {
    var matchAll = new RegExp(Prototype.ScriptFragment, 'img');
    var matchOne = new RegExp(Prototype.ScriptFragment, 'im');
    return (this.match(matchAll) || []).map(function(scriptTag) {
      return (scriptTag.match(matchOne) || ['', ''])[1];
    });
  },

//执行调用extractScripts返回字符串中的所有的脚本片段
  evalScripts: function() {
    return this.extractScripts().map(eval);
  },

//返回将HTML字符转义后的字符串，即将小于符号<转为&lt;
  escapeHTML: function() {
    var div = document.createElement('div');
    var text = document.createTextNode(this);
    div.appendChild(text);
    return div.innerHTML;
  },
 
 
//返回将HTML字符转义后的字符串，即将&lt;转为小于符号<
  unescapeHTML: function() {
    var div = document.createElement('div');
    div.innerHTML = this.stripTags();
    return div.childNodes[0] ? div.childNodes[0].nodeValue : '';
  },

//解析查询字符串，返回由参数名做index的联合array
  toQueryParams: function() {
    var pairs = this.match(/^\??(.*)$/)[1].split('&');
    return pairs.inject({}, function(params, pairString) {
      var pair = pairString.split('=');
      params[pair[0]] = pair[1];
      return params;
    });
  },

//把字符串转为数组
  toArray: function() {
    return this.split('');
  },
  
//将background－color字符串转换为backgroundColor的形式，在将CSS属性转换为脚本中的CSS属性时特别有用
  camelize: function() {
    var oStringList = this.split('-');
    if (oStringList.length == 1) return oStringList[0];

    var camelizedString = this.indexOf('-') == 0
      ? oStringList[0].charAt(0).toUpperCase() + oStringList[0].substring(1)
      : oStringList[0];

    for (var i = 1, len = oStringList.length; i < len; i++) {
      var s = oStringList[i];
      camelizedString += s.charAt(0).toUpperCase() + s.substring(1);
    }

    return camelizedString;
  },

//输出字符串，可以把单引号'等输出
  inspect: function() {
    return "'" + this.replace('\\', '\\\\').replace("'", '\\\'') + "'";
  },
  
  /******************************************************************************
  * Date：2008-3-4
  * 以下是对prototype框架的String操作函数补充
  *******************************************************************************/
  	trim: function() {  //去两边的空格
		if(typeof this != 'string')  this.toString();
    	return this.replace(/(^\s*)|(\s*$)/g, "");
  	},
  
	lTrim: function(){  //去左边空格
		if(typeof this != 'string')  this.toString();
    	return this.replace(/(^[\\s]*)/g, "");
	},
  	
	rTrim: function(){ //去右边空格
		if(typeof this != 'string')  this.toString();
    	return this.replace(/([\\s]*$)/g, "");
	},
	
	isEmpty: function(){  //检测字符串是否为空
    	if(this.trim() == ""){
        	return true;
		}
        return false;
	}
	
  
});

String.prototype.parseQuery = String.prototype.toQueryParams;
/*************************************String 扩展字符串类**********************************/



/***************************************Enumerable**************************************/
var $break    = new Object();
var $continue = new Object();

var Enumerable = {
//遍历list对象中的每个元素
  each: function(iterator) {
    var index = 0;
    try {
      this._each(function(value) {
        try {
          iterator(value, index++);
        } catch (e) {
          if (e != $continue) throw e;
        }
      });
    } catch (e) {
      if (e != $break) throw e;
    }
  },
//用于测试集合中所有元素是否满足某个条件，iterator是一个形式如function（value，index）的函数， value是Enumerable对象中的元素，index是集合中元素的索引
  all: function(iterator) {
    var result = true;
    this.each(function(value, index) {
      result = result && !!(iterator || Prototype.K)(value, index);
      if (!result) throw $break;
    });
    return result;
  },
//测试集合中是否包含任一元素满足某个条件，iterator是一个形式如function（value，index）的函数， value是Enumerable对象中的元素，index是集合中元素的索引
  any: function(iterator) {
    var result = true;
    this.each(function(value, index) {
      if (result = !!(iterator || Prototype.K)(value, index))
        throw $break;
    });
    return result;
  },
//使用iterator函数一次处理集合中的每个元素，并将处理结果收集成一个数组对象，最后返回转换得到的数组
  collect: function(iterator) {
    var results = [];
    this.each(function(value, index) {
      results.push(iterator(value, index));
    });
    return results;
  },
//获取集合中的第一个满足某个条件的元素
  detect: function (iterator) {
    var result;
    this.each(function(value, index) {
      if (iterator(value, index)) {
        result = value;
        throw $break;
      }
    });
    return result;
  },
//获取集合中所有满足某个条件的元素
  findAll: function(iterator) {
    var results = [];
    this.each(function(value, index) {
      if (iterator(value, index))
        results.push(value);
    });
    return results;
  },
//返回结合中所有匹配pattern正则表达式的元素
  grep: function(pattern, iterator) {
    var results = [];
    this.each(function(value, index) {
      var stringValue = value.toString();
      if (stringValue.match(pattern))
        results.push((iterator || Prototype.K)(value, index));
    })
    return results;
  },
//判断集合是否包含指定对象，包含则返回true
  include: function(object) {
    var found = false;
    this.each(function(value) {
      if (value == object) {
        found = true;
        throw $break;
      }
    });
    return found;
  },
//这是一个递归的函数，iterator连接所有集合中的元素，iterator在被调用时把上次迭代的结果作为第一个参数传给accumalator，第一次迭代是，accurmelator等于initialValue，足有返回accumulator的值。
  inject: function(memo, iterator) {
    this.each(function(value, index) {
      memo = iterator(memo, value, index);
    });
    return memo;
  },
//使用结合中的所有元素一次调用methodName方法，调用这些方法时，传入arg1，arg2等参数，最后返回所有元素调用methodName方法返回值组成的数组
  invoke: function(method) {
    var args = $A(arguments).slice(1);
    return this.collect(function(value) {
      return value[method].apply(value, args);
    });
  },
//使用iterator函数依次处理集合中的每个元素，最后返回处理的最大值。如果没有使用iterator函数，则返回集合的最大值
  max: function(iterator) {
    var result;
    this.each(function(value, index) {
      value = (iterator || Prototype.K)(value, index);
      if (value >= (result || value))
        result = value;
    });
    return result;
  },
//使用iterator函数依次处理集合中的每个元素，最后返回处理的最小值。如果没有使用iterator函数，则返回集合的最大值
  min: function(iterator) {