模块 Enumerable

这里有什么¶ ↑

模块 Enumerable 为集合类提供了有用的方法，用于

查询方法¶ ↑

这些方法返回关于 Enumerable 的信息，而不是元素本身

member?（别名为 include?）：如果 self == object 则返回 true，否则返回 false。
all?：如果所有元素都满足指定条件则返回 true；否则返回 false。
any?：如果任何元素满足指定条件则返回 true；否则返回 false。
none?：如果没有元素满足指定条件则返回 true；否则返回 false。
one?：如果恰好一个元素满足指定条件则返回 true；否则返回 false。
count：返回元素计数，如果给定，则基于参数或块条件。
tally：返回一个新的 Hash，其中包含每个元素的出现次数计数。

获取方法¶ ↑

这些方法返回 Enumerable 中的条目，而不修改它

开头、结尾或所有元素:

to_a (别名为 entries)：返回所有元素。
first：返回第一个元素或开头元素。
take：返回指定数量的开头元素。
drop：返回指定数量的结尾元素。
take_while：返回由给定块指定的开头元素。
drop_while：返回由给定块指定的结尾元素。

最小值和最大值元素:

min：返回其值在元素中最小的元素，由 <=> 或给定块确定。
max：返回其值在元素中最大的元素，由 <=> 或给定块确定。
minmax：返回一个包含最小和最大元素的 2 元素 Array。
min_by：返回最小元素，由给定块确定。
max_by：返回最大元素，由给定块确定。
minmax_by：返回最小和最大元素，由给定块确定。

组、切片和分区:

group_by：返回一个将元素划分为组的 Hash。
partition：返回根据给定块分成两个新数组的元素。
slice_after：返回一个新的 Enumerator，其条目是 self 的分区，基于给定的 object 或给定的块。
slice_before：返回一个新的 Enumerator，其条目是 self 的分区，基于给定的 object 或给定的块。
slice_when：返回一个新的 Enumerator，其条目是基于给定块的 self 的分区。
chunk：返回根据给定块指定的方式组织成块的元素。
chunk_while：返回根据给定块指定的方式组织成块的元素。

搜索和过滤方法¶ ↑

这些方法返回满足指定条件的元素

find（别名为 detect）：返回由块选择的元素。
find_all（别名为 filter、select）：返回由块选择的元素。
find_index：返回由给定对象或块选择的元素的索引。
reject：返回未被块拒绝的元素。
uniq：返回不是重复的元素。

排序方法¶ ↑

这些方法返回已排序的元素

sort：返回元素，按 <=> 或给定块排序。
sort_by：返回元素，按给定块排序。

迭代方法¶ ↑

each_entry：使用每个连续的元素调用块（与 each 略有不同）。
each_with_index：使用每个连续的元素及其索引调用块。
each_with_object：使用每个连续的元素和给定对象调用块。
each_slice：使用连续的不重叠切片调用块。
each_cons：使用连续的重叠切片调用块。（与 each_slice 不同）。
reverse_each：以相反的顺序使用每个连续的元素调用块。

其他方法¶ ↑

collect（别名为 map）：返回由块返回的对象。
filter_map：返回由块返回的真值对象。
flat_map（别名为 collect_concat）：返回由块返回的展平的对象。
grep：返回由给定对象或由给定块返回的对象选择的元素。
grep_v：返回由给定对象或由给定块返回的对象选择的元素。
inject（别名为 reduce）：返回通过组合所有元素形成的对象。
sum：返回元素的总和，使用方法 +。
zip：将每个元素与其他可枚举对象中的元素组合；返回 n 元组或使用每个元组调用块。
cycle：使用每个元素调用块，重复循环。

用法¶ ↑

要在集合类中使用模块 Enumerable

包含它
```
include Enumerable
```
实现方法 each，它必须产生集合的连续元素。该方法将由几乎所有 Enumerable 方法调用。

示例

class Foo
  include Enumerable
  def each
    yield 1
    yield 1, 2
    yield
  end
end
Foo.new.each_entry{ |element| p element }

输出

1
[1, 2]
nil

Ruby 类中的 Enumerable¶ ↑

这些 Ruby 核心类包含（或扩展）Enumerable

这些 Ruby 标准库类包含 Enumerable

CSV
CSV::Table
CSV::Row
Set

Enumerable 中的几乎所有方法都调用包含类中的方法 each

Hash#each 将下一个键值对作为 2 元素 Array 产生。
Struct#each 将下一个名称值对作为 2 元素 Array 产生。
对于上面的其他类，each 从集合中产生下一个对象。

关于示例¶ ↑

Enumerable 方法的示例代码片段

始终显示一个或多个类似数组的类（通常是 Array 本身）的用法。
有时会显示类似 Hash 的类的用法。但是，对于某些方法，用法没有意义，因此不显示。示例：tally 将会找到每个 Hash 条目的恰好一个。

公共实例方法

all? → true 或 false

all?(pattern) → true 或 false

all? {|element| ... } → true 或 false

来源

static VALUE
enum_all(int argc, VALUE *argv, VALUE obj)
{
    struct MEMO *memo = MEMO_ENUM_NEW(Qtrue);
    WARN_UNUSED_BLOCK(argc);
    ENUM_BLOCK_CALL(all);
    return memo->v1;
}

返回是否每个元素都满足给定条件。

如果 self 没有元素，则返回 true 并且不使用参数或块。

如果没有参数且没有块，则返回是否每个元素都是真值

(1..4).all?           # => true
%w[a b c d].all?      # => true
[1, 2, nil].all?      # => false
['a','b', false].all? # => false
[].all?               # => true

如果带有参数 pattern 且没有块，则返回是否对于每个元素 element，pattern === element

(1..4).all?(Integer)                 # => true
(1..4).all?(Numeric)                 # => true
(1..4).all?(Float)                   # => false
%w[bar baz bat bam].all?(/ba/)       # => true
%w[bar baz bat bam].all?(/bar/)      # => false
%w[bar baz bat bam].all?('ba')       # => false
{foo: 0, bar: 1, baz: 2}.all?(Array) # => true
{foo: 0, bar: 1, baz: 2}.all?(Hash)  # => false
[].all?(Integer)                     # => true

如果给定了代码块，则返回该代码块对于每个元素是否都返回真值。

(1..4).all? {|element| element < 5 }                    # => true
(1..4).all? {|element| element < 4 }                    # => false
{foo: 0, bar: 1, baz: 2}.all? {|key, value| value < 3 } # => true
{foo: 0, bar: 1, baz: 2}.all? {|key, value| value < 2 } # => false

相关方法：any?、none?、one?。

any? → true 或 false

any?(pattern) → true 或 false

any? {|element| ... } → true 或 false

来源

static VALUE
enum_any(int argc, VALUE *argv, VALUE obj)
{
    struct MEMO *memo = MEMO_ENUM_NEW(Qfalse);
    WARN_UNUSED_BLOCK(argc);
    ENUM_BLOCK_CALL(any);
    return memo->v1;
}

返回是否任何元素满足给定条件。

如果 self 没有元素，则返回 false，并且不使用参数或代码块。

如果没有参数且没有代码块，则返回是否任何元素为真值。

(1..4).any?          # => true
%w[a b c d].any?     # => true
[1, false, nil].any? # => true
[].any?              # => false

如果给定参数 pattern 且没有代码块，则返回对于任何元素 element，pattern === element 是否成立。

[nil, false, 0].any?(Integer)        # => true
[nil, false, 0].any?(Numeric)        # => true
[nil, false, 0].any?(Float)          # => false
%w[bar baz bat bam].any?(/m/)        # => true
%w[bar baz bat bam].any?(/foo/)      # => false
%w[bar baz bat bam].any?('ba')       # => false
{foo: 0, bar: 1, baz: 2}.any?(Array) # => true
{foo: 0, bar: 1, baz: 2}.any?(Hash)  # => false
[].any?(Integer)                     # => false

如果给定了代码块，则返回该代码块对于任何元素是否返回真值。

(1..4).any? {|element| element < 2 }                    # => true
(1..4).any? {|element| element < 1 }                    # => false
{foo: 0, bar: 1, baz: 2}.any? {|key, value| value < 1 } # => true
{foo: 0, bar: 1, baz: 2}.any? {|key, value| value < 0 } # => false

相关方法：all?、none?、one?。

chain(*enums) → enumerator

来源

static VALUE
enum_chain(int argc, VALUE *argv, VALUE obj)
{
    VALUE enums = rb_ary_new_from_values(1, &obj);
    rb_ary_cat(enums, argv, argc);
    return new_enum_chain(enums);
}

返回由此枚举器和给定可枚举对象生成的枚举器对象。

e = (1..3).chain([4, 5])
e.to_a #=> [1, 2, 3, 4, 5]

chunk {|array| ... } → enumerator

来源

static VALUE
enum_chunk(VALUE enumerable)
{
    VALUE enumerator;

    RETURN_SIZED_ENUMERATOR(enumerable, 0, 0, enum_size);

    enumerator = rb_obj_alloc(rb_cEnumerator);
    rb_ivar_set(enumerator, id_chunk_enumerable, enumerable);
    rb_ivar_set(enumerator, id_chunk_categorize, rb_block_proc());
    rb_block_call(enumerator, idInitialize, 0, 0, chunk_i, enumerator);
    return enumerator;
}

返回的枚举器中的每个元素都是一个包含 2 个元素的数组，其中包括：

代码块返回的值。
一个数组（“块”），其中包含返回该值的元素，以及代码块返回相同值的所有后续元素。

因此：

每个与前一个不同的代码块返回值都会开始一个新的块。
每个与前一个相同的代码块返回值都会继续相同的块。

示例

e = (0..10).chunk {|i| (i / 3).floor } # => #<Enumerator: ...>
# The enumerator elements.
e.next # => [0, [0, 1, 2]]
e.next # => [1, [3, 4, 5]]
e.next # => [2, [6, 7, 8]]
e.next # => [3, [9, 10]]

方法 chunk 对于已经排序的可枚举对象特别有用。此示例计算一个大型单词数组中每个首字母的单词数。

# Get sorted words from a web page.
url = 'https://raw.githubusercontent.com/eneko/data-repository/master/data/words.txt'
words = URI::open(url).readlines
# Make chunks, one for each letter.
e = words.chunk {|word| word.upcase[0] } # => #<Enumerator: ...>
# Display 'A' through 'F'.
e.each {|c, words| p [c, words.length]; break if c == 'F' }

输出

["A", 17096]
["B", 11070]
["C", 19901]
["D", 10896]
["E", 8736]
["F", 6860]

你可以使用特殊符号 :_alone 来强制将一个元素放入其自身的单独块中。

a = [0, 0, 1, 1]
e = a.chunk{|i| i.even? ? :_alone : true }
e.to_a # => [[:_alone, [0]], [:_alone, [0]], [true, [1, 1]]]

例如，你可以将每个包含 URL 的行放入其自身的块中。

pattern = /http/
open(filename) { |f|
  f.chunk { |line| line =~ pattern ? :_alone : true }.each { |key, lines|
    pp lines
  }
}

你可以使用特殊符号 :_separator 或 nil 来强制忽略一个元素（不包含在任何块中）。

a = [0, 0, -1, 1, 1]
e = a.chunk{|i| i < 0 ? :_separator : true }
e.to_a # => [[true, [0, 0]], [true, [1, 1]]]

请注意，分隔符会结束该块。

a = [0, 0, -1, 1, -1, 1]
e = a.chunk{|i| i < 0 ? :_separator : true }
e.to_a # => [[true, [0, 0]], [true, [1]], [true, [1]]]

例如，可以按如下方式消除 svn 日志中的连字符序列。

sep = "-"*72 + "\n"
IO.popen("svn log README") { |f|
  f.chunk { |line|
    line != sep || nil
  }.each { |_, lines|
    pp lines
  }
}
#=> ["r20018 | knu | 2008-10-29 13:20:42 +0900 (Wed, 29 Oct 2008) | 2 lines\n",
#    "\n",
#    "* README, README.ja: Update the portability section.\n",
#    "\n"]
#   ["r16725 | knu | 2008-05-31 23:34:23 +0900 (Sat, 31 May 2008) | 2 lines\n",
#    "\n",
#    "* README, README.ja: Add a note about default C flags.\n",
#    "\n"]
#   ...

可以用以下方式解析以空行分隔的段落。

File.foreach("README").chunk { |line|
  /\A\s*\z/ !~ line || nil
}.each { |_, lines|
  pp lines
}

chunk_while {|elt_before, elt_after| bool } → an_enumerator

来源

static VALUE
enum_chunk_while(VALUE enumerable)
{
    VALUE enumerator;
    VALUE pred;

    pred = rb_block_proc();

    enumerator = rb_obj_alloc(rb_cEnumerator);
    rb_ivar_set(enumerator, id_slicewhen_enum, enumerable);
    rb_ivar_set(enumerator, id_slicewhen_pred, pred);
    rb_ivar_set(enumerator, id_slicewhen_inverted, Qtrue);

    rb_block_call(enumerator, idInitialize, 0, 0, slicewhen_i, enumerator);
    return enumerator;
}

为每个分块的元素创建一个枚举器。块的开始由代码块定义。

此方法使用接收器枚举器中的相邻元素 elt_before 和 elt_after 分割每个块。此方法在代码块返回 false 的 elt_before 和 elt_after 之间分割块。

代码块的调用次数为接收器枚举器的长度减 1。

结果枚举器将分块的元素作为数组产生。因此可以按如下方式调用 each 方法。

enum.chunk_while { |elt_before, elt_after| bool }.each { |ary| ... }

还可以使用 Enumerator 类和 Enumerable 模块的其他方法，例如 to_a、map 等。

例如，可以按如下方式对逐个递增的子序列进行分块。

a = [1,2,4,9,10,11,12,15,16,19,20,21]
b = a.chunk_while {|i, j| i+1 == j }
p b.to_a #=> [[1, 2], [4], [9, 10, 11, 12], [15, 16], [19, 20, 21]]
c = b.map {|a| a.length < 3 ? a : "#{a.first}-#{a.last}" }
p c #=> [[1, 2], [4], "9-12", [15, 16], "19-21"]
d = c.join(",")
p d #=> "1,2,4,9-12,15,16,19-21"

可以按如下方式对递增（非递减）子序列进行分块。

a = [0, 9, 2, 2, 3, 2, 7, 5, 9, 5]
p a.chunk_while {|i, j| i <= j }.to_a
#=> [[0, 9], [2, 2, 3], [2, 7], [5, 9], [5]]

可以按如下方式对相邻的偶数和奇数进行分块：（Enumerable#chunk 是另一种方法。）

a = [7, 5, 9, 2, 0, 7, 9, 4, 2, 0]
p a.chunk_while {|i, j| i.even? == j.even? }.to_a
#=> [[7, 5, 9], [2, 0], [7, 9], [4, 2, 0]]

Enumerable#slice_when 的作用相同，只不过是在代码块返回 true 时进行分割，而不是 false。

collect

来源

别名：map

collect_concat

别名：flat_map

compact → array

来源

static VALUE
enum_compact(VALUE obj)
{
    VALUE ary;

    ary = rb_ary_new();
    rb_block_call(obj, id_each, 0, 0, compact_i, ary);

    return ary;
}

返回包含所有非 nil 元素的数组。

a = [nil, 0, nil, 'a', false, nil, false, nil, 'a', nil, 0, nil]
a.compact # => [0, "a", false, false, "a", 0]

count → integer

count(object) → integer

count {|element| ... } → integer

来源

static VALUE
enum_count(int argc, VALUE *argv, VALUE obj)
{
    VALUE item = Qnil;
    struct MEMO *memo;
    rb_block_call_func *func;

    if (argc == 0) {
        if (rb_block_given_p()) {
            func = count_iter_i;
        }
        else {
            func = count_all_i;
        }
    }
    else {
        rb_scan_args(argc, argv, "1", &item);
        if (rb_block_given_p()) {
            rb_warn("given block not used");
        }
        func = count_i;
    }

    memo = MEMO_NEW(item, 0, 0);
    rb_block_call(obj, id_each, 0, 0, func, (VALUE)memo);
    return imemo_count_value(memo);
}

返回基于给定参数或代码块条件的元素计数。

如果没有给定参数且没有代码块，则返回元素数量。

[0, 1, 2].count                # => 3
{foo: 0, bar: 1, baz: 2}.count # => 3

如果给定参数 object，则返回与 object == 的元素数量。

[0, 1, 2, 1].count(1)           # => 2

如果给定了代码块，则使用每个元素调用该代码块，并返回代码块返回真值的元素数量。

[0, 1, 2, 3].count {|element| element < 2}              # => 2
{foo: 0, bar: 1, baz: 2}.count {|key, value| value < 2} # => 2

cycle(n = nil) {|element| ...} → nil

cycle(n = nil) → enumerator

来源

static VALUE
enum_cycle(int argc, VALUE *argv, VALUE obj)
{
    VALUE ary;
    VALUE nv = Qnil;
    long n, i, len;

    rb_check_arity(argc, 0, 1);

    RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_cycle_size);
    if (!argc || NIL_P(nv = argv[0])) {
        n = -1;
    }
    else {
        n = NUM2LONG(nv);
        if (n <= 0) return Qnil;
    }
    ary = rb_ary_new();
    RBASIC_CLEAR_CLASS(ary);
    rb_block_call(obj, id_each, 0, 0, cycle_i, ary);
    len = RARRAY_LEN(ary);
    if (len == 0) return Qnil;
    while (n < 0 || 0 < --n) {
        for (i=0; i<len; i++) {
            enum_yield_array(RARRAY_AREF(ary, i));
        }
    }
    return Qnil;
}

当使用正整数参数 n 和代码块调用时，将使用每个元素调用该代码块，然后再次调用，直到执行 n 次；返回 nil。

a = []
(1..4).cycle(3) {|element| a.push(element) } # => nil
a # => [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]
a = []
('a'..'d').cycle(2) {|element| a.push(element) }
a # => ["a", "b", "c", "d", "a", "b", "c", "d"]
a = []
{foo: 0, bar: 1, baz: 2}.cycle(2) {|element| a.push(element) }
a # => [[:foo, 0], [:bar, 1], [:baz, 2], [:foo, 0], [:bar, 1], [:baz, 2]]

如果计数为零或负数，则不调用该代码块。

当使用代码块调用且 n 为 nil 时，将无限循环。

如果没有给定代码块，则返回 Enumerator。

detect

别名：find

drop(n) → array

来源

static VALUE
enum_drop(VALUE obj, VALUE n)
{
    VALUE result;
    struct MEMO *memo;
    long len = NUM2LONG(n);

    if (len < 0) {
        rb_raise(rb_eArgError, "attempt to drop negative size");
    }

    result = rb_ary_new();
    memo = MEMO_NEW(result, 0, len);
    rb_block_call(obj, id_each, 0, 0, drop_i, (VALUE)memo);
    return result;
}

对于正整数 n，返回包含除前 n 个元素之外的所有元素的数组。

r = (1..4)
r.drop(3)  # => [4]
r.drop(2)  # => [3, 4]
r.drop(1)  # => [2, 3, 4]
r.drop(0)  # => [1, 2, 3, 4]
r.drop(50) # => []

h = {foo: 0, bar: 1, baz: 2, bat: 3}
h.drop(2) # => [[:baz, 2], [:bat, 3]]

drop_while {|element| ... } → array

drop_while → enumerator

来源

static VALUE
enum_drop_while(VALUE obj)
{
    VALUE result;
    struct MEMO *memo;

    RETURN_ENUMERATOR(obj, 0, 0);
    result = rb_ary_new();
    memo = MEMO_NEW(result, 0, FALSE);
    rb_block_call(obj, id_each, 0, 0, drop_while_i, (VALUE)memo);
    return result;
}

只要代码块返回真值，就会使用连续的元素调用该代码块；返回该点之后的所有元素的数组。

(1..4).drop_while{|i| i < 3 } # => [3, 4]
h = {foo: 0, bar: 1, baz: 2}
a = h.drop_while{|element| key, value = *element; value < 2 }
a # => [[:baz, 2]]

如果没有给定代码块，则返回 Enumerator。

each_cons(n) { ... } → self

each_cons(n) → enumerator

来源

static VALUE
enum_each_cons(VALUE obj, VALUE n)
{
    long size = NUM2LONG(n);
    struct MEMO *memo;
    int arity;

    if (size <= 0) rb_raise(rb_eArgError, "invalid size");
    RETURN_SIZED_ENUMERATOR(obj, 1, &n, enum_each_cons_size);
    arity = rb_block_arity();
    if (enum_size_over_p(obj, size)) return obj;
    memo = MEMO_NEW(rb_ary_new2(size), dont_recycle_block_arg(arity), size);
    rb_block_call(obj, id_each, 0, 0, each_cons_i, (VALUE)memo);

    return obj;
}

使用每个连续的重叠 n 元组的元素调用代码块；返回 self。

a = []
(1..5).each_cons(3) {|element| a.push(element) }
a # => [[1, 2, 3], [2, 3, 4], [3, 4, 5]]

a = []
h = {foo: 0,  bar: 1, baz: 2, bam: 3}
h.each_cons(2) {|element| a.push(element) }
a # => [[[:foo, 0], [:bar, 1]], [[:bar, 1], [:baz, 2]], [[:baz, 2], [:bam, 3]]]

如果没有给定代码块，则返回 Enumerator。

each_entry(*args) {|element| ... } → self

each_entry(*args) → enumerator

来源

static VALUE
enum_each_entry(int argc, VALUE *argv, VALUE obj)
{
    RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_size);
    rb_block_call(obj, id_each, argc, argv, each_val_i, 0);
    return obj;
}

使用每个元素调用给定的代码块，将 yield 的多个值转换为一个数组；返回 self。

a = []
(1..4).each_entry {|element| a.push(element) } # => 1..4
a # => [1, 2, 3, 4]

a = []
h = {foo: 0, bar: 1, baz:2}
h.each_entry {|element| a.push(element) }
# => {:foo=>0, :bar=>1, :baz=>2}
a # => [[:foo, 0], [:bar, 1], [:baz, 2]]

class Foo
  include Enumerable
  def each
    yield 1
    yield 1, 2
    yield
  end
end
Foo.new.each_entry {|yielded| p yielded }

输出

1
[1, 2]
nil

如果没有给定代码块，则返回 Enumerator。

each_slice(n) { ... } → self

each_slice(n) → enumerator

来源

static VALUE
enum_each_slice(VALUE obj, VALUE n)
{
    long size = NUM2LONG(n);
    VALUE ary;
    struct MEMO *memo;
    int arity;

    if (size <= 0) rb_raise(rb_eArgError, "invalid slice size");
    RETURN_SIZED_ENUMERATOR(obj, 1, &n, enum_each_slice_size);
    size = limit_by_enum_size(obj, size);
    ary = rb_ary_new2(size);
    arity = rb_block_arity();
    memo = MEMO_NEW(ary, dont_recycle_block_arg(arity), size);
    rb_block_call(obj, id_each, 0, 0, each_slice_i, (VALUE)memo);
    ary = memo->v1;
    if (RARRAY_LEN(ary) > 0) rb_yield(ary);

    return obj;
}

使用每个连续的不相交 n 元组的元素调用代码块；返回 self。

a = []
(1..10).each_slice(3) {|tuple| a.push(tuple) }
a # => [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]

a = []
h = {foo: 0, bar: 1, baz: 2, bat: 3, bam: 4}
h.each_slice(2) {|tuple| a.push(tuple) }
a # => [[[:foo, 0], [:bar, 1]], [[:baz, 2], [:bat, 3]], [[:bam, 4]]]

如果没有给定代码块，则返回 Enumerator。

each_with_index(*args) {|element, i| ..... } → self

each_with_index(*args) → enumerator

来源

static VALUE
enum_each_with_index(int argc, VALUE *argv, VALUE obj)
{
    RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_size);

    rb_block_call(obj, id_each, argc, argv, each_with_index_i, INT2FIX(0));
    return obj;
}

使用 *args 调用 self.each。如果给定代码块，则该代码块接收每个元素及其索引；返回 self。

h = {}
(1..4).each_with_index {|element, i| h[element] = i } # => 1..4
h # => {1=>0, 2=>1, 3=>2, 4=>3}

h = {}
%w[a b c d].each_with_index {|element, i| h[element] = i }
# => ["a", "b", "c", "d"]
h # => {"a"=>0, "b"=>1, "c"=>2, "d"=>3}

a = []
h = {foo: 0, bar: 1, baz: 2}
h.each_with_index {|element, i| a.push([i, element]) }
# => {:foo=>0, :bar=>1, :baz=>2}
a # => [[0, [:foo, 0]], [1, [:bar, 1]], [2, [:baz, 2]]]

如果没有给定代码块，则返回 Enumerator。

each_with_object(object) { |(*args), memo_object| ... } → object

each_with_object(object) → enumerator

来源

static VALUE
enum_each_with_object(VALUE obj, VALUE memo)
{
    RETURN_SIZED_ENUMERATOR(obj, 1, &memo, enum_size);

    rb_block_call(obj, id_each, 0, 0, each_with_object_i, memo);

    return memo;
}

对于每个元素，调用代码块一次，传递该元素和给定的对象。

(1..4).each_with_object([]) {|i, a| a.push(i**2) }
# => [1, 4, 9, 16]

{foo: 0, bar: 1, baz: 2}.each_with_object({}) {|(k, v), h| h[v] = k }
# => {0=>:foo, 1=>:bar, 2=>:baz}

如果没有给定代码块，则返回 Enumerator。

entries

别名：to_a

filter

别名：find_all

filter_map {|element| ... } → array

filter_map → enumerator

来源

static VALUE
enum_filter_map(VALUE obj)
{
    VALUE ary;

    RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);

    ary = rb_ary_new();
    rb_block_call(obj, id_each, 0, 0, filter_map_i, ary);

    return ary;
}

返回一个包含代码块返回的真值的数组。

如果给定了代码块，则使用连续的元素调用该代码块；返回一个包含代码块返回的每个真值的数组。

(0..9).filter_map {|i| i * 2 if i.even? }                              # => [0, 4, 8, 12, 16]
{foo: 0, bar: 1, baz: 2}.filter_map {|key, value| key if value.even? } # => [:foo, :baz]

如果没有给定代码块，则返回 Enumerator。

find(if_none_proc = nil) {|element| ... } → object 或 nil

find(if_none_proc = nil) → enumerator

来源

static VALUE
enum_find(int argc, VALUE *argv, VALUE obj)
{
    struct MEMO *memo;
    VALUE if_none;

    if_none = rb_check_arity(argc, 0, 1) ? argv[0] : Qnil;
    RETURN_ENUMERATOR(obj, argc, argv);
    memo = MEMO_NEW(Qundef, 0, 0);
    if (rb_block_pair_yield_optimizable())
        rb_block_call2(obj, id_each, 0, 0, find_i_fast, (VALUE)memo, RB_BLOCK_NO_USE_PACKED_ARGS);
    else
        rb_block_call2(obj, id_each, 0, 0, find_i, (VALUE)memo, RB_BLOCK_NO_USE_PACKED_ARGS);
    if (memo->u3.cnt) {
        return memo->v1;
    }
    if (!NIL_P(if_none)) {
        return rb_funcallv(if_none, id_call, 0, 0);
    }
    return Qnil;
}

返回代码块返回真值的第一个元素。

如果给定了代码块，则使用集合的连续元素调用该代码块；返回代码块返回真值的第一个元素。

(0..9).find {|element| element > 2}                # => 3

如果没有找到此类元素，则调用 if_none_proc 并返回其返回值。

(0..9).find(proc {false}) {|element| element > 12} # => false
{foo: 0, bar: 1, baz: 2}.find {|key, value| key.start_with?('b') }            # => [:bar, 1]
{foo: 0, bar: 1, baz: 2}.find(proc {[]}) {|key, value| key.start_with?('c') } # => []

如果没有给定代码块，则返回 Enumerator。

别名：detect

find_all

来源

别名：select、filter

find_index(object) → integer 或 nil

find_index {|element| ... } → integer 或 nil

find_index → enumerator

来源

static VALUE
enum_find_index(int argc, VALUE *argv, VALUE obj)
{
    struct MEMO *memo;  /* [return value, current index, ] */
    VALUE condition_value = Qnil;
    rb_block_call_func *func;

    if (argc == 0) {
        RETURN_ENUMERATOR(obj, 0, 0);
        func = find_index_iter_i;
    }
    else {
        rb_scan_args(argc, argv, "1", &condition_value);
        if (rb_block_given_p()) {
            rb_warn("given block not used");
        }
        func = find_index_i;
    }

    memo = MEMO_NEW(Qnil, condition_value, 0);
    rb_block_call(obj, id_each, 0, 0, func, (VALUE)memo);
    return memo->v1;
}

返回满足指定条件的第一个元素的索引，如果未找到此类元素，则返回 nil。

如果给定参数 object，则返回第一个 == object 的元素的索引。

['a', 'b', 'c', 'b'].find_index('b') # => 1

如果给定了代码块，则使用连续的元素调用该代码块；返回代码块返回真值的第一个元素。

['a', 'b', 'c', 'b'].find_index {|element| element.start_with?('b') } # => 1
{foo: 0, bar: 1, baz: 2}.find_index {|key, value| value > 1 }         # => 2

如果没有给定参数且没有代码块，则返回 Enumerator。

first → element 或 nil

first(n) → array

来源

static VALUE
enum_first(int argc, VALUE *argv, VALUE obj)
{
    struct MEMO *memo;
    rb_check_arity(argc, 0, 1);
    if (argc > 0) {
        return enum_take(obj, argv[0]);
    }
    else {
        memo = MEMO_NEW(Qnil, 0, 0);
        rb_block_call(obj, id_each, 0, 0, first_i, (VALUE)memo);
        return memo->v1;
    }
}

返回第一个元素或多个元素。

如果没有参数，则返回第一个元素，如果没有，则返回 nil。

(1..4).first                   # => 1
%w[a b c].first                # => "a"
{foo: 1, bar: 1, baz: 2}.first # => [:foo, 1]
[].first                       # => nil

如果给定整数参数 n，则返回一个包含存在的头 n 个元素的数组。

(1..4).first(2)                   # => [1, 2]
%w[a b c d].first(3)              # => ["a", "b", "c"]
%w[a b c d].first(50)             # => ["a", "b", "c", "d"]
{foo: 1, bar: 1, baz: 2}.first(2) # => [[:foo, 1], [:bar, 1]]
[].first(2)                       # => []

flat_map {|element| ... } → array

flat_map → enumerator

来源

static VALUE
enum_flat_map(VALUE obj)
{
    VALUE ary;

    RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);

    ary = rb_ary_new();
    rb_block_call(obj, id_each, 0, 0, flat_map_i, ary);

    return ary;
}

返回由代码块返回的扁平化对象的数组。

如果给定了代码块，则使用连续的元素调用该代码块；返回由代码块返回的扁平化对象数组。

[0, 1, 2, 3].flat_map {|element| -element }                    # => [0, -1, -2, -3]
[0, 1, 2, 3].flat_map {|element| [element, -element] }         # => [0, 0, 1, -1, 2, -2, 3, -3]
[[0, 1], [2, 3]].flat_map {|e| e + [100] }                     # => [0, 1, 100, 2, 3, 100]
{foo: 0, bar: 1, baz: 2}.flat_map {|key, value| [key, value] } # => [:foo, 0, :bar, 1, :baz, 2]

如果没有给定代码块，则返回 Enumerator。

别名：collect_concat。

别名：collect_concat

grep(pattern) → array

grep(pattern) {|element| ... } → array

来源

static VALUE
enum_grep(VALUE obj, VALUE pat)
{
    return enum_grep0(obj, pat, Qtrue);
}

返回基于与给定模式匹配的 self 元素的数组。

如果没有给定代码块，则返回一个包含 pattern === element 为 true 的每个元素的数组。

a = ['foo', 'bar', 'car', 'moo']
a.grep(/ar/)                   # => ["bar", "car"]
(1..10).grep(3..8)             # => [3, 4, 5, 6, 7, 8]
['a', 'b', 0, 1].grep(Integer) # => [0, 1]

如果给定了代码块，则使用每个匹配的元素调用该代码块，并返回一个包含代码块返回的每个对象的数组。

a = ['foo', 'bar', 'car', 'moo']
a.grep(/ar/) {|element| element.upcase } # => ["BAR", "CAR"]

示例¶ ↑

以下程序查找毕达哥拉斯三元组

def pythagorean_triples
  (1..Float::INFINITY).lazy.flat_map {|z|
    (1..z).flat_map {|x|
      (x..z).select {|y|
        x**2 + y**2 == z**2
      }.map {|y|
        [x, y, z]
      }
    }
  }
end
# show first ten pythagorean triples
p pythagorean_triples.take(10).force # take is lazy, so force is needed
p pythagorean_triples.first(10)      # first is eager
# show pythagorean triples less than 100
p pythagorean_triples.take_while { |*, z| z < 100 }.force

map {|element| ... } → array

map → enumerator

返回由代码块返回的对象组成的数组。

在给定代码块的情况下，使用连续的元素调用代码块；返回由代码块返回的对象组成的数组

(0..4).map {|i| i*i }                               # => [0, 1, 4, 9, 16]
{foo: 0, bar: 1, baz: 2}.map {|key, value| value*2} # => [0, 2, 4]

如果没有给定代码块，则返回 Enumerator。

别名为： collect

max → element

max(n) → array

max {|a, b| ... } → element

max(n) {|a, b| ... } → array

来源

static VALUE
enum_max(int argc, VALUE *argv, VALUE obj)
{
    VALUE memo;
    struct max_t *m = NEW_MEMO_FOR(struct max_t, memo);
    VALUE result;
    VALUE num;

    if (rb_check_arity(argc, 0, 1) && !NIL_P(num = argv[0]))
       return rb_nmin_run(obj, num, 0, 1, 0);

    m->max = Qundef;
    if (rb_block_given_p()) {
        rb_block_call(obj, id_each, 0, 0, max_ii, (VALUE)memo);
    }
    else {
        rb_block_call(obj, id_each, 0, 0, max_i, (VALUE)memo);
    }
    result = m->max;
    if (UNDEF_P(result)) return Qnil;
    return result;
}

根据给定的标准返回具有最大值的元素。相等元素的顺序是不确定的，并且可能不稳定。

如果没有参数且没有代码块，则返回最大元素，使用元素自己的方法 <=> 进行比较

(1..4).max                   # => 4
(-4..-1).max                 # => -1
%w[d c b a].max              # => "d"
{foo: 0, bar: 1, baz: 2}.max # => [:foo, 0]
[].max                       # => nil

如果给定了正整数参数 n，并且没有代码块，则返回一个包含存在的前 n 个最大元素的数组

(1..4).max(2)                   # => [4, 3]
(-4..-1).max(2)                # => [-1, -2]
%w[d c b a].max(2)              # => ["d", "c"]
{foo: 0, bar: 1, baz: 2}.max(2) # => [[:foo, 0], [:baz, 2]]
[].max(2)                       # => []

如果给定了代码块，则代码块确定最大元素。使用两个元素 a 和 b 调用代码块，并且必须返回

如果 a < b，则为负整数。
如果 a == b，则为零。
如果 a > b，则为正整数。

如果给定了代码块且没有参数，则返回由代码块确定的最大元素

%w[xxx x xxxx xx].max {|a, b| a.size <=> b.size } # => "xxxx"
h = {foo: 0, bar: 1, baz: 2}
h.max {|pair1, pair2| pair1[1] <=> pair2[1] }     # => [:baz, 2]
[].max {|a, b| a <=> b }                          # => nil

如果给定了代码块且给定了正整数参数 n，则返回一个包含由代码块确定的存在的前 n 个最大元素的数组。

%w[xxx x xxxx xx].max(2) {|a, b| a.size <=> b.size } # => ["xxxx", "xxx"]
h = {foo: 0, bar: 1, baz: 2}
h.max(2) {|pair1, pair2| pair1[1] <=> pair2[1] }
# => [[:baz, 2], [:bar, 1]]
[].max(2) {|a, b| a <=> b }                          # => []

相关： min，minmax，max_by。

max_by {|element| ... } → element

max_by(n) {|element| ... } → array

max_by → enumerator

max_by(n) → enumerator

来源

static VALUE
enum_max_by(int argc, VALUE *argv, VALUE obj)
{
    struct MEMO *memo;
    VALUE num;

    rb_check_arity(argc, 0, 1);

    RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_size);

    if (argc && !NIL_P(num = argv[0]))
        return rb_nmin_run(obj, num, 1, 1, 0);

    memo = MEMO_NEW(Qundef, Qnil, 0);
    rb_block_call(obj, id_each, 0, 0, max_by_i, (VALUE)memo);
    return memo->v2;
}

返回代码块返回最大值的元素。

如果给定了代码块且没有参数，则返回代码块返回最大值的元素

(1..4).max_by {|element| -element }                    # => 1
%w[a b c d].max_by {|element| -element.ord }           # => "a"
{foo: 0, bar: 1, baz: 2}.max_by {|key, value| -value } # => [:foo, 0]
[].max_by {|element| -element }                        # => nil

如果给定了代码块且给定了正整数参数 n，则返回一个包含代码块返回最大值的 n 个元素的数组

(1..4).max_by(2) {|element| -element }
# => [1, 2]
%w[a b c d].max_by(2) {|element| -element.ord }
# => ["a", "b"]
{foo: 0, bar: 1, baz: 2}.max_by(2) {|key, value| -value }
# => [[:foo, 0], [:bar, 1]]
[].max_by(2) {|element| -element }
# => []

如果没有给出代码块，则返回 Enumerator。

相关： max，minmax，min_by。

member?

来源

也别名为： include?

min → element

min(n) → array

min {|a, b| ... } → element

min(n) {|a, b| ... } → array

来源

static VALUE
enum_min(int argc, VALUE *argv, VALUE obj)
{
    VALUE memo;
    struct min_t *m = NEW_MEMO_FOR(struct min_t, memo);
    VALUE result;
    VALUE num;

    if (rb_check_arity(argc, 0, 1) && !NIL_P(num = argv[0]))
       return rb_nmin_run(obj, num, 0, 0, 0);

    m->min = Qundef;
    if (rb_block_given_p()) {
        rb_block_call(obj, id_each, 0, 0, min_ii, memo);
    }
    else {
        rb_block_call(obj, id_each, 0, 0, min_i, memo);
    }
    result = m->min;
    if (UNDEF_P(result)) return Qnil;
    return result;
}

根据给定的标准返回具有最小值的元素。相等元素的顺序是不确定的，并且可能不稳定。

如果没有参数且没有代码块，则返回最小元素，使用元素自己的方法 <=> 进行比较

(1..4).min                   # => 1
(-4..-1).min                 # => -4
%w[d c b a].min              # => "a"
{foo: 0, bar: 1, baz: 2}.min # => [:bar, 1]
[].min                       # => nil

如果给定了正整数参数 n，并且没有代码块，则返回一个包含存在的前 n 个最小元素的数组

(1..4).min(2)                   # => [1, 2]
(-4..-1).min(2)                 # => [-4, -3]
%w[d c b a].min(2)              # => ["a", "b"]
{foo: 0, bar: 1, baz: 2}.min(2) # => [[:bar, 1], [:baz, 2]]
[].min(2)                       # => []

如果给定了代码块，则代码块确定最小元素。使用两个元素 a 和 b 调用代码块，并且必须返回

如果 a < b，则为负整数。
如果 a == b，则为零。
如果 a > b，则为正整数。

如果给定了代码块且没有参数，则返回由代码块确定的最小元素

%w[xxx x xxxx xx].min {|a, b| a.size <=> b.size } # => "x"
h = {foo: 0, bar: 1, baz: 2}
h.min {|pair1, pair2| pair1[1] <=> pair2[1] } # => [:foo, 0]
[].min {|a, b| a <=> b }                          # => nil

如果给定了代码块且给定了正整数参数 n，则返回一个包含由代码块确定的存在的前 n 个最小元素的数组。

%w[xxx x xxxx xx].min(2) {|a, b| a.size <=> b.size } # => ["x", "xx"]
h = {foo: 0, bar: 1, baz: 2}
h.min(2) {|pair1, pair2| pair1[1] <=> pair2[1] }
# => [[:foo, 0], [:bar, 1]]
[].min(2) {|a, b| a <=> b }                          # => []

相关： min_by，minmax，max。

min_by {|element| ... } → element

min_by(n) {|element| ... } → array

min_by → enumerator

min_by(n) → enumerator

来源

static VALUE
enum_min_by(int argc, VALUE *argv, VALUE obj)
{
    struct MEMO *memo;
    VALUE num;

    rb_check_arity(argc, 0, 1);

    RETURN_SIZED_ENUMERATOR(obj, argc, argv, enum_size);

    if (argc && !NIL_P(num = argv[0]))
        return rb_nmin_run(obj, num, 1, 0, 0);

    memo = MEMO_NEW(Qundef, Qnil, 0);
    rb_block_call(obj, id_each, 0, 0, min_by_i, (VALUE)memo);
    return memo->v2;
}

返回代码块返回最小值的元素。

如果给定了代码块且没有参数，则返回代码块返回最小值的元素

(1..4).min_by {|element| -element }                    # => 4
%w[a b c d].min_by {|element| -element.ord }           # => "d"
{foo: 0, bar: 1, baz: 2}.min_by {|key, value| -value } # => [:baz, 2]
[].min_by {|element| -element }                        # => nil

如果给定了代码块且给定了正整数参数 n，则返回一个包含代码块返回最小值的 n 个元素的数组

(1..4).min_by(2) {|element| -element }
# => [4, 3]
%w[a b c d].min_by(2) {|element| -element.ord }
# => ["d", "c"]
{foo: 0, bar: 1, baz: 2}.min_by(2) {|key, value| -value }
# => [[:baz, 2], [:bar, 1]]
[].min_by(2) {|element| -element }
# => []

如果没有给出代码块，则返回 Enumerator。

相关： min，minmax，max_by。

minmax → [minimum, maximum]

minmax {|a, b| ... } → [minimum, maximum]

来源

static VALUE
enum_minmax(VALUE obj)
{
    VALUE memo;
    struct minmax_t *m = NEW_MEMO_FOR(struct minmax_t, memo);

    m->min = Qundef;
    m->last = Qundef;
    if (rb_block_given_p()) {
        rb_block_call(obj, id_each, 0, 0, minmax_ii, memo);
        if (!UNDEF_P(m->last))
            minmax_ii_update(m->last, m->last, m);
    }
    else {
        rb_block_call(obj, id_each, 0, 0, minmax_i, memo);
        if (!UNDEF_P(m->last))
            minmax_i_update(m->last, m->last, m);
    }
    if (!UNDEF_P(m->min)) {
        return rb_assoc_new(m->min, m->max);
    }
    return rb_assoc_new(Qnil, Qnil);
}

返回一个包含根据给定标准确定的最小和最大元素的 2 元素数组。相等元素的顺序是不确定的，并且可能不稳定。

如果没有参数且没有代码块，则返回最小和最大元素，使用元素自己的方法 <=> 进行比较

(1..4).minmax                   # => [1, 4]
(-4..-1).minmax                 # => [-4, -1]
%w[d c b a].minmax              # => ["a", "d"]
{foo: 0, bar: 1, baz: 2}.minmax # => [[:bar, 1], [:foo, 0]]
[].minmax                       # => [nil, nil]

如果给定了代码块，则返回由代码块确定的最小和最大元素

%w[xxx x xxxx xx].minmax {|a, b| a.size <=> b.size } # => ["x", "xxxx"]
h = {foo: 0, bar: 1, baz: 2}
h.minmax {|pair1, pair2| pair1[1] <=> pair2[1] }
# => [[:foo, 0], [:baz, 2]]
[].minmax {|a, b| a <=> b }                          # => [nil, nil]

相关： min，max，minmax_by。

minmax_by {|element| ... } → [minimum, maximum]

minmax_by → enumerator

来源

static VALUE
enum_minmax_by(VALUE obj)
{
    VALUE memo;
    struct minmax_by_t *m = NEW_MEMO_FOR(struct minmax_by_t, memo);

    RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);

    m->min_bv = Qundef;
    m->max_bv = Qundef;
    m->min = Qnil;
    m->max = Qnil;
    m->last_bv = Qundef;
    m->last = Qundef;
    rb_block_call(obj, id_each, 0, 0, minmax_by_i, memo);
    if (!UNDEF_P(m->last_bv))
        minmax_by_i_update(m->last_bv, m->last_bv, m->last, m->last, m);
    m = MEMO_FOR(struct minmax_by_t, memo);
    return rb_assoc_new(m->min, m->max);
}

返回一个包含代码块返回最小和最大值的元素的 2 元素数组

(1..4).minmax_by {|element| -element }
# => [4, 1]
%w[a b c d].minmax_by {|element| -element.ord }
# => ["d", "a"]
{foo: 0, bar: 1, baz: 2}.minmax_by {|key, value| -value }
# => [[:baz, 2], [:foo, 0]]
[].minmax_by {|element| -element }
# => [nil, nil]

如果没有给出代码块，则返回 Enumerator。

相关： max_by，minmax，min_by。

none? → true 或 false

none?(pattern) → true 或 false

none? {|element| ... } → true 或 false

来源

static VALUE
enum_none(int argc, VALUE *argv, VALUE obj)
{
    struct MEMO *memo = MEMO_ENUM_NEW(Qtrue);

    WARN_UNUSED_BLOCK(argc);
    ENUM_BLOCK_CALL(none);
    return memo->v1;
}

返回是否没有元素满足给定的标准。

如果没有参数且没有代码块，则返回是否没有元素是真值

(1..4).none?           # => false
[nil, false].none?     # => true
{foo: 0}.none?         # => false
{foo: 0, bar: 1}.none? # => false
[].none?               # => true

如果参数为 pattern 且没有代码块，则返回对于任何元素 element，是否 pattern === element

[nil, false, 1.1].none?(Integer)      # => true
%w[bar baz bat bam].none?(/m/)        # => false
%w[bar baz bat bam].none?(/foo/)      # => true
%w[bar baz bat bam].none?('ba')       # => true
{foo: 0, bar: 1, baz: 2}.none?(Hash)  # => true
{foo: 0}.none?(Array)                 # => false
[].none?(Integer)                     # => true

如果给定了代码块，则返回是否代码块对于任何元素都没有返回真值

(1..4).none? {|element| element < 1 }                     # => true
(1..4).none? {|element| element < 2 }                     # => false
{foo: 0, bar: 1, baz: 2}.none? {|key, value| value < 0 }  # => true
{foo: 0, bar: 1, baz: 2}.none? {|key, value| value < 1 } # => false

相关： reject。

别名：find_all

slice_after(pattern) → an_enumerator

slice_after { |elt| bool } → an_enumerator

来源

static VALUE
enum_slice_after(int argc, VALUE *argv, VALUE enumerable)
{
    VALUE enumerator;
    VALUE pat = Qnil, pred = Qnil;

    if (rb_block_given_p()) {
        if (0 < argc)
            rb_raise(rb_eArgError, "both pattern and block are given");
        pred = rb_block_proc();
    }
    else {
        rb_scan_args(argc, argv, "1", &pat);
    }

    enumerator = rb_obj_alloc(rb_cEnumerator);
    rb_ivar_set(enumerator, id_sliceafter_enum, enumerable);
    rb_ivar_set(enumerator, id_sliceafter_pat, pat);
    rb_ivar_set(enumerator, id_sliceafter_pred, pred);

    rb_block_call(enumerator, idInitialize, 0, 0, sliceafter_i, enumerator);
    return enumerator;
}

为每个分块元素创建枚举器。块的结尾由 pattern 和代码块定义。

如果 pattern === elt 返回 true 或代码块对于该元素返回 true，则该元素是块的结尾。

从 enum 的第一个元素到最后一个元素调用 === 和 代码块。

结果枚举器将分块的元素作为数组产生。因此可以按如下方式调用 each 方法。

enum.slice_after(pattern).each { |ary| ... }
enum.slice_after { |elt| bool }.each { |ary| ... }

还可以使用 Enumerator 类和 Enumerable 模块的其他方法，例如 map 等。

例如，可以将连续行（以反斜杠结尾的行）连接如下

lines = ["foo\n", "bar\\\n", "baz\n", "\n", "qux\n"]
e = lines.slice_after(/(?<!\\)\n\z/)
p e.to_a
#=> [["foo\n"], ["bar\\\n", "baz\n"], ["\n"], ["qux\n"]]
p e.map {|ll| ll[0...-1].map {|l| l.sub(/\\\n\z/, "") }.join + ll.last }
#=>["foo\n", "barbaz\n", "\n", "qux\n"]

slice_before(pattern) → enumerator

slice_before {|elt| ... } → enumerator

来源

static VALUE
enum_slice_before(int argc, VALUE *argv, VALUE enumerable)
{
    VALUE enumerator;

    if (rb_block_given_p()) {
        if (argc != 0)
            rb_error_arity(argc, 0, 0);
        enumerator = rb_obj_alloc(rb_cEnumerator);
        rb_ivar_set(enumerator, id_slicebefore_sep_pred, rb_block_proc());
    }
    else {
        VALUE sep_pat;
        rb_scan_args(argc, argv, "1", &sep_pat);
        enumerator = rb_obj_alloc(rb_cEnumerator);
        rb_ivar_set(enumerator, id_slicebefore_sep_pat, sep_pat);
    }
    rb_ivar_set(enumerator, id_slicebefore_enumerable, enumerable);
    rb_block_call(enumerator, idInitialize, 0, 0, slicebefore_i, enumerator);
    return enumerator;
}

使用参数 pattern，返回一个枚举器，该枚举器使用模式将元素划分为数组（“切片”）。如果 element === pattern（或者如果它是第一个元素），则一个元素开始一个新的切片。

a = %w[foo bar fop for baz fob fog bam foy]
e = a.slice_before(/ba/) # => #<Enumerator: ...>
e.each {|array| p array }

输出

["foo"]
["bar", "fop", "for"]
["baz", "fob", "fog"]
["bam", "foy"]

使用代码块，返回一个枚举器，该枚举器使用代码块将元素划分为数组。如果其代码块返回真值（或者如果它是第一个元素），则一个元素开始一个新的切片。

e = (1..20).slice_before {|i| i % 4 == 2 } # => #<Enumerator: ...>
e.each {|array| p array }

输出

[1]
[2, 3, 4, 5]
[6, 7, 8, 9]
[10, 11, 12, 13]
[14, 15, 16, 17]
[18, 19, 20]

还可以使用 Enumerator 类和 Enumerable 模块的其他方法，例如 to_a、map 等。

例如，可以按如下方式实现对 ChangeLog 条目的迭代

# iterate over ChangeLog entries.
open("ChangeLog") { |f|
  f.slice_before(/\A\S/).each { |e| pp e }
}

# same as above.  block is used instead of pattern argument.
open("ChangeLog") { |f|
  f.slice_before { |line| /\A\S/ === line }.each { |e| pp e }
}

“svn proplist -R” 为每个文件生成多行输出。它们可以按如下方式分块

IO.popen([{"LC_ALL"=>"C"}, "svn", "proplist", "-R"]) { |f|
  f.lines.slice_before(/\AProp/).each { |lines| p lines }
}
#=> ["Properties on '.':\n", "  svn:ignore\n", "  svk:merge\n"]
#   ["Properties on 'goruby.c':\n", "  svn:eol-style\n"]
#   ["Properties on 'complex.c':\n", "  svn:mime-type\n", "  svn:eol-style\n"]
#   ["Properties on 'regparse.c':\n", "  svn:eol-style\n"]
#   ...

如果代码块需要在多个元素上维护状态，可以使用局部变量。例如，可以将三个或更多连续递增的数字压缩如下（有关更好的方法，请参见 chunk_while）

a = [0, 2, 3, 4, 6, 7, 9]
prev = a[0]
p a.slice_before { |e|
  prev, prev2 = e, prev
  prev2 + 1 != e
}.map { |es|
  es.length <= 2 ? es.join(",") : "#{es.first}-#{es.last}"
}.join(",")
#=> "0,2-4,6,7,9"

但是，如果结果枚举器被枚举两次或更多次，则应小心使用局部变量。局部变量应为每次枚举初始化。可以使用 Enumerator.new 来完成此操作。

# Word wrapping.  This assumes all characters have same width.
def wordwrap(words, maxwidth)
  Enumerator.new {|y|
    # cols is initialized in Enumerator.new.
    cols = 0
    words.slice_before { |w|
      cols += 1 if cols != 0
      cols += w.length
      if maxwidth < cols
        cols = w.length
        true
      else
        false
      end
    }.each {|ws| y.yield ws }
  }
end
text = (1..20).to_a.join(" ")
enum = wordwrap(text.split(/\s+/), 10)
puts "-"*10
enum.each { |ws| puts ws.join(" ") } # first enumeration.
puts "-"*10
enum.each { |ws| puts ws.join(" ") } # second enumeration generates same result as the first.
puts "-"*10
#=> ----------
#   1 2 3 4 5
#   6 7 8 9 10
#   11 12 13
#   14 15 16
#   17 18 19
#   20
#   ----------
#   1 2 3 4 5
#   6 7 8 9 10
#   11 12 13
#   14 15 16
#   17 18 19
#   20
#   ----------

mbox 包含一系列以 Unix From 行开头的邮件。因此，可以通过在 Unix From 行之前进行切片来提取每封邮件。

# parse mbox
open("mbox") { |f|
  f.slice_before { |line|
    line.start_with? "From "
  }.each { |mail|
    unix_from = mail.shift
    i = mail.index("\n")
    header = mail[0...i]
    body = mail[(i+1)..-1]
    body.pop if body.last == "\n"
    fields = header.slice_before { |line| !" \t".include?(line[0]) }.to_a
    p unix_from
    pp fields
    pp body
  }
}

# split mails in mbox (slice before Unix From line after an empty line)
open("mbox") { |f|
  emp = true
  f.slice_before { |line|
    prevemp = emp
    emp = line == "\n"
    prevemp && line.start_with?("From ")
  }.each { |mail|
    mail.pop if mail.last == "\n"
    pp mail
  }
}

slice_when {|elt_before, elt_after| bool } → an_enumerator

来源

static VALUE
enum_slice_when(VALUE enumerable)
{
    VALUE enumerator;
    VALUE pred;

    pred = rb_block_proc();

    enumerator = rb_obj_alloc(rb_cEnumerator);
    rb_ivar_set(enumerator, id_slicewhen_enum, enumerable);
    rb_ivar_set(enumerator, id_slicewhen_pred, pred);
    rb_ivar_set(enumerator, id_slicewhen_inverted, Qfalse);

    rb_block_call(enumerator, idInitialize, 0, 0, slicewhen_i, enumerator);
    return enumerator;
}

为每个分块的元素创建一个枚举器。块的开始由代码块定义。

此方法使用接收器枚举器中的相邻元素 elt_before 和 elt_after 分割每个块。此方法在 elt_before 和 elt_after 之间分割块，其中代码块返回 true。

代码块的调用次数为接收器枚举器的长度减 1。

结果枚举器将分块的元素作为数组产生。因此可以按如下方式调用 each 方法。

enum.slice_when { |elt_before, elt_after| bool }.each { |ary| ... }

还可以使用 Enumerator 类和 Enumerable 模块的其他方法，例如 to_a、map 等。

例如，可以按如下方式对逐个递增的子序列进行分块。

a = [1,2,4,9,10,11,12,15,16,19,20,21]
b = a.slice_when {|i, j| i+1 != j }
p b.to_a #=> [[1, 2], [4], [9, 10, 11, 12], [15, 16], [19, 20, 21]]
c = b.map {|a| a.length < 3 ? a : "#{a.first}-#{a.last}" }
p c #=> [[1, 2], [4], "9-12", [15, 16], "19-21"]
d = c.join(",")
p d #=> "1,2,4,9-12,15,16,19-21"

排序数组中的近元素（阈值：6）可以按如下方式分块

a = [3, 11, 14, 25, 28, 29, 29, 41, 55, 57]
p a.slice_when {|i, j| 6 < j - i }.to_a
#=> [[3], [11, 14], [25, 28, 29, 29], [41], [55, 57]]

可以按如下方式对递增（非递减）子序列进行分块。

a = [0, 9, 2, 2, 3, 2, 7, 5, 9, 5]
p a.slice_when {|i, j| i > j }.to_a
#=> [[0, 9], [2, 2, 3], [2, 7], [5, 9], [5]]

可以按如下方式对相邻的偶数和奇数进行分块：（Enumerable#chunk 是另一种方法。）

a = [7, 5, 9, 2, 0, 7, 9, 4, 2, 0]
p a.slice_when {|i, j| i.even? != j.even? }.to_a
#=> [[7, 5, 9], [2, 0], [7, 9], [4, 2, 0]]

段落（带有尾随空行的非空行）可以按如下方式分块：（请参阅 Enumerable#chunk 以忽略空行。）

lines = ["foo\n", "bar\n", "\n", "baz\n", "qux\n"]
p lines.slice_when {|l1, l2| /\A\s*\z/ =~ l1 && /\S/ =~ l2 }.to_a
#=> [["foo\n", "bar\n", "\n"], ["baz\n", "qux\n"]]

Enumerable#chunk_while 执行相同的操作，但当代码块返回 false 而不是 true 时进行分割。

sort → array

sort {|a, b| ... } → array

来源

static VALUE
enum_sort(VALUE obj)
{
    return rb_ary_sort_bang(enum_to_a(0, 0, obj));
}

返回一个包含 self 的排序元素的数组。相等元素的顺序是不确定的，并且可能不稳定。

如果未给定代码块，则排序使用元素自己的 <=> 方法进行比较。

%w[b c a d].sort              # => ["a", "b", "c", "d"]
{foo: 0, bar: 1, baz: 2}.sort # => [[:bar, 1], [:baz, 2], [:foo, 0]]

如果给定代码块，则代码块中的比较确定顺序。代码块使用两个元素 a 和 b 调用，并且必须返回

如果 a < b，则为负整数。
如果 a == b，则为零。
如果 a > b，则为正整数。

示例

a = %w[b c a d]
a.sort {|a, b| b <=> a } # => ["d", "c", "b", "a"]
h = {foo: 0, bar: 1, baz: 2}
h.sort {|a, b| b <=> a } # => [[:foo, 0], [:baz, 2], [:bar, 1]]

另请参阅 sort_by。它实现了一个施瓦茨变换，当键计算或比较成本很高时，该变换很有用。

sort_by {|element| ... } → array

sort_by → enumerator

来源

static VALUE
enum_sort_by(VALUE obj)
{
    VALUE ary, buf;
    struct MEMO *memo;
    long i;
    struct sort_by_data *data;

    RETURN_SIZED_ENUMERATOR(obj, 0, 0, enum_size);

    if (RB_TYPE_P(obj, T_ARRAY) && RARRAY_LEN(obj) <= LONG_MAX/2) {
        ary = rb_ary_new2(RARRAY_LEN(obj)*2);
    }
    else {
        ary = rb_ary_new();
    }
    RBASIC_CLEAR_CLASS(ary);
    buf = rb_ary_hidden_new(SORT_BY_BUFSIZE*2);
    rb_ary_store(buf, SORT_BY_BUFSIZE*2-1, Qnil);
    memo = MEMO_NEW(0, 0, 0);
    data = (struct sort_by_data *)&memo->v1;
    RB_OBJ_WRITE(memo, &data->ary, ary);
    RB_OBJ_WRITE(memo, &data->buf, buf);
    data->n = 0;
    data->primitive_uniformed = SORT_BY_UNIFORMED((CMP_OPTIMIZABLE(FLOAT) && CMP_OPTIMIZABLE(INTEGER)),
                                                  CMP_OPTIMIZABLE(FLOAT),
                                                  CMP_OPTIMIZABLE(INTEGER));
    rb_block_call(obj, id_each, 0, 0, sort_by_i, (VALUE)memo);
    ary = data->ary;
    buf = data->buf;
    if (data->n) {
        rb_ary_resize(buf, data->n*2);
        rb_ary_concat(ary, buf);
    }
    if (RARRAY_LEN(ary) > 2) {
        if (data->primitive_uniformed) {
            RARRAY_PTR_USE(ary, ptr,
                           rb_uniform_intro_sort_2((struct rb_uniform_sort_data*)ptr,
                                                   (struct rb_uniform_sort_data*)(ptr + RARRAY_LEN(ary))));
        }
        else {
            RARRAY_PTR_USE(ary, ptr,
                           ruby_qsort(ptr, RARRAY_LEN(ary)/2, 2*sizeof(VALUE),
                                      sort_by_cmp, (void *)ary));
        }
    }
    if (RBASIC(ary)->klass) {
        rb_raise(rb_eRuntimeError, "sort_by reentered");
    }
    for (i=1; i<RARRAY_LEN(ary); i+=2) {
        RARRAY_ASET(ary, i/2, RARRAY_AREF(ary, i));
    }
    rb_ary_resize(ary, RARRAY_LEN(ary)/2);
    RBASIC_SET_CLASS_RAW(ary, rb_cArray);

    return ary;
}

如果给定代码块，则返回一个 self 的元素数组，该数组根据代码块为每个元素返回的值进行排序。相等元素的顺序是不确定的，并且可能不稳定。

示例

a = %w[xx xxx x xxxx]
a.sort_by {|s| s.size }        # => ["x", "xx", "xxx", "xxxx"]
a.sort_by {|s| -s.size }       # => ["xxxx", "xxx", "xx", "x"]
h = {foo: 2, bar: 1, baz: 0}
h.sort_by{|key, value| value } # => [[:baz, 0], [:bar, 1], [:foo, 2]]
h.sort_by{|key, value| key }   # => [[:bar, 1], [:baz, 0], [:foo, 2]]

如果没有给定代码块，则返回 Enumerator。

sort_by 的当前实现生成一个包含原始集合元素和映射值的元组数组。这使得当键集很简单时，sort_by 的开销相当大。

require 'benchmark'

a = (1..100000).map { rand(100000) }

Benchmark.bm(10) do |b|
  b.report("Sort")    { a.sort }
  b.report("Sort by") { a.sort_by { |a| a } }
end

生成

user     system      total        real
Sort        0.180000   0.000000   0.180000 (  0.175469)
Sort by     1.980000   0.040000   2.020000 (  2.013586)

但是，考虑比较键是非平凡操作的情况。以下代码使用基本的 sort 方法按修改时间对一些文件进行排序。

files = Dir["*"]
sorted = files.sort { |a, b| File.new(a).mtime <=> File.new(b).mtime }
sorted   #=> ["mon", "tues", "wed", "thurs"]

此排序效率低下：它在每次比较期间生成两个新的 File 对象。一种稍微好一点的技术是使用 Kernel#test 方法直接生成修改时间。

files = Dir["*"]
sorted = files.sort { |a, b|
  test(?M, a) <=> test(?M, b)
}
sorted   #=> ["mon", "tues", "wed", "thurs"]

这仍然会生成许多不必要的 Time 对象。一种更有效的技术是在排序之前缓存排序键（在本例中为修改时间）。Perl 用户通常将这种方法称为施瓦茨变换，以 Randal Schwartz 的名字命名。我们构建一个临时数组，其中每个元素都是一个数组，包含我们的排序键以及文件名。我们对这个数组进行排序，然后从结果中提取文件名。

sorted = Dir["*"].collect { |f|
   [test(?M, f), f]
}.sort.collect { |f| f[1] }
sorted   #=> ["mon", "tues", "wed", "thurs"]

这正是 sort_by 内部执行的操作。

sorted = Dir["*"].sort_by { |f| test(?M, f) }
sorted   #=> ["mon", "tues", "wed", "thurs"]

要生成特定顺序的相反顺序，可以使用以下方法

ary.sort_by { ... }.reverse!

sum(initial_value = 0) → number

sum(initial_value = 0) {|element| ... } → object

来源

static VALUE
enum_sum(int argc, VALUE* argv, VALUE obj)
{
    struct enum_sum_memo memo;
    VALUE beg, end;
    int excl;

    memo.v = (rb_check_arity(argc, 0, 1) == 0) ? LONG2FIX(0) : argv[0];
    memo.block_given = rb_block_given_p();
    memo.n = 0;
    memo.r = Qundef;

    if ((memo.float_value = RB_FLOAT_TYPE_P(memo.v))) {
        memo.f = RFLOAT_VALUE(memo.v);
        memo.c = 0.0;
    }
    else {
        memo.f = 0.0;
        memo.c = 0.0;
    }

    if (RTEST(rb_range_values(obj, &beg, &end, &excl))) {
        if (!memo.block_given && !memo.float_value &&
                (FIXNUM_P(beg) || RB_BIGNUM_TYPE_P(beg)) &&
                (FIXNUM_P(end) || RB_BIGNUM_TYPE_P(end))) {
            return int_range_sum(beg, end, excl, memo.v);
        }
    }

    if (RB_TYPE_P(obj, T_HASH) &&
            rb_method_basic_definition_p(CLASS_OF(obj), id_each))
        hash_sum(obj, &memo);
    else
        rb_block_call(obj, id_each, 0, 0, enum_sum_i, (VALUE)&memo);

    if (memo.float_value) {
        return DBL2NUM(memo.f + memo.c);
    }
    else {
        if (memo.n != 0)
            memo.v = rb_fix_plus(LONG2FIX(memo.n), memo.v);
        if (!UNDEF_P(memo.r)) {
            memo.v = rb_rational_plus(memo.r, memo.v);
        }
        return memo.v;
    }
}

如果未给定代码块，则返回 initial_value 和元素的总和

(1..100).sum          # => 5050
(1..100).sum(1)       # => 5051
('a'..'d').sum('foo') # => "fooabcd"

通常，总和是使用方法 + 和 each 计算的；为了进行性能优化，可能不会使用这些方法，因此对这些方法的任何重新定义可能在此处无效。

一个这样的优化：在可能的情况下，使用高斯求和公式 *n(n+1)/2* 进行计算

100 * (100 + 1) / 2 # => 5050

如果给定代码块，则使用每个元素调用该代码块；返回 initial_value 和代码块返回值的总和

(1..4).sum {|i| i*i }                        # => 30
(1..4).sum(100) {|i| i*i }                   # => 130
h = {a: 0, b: 1, c: 2, d: 3, e: 4, f: 5}
h.sum {|key, value| value.odd? ? value : 0 } # => 9
('a'..'f').sum('x') {|c| c < 'd' ? c : '' }  # => "xabc"

take(n) → array

来源

static VALUE
enum_take(VALUE obj, VALUE n)
{
    struct MEMO *memo;
    VALUE result;
    long len = NUM2LONG(n);

    if (len < 0) {
        rb_raise(rb_eArgError, "attempt to take negative size");
    }

    if (len == 0) return rb_ary_new2(0);
    result = rb_ary_new2(len);
    memo = MEMO_NEW(result, 0, len);
    rb_block_call(obj, id_each, 0, 0, take_i, (VALUE)memo);
    return result;
}

对于非负整数 n，返回前 n 个元素

r = (1..4)
r.take(2) # => [1, 2]
r.take(0) # => []

h = {foo: 0, bar: 1, baz: 2, bat: 3}
h.take(2) # => [[:foo, 0], [:bar, 1]]

take_while {|element| ... } → array

take_while → enumerator

来源

static VALUE
enum_take_while(VALUE obj)
{
    VALUE ary;

    RETURN_ENUMERATOR(obj, 0, 0);
    ary = rb_ary_new();
    rb_block_call(obj, id_each, 0, 0, take_while_i, ary);
    return ary;
}

只要代码块返回真值，就使用连续元素调用该代码块；返回到该点为止的所有元素的数组

(1..4).take_while{|i| i < 3 } # => [1, 2]
h = {foo: 0, bar: 1, baz: 2}
h.take_while{|element| key, value = *element; value < 2 }
# => [[:foo, 0], [:bar, 1]]

如果没有给定代码块，则返回 Enumerator。

tally(hash = {}) → hash

来源

static VALUE
enum_tally(int argc, VALUE *argv, VALUE obj)
{
    VALUE hash;
    if (rb_check_arity(argc, 0, 1)) {
        hash = rb_to_hash_type(argv[0]);
        rb_check_frozen(hash);
    }
    else {
        hash = rb_hash_new();
    }

    return enum_hashify_into(obj, 0, 0, tally_i, hash);
}

当未给出参数 hash 时，返回一个新哈希，其键是 self 中的不同元素；每个整数值是每个元素出现的次数

%w[a b c b c a c b].tally # => {"a"=>2, "b"=>3, "c"=>3}

当给出参数 hash 时，返回 hash，可能会进行扩充；对于 self 中的每个元素 ele

如果该键尚不存在，则将其添加为键，值为零
```
hash[ele] = 0 unless hash.include?(ele)
```
递增键 ele 的值
```
hash[ele] += 1
```

这对于累积多个可枚举的计数很有用

h = {}                   # => {}
%w[a c d b c a].tally(h) # => {"a"=>2, "c"=>2, "d"=>1, "b"=>1}
%w[b a z].tally(h)       # => {"a"=>3, "c"=>2, "d"=>1, "b"=>2, "z"=>1}
%w[b a m].tally(h)       # => {"a"=>4, "c"=>2, "d"=>1, "b"=>3, "z"=>1, "m"=>1}

要添加或找到的元素的键取决于 self 的类；请参阅 Ruby 类中的 Enumerable。

示例

Array（以及某些类似数组的类）：键是元素（如上所述）。

Hash（以及某些类似哈希的类）：键是由键值对形成的 2 元素数组

h = {}                        # => {}
{foo: 'a', bar: 'b'}.tally(h) # => {[:foo, "a"]=>1, [:bar, "b"]=>1}
{foo: 'c', bar: 'd'}.tally(h) # => {[:foo, "a"]=>1, [:bar, "b"]=>1, [:foo, "c"]=>1, [:bar, "d"]=>1}
{foo: 'a', bar: 'b'}.tally(h) # => {[:foo, "a"]=>2, [:bar, "b"]=>2, [:foo, "c"]=>1, [:bar, "d"]=>1}
{foo: 'c', bar: 'd'}.tally(h) # => {[:foo, "a"]=>2, [:bar, "b"]=>2, [:foo, "c"]=>2, [:bar, "d"]=>2}

to_a(*args) → array

来源

static VALUE
enum_to_a(int argc, VALUE *argv, VALUE obj)
{
    VALUE ary = rb_ary_new();

    rb_block_call_kw(obj, id_each, argc, argv, collect_all, ary, RB_PASS_CALLED_KEYWORDS);

    return ary;
}

返回一个包含 self 中的项的数组

(0..4).to_a # => [0, 1, 2, 3, 4]

也别名为：entries

to_h(*args) → hash

to_h(*args) {|element| ... } → hash

来源

static VALUE
enum_to_h(int argc, VALUE *argv, VALUE obj)
{
    rb_block_call_func *iter = rb_block_given_p() ? enum_to_h_ii : enum_to_h_i;
    return enum_hashify(obj, argc, argv, iter);
}

当 self 由 2 元素数组组成时，返回一个哈希，其每个条目是由其中一个数组形成的键值对

[[:foo, 0], [:bar, 1], [:baz, 2]].to_h # => {:foo=>0, :bar=>1, :baz=>2}

当给定代码块时，将使用 self 的每个元素调用该代码块；该代码块应返回一个 2 元素数组，该数组将成为返回的哈希中的键值对

(0..3).to_h {|i| [i, i ** 2]} # => {0=>0, 1=>1, 2=>4, 3=>9}

如果 self 的元素不是 2 元素数组，并且未传递代码块，则引发异常。

to_set (klass = Set, *args, &block)

来源

# File lib/set.rb, line 850
def to_set(klass = Set, *args, &block)
  klass.new(self, *args, &block)
end

使用给定参数从可枚举对象创建集合。需要 require "set" 才能使用此方法。

uniq → array

uniq {|element| ... } → array

来源

static VALUE
enum_uniq(VALUE obj)
{
    VALUE hash, ret;
    rb_block_call_func *const func =
        rb_block_given_p() ? uniq_iter : uniq_func;

    hash = rb_obj_hide(rb_hash_new());
    rb_block_call(obj, id_each, 0, 0, func, hash);
    ret = rb_hash_values(hash);
    rb_hash_clear(hash);
    return ret;
}

如果没有代码块，则返回一个仅包含唯一元素的新数组；该数组没有两个元素 e0 和 e1，使得 e0.eql?(e1)

%w[a b c c b a a b c].uniq       # => ["a", "b", "c"]
[0, 1, 2, 2, 1, 0, 0, 1, 2].uniq # => [0, 1, 2]

如果有代码块，则返回一个新数组，其中仅包含代码块返回唯一值的元素

a = [0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1]
a.uniq {|i| i.even? ? i : 0 } # => [0, 2, 4]
a = %w[a b c d e e d c b a a b c d e]
a.uniq {|c| c < 'c' }         # => ["a", "c"]

zip(*other_enums) → array

zip(*other_enums) {|array| ... } → nil

来源

static VALUE
enum_zip(int argc, VALUE *argv, VALUE obj)
{
    int i;
    ID conv;
    struct MEMO *memo;
    VALUE result = Qnil;
    VALUE args = rb_ary_new4(argc, argv);
    int allary = TRUE;

    argv = RARRAY_PTR(args);
    for (i=0; i<argc; i++) {
        VALUE ary = rb_check_array_type(argv[i]);
        if (NIL_P(ary)) {
            allary = FALSE;
            break;
        }
        argv[i] = ary;
    }
    if (!allary) {
        static const VALUE sym_each = STATIC_ID2SYM(id_each);
        CONST_ID(conv, "to_enum");
        for (i=0; i<argc; i++) {
            if (!rb_respond_to(argv[i], id_each)) {
                rb_raise(rb_eTypeError, "wrong argument type %"PRIsVALUE" (must respond to :each)",
                         rb_obj_class(argv[i]));
            }
            argv[i] = rb_funcallv(argv[i], conv, 1, &sym_each);
        }
    }
    if (!rb_block_given_p()) {
        result = rb_ary_new();
    }

    /* TODO: use NODE_DOT2 as memo(v, v, -) */
    memo = MEMO_NEW(result, args, 0);
    rb_block_call(obj, id_each, 0, 0, allary ? zip_ary : zip_i, (VALUE)memo);

    return result;
}

如果未给定代码块，则返回一个大小为 self.size 的新数组 new_array，其元素是数组。每个嵌套数组 new_array[n] 的大小为 other_enums.size+1，并且包含

self 的第 n 个元素。
每个 other_enums 的第 n 个元素。

如果所有 other_enums 和 self 的大小相同，则所有元素都包含在结果中，并且没有 nil 填充

a = [:a0, :a1, :a2, :a3]
b = [:b0, :b1, :b2, :b3]
c = [:c0, :c1, :c2, :c3]
d = a.zip(b, c)
d # => [[:a0, :b0, :c0], [:a1, :b1, :c1], [:a2, :b2, :c2], [:a3, :b3, :c3]]

f = {foo: 0, bar: 1, baz: 2}
g = {goo: 3, gar: 4, gaz: 5}
h = {hoo: 6, har: 7, haz: 8}
d = f.zip(g, h)
d # => [
  #      [[:foo, 0], [:goo, 3], [:hoo, 6]],
  #      [[:bar, 1], [:gar, 4], [:har, 7]],
  #      [[:baz, 2], [:gaz, 5], [:haz, 8]]
  #    ]

如果 other_enums 中的任何可枚举对象小于 self，则用 nil 填充到 self.size

a = [:a0, :a1, :a2, :a3]
b = [:b0, :b1, :b2]
c = [:c0, :c1]
d = a.zip(b, c)
d # => [[:a0, :b0, :c0], [:a1, :b1, :c1], [:a2, :b2, nil], [:a3, nil, nil]]

如果 other_enums 中的任何可枚举对象大于 self，则忽略其尾随元素

a = [:a0, :a1, :a2, :a3]
b = [:b0, :b1, :b2, :b3, :b4]
c = [:c0, :c1, :c2, :c3, :c4, :c5]
d = a.zip(b, c)
d # => [[:a0, :b0, :c0], [:a1, :b1, :c1], [:a2, :b2, :c2], [:a3, :b3, :c3]]

当给定代码块时，使用每个子数组（如上所述形成）调用代码块；返回 nil

a = [:a0, :a1, :a2, :a3]
b = [:b0, :b1, :b2, :b3]
c = [:c0, :c1, :c2, :c3]
a.zip(b, c) {|sub_array| p sub_array} # => nil

输出

[:a0, :b0, :c0]
[:a1, :b1, :c1]
[:a2, :b2, :c2]
[:a3, :b3, :c3]