类 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

# 默认包含给定结束值的范围。Range.new(1, 4).to_a # => [1, 2, 3, 4] Range.new('a', 'd').to_a # => ["a", "b", "c", "d"] # 使用第三个参数 exclude_end 排除给定结束值的范围。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]
# Include the third array element in the slice
r = (..2)  # => nil..2
a[r]       # => [1, 2, 3]
# Exclude the third array element from the slice
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) → enumerator 或 arithmetic_sequence

与 step 相同（但未提供 n 的默认值）。此方法对于表达性地生成 Enumerator::ArithmeticSequence 很方便。

array = [0, 1, 2, 3, 4, 5, 6]

# slice each second element:
seq = (0..) % 2 #=> ((0..).%(2))
array[seq] #=> [0, 2, 4, 6]
# or just
array[(0..) % 2] #=> [0, 2, 4, 6]

请注意，由于 Ruby 中的运算符优先级，在这种情况下，范围周围必须使用括号

(0..7) % 2 #=> ((0..7).%(2)) -- as expected
0..7 % 2 #=> 0..1 -- parsed as 0..(7 % 2)

static VALUE
range_percent_step(VALUE range, VALUE step)
{
    return range_step(1, &step, range);
}

self == other → true 或 false 点击以切换源

当且仅当满足以下条件时，返回 true：

other 是一个范围。
other.begin == self.begin.
other.end == self.end.
other.exclude_end? == self.exclude_end?.

否则返回 false。

r = (1..5)
r == (1..5)                # => true
r = Range.new(1, 5)
r == 'foo'                 # => false
r == (2..5)                # => false
r == (1..4)                # => false
r == (1...5)               # => false
r == Range.new(1, 5, true) # => false

请注意，即使使用相同的参数，== 和 eql? 的返回值也可能不同。

(1..2) == (1..2.0)   # => true
(1..2).eql? (1..2.0) # => false