prototype.js

电子商城

	这有可能是作者考虑的一个小失误，毕竟返回"undefined"并不是一个好的风格（仅是猜测）
	*/
  detect: function (iterator) {
    var result;
    this.each(function(value, index) {
      if (iterator(value, index)) {
        result = value;
        throw $break;
      }
    });
    return result;
  },
	/*
	返回所有能够使得迭代器返回true的枚举元素，作为数组返回。
	*/
  findAll: function(iterator) {
    var results = [];
    this.each(function(value, index) {
      if (iterator(value, index))
        results.push(value);
    });
    return results;
  },
	/*
	grep是unix类操作系统下的一个经典命令，而这里则是JavaScript的一个类似实现
	pattern是正则模式，对所有符合此模式的枚举元素进行迭代器运算，并将运算结果保存到数组中并返回。
	需要注意，这里的iterator参数是可选的，此时仅仅对枚举元素进行模式匹配，返回所有的匹配结果
	*/
  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;
  },
	/*
	判断枚举对象中是否包含指定值的枚举元素，这里仍然使用了each方法，而不是循环，可见prototype致力于提供一种ruby化的编程方式，
	如果用循环实现，则是类似于以下的代码：
	for(var i=0;i<this.length;i++){
		if(this[i]==object)return true;
	}
	而该函数中，定义了迭代器：
	function(value) {
      if (value == object) {
        found = true;
        throw $break;
      }
    }
	这个迭代器作为each方法的参数。
	
	*/
  include: function(object) {
    var found = false;
    this.each(function(value) {
      if (value == object) {
        found = true;
        throw $break;
      }
    });
    return found;
  },

	/*
	字面意思是“注入”，其作用相当于将memo作为联系各个迭代器的全局变量，每次迭代都对其进行操作，返回操作的最后结果。例如对于数组：
	var arr=[1,2,3];
	现在想将其字符串化为：123
	如果不调用join方法，传统做法是：
	var s="";
	for(var i=0;i<arr.length;i++){
		s+=arr[i];
	}
	现在通过调用inject函数，则：
	var s=arr.inject("",function(memo,value){return memo+value});
	两者运行的结果是完全相同的。
	*/
  inject: function(memo, iterator) {
    this.each(function(value, index) {
      memo = iterator(memo, value, index);
    });
    return memo;
  },


	/*
	在所有枚举元素上调用method方法，并可以给这个方法传递参数
	返回所有method的执行结果，作为数组返回
	*/
  invoke: function(method) {
    var args = $A(arguments).slice(1);
    return this.collect(function(value) {
      return value[method].apply(value, args);
    });
  },
	/*
	返回最大的迭代器返回值
	*/
  max: function(iterator) {
    var result;
    this.each(function(value, index) {
      value = (iterator || Prototype.K)(value, index);
      if (value >= (result || value))
        result = value;
    });
    return result;
  },
	/*
	返回最小的迭代器返回值
	*/
  min: function(iterator) {
    var result;
    this.each(function(value, index) {
      value = (iterator || Prototype.K)(value, index);
      if (value <= (result || value))
        result = value;
    });
    return result;
  },
	/*
	按照迭代器的返回结果，将枚举元素分为两个数组trues和falses，其中trues包括迭代器返回true的枚举元素，falses则相反。
	*/
  partition: function(iterator) {
    var trues = [], falses = [];
    this.each(function(value, index) {
      ((iterator || Prototype.K)(value, index) ?
        trues : falses).push(value);
    });
    return [trues, falses];
  },
	/*
	返回所有枚举元素的property属性
	*/
  pluck: function(property) {
    var results = [];
    this.each(function(value, index) {
      results.push(value[property]);
    });
    return results;
  },

	/*
	返回所有迭代器执行结果为false的枚举元素
	*/
  reject: function(iterator) {
    var results = [];
    this.each(function(value, index) {
      if (!iterator(value, index))
        results.push(value);
    });
    return results;
  },
	/*
	结构复杂的一个函数，作用是根据迭代器iterator的结果对枚举元素进行排序。使iterator执行结果小的元素排在前面。
	主要包括三个函数的调用：
	1。collect方法，返回的每个数组元素包括：值和迭代器运行该值的结果，用{value:value,criteria:iterator(value,index)}得到
	2。对collect返回的数组执行sort方法，这时数组对象内置的对象，参数是一个委托函数，用于指定排序规则。其标准是对迭代器返回的值排序，小的在前面
	3。对sort的结果执行pluck方法，即返回value属性的值，于是最后还是返回的枚举对象中的原有值，只是根据迭代器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');
  },

	/*
	将枚举对象转换为数组，使用了collect方法和Prototype.K函数，减少了重复代码
	*/
  toArray: function() {
    return this.collect(Prototype.K);
  },
	/*
	压缩函数，实现复杂，作用尚不能体会-_-。
	接收的参数需要是可枚举对象，可以有多个参数。最后一个参数是迭代器，可选。
	作用是将自身和参数组成的二维阵列进行行列对换，并切除多余的数据，或补充缺少的数据(用undefined)。切换后的行数由调用者中元素的个数决定，而列数是数组参数的个数加1。
	每个数组参数的第一个元素顺序组成第一行，第二个元素顺序组成第二行，依次类推。直到调用者中的元素用完为止。
	迭代器的作用就是对转换后的每一行进行一次运算。
	例如：
	var arr1=[1,2,3];
	var arr2=[4,5,6];
	var arr3=[7,8,9];
	var arr=arr1.zip(arr2,arr3);

	//使用迭代器输出结果，inspect用于输出数组语法表示的数组字符串，后面有介绍
	arr.each(function(s){
			document.write(s.inspect());
			document.write("<br/>");
		}
	);
	得到的结果为：
	[1, 4, 7]
	[2, 5, 8]
	[3, 6, 9]

	如果让arr1=[1,2]，其他不变，则执行结果为：
	[1, 4, 7]
	[2, 5, 8]

	*/
  zip: function() {
    var iterator = Prototype.K, args = $A(arguments);
    if (typeof args.last() == 'function')
      iterator = args.pop();
	//将自身枚举对象作为一个元素，与参数（也是可枚举的）组成一个数组，并将枚举对象转换为数组（通过$A迭代器）
    var collections = [this].concat(args).map($A);

    return this.map(function(value, index) {
      iterator(value = collections.pluck(index));
      return value;
    });
  },
	/*
	这实际上这是一个待实现的抽象方法，在Array对象中有对其进行的重定义
	所以将this转换为数组（toArray()），再调用inspect。
	对于非数组形式的枚举对象，则会加上'#<Enumerable:....>'这样的形式
	*/
  inspect: function() {
    return '#<Enumerable:' + this.toArray().inspect() + '>';
  }
}
//对Enumerable基类的一些方法做了快速链接
Object.extend(Enumerable, {
  map:     Enumerable.collect,
  find:    Enumerable.detect,
  select:  Enumerable.findAll,
  member:  Enumerable.include,
  entries: Enumerable.toArray
});

/*
将一个对象转换为数组。
对于字符串则直接变为字符数组，例如$A("abc")将得到，["a","b","c"]
否则集合对象变为数组，这类对象包括函数的参数集合arguments，<select>的options集合，
<form>的elements集合等等，一个节点的所有子结点childNodes等等。
*/
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;
}
}
/*
让数组继承于Enumarable对象（基类）
*/
Object.extend(Array.prototype, Enumerable);
/*
做一个链接，prototype中一般私有的成员或抽象成员都用下划线开头，这里的_reverse大概就是起一个说明性的作用，将其作为抽象方法使用。
*/
Array.prototype._reverse = Array.prototype.reverse;

/*
为数组对象添加一些快捷方法
*/
Object.extend(Array.prototype, {
	/*
	迭代器方法，源于Ruby中的迭代器用法
	_each方法的作用就是将数组的每个元素作为iterator函数的参数，并执行iterator方法。例如对于数组：var arr=[1,2,3,4,5,6];
	如果要显示其中的每个元素，通常的做法是
	for(var i=0;i<arr.length;i++){
		alert(arr[i]);
	}
	而使用此方法则：
	arr._each(function(s){alert(s)});
	因此，在Ruby的代码中很少出现循环，这个函数使得JavaScript同样也能够实现。
	*/
  _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值
	这里的select是从Emurable中继承的方法，而select又是findAll函数的别名
	*/
  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;
  },
	/*
	将数组元素顺序逆转，inline用于确保是数组
	*/
  reverse: function(inline) {
    return (inline !== false ? this : this.toArray())._reverse();
  },
	/*
	取出数组的第一个元素并返回
	*/
  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(', ') + ']';
  }
});
/*
定义哈希对象的通用操作
*/
var Hash = {
	/*
	实现可枚举接口。
	对hash对象中的每个元素进行迭代操作，迭代器被认为接收一个数组参数，数组的第一个元素是key，第二个元素是value
	同时，此数组对象还增加了两个属性key和value。分表表示键和值。
	*/
  _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);
    }
  },
	/*
	返回所有的键组成的数组
	*/
  keys: function() {
    return this.pluck('key');
  },
	/*
	返回所有的值组成的数组
	*/
  values: function() {
    return this.pluck('value');
  },
	/*
	将两个hash对象合并，如果键相同，则用参数中相应键对应的值覆盖调用者的。
	*/
  merge: function(hash) {
    return $H(hash).inject($H(this), function(mergedHash, pair) {
      mergedHash[pair.key] = pair.value;
      return mergedHash;
    });
  },
	/*
	将hash对象转换为查询字符串表示的形式
	*/
  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(', ') + '}>';
  }
}

/*
将一个对象转换为哈希对象，对象的属性名（方法名）作为key，值作为value
同时hash对象也是一个可枚举对象
*/
function $H(object) {
/*
object || {}使得参数为空时也能够创建一个hash对象
*/
var hash = Object.extend({}, object || {});
Object.extend(hash, Enumerable);
Object.extend(hash, Hash);
return hash;
}

/*
又一个实现Enumerable接口的对象。
有了这个类，基本上就可以完全避免使用for循环了，一个例子，计算1到100的和：
传统写法：
var s=0;
for(var i=0;i<=100;i++){
	s+=i;
}
document.write(s);