класс Range

Родительский класс:: Object
Подключённые модули:: Enumerable

Объект 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 и для начала, и для конца, поскольку именно так Ruby отображает диапазон в методе Range#inspect:

(nil..)    # => (nil..nil)
(..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; вызывает блок для каждого n-го элемента self.
each: вызывает блок для каждого элемента self.
step: принимает необязательный аргумент n (по умолчанию равен 1); вызывает блок для каждого n-го элемента self.

Методы для преобразования

inspect: возвращает строковое представление self (использует inspect).
to_a (также доступен под псевдонимом entries): возвращает элементы self в виде массива.
to_s: возвращает строковое представление self (использует to_s).

Методы для работы с JSON

::json_create: возвращает новый объект Range, созданный на основе заданного объекта.
as_json: возвращает хеш из двух элементов, представляющий self.
to_json: возвращает строку JSON, представляющую self.

Чтобы сделать эти методы доступными:

require 'json/add/range'

Открытые методы класса

json_create (object) Показать исходный код

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

См. as_json.

new(begin, end, exclude_end = false) → new_range Показать исходный код

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;
}

Возвращает новый диапазон на основе заданных объектов 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"]

Общедоступные методы экземпляра

%(n) {|element| ... } → self Показать исходный код

%(n) → enumerator or arithmetic_sequence

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

То же, что и 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)

self == other → true or false Показать исходный код

static VALUE
range_eq(VALUE range, VALUE obj)
{
    if (range == obj)
        return Qtrue;
    if (!rb_obj_is_kind_of(obj, rb_cRange))
        return Qfalse;

    return rb_exec_recursive_paired(recursive_equal, range, obj, obj);
}

Возвращает 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

Связанный метод: Range#eql?.

self === object → true or false Показать исходный код

static VALUE
range_eqq(VALUE range, VALUE val)
{
    return r_cover_p(range, RANGE_BEG(range), RANGE_END(range), val);
}

Возвращает true, если object находится между self.begin и self.end. В противном случае возвращает false:

(1..4) === 2       # => true
(1..4) === 5       # => false
(1..4) === 'a'     # => false
(1..4) === 4       # => true
(1...4) === 4      # => false
('a'..'d') === 'c' # => true
('a'..'d') === 'e' # => false

В операторе case используется метод ===, поэтому:

case 79
when (1..50)
  "low"
when (51..75)
  "medium"
when (76..100)
  "high"
end # => "high"

case "2.6.5"
when ..."2.4"
  "EOL"
when "2.4"..."2.5"
  "maintenance"
when "2.5"..."3.0"
  "stable"
when "3.1"..
  "upcoming"
end # => "stable"

as_json (*) Показать исходный код

# File ext/json/lib/json/add/range.rb, line 31
def as_json(*)
  {
    JSON.create_id  => self.class.name,
    'a'             => [ first, last, exclude_end? ]
  }
end

Методы Range#as_json и Range.json_create можно использовать для сериализации и десериализации объекта Range; см. Marshal.

Метод Range#as_json сериализует self, возвращая хеш из двух элементов, представляющий self:

require 'json/add/range'
x = (1..4).as_json     # => {"json_class"=>"Range", "a"=>[1, 4, false]}
y = (1...4).as_json    # => {"json_class"=>"Range", "a"=>[1, 4, true]}
z = ('a'..'d').as_json # => {"json_class"=>"Range", "a"=>["a", "d", false]}

Метод JSON.create десериализует такой хеш, возвращая объект Range:

Range.json_create(x) # => 1..4
Range.json_create(y) # => 1...4
Range.json_create(z) # => "a".."d"

begin → object Показать исходный код

static VALUE
range_begin(VALUE range)
{
    return RANGE_BEG(range);
}

Возвращает объект, определяющий начало self.

(1..4).begin # => 1
(..2).begin  # => nil

Связанные методы: Range#first, Range#end.

bsearch {|obj| block } → value Показать исходный код

static VALUE
range_bsearch(VALUE range)
{
    VALUE beg, end, satisfied = Qnil;
    int smaller;

    /* Implementation notes:
     * Floats are handled by mapping them to 64 bits integers.
     * Apart from sign issues, floats and their 64 bits integer have the
     * same order, assuming they are represented as exponent followed
     * by the mantissa. This is true with or without implicit bit.
     *
     * Finding the average of two ints needs to be careful about
     * potential overflow (since float to long can use 64 bits).
     *
     * The half-open interval (low, high] indicates where the target is located.
     * The loop continues until low and high are adjacent.
     *
     * -1/2 can be either 0 or -1 in C89. However, when low and high are not adjacent,
     * the rounding direction of mid = (low + high) / 2 does not affect the result of
     * the binary search.
     *
     * Note that -0.0 is mapped to the same int as 0.0 as we don't want
     * (-1...0.0).bsearch to yield -0.0.
     */

#define BSEARCH(conv, excl) \
    do { \
        RETURN_ENUMERATOR(range, 0, 0); \
        if (!(excl)) high++; \
        low--; \
        while (low + 1 < high) { \
            mid = ((high < 0) == (low < 0)) ? low + ((high - low) / 2) \
                : (low + high) / 2; \
            BSEARCH_CHECK(conv(mid)); \
            if (smaller) { \
                high = mid; \
            } \
            else { \
                low = mid; \
            } \
        } \
        return satisfied; \
    } while (0)

#define BSEARCH_FIXNUM(beg, end, excl) \
    do { \
        long low = FIX2LONG(beg); \
        long high = FIX2LONG(end); \
        long mid; \
        BSEARCH(INT2FIX, (excl)); \
    } while (0)

    beg = RANGE_BEG(range);
    end = RANGE_END(range);

    if (FIXNUM_P(beg) && FIXNUM_P(end)) {
        BSEARCH_FIXNUM(beg, end, EXCL(range));
    }
#if SIZEOF_DOUBLE == 8 && defined(HAVE_INT64_T)
    else if (RB_FLOAT_TYPE_P(beg) || RB_FLOAT_TYPE_P(end)) {
        int64_t low  = double_as_int64(NIL_P(beg) ? -HUGE_VAL : RFLOAT_VALUE(rb_Float(beg)));
        int64_t high = double_as_int64(NIL_P(end) ?  HUGE_VAL : RFLOAT_VALUE(rb_Float(end)));
        int64_t mid;
        BSEARCH(int64_as_double_to_num, EXCL(range));
    }
#endif
    else if (is_integer_p(beg) && is_integer_p(end)) {
        RETURN_ENUMERATOR(range, 0, 0);
        return bsearch_integer_range(beg, end, EXCL(range));
    }
    else if (is_integer_p(beg) && NIL_P(end)) {
        VALUE diff = LONG2FIX(1);
        RETURN_ENUMERATOR(range, 0, 0);
        while (1) {
            VALUE mid = rb_funcall(beg, '+', 1, diff);
            BSEARCH_CHECK(mid);
            if (smaller) {
                if (FIXNUM_P(beg) && FIXNUM_P(mid)) {
                    BSEARCH_FIXNUM(beg, mid, false);
                }
                else {
                    return bsearch_integer_range(beg, mid, false);
                }
            }
            diff = rb_funcall(diff, '*', 1, LONG2FIX(2));
            beg = mid;
        }
    }
    else if (NIL_P(beg) && is_integer_p(end)) {
        VALUE diff = LONG2FIX(-1);
        RETURN_ENUMERATOR(range, 0, 0);
        while (1) {
            VALUE mid = rb_funcall(end, '+', 1, diff);
            BSEARCH_CHECK(mid);
            if (!smaller) {
                if (FIXNUM_P(mid) && FIXNUM_P(end)) {
                    BSEARCH_FIXNUM(mid, end, false);
                }
                else {
                    return bsearch_integer_range(mid, end, false);
                }
            }
            diff = rb_funcall(diff, '*', 1, LONG2FIX(2));
            end = mid;
        }
    }
    else {
        rb_raise(rb_eTypeError, "can't do binary search for %s", rb_obj_classname(beg));
    }
    return range;
}

Возвращает элемент из self, найденный с помощью двоичного поиска.

См. Двоичный поиск.

count → integer Показать исходный код

count(object) → integer

count {|element| ... } → integer

static VALUE
range_count(int argc, VALUE *argv, VALUE range)
{
    if (argc != 0) {
        /* It is odd for instance (1...).count(0) to return Infinity. Just let
         * it loop. */
        return rb_call_super(argc, argv);
    }
    else if (rb_block_given_p()) {
        /* Likewise it is odd for instance (1...).count {|x| x == 0 } to return
         * Infinity. Just let it loop. */
        return rb_call_super(argc, argv);
    }

    VALUE beg = RANGE_BEG(range), end = RANGE_END(range);

    if (NIL_P(beg) || NIL_P(end)) {
        /* We are confident that the answer is Infinity. */
        return DBL2NUM(HUGE_VAL);
    }

    if (is_integer_p(beg)) {
        VALUE size = range_size(range);
        if (!NIL_P(size)) {
            return size;
        }
    }

    return rb_call_super(argc, argv);
}

Возвращает количество элементов, соответствующих заданному аргументу или условию блока, если они указаны.

Если аргумент и блок не заданы, возвращает количество элементов:

(1..4).count      # => 4
(1...4).count     # => 3
('a'..'d').count  # => 4
('a'...'d').count # => 3
(1..).count       # => Infinity
(..4).count       # => Infinity

Если задан аргумент object, возвращает количество вхождений object в self; обычно это ноль или один:

(1..4).count(2)   # => 1
(1..4).count(5)   # => 0
(1..4).count('a')  # => 0

Если задан блок, вызывает его для каждого элемента и возвращает количество элементов, для которых блок возвращает истинное значение:

(1..4).count {|element| element < 3 } # => 2

Связанный метод: Range#size.

cover?(object) → true or false Показать исходный код

cover?(range) → true or false

static VALUE
range_cover(VALUE range, VALUE val)
{
    VALUE beg, end;

    beg = RANGE_BEG(range);
    end = RANGE_END(range);

    if (rb_obj_is_kind_of(val, rb_cRange)) {
        return RBOOL(r_cover_range_p(range, beg, end, val));
    }
    return r_cover_p(range, beg, end, val);
}

Возвращает true, если переданный аргумент входит в self, и false в противном случае.

Если аргумент object не является диапазоном, выполняет проверку с помощью <= и <.

Для диапазона self с включённым конечным значением (#exclude_end? == false) проверка выполняется следующим образом:

self.begin <= object <= self.end

Примеры:

r = (1..4)
r.cover?(1)     # => true
r.cover?(4)     # => true
r.cover?(0)     # => false
r.cover?(5)     # => false
r.cover?('foo') # => false

r = ('a'..'d')
r.cover?('a')     # => true
r.cover?('d')     # => true
r.cover?(' ')     # => false
r.cover?('e')     # => false
r.cover?(0)       # => false

Для диапазона r с исключённым конечным значением (#exclude_end? == true) проверка выполняется следующим образом:

r.begin <= object < r.end

Примеры:

r = (1...4)
r.cover?(1)     # => true
r.cover?(3)     # => true
r.cover?(0)     # => false
r.cover?(4)     # => false
r.cover?('foo') # => false

r = ('a'...'d')
r.cover?('a')     # => true
r.cover?('c')     # => true
r.cover?(' ')     # => false
r.cover?('d')     # => false
r.cover?(0)       # => false

Если аргумент range является диапазоном, сравниваются первый и последний элементы self и range:

r = (1..4)
r.cover?(1..4)     # => true
r.cover?(0..4)     # => false
r.cover?(1..5)     # => false
r.cover?('a'..'d') # => false

r = (1...4)
r.cover?(1..3)     # => true
r.cover?(1..4)     # => false

Если начало и конец — числовые значения, cover? работает так же, как include?.

(1..3).cover?(1.5) # => true
(1..3).include?(1.5) # => true

Однако для нечисловых значений результаты этих двух методов могут различаться:

('a'..'d').cover?('cc')   # => true
('a'..'d').include?('cc') # => false

Возвращает false в любом из следующих случаев:

Начальное значение self больше конечного.
Внутренний вызов <=> возвращает nil, то есть операнды несравнимы.

Диапазоны без начала охватывают все значения того же типа, предшествующие конечному значению; для диапазонов с исключённой границей конечное значение не включается. Диапазоны без начала охватывают диапазоны, заканчивающиеся до конечного значения такого диапазона, а для диапазонов с включённой границей — также заканчивающиеся на нём.

(..2).cover?(1)     # => true
(..2).cover?(2)     # => true
(..2).cover?(3)     # => false
(...2).cover?(2)    # => false
(..2).cover?("2")   # => false
(..2).cover?(..2)   # => true
(..2).cover?(...2)  # => true
(..2).cover?(.."2") # => false
(...2).cover?(..2)  # => false

Диапазоны без конца охватывают все значения того же типа, следующие за начальным значением. Бесконечные диапазоны с исключённой границей не охватывают бесконечные диапазоны с включённой границей.

(2..).cover?(1)     # => false
(2..).cover?(3)     # => true
(2...).cover?(3)    # => true
(2..).cover?(2)     # => true
(2..).cover?("2")   # => false
(2..).cover?(2..)   # => true
(2..).cover?(2...)  # => true
(2..).cover?("2"..) # => false
(2...).cover?(2..)  # => false
(2...).cover?(3...) # => true
(2...).cover?(3..)  # => false
(3..).cover?(2..)   # => false

Диапазоны без начала и конца охватывают все значения и диапазоны и возвращают true для любых аргументов, за исключением того, что диапазоны без начала и конца с исключённой границей не охватывают бесконечные диапазоны с включённой границей.

(nil...).cover?(Object.new) # => true
(nil...).cover?(nil...)     # => true
(nil..).cover?(nil...)      # => true
(nil...).cover?(nil..)      # => false
(nil...).cover?(1..)        # => false

Связанный метод: Range#include?.

each {|element| ... } → self Показать исходный код

each → an_enumerator

static VALUE
range_each(VALUE range)
{
    VALUE beg, end;
    long i;

    RETURN_SIZED_ENUMERATOR(range, 0, 0, range_enum_size);

    beg = RANGE_BEG(range);
    end = RANGE_END(range);

    if (FIXNUM_P(beg) && NIL_P(end)) {
        range_each_fixnum_endless(beg);
    }
    else if (FIXNUM_P(beg) && FIXNUM_P(end)) { /* fixnums are special */
        return range_each_fixnum_loop(beg, end, range);
    }
    else if (RB_INTEGER_TYPE_P(beg) && (NIL_P(end) || RB_INTEGER_TYPE_P(end))) {
        if (SPECIAL_CONST_P(end) || RBIGNUM_POSITIVE_P(end)) { /* end >= FIXNUM_MIN */
            if (!FIXNUM_P(beg)) {
                if (RBIGNUM_NEGATIVE_P(beg)) {
                    do {
                        rb_yield(beg);
                    } while (!FIXNUM_P(beg = rb_big_plus(beg, INT2FIX(1))));
                    if (NIL_P(end)) range_each_fixnum_endless(beg);
                    if (FIXNUM_P(end)) return range_each_fixnum_loop(beg, end, range);
                }
                else {
                    if (NIL_P(end)) range_each_bignum_endless(beg);
                    if (FIXNUM_P(end)) return range;
                }
            }
            if (FIXNUM_P(beg)) {
                i = FIX2LONG(beg);
                do {
                    rb_yield(LONG2FIX(i));
                } while (POSFIXABLE(++i));
                beg = LONG2NUM(i);
            }
            ASSUME(!FIXNUM_P(beg));
            ASSUME(!SPECIAL_CONST_P(end));
        }
        if (!FIXNUM_P(beg) && RBIGNUM_SIGN(beg) == RBIGNUM_SIGN(end)) {
            if (EXCL(range)) {
                while (rb_big_cmp(beg, end) == INT2FIX(-1)) {
                    rb_yield(beg);
                    beg = rb_big_plus(beg, INT2FIX(1));
                }
            }
            else {
                VALUE c;
                while ((c = rb_big_cmp(beg, end)) != INT2FIX(1)) {
                    rb_yield(beg);
                    if (c == INT2FIX(0)) break;
                    beg = rb_big_plus(beg, INT2FIX(1));
                }
            }
        }
    }
    else if (SYMBOL_P(beg) && (NIL_P(end) || SYMBOL_P(end))) { /* symbols are special */
        beg = rb_sym2str(beg);
        if (NIL_P(end)) {
            rb_str_upto_endless_each(beg, sym_each_i, 0);
        }
        else {
            rb_str_upto_each(beg, rb_sym2str(end), EXCL(range), sym_each_i, 0);
        }
    }
    else {
        VALUE tmp = rb_check_string_type(beg);

        if (!NIL_P(tmp)) {
            if (!NIL_P(end)) {
                rb_str_upto_each(tmp, end, EXCL(range), each_i, 0);
            }
            else {
                rb_str_upto_endless_each(tmp, each_i, 0);
            }
        }
        else {
            if (!discrete_object_p(beg)) {
                rb_raise(rb_eTypeError, "can't iterate from %s",
                         rb_obj_classname(beg));
            }
            if (!NIL_P(end))
                range_each_func(range, each_i, 0);
            else
                for (;; beg = rb_funcallv(beg, id_succ, 0, 0))
                    rb_yield(beg);
        }
    }
    return range;
}

Если задан блок, передаёт ему каждый элемент self:

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

Вызывает исключение, если self.first.respond_to?(:succ).

Если блок не задан, возвращает перечислитель.

end → object Показать исходный код

static VALUE
range_end(VALUE range)
{
    return RANGE_END(range);
}

Возвращает объект, определяющий конец self.

(1..4).end  # => 4
(1...4).end # => 4
(1..).end   # => nil

Связанные методы: Range#begin, Range#last.

entries

Псевдоним для: to_a

eql?(other) → true or false Показать исходный код

static VALUE
range_eql(VALUE range, VALUE obj)
{
    if (range == obj)
        return Qtrue;
    if (!rb_obj_is_kind_of(obj, rb_cRange))
        return Qfalse;
    return rb_exec_recursive_paired(recursive_eql, range, obj, obj);
}

Возвращает true тогда и только тогда, когда:

other является диапазоном.
other.begin.eql?(self.begin).
other.end.eql?(self.end).
other.exclude_end? == self.exclude_end?.

В противном случае возвращает false.

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

Обратите внимание: даже при одинаковом аргументе возвращаемые значения == и eql? могут различаться:

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

Связанный метод: Range#==.

exclude_end? → true or false Показать исходный код

static VALUE
range_exclude_end_p(VALUE range)
{
    return RBOOL(EXCL(range));
}

Возвращает true, если self исключает конечное значение; в противном случае возвращает false:

Range.new(2, 5).exclude_end?       # => false
Range.new(2, 5, true).exclude_end? # => true
(2..5).exclude_end?                # => false
(2...5).exclude_end?               # => true

first → object Показать исходный код

first(n) → array

static VALUE
range_first(int argc, VALUE *argv, VALUE range)
{
    VALUE n, ary[2];

    if (NIL_P(RANGE_BEG(range))) {
        rb_raise(rb_eRangeError, "cannot get the first element of beginless range");
    }
    if (argc == 0) return RANGE_BEG(range);

    rb_scan_args(argc, argv, "1", &n);
    ary[0] = n;
    ary[1] = rb_ary_new2(NUM2LONG(n));
    rb_block_call(range, idEach, 0, 0, first_i, (VALUE)ary);

    return ary[1];
}

Если аргумент не задан, возвращает первый элемент self, если он существует:

(1..4).first     # => 1
('a'..'d').first # => "a"

Если задан неотрицательный целочисленный аргумент n, возвращает первые n элементов в массиве:

(1..10).first(3) # => [1, 2, 3]
(1..10).first(0) # => []
(1..4).first(50) # => [1, 2, 3, 4]

Если первого элемента нет, вызывает исключение:

(..4).first # Raises RangeError

hash → integer Показать исходный код

static VALUE
range_hash(VALUE range)
{
    st_index_t hash = EXCL(range);
    VALUE v;

    hash = rb_hash_start(hash);
    v = rb_hash(RANGE_BEG(range));
    hash = rb_hash_uint(hash, NUM2LONG(v));
    v = rb_hash(RANGE_END(range));
    hash = rb_hash_uint(hash, NUM2LONG(v));
    hash = rb_hash_uint(hash, EXCL(range) << 24);
    hash = rb_hash_end(hash);

    return ST2FIX(hash);
}

Возвращает целочисленное хеш-значение для self. Два объекта диапазона r0 и r1 имеют одинаковое хеш-значение тогда и только тогда, когда r0.eql?(r1).

Связанные методы: Range#eql?, Object#hash.

include?(object) → true or false

Возвращает true, если object является элементом self, и false в противном случае:

(1..4).include?(2)        # => true
(1..4).include?(5)        # => false
(1..4).include?(4)        # => true
(1...4).include?(4)       # => false
('a'..'d').include?('b')  # => true
('a'..'d').include?('e')  # => false
('a'..'d').include?('B')  # => false
('a'..'d').include?('d')  # => true
('a'...'d').include?('d') # => false

Если начало и конец — числовые значения, include? работает так же, как cover?.

(1..3).include?(1.5) # => true
(1..3).cover?(1.5) # => true

Однако для нечисловых значений результаты этих двух методов могут различаться:

('a'..'d').include?('cc') # => false
('a'..'d').cover?('cc')   # => true

Связанный метод: Range#cover?.

Псевдоним для: member?

inspect → string Показать исходный код

static VALUE
range_inspect(VALUE range)
{
    return rb_exec_recursive(inspect_range, range, 0);
}

Возвращает строковое представление self, включая begin.inspect и end.inspect:

(1..4).inspect  # => "1..4"
(1...4).inspect # => "1...4"
(1..).inspect   # => "1.."
(..4).inspect   # => "..4"

Обратите внимание: результаты методов to_s и inspect могут различаться:

('a'..'d').to_s    # => "a..d"
('a'..'d').inspect # => "\"a\"..\"d\""

Связанный метод: Range#to_s.

last → object Показать исходный код

last(n) → array

static VALUE
range_last(int argc, VALUE *argv, VALUE range)
{
    if (NIL_P(RANGE_END(range))) {
        rb_raise(rb_eRangeError, "cannot get the last element of endless range");
    }
    if (argc == 0) return RANGE_END(range);
    if (integer_end_optimizable(range)) {
        return rb_int_range_last(argc, argv, range);
    }
    return rb_ary_last(argc, argv, rb_Array(range));
}

Если аргумент не задан, возвращает последний элемент self, если он существует:

(1..4).last     # => 4
('a'..'d').last # => "d"

Обратите внимание: вызов last без аргумента возвращает конечный элемент self, даже если exclude_end? равен true:

(1...4).last     # => 4
('a'...'d').last # => "d"

Если задан неотрицательный целочисленный аргумент n, возвращает последние n элементов в массиве:

(1..10).last(3) # => [8, 9, 10]
(1..10).last(0) # => []
(1..4).last(50) # => [1, 2, 3, 4]

Обратите внимание: вызов last с аргументом не возвращает конечный элемент self, если exclude_end? равен true:

(1...4).last(3)     # => [1, 2, 3]
('a'...'d').last(3) # => ["a", "b", "c"]

Если последнего элемента нет, вызывает исключение:

(1..).last # Raises RangeError

max → object Показать исходный код

max(n) → array

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

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

static VALUE
range_max(int argc, VALUE *argv, VALUE range)
{
    VALUE e = RANGE_END(range);
    int nm = FIXNUM_P(e) || rb_obj_is_kind_of(e, rb_cNumeric);

    if (NIL_P(RANGE_END(range))) {
        rb_raise(rb_eRangeError, "cannot get the maximum of endless range");
    }

    VALUE b = RANGE_BEG(range);

    if (rb_block_given_p() || (EXCL(range) && !nm)) {
        if (NIL_P(b)) {
            rb_raise(rb_eRangeError, "cannot get the maximum of beginless range with custom comparison method");
        }
        return rb_call_super(argc, argv);
    }
    else if (argc) {
        VALUE ary[2];
        ID reverse_each;
        CONST_ID(reverse_each, "reverse_each");
        rb_scan_args(argc, argv, "1", &ary[0]);
        ary[1] = rb_ary_new2(NUM2LONG(ary[0]));
        rb_block_call(range, reverse_each, 0, 0, first_i, (VALUE)ary);
        return ary[1];
#if 0
        if (integer_end_optimizable(range)) {
            return rb_int_range_last(argc, argv, range, true);
        }
        return rb_ary_reverse(rb_ary_last(argc, argv, rb_Array(range)));
#endif
    }
    else {
        int c = NIL_P(b) ? -1 : OPTIMIZED_CMP(b, e);

        if (c > 0)
            return Qnil;
        if (EXCL(range)) {
            if (!RB_INTEGER_TYPE_P(e)) {
                rb_raise(rb_eTypeError, "cannot exclude non Integer end value");
            }
            if (c == 0) return Qnil;
            if (!NIL_P(b) && !RB_INTEGER_TYPE_P(b)) {
                rb_raise(rb_eTypeError, "cannot exclude end value with non Integer begin value");
            }
            if (FIXNUM_P(e)) {
                return LONG2NUM(FIX2LONG(e) - 1);
            }
            return rb_int_minus(e,INT2FIX(1));
        }
        return e;
    }
}

Возвращает максимальное значение в self, используя для сравнения метод <=> или заданный блок.

Если аргумент и блок не заданы, возвращает элемент self с наибольшим значением.

(1..4).max     # => 4
('a'..'d').max # => "d"
(-4..-1).max   # => -1

Если задан неотрицательный целочисленный аргумент n, а блок не задан, возвращает n элементов self с наибольшими значениями в виде массива:

(1..4).max(2)     # => [4, 3]
('a'..'d').max(2) # => ["d", "c"]
(-4..-1).max(2)   # => [-1, -2]
(1..4).max(50)    # => [4, 3, 2, 1]

Если задан блок, он вызывается:

Сначала для первых двух элементов self.
Затем последовательно для текущего максимального значения и следующего элемента self.

Например:

(1..4).max {|a, b| p [a, b]; a <=> b } # => 4

Результат:

[2, 1]
[3, 2]
[4, 3]

Если аргумент не задан, а блок задан, возвращает значение, полученное при последнем вызове блока:

(1..4).max {|a, b| -(a <=> b) } # => 1

Если задан неотрицательный целочисленный аргумент n и блок, возвращает в виде массива значения, полученные при последних n вызовах блока:

(1..4).max(2) {|a, b| -(a <=> b) }  # => [1, 2]
(1..4).max(50) {|a, b| -(a <=> b) } # => [1, 2, 3, 4]

Возвращает пустой массив, если n равен нулю:

(1..4).max(0)                      # => []
(1..4).max(0) {|a, b| -(a <=> b) } # => []

Возвращает nil или пустой массив, если:

Начальное значение диапазона больше конечного:

(4..1).max                         # => nil
(4..1).max(2)                      # => []
(4..1).max {|a, b| -(a <=> b) }    # => nil
(4..1).max(2) {|a, b| -(a <=> b) } # => []

В диапазоне с исключённой границей начальное значение равно конечному:

(1...1).max                          # => nil
(1...1).max(2)                       # => []
(1...1).max  {|a, b| -(a <=> b) }    # => nil
(1...1).max(2)  {|a, b| -(a <=> b) } # => []

Вызывает исключение в любом из следующих случаев:

self является бесконечным диапазоном: (1..).
Задан блок, а self является диапазоном без начала.

Связанные методы: Range#min, Range#minmax.

member? Показать исходный код

static VALUE
range_include(VALUE range, VALUE val)
{
    VALUE ret = range_include_internal(range, val);
    if (!UNDEF_P(ret)) return ret;
    return rb_call_super(1, &val);
}

Также имеет псевдоним: include?

min → object Показать исходный код

min(n) → array

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

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

static VALUE
range_min(int argc, VALUE *argv, VALUE range)
{
    if (NIL_P(RANGE_BEG(range))) {
        rb_raise(rb_eRangeError, "cannot get the minimum of beginless range");
    }

    if (rb_block_given_p()) {
        if (NIL_P(RANGE_END(range))) {
            rb_raise(rb_eRangeError, "cannot get the minimum of endless range with custom comparison method");
        }
        return rb_call_super(argc, argv);
    }
    else if (argc != 0) {
        return range_first(argc, argv, range);
    }
    else {
        VALUE b = RANGE_BEG(range);
        VALUE e = RANGE_END(range);
        int c = NIL_P(e) ? -1 : OPTIMIZED_CMP(b, e);

        if (c > 0 || (c == 0 && EXCL(range)))
            return Qnil;
        return b;
    }
}

Возвращает минимальное значение в self, используя для сравнения метод <=> или заданный блок.

Если аргумент и блок не заданы, возвращает элемент self с наименьшим значением.

(1..4).min     # => 1
('a'..'d').min # => "a"
(-4..-1).min   # => -4

Если задан неотрицательный целочисленный аргумент n, а блок не задан, возвращает n элементов self с наименьшими значениями в виде массива:

(1..4).min(2)     # => [1, 2]
('a'..'d').min(2) # => ["a", "b"]
(-4..-1).min(2)   # => [-4, -3]
(1..4).min(50)    # => [1, 2, 3, 4]

Если задан блок, он вызывается:

Сначала для первых двух элементов self.
Затем последовательно для текущего минимального значения и следующего элемента self.

Например:

(1..4).min {|a, b| p [a, b]; a <=> b } # => 1

Результат:

[2, 1]
[3, 1]
[4, 1]

Если аргумент не задан, а блок задан, возвращает значение, полученное при последнем вызове блока:

(1..4).min {|a, b| -(a <=> b) } # => 4

(1..4).min(2) {|a, b| -(a <=> b) }  # => [4, 3]
(1..4).min(50) {|a, b| -(a <=> b) } # => [4, 3, 2, 1]

Возвращает пустой массив, если n равен нулю:

(1..4).min(0)                      # => []
(1..4).min(0) {|a, b| -(a <=> b) } # => []

Возвращает nil или пустой массив, если:

Начальное значение диапазона больше конечного:

(4..1).min                         # => nil
(4..1).min(2)                      # => []
(4..1).min {|a, b| -(a <=> b) }    # => nil
(4..1).min(2) {|a, b| -(a <=> b) } # => []

В диапазоне с исключённой границей начальное значение равно конечному:

(1...1).min                          # => nil
(1...1).min(2)                       # => []
(1...1).min  {|a, b| -(a <=> b) }    # => nil
(1...1).min(2)  {|a, b| -(a <=> b) } # => []

Вызывает исключение в любом из следующих случаев:

self является диапазоном без начала: (..4).
Задан блок, а self является бесконечным диапазоном.

Связанные методы: Range#max, Range#minmax.

minmax → [object, object] Показать исходный код

minmax {|a, b| ... } → [object, object]

static VALUE
range_minmax(VALUE range)
{
    if (rb_block_given_p()) {
        return rb_call_super(0, NULL);
    }
    return rb_assoc_new(
        rb_funcall(range, id_min, 0),
        rb_funcall(range, id_max, 0)
    );
}

Возвращает массив из двух элементов, содержащий минимальное и максимальное значения в self, определённые методом сравнения <=> или заданным блоком.

Если блок не задан, возвращает минимальное и максимальное значения, используя для сравнения <=>:

(1..4).minmax     # => [1, 4]
(1...4).minmax    # => [1, 3]
('a'..'d').minmax # => ["a", "d"]
(-4..-1).minmax   # => [-4, -1]

Если задан блок, он должен возвращать целое число:

Отрицательное, если a меньше b.
Ноль, если a и b равны.
Положительное, если a больше b.

Блок вызывается self.size раз для сравнения элементов; возвращается массив из двух элементов Array, содержащий минимальное и максимальное значения из self согласно блоку:

(1..4).minmax {|a, b| -(a <=> b) } # => [4, 1]

Возвращает [nil, nil], если:

Начальное значение диапазона больше конечного:

(4..1).minmax                      # => [nil, nil]
(4..1).minmax {|a, b| -(a <=> b) } # => [nil, nil]

В диапазоне с исключённой границей начальное значение равно конечному:
```
(1...1).minmax                          # => [nil, nil]
(1...1).minmax  {|a, b| -(a <=> b) }    # => [nil, nil]
```

Вызывает исключение, если self является диапазоном без начала или без конца.

Связанные методы: Range#min, Range#max.

overlap?(range) → true or false Показать исходный код

static VALUE
range_overlap(VALUE range, VALUE other)
{
    if (!rb_obj_is_kind_of(other, rb_cRange)) {
        rb_raise(rb_eTypeError, "wrong argument type %"PRIsVALUE" (expected Range)",
                 rb_class_name(rb_obj_class(other)));
    }

    VALUE self_beg = RANGE_BEG(range);
    VALUE self_end = RANGE_END(range);
    int self_excl = EXCL(range);
    VALUE other_beg = RANGE_BEG(other);
    VALUE other_end = RANGE_END(other);
    int other_excl = EXCL(other);

    if (empty_region_p(self_beg, other_end, other_excl)) return Qfalse;
    if (empty_region_p(other_beg, self_end, self_excl)) return Qfalse;

    if (!NIL_P(self_beg) && !NIL_P(other_beg)) {
        VALUE cmp = rb_funcall(self_beg, id_cmp, 1, other_beg);
        if (NIL_P(cmp)) return Qfalse;
        /* if both begin values are equal, no more comparisons needed */
        if (rb_cmpint(cmp, self_beg, other_beg) == 0) return Qtrue;
    }
    else if (NIL_P(self_beg) && !NIL_P(self_end) && NIL_P(other_beg) && !NIL_P(other_end)) {
        VALUE cmp = rb_funcall(self_end, id_cmp, 1, other_end);
        return RBOOL(!NIL_P(cmp));
    }

    if (empty_region_p(self_beg, self_end, self_excl)) return Qfalse;
    if (empty_region_p(other_beg, other_end, other_excl)) return Qfalse;

    return Qtrue;
}

Возвращает true, если range пересекается с self, и false в противном случае:

(0..2).overlap?(1..3) #=> true
(0..2).overlap?(3..4) #=> false
(0..).overlap?(..0)   #=> true

Если аргумент не является диапазоном, вызывает TypeError.

(1..3).overlap?(1)         # TypeError

Возвращает false, если внутренний вызов <=> возвращает nil, то есть операнды несравнимы.

(1..3).overlap?('a'..'d')  # => false

Возвращает false, если self или range пуст. «Пустой диапазон» — это диапазон, начальное значение которого больше конечного или равно ему (если конечная граница исключена).

(4..1).overlap?(2..3)      # => false
(4..1).overlap?(..3)       # => false
(4..1).overlap?(2..)       # => false
(2...2).overlap?(1..2)     # => false

(1..4).overlap?(3..2)      # => false
(..4).overlap?(3..2)       # => false
(1..).overlap?(3..2)       # => false
(1..2).overlap?(2...2)     # => false

Возвращает false, если начальное значение одного из self и range больше конечного значения другого или равно ему, если другой диапазон имеет исключённую границу:

(4..5).overlap?(2..3)      # => false
(4..5).overlap?(2...4)     # => false

(1..2).overlap?(3..4)      # => false
(1...3).overlap?(3..4)     # => false

Возвращает false, если конечное значение одного из self и range больше конечного значения другого или равно ему, если другой диапазон имеет исключённую границу:

(4..5).overlap?(2..3)      # => false
(4..5).overlap?(2...4)     # => false

(1..2).overlap?(3..4)      # => false
(1...3).overlap?(3..4)     # => false

Обратите внимание: метод не предполагает, что диапазон без начала фактически пуст, даже если его верхняя граница является минимально возможным значением данного типа; поэтому все приведённые ниже выражения вернут true:

(...-Float::INFINITY).overlap?(...-Float::INFINITY) # => true
(..."").overlap?(..."") # => true
(...[]).overlap?(...[]) # => true

Даже если эти диапазоны фактически пусты (ни одно число не может быть меньше -Float::INFINITY), они всё равно считаются пересекающимися сами с собой.

Связанный метод: Range#cover?.

reverse_each {|element| ... } → self Показать исходный код

reverse_each → an_enumerator

static VALUE
range_reverse_each(VALUE range)
{
    RETURN_SIZED_ENUMERATOR(range, 0, 0, range_enum_reverse_size);

    VALUE beg = RANGE_BEG(range);
    VALUE end = RANGE_END(range);
    int excl = EXCL(range);

    if (NIL_P(end)) {
        rb_raise(rb_eTypeError, "can't iterate from %s",
                 rb_obj_classname(end));
    }

    if (FIXNUM_P(beg) && FIXNUM_P(end)) {
        if (excl) {
            if (end == LONG2FIX(FIXNUM_MIN)) return range;

            end = rb_int_minus(end, INT2FIX(1));
        }

        range_reverse_each_fixnum_section(beg, end);
    }
    else if ((NIL_P(beg) || RB_INTEGER_TYPE_P(beg)) && RB_INTEGER_TYPE_P(end)) {
        if (excl) {
            end = rb_int_minus(end, INT2FIX(1));
        }
        range_reverse_each_positive_bignum_section(beg, end);
        range_reverse_each_fixnum_section(beg, end);
        range_reverse_each_negative_bignum_section(beg, end);
    }
    else {
        return rb_call_super(0, NULL);
    }

    return range;
}

Если задан блок, передаёт ему каждый элемент self в обратном порядке:

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

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

Если блок не задан, возвращает перечислитель.

size → non_negative_integer or Infinity or nil Показать исходный код

static VALUE
range_size(VALUE range)
{
    VALUE b = RANGE_BEG(range), e = RANGE_END(range);

    if (RB_INTEGER_TYPE_P(b)) {
        if (rb_obj_is_kind_of(e, rb_cNumeric)) {
            return ruby_num_interval_step_size(b, e, INT2FIX(1), EXCL(range));
        }
        if (NIL_P(e)) {
            return DBL2NUM(HUGE_VAL);
        }
    }

    if (!discrete_object_p(b)) {
        CANT_ITERATE_FROM(b);
    }

    return Qnil;
}

Возвращает количество элементов в self, если начальное и конечное значения являются числовыми; в противном случае возвращает nil:

(1..4).size      # => 4
(1...4).size     # => 3
(1..).size       # => Infinity
('a'..'z').size  # => nil

Если self не является итерируемым объектом, вызывает исключение:

(0.5..2.5).size  # TypeError
(..1).size       # TypeError

Связанный метод: Range#count.

step(s = 1) {|element| ... } → self Показать исходный код

step(s = 1) → enumerator/arithmetic_sequence

static VALUE
range_step(int argc, VALUE *argv, VALUE range)
{
    VALUE b, e, v, step;
    int c, dir;

    b = RANGE_BEG(range);
    e = RANGE_END(range);
    v = b;

    const VALUE b_num_p = rb_obj_is_kind_of(b, rb_cNumeric);
    const VALUE e_num_p = rb_obj_is_kind_of(e, rb_cNumeric);
    // For backward compatibility reasons (conforming to behavior before 3.4), String/Symbol
    // supports both old behavior ('a'..).step(1) and new behavior ('a'..).step('a')
    // Hence the additional conversion/additional checks.
    const VALUE str_b = rb_check_string_type(b);
    const VALUE sym_b = SYMBOL_P(b) ? rb_sym2str(b) : Qnil;

    if (rb_check_arity(argc, 0, 1))
        step = argv[0];
    else {
        if (b_num_p || !NIL_P(str_b) || !NIL_P(sym_b) || (NIL_P(b) && e_num_p))
            step = INT2FIX(1);
        else
            rb_raise(rb_eArgError, "step is required for non-numeric ranges");
    }

    const VALUE step_num_p = rb_obj_is_kind_of(step, rb_cNumeric);

    if (step_num_p && b_num_p && rb_equal(step, INT2FIX(0))) {
        rb_raise(rb_eArgError, "step can't be 0");
    }

    if (!rb_block_given_p()) {
        // This code is allowed to create even beginless ArithmeticSequence, which can be useful,
        // e.g., for array slicing:
        //   ary[(..-1) % 3]
        if (step_num_p && ((b_num_p && (NIL_P(e) || e_num_p)) || (NIL_P(b) && e_num_p))) {
            return rb_arith_seq_new(range, ID2SYM(rb_frame_this_func()), argc, argv,
                    range_step_size, b, e, step, EXCL(range));
        }

        // ...but generic Enumerator from beginless range is useless and probably an error.
        if (NIL_P(b)) {
            rb_raise(rb_eArgError, "#step for non-numeric beginless ranges is meaningless");
        }

        RETURN_SIZED_ENUMERATOR(range, argc, argv, 0);
    }

    if (NIL_P(b)) {
        rb_raise(rb_eArgError, "#step iteration for beginless ranges is meaningless");
    }

    if (FIXNUM_P(b) && NIL_P(e) && FIXNUM_P(step)) {
        /* perform summation of numbers in C until their reach Fixnum limit */
        long i = FIX2LONG(b), unit = FIX2LONG(step);
        do {
            rb_yield(LONG2FIX(i));
            i += unit;          /* FIXABLE+FIXABLE never overflow */
        } while (FIXABLE(i));
        b = LONG2NUM(i);

        /* then switch to Bignum API */
        for (;; b = rb_big_plus(b, step))
            rb_yield(b);
    }
    else if (FIXNUM_P(b) && FIXNUM_P(e) && FIXNUM_P(step)) {
        /* fixnums are special: summation is performed in C for performance */
        long end = FIX2LONG(e);
        long i, unit = FIX2LONG(step);

        if (unit < 0) {
            if (!EXCL(range))
                end -= 1;
            i = FIX2LONG(b);
            while (i > end) {
                rb_yield(LONG2NUM(i));
                i += unit;
            }
        }
        else {
            if (!EXCL(range))
                end += 1;
            i = FIX2LONG(b);
            while (i < end) {
                rb_yield(LONG2NUM(i));
                i += unit;
            }
        }
    }
    else if (b_num_p && step_num_p && ruby_float_step(b, e, step, EXCL(range), TRUE)) {
        /* done */
    }
    else if (!NIL_P(str_b) && FIXNUM_P(step)) {
        // backwards compatibility behavior for String only, when no step/Integer step is passed
        // See discussion in https://bugs.ruby-lang.org/issues/18368

        VALUE iter[2] = {INT2FIX(1), step};

        if (NIL_P(e)) {
            rb_str_upto_endless_each(str_b, step_i, (VALUE)iter);
        }
        else {
            rb_str_upto_each(str_b, e, EXCL(range), step_i, (VALUE)iter);
        }
    }
    else if (!NIL_P(sym_b) && FIXNUM_P(step)) {
        // same as above: backward compatibility for symbols

        VALUE iter[2] = {INT2FIX(1), step};

        if (NIL_P(e)) {
            rb_str_upto_endless_each(sym_b, sym_step_i, (VALUE)iter);
        }
        else {
            rb_str_upto_each(sym_b, rb_sym2str(e), EXCL(range), sym_step_i, (VALUE)iter);
        }
    }
    else if (NIL_P(e)) {
        // endless range
        for (;; v = rb_funcall(v, id_plus, 1, step))
            rb_yield(v);
    }
    else if (b_num_p && step_num_p && r_less(step, INT2FIX(0)) < 0) {
        // iterate backwards, for consistency with ArithmeticSequence
        if (EXCL(range)) {
            for (; r_less(e, v) < 0; v = rb_funcall(v, id_plus, 1, step))
                rb_yield(v);
        }
        else {
            for (; (c = r_less(e, v)) <= 0; v = rb_funcall(v, id_plus, 1, step)) {
                rb_yield(v);
                if (!c) break;
            }
        }

    }
    else if ((dir = r_less(b, e)) == 0) {
        if (!EXCL(range)) {
            rb_yield(v);
        }
    }
    else if (dir == r_less(b, rb_funcall(b, id_plus, 1, step))) {
        // Direction of the comparison. We use it as a comparison operator in cycle:
        // if begin < end, the cycle performs while value < end (iterating forward)
        // if begin > end, the cycle performs while value > end (iterating backward with
        // a negative step)
        // One preliminary addition to check the step moves iteration in the same direction as
        // from begin to end; otherwise, the iteration should be empty.
        if (EXCL(range)) {
            for (; r_less(v, e) == dir; v = rb_funcall(v, id_plus, 1, step))
                rb_yield(v);
        }
        else {
            for (; (c = r_less(v, e)) == dir || c == 0; v = rb_funcall(v, id_plus, 1, step)) {
                rb_yield(v);
                if (!c) break;
            }
        }
    }
    return range;
}

Выполняет итерацию по элементам диапазона с шагом s. Итерация выполняется с помощью оператора +:

(0..6).step(2) { puts _1 } #=> 1..5
# Prints: 0, 2, 4, 6

# Iterate between two dates in step of 1 day (24 hours)
(Time.utc(2022, 2, 24)..Time.utc(2022, 3, 1)).step(24*60*60) { puts _1 }
# Prints:
#   2022-02-24 00:00:00 UTC
#   2022-02-25 00:00:00 UTC
#   2022-02-26 00:00:00 UTC
#   2022-02-27 00:00:00 UTC
#   2022-02-28 00:00:00 UTC
#   2022-03-01 00:00:00 UTC

Если + step уменьшает значение, итерация всё равно выполняется, когда шаг begin больше, чем end:

(0..6).step(-2) { puts _1 }
# Prints nothing

(6..0).step(-2) { puts _1 }
# Prints: 6, 4, 2, 0

(Time.utc(2022, 3, 1)..Time.utc(2022, 2, 24)).step(-24*60*60) { puts _1 }
# Prints:
#   2022-03-01 00:00:00 UTC
#   2022-02-28 00:00:00 UTC
#   2022-02-27 00:00:00 UTC
#   2022-02-26 00:00:00 UTC
#   2022-02-25 00:00:00 UTC
#   2022-02-24 00:00:00 UTC

Если блок не указан, а границы диапазона и шаг являются Numeric, метод возвращает Enumerator::ArithmeticSequence.

(1..5).step(2) # => ((1..5).step(2))
(1.0..).step(1.5) #=> ((1.0..).step(1.5))
(..3r).step(1/3r) #=> ((..3/1).step((1/3)))

Enumerator::ArithmeticSequence можно использовать далее как объект-значение для итерации или среза коллекций (см. Array#[]). Для более выразительного создания арифметических последовательностей предусмотрен удобный метод %, поведение которого аналогично step:

# Same as (1..5).step(2)
(1..5) % 2 # => ((1..5).%(2))

В общем случае, если блок не указан, возвращается Enumerator:

('a'..).step('b')         #=> #<Enumerator: "a"..:step("b")>
('a'..).step('b').take(3) #=> ["a", "ab", "abb"]

Если s не указан, для диапазонов с числовым begin он считается равным 1:

(1..5).step { p _1 }
# Prints: 1, 2, 3, 4, 5

Для диапазонов, не являющихся числовыми, отсутствие шага вызывает ошибку:

(Time.utc(2022, 3, 1)..Time.utc(2022, 2, 24)).step { p _1 }
# raises: step is required for non-numeric ranges (ArgumentError)

Для обеспечения обратной совместимости диапазоны String поддерживают итерацию как со строковым, так и с целочисленным шагом. Во втором случае итерация выполняется путём вычисления следующих значений с помощью String#succ:

('a'..'e').step(2) { p _1 }
# Prints: a, c, e
('a'..'e').step { p _1 }
# Default step 1; prints: a, b, c, d, e

to_a → array Показать исходный код

static VALUE
range_to_a(VALUE range)
{
    if (NIL_P(RANGE_END(range))) {
        rb_raise(rb_eRangeError, "cannot convert endless range to an array");
    }
    return rb_call_super(0, 0);
}

Возвращает массив, содержащий элементы self, если это конечная коллекция; в противном случае вызывает исключение.

(1..4).to_a     # => [1, 2, 3, 4]
(1...4).to_a    # => [1, 2, 3]
('a'..'d').to_a # => ["a", "b", "c", "d"]

Также имеет псевдоним: entries

to_json (*args) Показать исходный код

# File ext/json/lib/json/add/range.rb, line 51
def to_json(*args)
  as_json.to_json(*args)
end

Возвращает строку в формате JSON, представляющую self:

require 'json/add/range'
puts (1..4).to_json
puts (1...4).to_json
puts ('a'..'d').to_json

Результат:

{"json_class":"Range","a":[1,4,false]}
{"json_class":"Range","a":[1,4,true]}
{"json_class":"Range","a":["a","d",false]}

to_s → string Показать исходный код

static VALUE
range_to_s(VALUE range)
{
    VALUE str, str2;

    str = rb_obj_as_string(RANGE_BEG(range));
    str2 = rb_obj_as_string(RANGE_END(range));
    str = rb_str_dup(str);
    rb_str_cat(str, "...", EXCL(range) ? 3 : 2);
    rb_str_append(str, str2);

    return str;
}

Возвращает строковое представление self, включая begin.to_s и end.to_s:

(1..4).to_s  # => "1..4"
(1...4).to_s # => "1...4"
(1..).to_s   # => "1.."
(..4).to_s   # => "..4"

Обратите внимание, что результаты вызовов to_s и inspect могут различаться:

('a'..'d').to_s    # => "a..d"
('a'..'d').inspect # => "\"a\"..\"d\""

См. также: Range#inspect.

to_set → set Показать исходный код

static VALUE
range_to_set(int argc, VALUE *argv, VALUE range)
{
    if (NIL_P(RANGE_END(range))) {
        rb_raise(rb_eRangeError, "cannot convert endless range to a set");
    }
    return rb_call_super(argc, argv);
}

Возвращает множество, содержащее элементы self, если это конечная коллекция; в противном случае вызывает исключение.

(1..4).to_set   # => Set[1, 2, 3, 4]
(1...4).to_set   # => Set[1, 2, 3]

(1..).to_set
# in 'Range#to_set': cannot convert endless range to a set (RangeError)

Ruby Core © 1993–2025 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.