类 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'

公共类方法

json_create(object) 点击切换源代码

参见 as_json。

# File ext/json/lib/json/add/range.rb, line 9
def self.json_create(object)
  new(*object['a'])
end

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: ...>