prototype.js

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

    var result;
    this.each(function(value, index) {
      value = (iterator || Prototype.K)(value, index);
      if (value <= (result || value))
        result = value;
    });
    return result;
  },
//调用iterator函数依次处理集合中的每个元素，将所有处理结果为true的放在第一个数组返回，其余作为第二个数组。没有iterator函数，则直接判断集合元素，将所有为true的集合元素收集到第一个数组到返回，其余收集到第二个数组返回。
  partition: function(iterator) {
    var trues = [], falses = [];
    this.each(function(value, index) {
      ((iterator || Prototype.K)(value, index) ?
        trues : falses).push(value);
    });
    return [trues, falses];
  },
//返回集合中所有元素属性组成的数组
  pluck: function(property) {
    var results = [];
    this.each(function(value, index) {
      results.push(value[property]);
    });
    return results;
  },
//与findAll（）恰好相反，获取集合中所有不满足条件的元素
  reject: function(iterator) {
    var results = [];
    this.each(function(value, index) {
      if (!iterator(value, index))
        results.push(value);
    });
    return results;
  },
//使用iterator依次调用每个元素，最后根据返回值对集合元素排序，最后返回排序后的数组
  sortBy: function(iterator) {
    return this.collect(function(value, index) {
      return {value: value, criteria: iterator(value, index)};
    }).sort(function(left, right) {
      var a = left.criteria, b = right.criteria;
      return a < b ? -1 : a > b ? 1 : 0;
    }).pluck('value');
  },
//返回由集合元素组成的数组
  toArray: function() {
    return this.collect(Prototype.K);
  },
//将collectionN结合中的元素抽取出来，将抽取出来的元素以及器index相同的原集合元素一起组成一个二维数组返回
  zip: function() {
    var iterator = Prototype.K, args = $A(arguments);
    if (typeof args.last() == 'function')
      iterator = args.pop();

    var collections = [this].concat(args).map($A);
    return this.map(function(value, index) {
      iterator(value = collections.pluck(index));
      return value;
    });
  },
//与某种形式返回集合元素
  inspect: function() {
    return '#<Enumerable:' + this.toArray().inspect() + '>';
  }
}

Object.extend(Enumerable, {
  map:     Enumerable.collect,//与collect（）相同
  find:    Enumerable.detect,//与detect（）相同
  select:  Enumerable.findAll,//与findAll（）相同
  member:  Enumerable.include,//与include（）相同
  entries: Enumerable.toArray//与toArray（）相同
});
/***************************************Enumerable*************************************/




/*************************************Array  数组********************************************/
/*
$A()函数能把单个参数转换为一个Array对象，结合被prototype.js扩展后的Array类，能方便地把任何可枚举列表转换或复制到一个Array对象
*/
var $A = Array.from = function(iterable) {
  if (!iterable) return [];
  //如果是可以直接转为一维数组
  if (iterable.toArray) {
    return iterable.toArray();
  }//如果不能则，取出值，放在一新的数组 
  else {
    var results = [];
    for (var i = 0; i < iterable.length; i++)
      results.push(iterable[i]);
    return results;
  }
}


Object.extend(Array.prototype, Enumerable);

Array.prototype._reverse = Array.prototype.reverse;

Object.extend(Array.prototype, {
  _each: function(iterator) {
    for (var i = 0; i < this.length; i++)
      iterator(this[i]);
  },
//清除数组
  clear: function() {
    this.length = 0;
    return this;
  },
//数组的第一个元素
  first: function() {
    return this[0];
  },
//数组的最后一个元素
  last: function() {
    return this[this.length - 1];
  },
//压缩数组，返回源数组中的null和undefined等值删除后的数组，不会影响源数组
  compact: function() {
    return this.select(function(value) {
      return value != undefined || value != null;
    });
  },
//用于将一个多维数组转换为一维数组
  flatten: function() {
    return this.inject([], function(array, value) {
      return array.concat(value.constructor == Array ?
        value.flatten() : [value]);
    });
  },
//将指定元素从数组删除，参数可以为多个
  without: function() {
    var values = $A(arguments);
    return this.select(function(value) {
      return !values.include(value);
    });
  },
//返回数组中的某个元素的索引值
  indexOf: function(object) {
    for (var i = 0; i < this.length; i++)
      if (this[i] == object) return i;
    return -1;
  },
//返回源数组每个元素反转后的数组
  reverse: function(inline) {
    return (inline !== false ? this : this.toArray())._reverse();
  },
//返回数组的第一个元素，并将该元素从数组中删除，因此数组的长度减1
  shift: function() {
    var result = this[0];
    for (var i = 0; i < this.length - 1; i++)
      this[i] = this[i + 1];
    this.length--;
    return result;
  },
//以某种格式输出数组的每个元素
  inspect: function() {
    return '[' + this.map(Object.inspect).join(', ') + ']';
  }
});
/***************************************Array  数组********************************************/





/************************************Hash 哈希***************************************************/
//Hash 对象实现是一种类似于java语言里的Map的数据结构，他是一个key＝value对的集合
var Hash = {
  _each: function(iterator) {
    for (key in this) {
      var value = this[key];
      if (typeof value == 'function') continue;

      var pair = [key, value];
      pair.key = key;
      pair.value = value;
      iterator(pair);
    }
  },

//返回hash对象的全部key组成的数组
  keys: function() {
    return this.pluck('key');
  },

//返回hash对象的全部value组成的数组
  values: function() {
    return this.pluck('value');
  },

//将新的hash对象合并到原有的hash对象，返回合并后的新hash对象
  merge: function(hash) {
    return $H(hash).inject($H(this), function(mergedHash, pair) {
      mergedHash[pair.key] = pair.value;
      return mergedHash;
    });
  },

//将hash对象转换为查询字符串，这种查询字符串以key1＝value1&key2=value2的形式出现
  toQueryString: function() {
    return this.map(function(pair) {
      return pair.map(encodeURIComponent).join('=');
    }).join('&');
  },

//以一种合适的方法显示hash对象
  inspect: function() {
    return '#<Hash:{' + this.map(function(pair) {
      return pair.map(Object.inspect).join(': ');
    }).join(', ') + '}>';
  }
}


/*
$H()，用于将一些对象转换成Hash对象
*/
function $H(object) {
  var hash = Object.extend({}, object || {});
  Object.extend(hash, Enumerable);
  Object.extend(hash, Hash);
  return hash;
}
/***************************************Hash 哈希*****************************************/




/***********************************ObjectRange**************************************************/
/*
用于构造一个ObjectRange对象
*/
ObjectRange = Class.create();
Object.extend(ObjectRange.prototype, Enumerable);
Object.extend(ObjectRange.prototype, {
  initialize: function(start, end, exclusive) {
    this.start = start;
    this.end = end;
    this.exclusive = exclusive;
  },

  _each: function(iterator) {
    var value = this.start;
    do {
      iterator(value);
      value = value.succ();
    } while (this.include(value));
  },

  include: function(value) {
    if (value < this.start)
      return false;
    if (this.exclusive)
      return value < this.end;
    return value <= this.end;
  }
});

var $R = function(start, end, exclusive) {
  return new ObjectRange(start, end, exclusive);
}
/*************************************ObjectRange**********************************************/





/***************************************AJAX************************************************/
/*
ajax对象是一个全局对象
*/
var Ajax = {
	//返回一个新的XMLHttpRquest对象
  getTransport: function() {
    return Try.these(
      function() {return new ActiveXObject('Msxml2.XMLHTTP')},
      function() {return new ActiveXObject('Microsoft.XMLHTTP')},
      function() {return new XMLHttpRequest()}
    ) || false;
  },
//正在处理过程中的ajax请求的个数
  activeRequestCount: 0
}

/////////////////////////////////注册ajax事件监听器/////////////////////////////////
Ajax.Responders = {
  responders: [],

  _each: function(iterator) {
    this.responders._each(iterator);
  },
//注册一个全局的ajax事件处理器，该事件处理器应包含名如ajax事件的系列方法（如onCreate，onComplete，onException，onFailure）的属性
  register: function(responderToAdd) {
    if (!this.include(responderToAdd))
      this.responders.push(responderToAdd);
  },
//删除一个已经注册的事件处理器
  unregister: function(responderToRemove) {
    this.responders = this.responders.without(responderToRemove);
  },
//遍历被注册的事件处理器，找出参数callback指定的处理器，然后向这个处理器传递其他3个参数，如果ajax响应中包含一个含有json内容的x－json http头，处理将被触发，json作为参数被传入该处理器，如果事件是onExceptioin，则异常对象会代替transport，json参数也不会传递
  dispatch: function(callback, request, transport, json) {
    this.each(function(responder) {
      if (responder[callback] && typeof responder[callback] == 'function') {
        try {
          responder[callback].apply(responder, [request, transport, json]);
        } catch (e) {}
      }
    });
  }
};

Object.extend(Ajax.Responders, Enumerable);

Ajax.Responders.register({
  onCreate: function() {
    Ajax.activeRequestCount++;
  },

  onComplete: function() {
    Ajax.activeRequestCount--;
  }
});
////////////////////////////////注册ajax事件监听器////////////////////////////


//////////////////创建XMLHttpRequest，打开与服务器的连接////////////////////////////////////
Ajax.Base = function() {};
Ajax.Base.prototype = {
  setOptions: function(options) {
    this.options = {
      method:       'post',//post请求方式
      asynchronous: true,//同步
      parameters:   ''//请求参数
    }
    Object.extend(this.options, options || {});
  },
//请求是否成功
  responseIsSuccess: function() {
    return this.transport.status == undefined
        || this.transport.status == 0
        || (this.transport.status >= 200 && this.transport.status < 300);
  },
//请求是否失败
  responseIsFailure: function() {
    return !this.responseIsSuccess();
  }
}

Ajax.Request = Class.create();
//创建Rquest对象的4个属性，method：发送请求的方法，只能是post和get，不能大写
//parameters：发送请求参数，应采用name＝value的形式
//onLoading：指定readystate为1时的回调函数
//onLoaded：指定readystate为2时的回调函数
//onInteractive：指定readystate为3时的回调函数
//onComplete：指定readystate为4时的回调函数
//asynchronous：是否异步发送请求，该参数默认是true

//ajax操作中所有XMLHttpRequest对象redystate的5个状态
//Uninitialized：0，XMLHttpRequest还没有完成初始化
//Loading：1，XMLHttpRequest开始发送请求
//Loaded：2，XMLHttpRequest发送请求完成
//Interactive：3，XMLHttpRequest开始读取服务器的响应
//Complete：4，XMLHttpRequest读取服务器响应结束
Ajax.Request.Events =
  ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];

Ajax.Request.prototype = Object.extend(new Ajax.Base(), {
  initialize: function(url, options) {
    this.transport = Ajax.getTransport();//本次ajax交互所使用的XMLHttpRequest对象
    this.setOptions(options);
    this.request(url);//url异步请求发送的url
  },

  request: function(url) {
    var parameters = this.options.parameters || '';
    if (parameters.length > 0) parameters += '&_=';

    try {
      this.url = url;
      if (this.options.method == 'get' && parameters.length > 0)
        this.url += (this.url.match(/\?/) ? '&' : '?') + parameters;

      Ajax.Responders.dispatch('onCreate', this, this.transport);

      this.transport.open(this.options.method, this.url,
        this.options.asynchronous);

      if (this.options.asynchronous) {
        this.transport.onreadystatechange = this.onStateChange.bind(this);
        setTimeout((function() {this.respondToReadyState(1)}).bind(this), 10);
      }