Prototype Enumerable对象 学习_prototype

Enumerable是Prototype框架的基石，而Enumerable不单独使用，在Prototype中其它对象mix了Enumerable里面的方法，这样就可以在这些对象上应用Enumerable的方法，这样的对象有：Array，Hash，ObjectRange，还有一些和DOM，AJAX相关的对象。

Enumerable provides a large set of useful methods for enumerations, that is, objects that act as collections of values. It is a cornerstone of Prototype.

Enumerable is what we like to call a module: a consistent set of methods intended not for independent use, but for mixin: incorporation into other objects that “fit” with it.

Quite a few objects, in Prototype, mix Enumerable in already. The most visible cases are Array and Hash, but you'll find it in less obvious spots as well, such as in ObjectRange and various DOM- or AJAX-related objects.

上面这短话的意思大概就是说Enumerable是Prototype框架的基石，而Enumerable不单独使用，在Prototype中其它对象mix了Enumerable里面的方法，这样就可以在这些对象上应用Enumerable的方法，这样的对象有：Array，Hash，ObjectRange，还有一些和DOM，AJAX相关的对象。
个人理解Enumerable相当于C++中的抽象类的概念，其它类可以继承自这个类，并且实现Enumerable里面的抽象方法"_each"，并且可以覆盖其它的方法，而Enumerable本身却不可以实例化，只可以实例化它的子类。
下面看一下如何通过Enumerable来写自己的类：

复制代码 代码如下:

var YourObject = Class.create();
Object.extend(YourObject.prototype, Enumerable); Object.extend(YourObject.prototype, {
initialize: function() {
// with whatever constructor arguments you need
// Your construction code
},
_each: function(iterator) {
// Your iteration code, invoking iterator at every turn
},
// Your other methods here, including Enumerable overrides
});

可以看出最重要的就是实现_each方法，initialize方法就相当于构造函数，如果不需要外部传进来什么参数，完全可以省略。下面我自己写了一个产生随机数数组的类，非常简单，有许多不完善的地方，这里只做演示用：

复制代码 代码如下:

//创建RandomArray类
var RandomArray = Class.create();
//mixin Enumerable
Object.extend(RandomArray.prototype, Enumerable);
//实现_each和所需方法
Object.extend(RandomArray.prototype, {
    initialize: function(min,max,count) {
        this.min=min;
        this.max=max;
        this.count=count;
        this._numbers=[];
        this._createRandomArray();
    },
    _each: function(iterator) {
        var index=this.count;
        while(index-->0){
            iterator(this._numbers[index]);
        }
    },
//产生随机数数组
    _createRandomArray:function(){
        var index=0;
        while(index var random=Math.round(Math.random()*(this.max-this.min)+this.min);
if(this.include(random)){
continue;
}
this._numbers[index++]=random;
}
},
include:function(number){
return this._numbers.indexOf(number)!=-1;
}
});

var obj = new RandomArray(4,19,5);
//alert(obj.size());
alert(obj.entries());

看一下Enumerable的源码，然后具体学习其中的每个方法：

复制代码 代码如下:

var $break = { };

var Enumerable = (function() {
//遍历每个数据
function each(iterator, context) {
var index = 0;
try {
this._each(function(value) {
iterator.call(context, value, index++);
});
} catch (e) {
if (e != $break) throw e;
}
return this;
}

//把数据划分成N组，其中每组有number个数，最后一组可能小于number个数
function eachSlice(number, iterator, context) {
var index = -number, slices = [], array = this.toArray();
if (number < 1) return array;
while ((index += number) < array.length)
slices.push(array.slice(index, index+number));
return slices.collect(iterator, context);
}

//测试是否所有数据都满足某个条件
function all(iterator, context) {
iterator = iterator || Prototype.K;
var result = true;
this.each(function(value, index) {
result = result && !!iterator.call(context, value, index);
if (!result) throw $break;
});
return result;
}

//检查是否有任意一个数据满足某个条件
function any(iterator, context) {
iterator = iterator || Prototype.K;
var result = false;
this.each(function(value, index) {
if (result = !!iterator.call(context, value, index))
throw $break;
});
return result;
}

//可以对所有数据进行任何操作，并返回结果数组
function collect(iterator, context) {
iterator = iterator || Prototype.K;
var results = [];
this.each(function(value, index) {
results.push(iterator.call(context, value, index));
});
return results;
}

//查找第一个满足某个条件的数据，并返回，相当于find方法的别名
function detect(iterator, context) {
var result;
this.each(function(value, index) {
if (iterator.call(context, value, index)) {
result = value;
throw $break;
}
});
return result;
}

//查找所有满足某个条件的数据，并返回结果
function findAll(iterator, context) {
var results = [];
this.each(function(value, index) {
if (iterator.call(context, value, index))
results.push(value);
});
return results;
}

//根据filter条件过滤所有数据，找到满足filter条件的数据，并返回结果
//filter为字符串或者正则表达式
function grep(filter, iterator, context) {
iterator = iterator || Prototype.K;
var results = [];

if (Object.isString(filter))
filter = new RegExp(RegExp.escape(filter));

this.each(function(value, index) {
if (filter.match(value))
results.push(iterator.call(context, value, index));
});
return results;
}

//检查是否包含某个数据
function include(object) {
if (Object.isFunction(this.indexOf))
if (this.indexOf(object) != -1) return true;

var found = false;
this.each(function(value) {
if (value == object) {
found = true;
throw $break;
}
});
return found;
}

//和eachSlice方法类似，如果最后一组元素个数不足number，则用fillWith参数填充
function inGroupsOf(number, fillWith) {
fillWith = Object.isUndefined(fillWith) ? null : fillWith;
return this.eachSlice(number, function(slice) {
while(slice.length < number) slice.push(fillWith);
return slice;
});
}

//对所有数据连续进行某个操作，可以实现累加或者累乘等操作
function inject(memo, iterator, context) {
this.each(function(value, index) {
memo = iterator.call(context, memo, value, index);
});
return memo;
}

//在所有数据上执行某个方法
function invoke(method) {
var args = $A(arguments).slice(1);
return this.map(function(value) {
return value[method].apply(value, args);
});
}

//找数据中的最大值
function max(iterator, context) {
iterator = iterator || Prototype.K;
var result;
this.each(function(value, index) {
value = iterator.call(context, value, index);
if (result == null || value >= result)
result = value;
});
return result;
}

//找数据中的最小值
function min(iterator, context) {
iterator = iterator || Prototype.K;
var result;
this.each(function(value, index) {
value = iterator.call(context, value, index);
if (result == null || value < result)
result = value;
});
return result;
}

//把所有数据一分为二，第一组为满足某个条件的数据，第二组为不满足条件的数据
function partition(iterator, context) {
iterator = iterator || Prototype.K;
var trues = [], falses = [];
this.each(function(value, index) {
(iterator.call(context, value, index) ?
trues : falses).push(value);
});
return [trues, falses];
}

//取出所有数据的property的值，并返回结果
function pluck(property) {
var results = [];
this.each(function(value) {
results.push(value[property]);
});
return results;
}

//找到不满足某个条件的数据
function reject(iterator, context) {
var results = [];
this.each(function(value, index) {
if (!iterator.call(context, value, index))
results.push(value);
});
return results;
}

//根据某个条件对所有数据进行排序
function sortBy(iterator, context) {
return this.map(function(value, index) {
return {
value: value,
criteria: iterator.call(context, value, index)
};
}).sort(function(left, right) {
var a = left.criteria, b = right.criteria;
return a < b ? -1 : a > b ? 1 : 0;
}).pluck('value');
}

//返回数据的数组表示形式
function toArray() {
return this.map();
}

//基本就是把两组数据放在一起进行某些操作
function zip() {
var iterator = Prototype.K, args = $A(arguments);
if (Object.isFunction(args.last()))
iterator = args.pop();

var collections = [this].concat(args).map($A);
return this.map(function(value, index) {
return iterator(collections.pluck(index));
});
}

function size() {
return this.toArray().length;
}

//返回表示Enumerable对象的字符串表示形式
function inspect() {
return '#';
}

return {
each: each,
eachSlice: eachSlice,
all: all,
every: all,
any: any,
some: any,
collect: collect,
map: collect,
detect: detect,
findAll: findAll,
select: findAll,
filter: findAll,
grep: grep,
include: include,
member: include,
inGroupsOf: inGroupsOf,
inject: inject,
invoke: invoke,
max: max,
min: min,
partition: partition,
pluck: pluck,
reject: reject,
sortBy: sortBy,
toArray: toArray,
entries: toArray,
zip: zip,
size: size,
inspect: inspect,
find: detect
};
})();

下面学习Enumerable所提供的方法：

all
any
collect
detect
each
eachSlice
entries
find
findAll
grep
inGroupsOf
include
inject
invoke
map
max
member
min
partition
pluck
reject
select
size
sortBy
toArray
zip
 all方法：

Determines whether all the elements are boolean-equivalent to true, either directly or through computation by the provided iterator.

基本就是调用each方法，检查每个数据是否满足iterator条件，其中有一个不满足就抛出$break异常,然后在each方法里面会捕获这个异常。这里注意一下'!!'的用法，可以把某些对象转换成相应的bool值：

!!{}                true

!![]                 true

!!''                  false

!!'string'         true

!!0                  false

下面看一下示例：

复制代码 代码如下:

[].all()
// -> true (empty arrays have no elements that could be false-equivalent)

$R(1, 5).all()
// -> true (all values in [1..5] are true-equivalent)

[0, 1, 2].all()
// -> false (with only one loop cycle: 0 is false-equivalent)

[9, 10, 15].all(function(n) { return n >= 10; })
// -> false (the iterator will return false on 9)

$H({ name: 'John', age: 29, oops: false }).all(function(pair) { return pair.value; })
// -> false (the oops/false pair yields a value of false)

any方法：

跟all方法差不多，就不详细说了，看一下示例

复制代码 代码如下:

[].any()
// -> false (empty arrays have no elements that could be true-equivalent)

$R(0, 2).any()
// -> true (on the second loop cycle, 1 is true-equivalent)

[2, 4, 6, 8, 10].any(function(n) { return 0 == n % 3; })
// -> true (the iterator will return true on 6: the array does have 1+ multiple of 3)

$H({ opt1: null, opt2: false, opt3: '', opt4: 'pfew!' }).any(function(pair) { return pair.value; })
// -> true (thanks to the opt4/'pfew!' pair, whose value is true-equivalent)

collect/map（collect方法别名）方法：

 

Returns the results of applying the iterator to each element. Aliased as map.

This is a sort of Swiss-Army knife for sequences. You can turn the original values into virtually anything!

这个方法被称为”瑞士军刀“，这个方法基本上可以对数据进行任何操作，其中map方法是这个方法的别名，这个方法实现很简单，results.push(iterator.call(context, value, index));这句话是关键，就是对每个数据进行iterator调用，并且把结果存储到要返回的数组中，看一下示例：

复制代码 代码如下:

['Hitch', "Hiker's", 'Guide', 'To', 'The', 'Galaxy'].collect(function(s) { return s.charAt(0).toUpperCase(); }).join('')
// -> 'HHGTTG'

$R(1,5).collect(function(n) { return n * n; })
// -> [1, 4, 9, 16, 25]

注意帮助文档上最后有这样几行提示：

First, the method-calling scenario: you want to invoke the same method on all elements, possibly with arguments, and use the result values. This can be achieved easily with invoke.

Second, the property-fetching scenario: you want to fetch the same property on all elements, and use those. This is a breeze with pluck.
detect方法：
找到第一个满足某个条件的数据，并返回，看一下示例，其实这个方法就是find的别名，所以调用detect和find是一样的：

复制代码 代码如下:

// An optimal exact prime detection method, slightly compacted.
function isPrime(n) {
if (2 > n) return false;
if (0 == n % 2) return (2 == n);
for (var index = 3; n / index > index; index += 2)
if (0 == n % index) return false;
return true;
}
// isPrime
$R(10,15).find(isPrime) // -> 11

[ 'hello', 'world', 'this', 'is', 'nice'].find(function(s) { return s.length <= 3; })
// -> 'is'

each方法：

调用这个方法时，其实就是对每个数据进行iterator操作，传入iterator函数的第一个参数为数据，第二个参数为索引，在遍历过程中可以抛出$continue和$break异常，注意：

The usage of <span style="font-family:新宋体">$continue</span> is deprecated. This feature will not be available in releases after Prototype 1.5 in favor of speed.

看一下示例：

复制代码 代码如下:

['one', 'two', 'three'].each(function(s) { alert(s); });

[ 'hello', 'world'].each(function(s, index) { alert(index + ': ' + s); });
// alerts -> '0: hello' then '1: world'

// This could be done better with an accumulator using inject, but humor me
// here...
var result = [];
$R(1,10).each(function(n) {
if (0 == n % 2) throw $continue;
if (n > 6) throw $break;
result.push(n);
});
// result -> [1, 3, 5]

eachSlice方法：

下面很多简单的方法就直接给出示例了，不在解释了，算法也没有什么难得，基本一看就懂：

复制代码 代码如下:

var students = [ { name: 'Sunny', age: 20 }, { name: 'Audrey', age: 21 }, { name: 'Matt', age: 20 }, { name: 'Élodie', age: 26 }, { name: 'Will', age: 21 }, { name: 'David', age: 23 }, { name: 'Julien', age: 22 }, { name: 'Thomas', age: 21 }, { name: 'Serpil', age: 22 } ];

students.eachSlice(4, function(toon) { return toon.pluck('name'); })
// -> [ ['Sunny', 'Audrey', 'Matt', 'Élodie'],
// ['Will', 'David', 'Julien', 'Thomas'],
// ['Serpil'] ]

//下面的first方法是Array对象提供的
students.eachSlice(2).first()
// -> [{ name: 'Sunny', age: 20 }, { name: 'Audrey', age: 21 }]

entries方法，就是toArray方法，toArray方法里面又调用map方法，map方法就相当于collect方法：

复制代码 代码如下:

$R(1, 5).toArray() // -> [1, 2, 3, 4, 5]

find/findAll（select方法的别名）方法：

复制代码 代码如下:

//find方法
[ 'hello', 'world', 'this', 'is', 'nice'].find(function(s) { return s.length <= 3; })
// -> 'is'
//findAll方法
$R(1, 10).findAll(function(n) { return 0 == n % 2; })
// -> [2, 4, 6, 8, 10] [ 'hello', 'world', 'this', 'is', 'nice'].findAll(function(s) { return s.length >= 5; })
// -> ['hello', 'world']

grep方法：
这个方法需要注意的就是，参数filter在函数里面是要被统一成正则表达式的，然后调用正则表达式的match方法来进行判断

复制代码 代码如下:

// Get all strings with a repeated letter somewhere
['hello', 'world', 'this', 'is', 'cool'].grep(/(.)\1/)
// -> ['hello', 'cool']
// Get all numbers ending with 0 or 5
$R(1,30).grep(/[05]$/)
// -> [5, 10, 15, 20, 25, 30]
// Those, minus 1
$R(1,30).grep(/[05]$/, function(n) { return n - 1; })
// -> [4, 9, 14, 19, 24, 29]
// Get all strings with a repeated letter somewhere
['hello', 'world', 'this', 'is', 'cool'].grep(/(.)\1/)
// -> ['hello', 'cool']
// Get all numbers ending with 0 or 5
$R(1,30).grep(/[05]$/)
// -> [5, 10, 15, 20, 25, 30]
// Those, minus 1
$R(1,30).grep(/[05]$/, function(n) { return n - 1; })
// -> [4, 9, 14, 19, 24, 29]

inGroupsOf方法：

复制代码 代码如下:

var students = [ { name: 'Sunny', age: 20 }, { name: 'Audrey', age: 21 }, { name: 'Matt', age: 20 }, { name: 'Élodie', age: 26 }, { name: 'Will', age: 21 }, { name: 'David', age: 23 }, { name: 'Julien', age: 22 }, { name: 'Thomas', age: 21 }, { name: 'Serpil', age: 22 } ];
//pluck方法就是取得对象的某个属性，这里取得的是name属性
students.pluck('name').inGroupsOf(4)
// -> [ ['Sunny', 'Audrey', 'Matt', 'Élodie'],
// ['Will', 'David', 'Julien', 'Thomas'],
// ['Serpil', null, null, null] ]

include/member（include方法的别名）方法，这里先检查了一下对象上是否有indexOf方法，如果有的话则直接调用这个方法：

复制代码 代码如下:

$R(1,15).include(10)
// -> true
['hello', 'world'].include('HELLO')
// -> false
[1, 2, '3', '4', '5'].include(3)
// -> true (== ignores actual type)

inject方法：

复制代码 代码如下:

$R(1,10).inject(0, function(acc, n) { return acc + n; })
// -> 55 (sum of 1 to 10)
$R(2,5).inject(1, function(acc, n) { return acc * n; })
// -> 120 (factorial 5)
['hello', 'world', 'this', 'is', 'nice'].inject([], function(array, value, index) {
if (0 == index % 2) array.push(value);
return array;
})
// -> ['hello', 'this', 'nice']

invoke方法：

复制代码 代码如下:

['hello', 'world', 'cool!'].invoke('toUpperCase')
// ['HELLO', 'WORLD', 'COOL!']
['hello', 'world', 'cool!'].invoke('substring', 0, 3)
// ['hel', 'wor', 'coo']

max/min方法：

复制代码 代码如下:

$R(1,10).max() // -> 10
['hello', 'world', 'gizmo'].max()
// -> 'world'
function Person(name, age) { this.name = name; this.age = age; }
var john = new Person('John', 20);
var mark = new Person('Mark', 35);
var daisy = new Person('Daisy', 22);
[john, mark, daisy].max(function(person) { return person.age; })
// -> 35

partition方法：

复制代码 代码如下:

['hello', null, 42, false, true, , 17].partition()
// -> [['hello', 42, true, 17], [null, false, undefined]]
$R(1, 10).partition(function(n) { return 0 == n % 2; })
// -> [[2, 4, 6, 8, 10], [1, 3, 5, 7, 9]]
['hello', null, 42, false, true, , 17].partition()
// -> [['hello', 42, true, 17], [null, false, undefined]]
$R(1, 10).partition(function(n) { return 0 == n % 2; })
// -> [[2, 4, 6, 8, 10], [1, 3, 5, 7, 9]]

pluck方法：

复制代码 代码如下:

['hello', 'world', 'this', 'is', 'nice'].pluck('length')
// -> [5, 5, 4, 3, 4]

reject方法：

复制代码 代码如下:

$R(1, 10).reject(function(n) { return 0 == n % 2; })
// -> [1, 3, 5, 7, 9]
[ 'hello', 'world', 'this', 'is', 'nice'].reject(function(s) { return s.length >= 5; })
// -> ['this', 'is', 'nice']
$R(1, 10).reject(function(n) { return 0 == n % 2; })
// -> [1, 3, 5, 7, 9]
[ 'hello', 'world', 'this', 'is', 'nice'].reject(function(s) { return s.length >= 5; })
// -> ['this', 'is', 'nice']

size方法省略。

sortBy方法：
这个方法首先通过map方法返回一个对象数组，然后调用数组的sort方法，最后在取出对象中的value属性

复制代码 代码如下:

['hello', 'world', 'this', 'is', 'nice'].sortBy(function(s) { return s.length; })
// -> 'is', 'this', 'nice', 'hello', 'world']
['hello', 'world', 'this', 'is', 'cool'].sortBy(function(s) {
var md = s.match(/[aeiouy]/g);
return null == md ? 0 : md.length;
})
// -> [ 'world', 'this', 'is', 'hello', 'cool'] (sorted by vowel count)

zip方法：

复制代码 代码如下:

var firstNames = ['Justin', 'Mislav', 'Tobie', 'Christophe'];
var lastNames = ['Palmer', 'Marohnić', 'Langel', 'Porteneuve'];
firstNames.zip(lastNames)
// -> [['Justin', 'Palmer'], ['Mislav', 'Marohnić'], ['Tobie', 'Langel'], ['Christophe', 'Porteneuve']]
//通过这个例子我们可以看出参数a就是一个数组，表示两个数组中的相对应的项
firstNames.zip(lastNames, function(a) { return a.join(' '); })
// -> ['Justin Palmer', 'Mislav Marohnić', 'Tobie Langel', 'Christophe Porteneuve']
//通过这个例子我们可以看到传入的可以是多个数组
var cities = ['Memphis', 'Zagreb', 'Montreal', 'Paris'];
firstNames.zip(lastNames, cities, function(p) { return p[0] + ' ' + p[1] + ', ' + p[2]; })
// -> ['Justin Palmer, Memphis', 'Mislav Marohnić, Zagreb', 'Tobie Langel, Montreal', 'Christophe Porteneuve, Paris']
firstNames.zip($R(1, 100), function(a) { return a.reverse().join('. '); })
// -> ['1. Justin', '2. Mislav', '3. Tobie', '4. Christophe']