Range 类

Range 对象表示给定开始值和结束值之间的值集合。

您可以使用以下方法显式创建 Range 对象：

# Ranges that use '..' to include the given end value.
(1..4).to_a      # => [1, 2, 3, 4]
('a'..'d').to_a  # => ["a", "b", "c", "d"]
# Ranges that use '...' to exclude the given end value.
(1...4).to_a     # => [1, 2, 3]
('a'...'d').to_a # => ["a", "b", "c"]

可以使用方法 Range.new 创建范围。

# Ranges that by default include the given end value.
Range.new(1, 4).to_a     # => [1, 2, 3, 4]
Range.new('a', 'd').to_a # => ["a", "b", "c", "d"]
# Ranges that use third argument +exclude_end+ to exclude the given end value.
Range.new(1, 4, true).to_a     # => [1, 2, 3]
Range.new('a', 'd', true).to_a # => ["a", "b", "c"]

无始范围¶ ↑

无始范围具有确定的结束值，但 nil 开始值。此类范围包括所有直到结束值的值。

r = (..4)               # => nil..4
r.begin                 # => nil
r.include?(-50)         # => true
r.include?(4)           # => true

r = (...4)              # => nil...4
r.include?(4)           # => false

Range.new(nil, 4)       # => nil..4
Range.new(nil, 4, true) # => nil...4

无始范围可用于切片数组

a = [1, 2, 3, 4]
r = (..2) # => nil...2
a[r]      # => [1, 2]

无始范围的 each 方法会引发异常。

无终范围¶ ↑

无终范围具有确定的开始值，但 nil 结束值。此类范围包括从开始值开始的所有值。

r = (1..)         # => 1..
r.end             # => nil
r.include?(50)    # => true

Range.new(1, nil) # => 1..

无终范围的字面量可以使用两个点或三个点来编写。无论哪种方式，范围都具有相同的元素。但请注意，两者并不相等

r0 = (1..)           # => 1..
r1 = (1...)          # => 1...
r0.begin == r1.begin # => true
r0.end == r1.end     # => true
r0 == r1             # => false

无终范围可用于切片数组

a = [1, 2, 3, 4]
r = (2..) # => 2..
a[r]      # => [3, 4]

无终范围的 each 方法会无限期地调用给定的块

a = []
r = (1..)
r.each do |i|
  a.push(i) if i.even?
  break if i > 10
end
a # => [2, 4, 6, 8, 10]

范围可以既是无始又是无终的。对于字面量无始、无终范围，至少必须将范围的开始或结束指定为显式 nil 值。建议使用显式 nil 开始和隐式 nil 结束，因为这是 Ruby 用于 Range#inspect 的方式

(nil..)    # => (nil..)
(..nil)    # => (nil..)
(nil..nil) # => (nil..)

范围和其他类¶ ↑

如果对象的类实现了实例方法 <=>，则可以将该对象放入范围中。实现此方法的 Ruby 核心类包括 Array、Complex、File::Stat、Float、Integer、Kernel、Module、Numeric、Rational、String、Symbol 和 Time。

示例

t0 = Time.now         # => 2021-09-19 09:22:48.4854986 -0500
t1 = Time.now         # => 2021-09-19 09:22:56.0365079 -0500
t2 = Time.now         # => 2021-09-19 09:23:08.5263283 -0500
(t0..t2).include?(t1) # => true
(t0..t1).include?(t2) # => false

只有当范围的元素实现了实例方法 succ 时，才能对其进行迭代。Ruby 核心类中实现此方法的类包括 Integer、String 和 Symbol（但不包括上面提到的其他类）。

迭代器方法包括

在 Range 本身中：each、step 和 %
从模块 Enumerable 中包含：each_entry、each_with_index、each_with_object、each_slice、each_cons 和 reverse_each。

示例

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

范围和用户定义类¶ ↑

要在一个范围内使用用户定义的类，必须实现实例 <=>；请参见 Integer#<=>。为了使迭代可用，它还必须实现实例方法 succ；请参见 Integer#succ。

下面的类同时实现了 <=> 和 succ，因此既可以用来构造范围，也可以用来迭代它们。请注意，包含了 Comparable 模块，因此 == 方法是根据 <=> 定义的。

# Represent a string of 'X' characters.
class Xs
  include Comparable
  attr_accessor :length
  def initialize(n)
    @length = n
  end
  def succ
    Xs.new(@length + 1)
  end
  def <=>(other)
    @length <=> other.length
  end
  def to_s
    sprintf "%2d #{inspect}", @length
  end
  def inspect
    'X' * @length
  end
end

r = Xs.new(3)..Xs.new(6) #=> XXX..XXXXXX
r.to_a                   #=> [XXX, XXXX, XXXXX, XXXXXX]
r.include?(Xs.new(5))    #=> true
r.include?(Xs.new(7))    #=> false

这里有什么¶ ↑

首先，其他地方有什么。类 Range

继承自类 Object。
包含模块 Enumerable，它提供了数十种其他方法。

这里，类 Range 提供了对以下方面有用的方法

创建范围的方法¶ ↑

::new：返回一个新的范围。

查询方法¶ ↑

begin：返回为 self 给出的开始值。
bsearch：返回 self 中通过二分查找选择的元素。
count：返回 self 中元素的数量。
end：返回为 self 给出的结束值。
exclude_end?：返回结束对象是否被排除。
first：返回 self 的第一个元素。
hash：返回整数哈希码。
last：返回 self 的最后一个元素。
max：返回 self 中的最大值。
min: 返回self中的最小值。
minmax: 返回self中的最小值和最大值。
size: 返回self中元素的数量。

比较方法¶ ↑

==: 返回给定对象是否等于self（使用 ==）。
===: 返回给定对象是否在开始值和结束值之间。
cover?: 返回给定对象是否在self中。
eql?: 返回给定对象是否等于self（使用 eql?）。
include? (别名为 member?): 返回给定对象是否为self的元素。

迭代方法¶ ↑

%: 需要参数n；使用self的每个第n个元素调用块。
each: 使用self的每个元素调用块。
step: 接受可选参数n（默认为 1）；使用self的每个第n个元素调用块。

转换方法¶ ↑

inspect: 返回self的字符串表示形式（使用 inspect）。
to_a (别名为 entries): 返回self中的元素，以数组形式。
to_s: 返回self的字符串表示形式（使用 to_s）。

用于处理 JSON 的方法¶ ↑

::json_create: 返回一个从给定对象构造的新 Range 对象。
as_json: 返回一个表示self的 2 元素哈希。
to_json: 返回一个表示self的 JSON 字符串。

使这些方法可用

require 'json/add/range'

公共类方法

new(begin, end, exclude_end = false) → new_range 点击切换源代码

根据给定的对象begin和end返回一个新的范围。可选参数exclude_end决定对象end是否包含在范围的最后一个对象中。

Range.new(2, 5).to_a            # => [2, 3, 4, 5]
Range.new(2, 5, true).to_a      # => [2, 3, 4]
Range.new('a', 'd').to_a        # => ["a", "b", "c", "d"]
Range.new('a', 'd', true).to_a  # => ["a", "b", "c"]

static VALUE
range_initialize(int argc, VALUE *argv, VALUE range)
{
    VALUE beg, end, flags;

    rb_scan_args(argc, argv, "21", &beg, &end, &flags);
    range_modify(range);
    range_init(range, beg, end, RBOOL(RTEST(flags)));
    return Qnil;
}

公共实例方法

%(n) {|element| ... } → self 点击切换源代码

%(n) → 枚举器

迭代self中的元素。

如果给定一个代码块，则使用范围中的选定元素调用代码块；返回self。

a = []
(1..5).%(2) {|element| a.push(element) } # => 1..5
a # => [1, 3, 5]
a = []
('a'..'e').%(2) {|element| a.push(element) } # => "a".."e"
a # => ["a", "c", "e"]

如果没有给定代码块，则返回一个枚举器，如果self是数字，则枚举器将是Enumerator::ArithmeticSequence类；否则是Enumerator类。

e = (1..5) % 2 # => ((1..5).%(2))
e.class        # => Enumerator::ArithmeticSequence
('a'..'e') % 2 # =>  #<Enumerator: ...>