Ruby/Справочник/Array

Массив — упорядоченная коллекция произвольных объектов с целочисленной индексацией. Нумерация элементов массива начинается с 0, как в языках Си или Java. Отрицательный индекс предполагает отсчет с конца массива, то есть индексу -1 соответствует последний элемент массива, -2 — предпоследний, и так далее.

Примеси

Enumerable (all?, any?, collect, detect, each_cons, each_slice, each_with_index, entries, enum_cons, enum_slice, enum_with_index, find, find_all, grep, group_by, include?, index_by, inject, map, max, member?, min, partition, reject, select, sort, sort_by, sum, to_a, to_set, zip)

Методы класса

[], new

Методы объекта

[]=, [], &, |, *, +, -, <<, <=>, ==, abbrev, assoc, append, at, bsearch, bsearch_index, clear, collect!, collect, combination, compact!, compact, concat, count, delete_at, delete_if, delete, each_index, each, empty?, eql?, fetch, fill, first, flatten!, flatten, frozen?, hash, include?, indexes, index, indices, insert, inspect, join, last, length, map!, map, min, nitems, pack, pop, push, rassoc, reject!, reject, replace, reverse!, reverse_each, reverse, rindex, rotate, rotate!, sample, select, shift, shuffle, size, slice!, slice, sort!, sort, to_ary, to_a, to_s, transpose, uniq!, uniq, unshift, values_at, zip

Array::[](...)

Возвращает новый массив, заполненный указанными объектами.

Array.[](1, 'a', /^A/)
Array[1, 'a', /^A/]
[1, 'a', /^A/]

Array.new(array)
Array.new(size=0, obj = nil)
Array.new(size){ |index| block }

Возвращает новый массив. В первой форме вызова, создается пустой массив. Во второй, создается массив размера size, заполненный копиями obj (то есть, size ссылок на obj). В третьей, создается копия массив, переданного в качестве параметра (массив создается при помощи вызова метода to_ary от массива-параметра). В последнем случае, создается массив указанного размера. Каждый элемент в этом массиве вычисляется в указанном блоке, которому передается индекс обрабатываемого элемента. Результат блока записывается в качестве значения элемента в массив.

Array.new
Array.new(2)
Array.new(5, "A")

# только одна копия объекта создается
a = Array.new(2, Hash.new)
a[0]['cat'] = 'feline'
a
a[1]['cat'] = 'Felix'
a

# здесь создается несколько копий объекта
a = Array.new(2) { Hash.new }
a[0]['cat'] = 'feline'
a

squares = Array.new(5) { |i| i*i }
squares

copy = Array.new(squares)

array & other_array

Пересечение множеств — возвращает новый массив, состоящий из элементов, которые есть в обоих массивах, но без дубликатов.

[1, 1, 3, 5] & [1, 2, 3]  #=> [1, 3]

array | other_array  #=> an_array

Объединение множеств — возвращает новый массив, который объединяет элементы массивов array и other_array, но с удаленными дубликатами.

["a", "b", "c"] | ["c", "d", "a"]  #=> ["a", "b", "c", "d"]

array * int  #=> an_array
array * str  #=> a_string

Повторение — со строковым аргументом эквивалентен коду array.join(str). Иначе, возвращает новый массив, состоящий из int сцепленных копий array.

[1, 2, 3] * 3    #=> [1, 2, 3, 1, 2, 3, 1, 2, 3]
[1, 2, 3] * ","  #=> "1,2,3"

array + other_array  #=> an_array

Сцепление — возвращает новый массив, созданный из двух массивов путем добавления одного к другому.

[1, 2, 3] + [4, 5]  #=> [1, 2, 3, 4, 5]

array - other_array  #=> an_array

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

[1, 1, 2, 2, 3, 3, 4, 5] - [1, 2, 4]  #=> [3, 3, 5]

Если вам необходима разность множеств, а не вычитание массивов, то смотрите в сторону класса Set

array << obj  #=> array

Добавить элемент — добавляет передаваемый объект в конец массива. Возвращает массив с уже добавленным элементом.

[1, 2] << "c" << "d" << [3, 4]  #=> [1, 2, "c", "d", [3, 4]]

Метод push имеет примерно такую же функциональность

array <=> other_array  #=> -1, 0, +1

Сравнение — возвращает целое число (-1, 0, или +1) если текущий массив меньше, равен или больше другого массива. Соответствующие элементы обоих массивов сравниваются (используется метод<=>). Если какая либо из пар элементов не совпадает, то возвращается результат этого сравнения. Если все пары элементов совпадают, то возвращается результат сравнения по длине. Таким образом, два массива считаются «равными» (по мнению методаArray#<=>) тогда и только тогда, когда их длины и соответствующие пары элементов совпадают.

["a", "a", "c"] <=> ["a", "b", "c"]  #=> -1
[1, 2, 3, 4, 5] <=> [1, 2, 3, 4, 5]  #=>  0
[1, 2, 3, 4, 5] <=> [1, 2, 3, 4]     #=> +1

array == other_array  #=> bool

Равенство — два массива считаются равными, если количество элементов и соответствующие пары элементов равны (используется метод==).

["a", "b"]    == ["a", "b", 5]    #=> false
["a", "b", 5] == ["a", "b", 5]    #=> true
["a", "b", 5] == ["a", "b", "c"]  #=> false

array[index]                #=> obj      или nil
array[start, length]        #=> an_array или nil
array[range]                #=> an_array или nil
array.slice(index)          #=> obj      или nil
array.slice(start, length)  #=> an_array или nil
array.slice(range)          #=> an_array или nil

Получение значения элемента — возвращает элемент с индексом index, или подмассив длины length, начиная с индекса start, или подмассив, который располагается в диапазоне range. Отрицательная индексация предполагает отчет с конца массива (по индексу -1 располагается последний элемент). Возвращаетnil, если индекс выходит за диапазон допустимых значений.

a = ["a", "b", "c", "d", "e"]
a[2] + a[0] + a[1]     #=> "cab"
a[6]                   #=> nil
a[1, 2]                #=> ["b", "c"]
a[1..3]                #=> ["b", "c", "d"]
a[4..7]                #=> ["e"]
a[6..10]               #=> nil
a[-3, 3]               #=> ["c", "d", "e"]
# Специальные случаи:
a[5]                   #=> nil
a[5, 1]                #=> []
a[5..10]               #=> []

Методы slice и [] — одно и тоже! Существует метод at, который обладает схожей, но меньшей функциональностью

array[index] = obj  #=> obj
array[start, length] = obj или an_array или nil  #=> obj или an_array или nil
array[range]         = obj или an_array или nil  #=> obj или an_array или nil

Распределение элементов — помещает элемент в array поindex, или заменяет подмассив некоторойlength (длины), начиная с индексаstart, или заменяет подмассив в определенномrange (диапазоне). Если индексация превышает текущий размер массива, то массив увеличивается автоматически. Отрицательная индексация подразумевает отсчет с конца массива. Если для второго случая использоватьlength равную 0, то указанные элементы будут вставлены перед элементом с индексомindex. Если все параметры для второго и третьего случая задать равнымиnil, то изarray будут удалены все элементы. Ошибка IndexError появляется тогда, когда отрицательный индекс указывает на элемент, расположенный перед началом массива.

a = Array.new
a[4] = "4"                 #=> [nil, nil, nil, nil, "4"]
a[0, 3] = ['a', 'b', 'c']  #=> ["a", "b", "c", nil, "4"]
a[1..2] = [1, 2]           #=> ["a", 1, 2, nil, "4"]
a[0, 2] = "?"              #=> ["?", 2, nil, "4"]
a[0..2] = "A"              #=> ["A", "4"]
a[-1]   = "Z"              #=> ["A", "Z"]
a[1..-1] = nil             #=> ["A"]

Полезно знать, что добавления элементов в массив существуют еще методы push и unshift

array.abbrev(pattern = nil)

Вычисляет набор однозначных сокращений для строк в array. Если в качестве pattern передается правило или строка, то будут обрабатываться только строки, которые соответствуют правилу или начинаются с данной строки.

%w{ car cone }.abbrev  #=> { "ca" => "car", "car"  => "car",
                       #=>   "co" => "cone", "con" => "cone",
                       #=> "cone" => "cone" }

array.assoc(obj)  #=> an_array или nil

Ищет в двумерном массиве массив, первый элемент которого равен obj (для сравнения используется метод==). Возвращает первый найденный массив (то есть, ассоциированный массив) или nil, если таковой найти не удалось.

s1 = ["colors", "red", "blue", "green"]
s2 = ["letters", "a", "b", "c"]
s3 = "foo"
a  = [s1, s2, s3]
a.assoc("letters")  #=> ["letters", "a", "b", "c"]
a.assoc("foo")      #=> nil

Для понимания происходящего, полезно взглянуть на метод rassoc

array.append(*args)  #=> array

Добавить элемент — добавляет передаваемый объект (или несколько объектов) в конец массива. Возвращает массив с выполненным преобразованием.

a = ["a", "b", "c"]
a.push("d", "e", "f")  #=> ["a", "b", "c", "d", "e", "f"]
a                      #=> ["a", "b", "c", "d", "e", "f"]

Добавляет каждый аргумент как один элемент, даже если это другой массив:

a = [:jay, "shri", 108]
a1 = a.push([:om, :tat], [:sat, :rama])
a1 # => [:jay, "shri", 108, [:om, :tat], [:sat, :rama]]

Методы append и push — одно и то же! Данный метод обычно используют совместно с методами shift, pop и unshift

array.at(index)  #=> obj или nil

Возвращает элемент массива array с индексом index. Отрицательная индексация подразумевает отсчет с конца массива. возвращаетnil, если индекс выходит за пределы допустимого диапазона.

a = ["a", "b", "c", "d", "e"]
a.at(0)   #=> "a"
a.at(-1)  #=> "e"

Рекомендуется также взглянуть на метод [] (aka «батарейка»), который обладает схожим функционалом Методat работает чуть быстрей метода[] за счет того, что не обрабатывает ничего кроме целочисленных индексов, то есть за счет игнорирования диапазонов

array.bsearch{|element| ... } #=> obj
array.bsearch                 #=> an_enumerator

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

Используя двоичный поиск, находит значение из этого array, которое удовлетворяет заданному условию в O (log n), где n - размер массива.

Есть два режима поиска:

Режим поиска-минимум: блок должен возвращать true или false.

Режим любого поиска: блок должен возвращать числовое значение.

Блок не должен смешивать режимы, иногда возвращая true или false, а иногда и возвращая числовое значение, но это не проверяется.

Режим поиска минимума

В режиме минимального поиска блок всегда возвращает true или false. Дальнейшее требование (хотя и не проверяемое) состоит в том, что не существует таких индексов i и j, что:

0 <= i < j <= self.size

Блок возвращает true для self[i] и false для self[j]

В режиме минимального поиска метод bsearch возвращает первый элемент, для которого блок возвращает true.

Примеры:
a = [0, 4, 7, 10, 12]
a.bsearch {|x| x >= 4 } # => 4
a.bsearch {|x| x >= 6 } # => 7
a.bsearch {|x| x >= -1 } # => 0
a.bsearch {|x| x >= 100 } # => nil

Продолжение следует... https://ruby-doc.org/core-3.0.2/Array.html

Рекомендуется также взглянуть на метод bsearch_index, который обладает схожим функционалом

array.bsearch_index{|element| ... } #=> int или nil
bsearch_index                       #=> an_enumerator

Ищет себя, как описано в методе bsearch, но возвращает индекс найденного элемента вместо самого элемента.

Рекомендуется также взглянуть на метод bsearch, который обладает схожим функционалом

array.clear  #=> array

Удаляет все элементы из массива array.

a = ["a", "b", "c", "d", "e"]
a.clear  #=> [ ]

array.collect{ |item| block }  #=> an_array
array.map{ |item| block }      #=> an_array

Выполняет выражение block для каждого элемента массива array. Создает новый массив, который состоит из значений, которые получены при вычислении выражения block.

a = ["a", "b", "c", "d"]
a.collect { |x| x + "!" }  #=> ["a!", "b!", "c!", "d!"]
a                          #=> ["a", "b", "c", "d"]

Есть итераторы Enumerable#collect и Enumerable#map, которые имеют схожую функциональность Итераторы map и collect — одно и то же!

array.collect!{ |item| block }  #=> array
array.map!{ |item| block }      #=> array

Выполняет выражение block для каждого элемента массива array, вычисленное выражение подставляется вместо текущего элемента.

a = ["a", "b", "c", "d"]
a.collect!{ |x| x + "!" }
a  #=> ["a!", "b!", "c!", "d!"]

Есть итераторы Enumerable#collect и Enumerable#map, которые имеют схожую функциональность Итераторы map! и collect! — одно и то же!

array.combination(n) {|element| ... } #=> self
combination(n)                        #=> new_enumerator

Вызывает block, если он задан, с комбинациями элементов self; возвращает self. Порядок комбинаций не определен.

Когда заданы block и входящий в диапазон положительный целочисленный аргумент n (0 <n <= self.size), вызывает block со всеми комбинациями кортежей из n элементов self.

Пример:

a = [0, 1, 2]
a.combination(2) {|combination| p combination }
#=>
[0, 1]
[0, 2]
[1, 2]
a #=> [0, 1, 2]

Другие примеры:

a = [0, 1, 2]
a.combination(3) {|combination| p combination }
Output:

[0, 1, 2]
When n is zero, calls the block once with a new empty Array:

a = [0, 1, 2]
a1 = a.combination(0) {|combination| p combination }
Output:

[]
When n is out of range (negative or larger than self.size), does not call the block:

a = [0, 1, 2]
a.combination(-1) {|combination| fail 'Cannot happen' }
a.combination(4) {|combination| fail 'Cannot happen' }
Returns a new Enumerator if no block given:

a = [0, 1, 2]
a.combination(2) # => #<Enumerator: [0, 1, 2]:combination(2)>

array.compact  #=> an_array

Возвращает копию массива array из которого удалены все элементы nil.

["a", nil, "b", nil, "c", nil].compact  #=> ["a", "b", "c"]

array.compact!  #=> array или nil

Удаляет все элементы nil из массива array. Возвращает nil, если изменять ничего не потребовалось.

["a", nil, "b", nil, "c"].compact!  #=> ["a", "b", "c"]
["a", "b", "c"].compact!            #=> nil

array.concat(other_array)  #=> array

Добавляет к массиву array элементы массива other_array.

["a", "b"].concat(["c", "d"]) #=> ["a", "b", "c", "d"]

array.count                  #=> int
array.count(obj)             #=> int
array.count { |item| block } #=> int

Без аргументов возвращает количество элементов массива. Если задан аргумент, считает количество элементов которые равны obj через ==. Если передан блок, считает количество элементов для которых блок возвращает true.

ary = [1, 2, 4, 2]
ary.count                  #=> 4
ary.count(2)               #=> 2
ary.count { |x| x%2 == 0 } #=> 3

array.delete(obj)           #=> obj или nil 
array.delete(obj){ block }  #=> obj или nil

Удаляет все элементы массива array, которые равны obj. Если ничего не было удалено, то возвращаетnil. Если задан блок, то, в случае отсутствия элементов для удаления, возвращает результат блока.

a = ["a", "b", "b", "b", "c"]
a.delete("b")                  #=> "b"
a                              #=> ["a", "c"]
a.delete("z")                  #=> nil
a.delete("z") { "not found" }  #=> "not found"

array.delete_at(index)  #=> obj или nil

Удаляет элемент из массива array, который имеет индекс index. Возвращает значение удаленного элемента илиnil, если index находится вне допустимого диапазона.

a = %w(ant bat cat dog)
a.delete_at(2)   #=> "cat"
a                #=> ["ant", "bat", "dog"]
a.delete_at(99)  #=> nil

Метод slice! имеет схожую функциональность

array.delete_if {|item| block }  #=> array

Удаляет все элементы массива array для которых значение внутри блока block равно true.

a = ["a", "b", "c"]
a.delete_if {|x| x >= "b" }  #=> ["a"]
a                            #=> ["a"]

Полезно посмотреть на следующие итераторы reject и reject!, которые имеют схожую функциональность

array.each {|item| block }  #=> array

Выполняет код в block для каждого элемента массива array, передавая в блок текущий элемент в качестве параметра.

a = ["a", "b", "c"]
a.each { |x| print x, " -- " }

результат:

a -- b -- c --

Данный итератор возвращает в качестве результата исходный массив. Это следует учитывать при построении цепочки методов Следует использовать данный метод только тогда, когда задачу невозможно решить при помощи других итераторов

array.each_index { |index| block }  #=> array

Работает точно также, как и each, но передает в блок не текущий элемент, а индекс текущего элемента.

a = ["a", "b", "c"]
a.each_index { |x| print x, " -- " }

результат:

0 -- 1 -- 2 --

array.empty?  #=> true или false

Возвращаетtrue, если array не содержит элементов.

[].empty?  #=> true

array.eql?(other)  #=> true или false

Возвращаетtrue, если array и other являются одним и тем же объектом или оба массива обладают одинаковым содержимым

array.fetch(index)                    #=> obj
array.fetch(index, default )          #=> obj
array.fetch(index) { |index| block }  #=> obj

Попытка получить элемент массива array по индексу index. Если индекс выходит за пределы массива то, в первой форме вызова возникнет ошибка IndexError, чтобы это предотвратить используется вторая форма вызова, которой будет возвращено значение default, так же для предотвращения ошибки IndexError используется третья форма вызова, которой будет возвращено значение блока block (в который передается запрашиваемый индекс в качестве параметра). Если во второй и третьей форме вызова будет использован индекс существующего элемента, то fetch просто вернет значение этого элемента. Отрицательная индексация подразумевает отсчёт с конца массива.

a = [11, 22, 33, 44]
a.fetch(1)              #=> 22
a.fetch(-1)             #=> 44
a.fetch(4, 'cat')       #=> "cat"
a.fetch(4) { |i| i*i }  #=> 16

array.fill(obj)                                #=> array
array.fill(obj, start [, length])              #=> array
array.fill(obj, range )                        #=> array
array.fill {|index| block }                    #=> array
array.fill(start [, length]) {|index| block }  #=> array
array.fill(range) { |index| block }            #=> array

Первые три формы вызова заменяют указанные элементы массива array на значение obj. Если значение start равно nil, то это эквивалентно

start = 0

Если значение length равноnil, то это эквивалентно

length = array.[[#Array#length|length]]

Последние три формы вызова заполняют массив значением выражения в блоке block (в который передается индекс текущего заменяемого элемента).

a = ["a", "b", "c", "d"]
a.fill("x")             #=> ["x", "x", "x", "x"]
a.fill("z", 2, 2)       #=> ["x", "x", "z", "z"]
a.fill("y", 0..1)       #=> ["y", "y", "z", "z"]
a.fill {|i| i*i}        #=> [0, 1, 4, 9]
a.fill(-2) {|i| i*i*i}  #=> [0, 1, 8, 27]

array.first     #=> obj или nil
array.first(n)  #=> an_array

Возвращает первый элемент или первыеn элементов массива array. Если массив пуст, то для первой формы вызова (безn) возвращаетсяnil, а для второй — пустой массив.

a = ["q", "r", "s", "t"]
a.first     #=> "q"
a.first(1)  #=> ["q"]
a.first(3)  #=> ["q", "r", "s"]

array.flatten #=> an_array

Преобразует многомерный массив array в одномерный.

s = [1, 2, 3]          #=> [1, 2, 3]
t = [4, 5, 6, [7, 8]]  #=> [4, 5, 6, [7, 8]]
a = [s, t, 9, 10]      #=> [[1, 2, 3], [4, 5, 6, [7, 8]], 9, 10]
a.flatten              #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

array.flatten! #=> array или nil

Преобразует многомерный массив array в одномерный. Возвращаетnil, если массив array изначально был одномерным.

a = [1, 2, [3, [4, 5]]]
a.flatten!  #=> [1, 2, 3, 4, 5]
a.flatten!  #=> nil
a           #=> [1, 2, 3, 4, 5]

array.frozen?  #=> true или false

Возвращаетtrue, если массив array заморожен (или временно заморожен, пока идет сортировка).

array.hash  #=> fixnum

Вычисляет хеш-код для массива array. Два массива с одним и тем же содержимым будут иметь одинаковый хеш-код (именно его использует eql?).

array.include?(obj)  #=> true или false

Возвращаетtrue, если объект obj является элементом массива array (то есть какой-то из элементов массива== obj). Иначе —false.

a = ["a", "b", "c"]
a.include?("b")  #=> true
a.include?("z")  #=> false

array.index(obj)  #=>  int или nil

Возвращает индекс первого вхождения элемента в массив array, который== obj. Возвращаетnil, если такой элемент не был найден.

a = ["a", "b", "c"]
a.index("b")  #=> 1
a.index("z")  #=> nil

Существует так же метод rindex, который возвращает первый соответствующий элемент с конца массива.

array.indexes(i1, i2, ... iN)   #=> an_array
array.indices(i1, i2, ... iN )  #=> an_array

array.indexes(i1, i2, ... iN)  #=> an_array
array.indices(i1, i2, ... iN)  #=> an_array

array.insert(index, obj...)  #=> array

Вставляет полученные значения перед элементом индексом index (может быть отрицательным).

a = %w{ a b c d }
a.insert(2, 99)        #=> ["a", "b", 99, "c", "d"]
a.insert(-2, 1, 2, 3)  #=> ["a", "b", 99, "c", 1, 2, 3, "d"]

array.inspect  #=> string

Создает «печатную» версию массива array.

 a = [“ad”, “cc”, “xczxc”, 1, 1..4]
 a.inspect	=> 	“[\”ad\”, \”cc\”, \”xczxc\”, 1, 1..4]”

array.join(sep=$,)  #=> str

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

["a", "b", "c" ].join       #=> "abc"
["a", "b", "c" ].join("-")  #=> "a-b-c"

array.last     #=> obj или nil
array.last(n)  #=> an_array

Возвращает последний элемент или последниеn элементов массива array. Если массив пуст, то для первой формы вызова (безn) возвращаетсяnil, а для второй — пустой массив.

[ "w", "x", "y", "z" ].last  #=> "z"

array.length  #=> int
array.size    #=> int

Возвращает количество элементов в array. Может быть нулевым (для пустого массива).

[ 1, 2, 3, 4, 5 ].length  #=> 5

Методы length и size — одно и то же!

array.collect {|item| block }  #=> an_array
array.map {|item| block }      #=> an_array

Перебирает массив и составляет новый массив из элементов, где каждый элемент - это "обработанный" элемент исходного массива. Исходный массив при этом не изменяется.

a = ["a", "b", "c", "d"]
a.map { |x| x + "!" }  #=> ["a!", "b!", "c!", "d!"]
a                      #=> ["a", "b", "c", "d"]
a = [1, 2, 3, 4]
a.map { |x| x * x }  #=> [1, 4, 9, 16]
a                      #=> [1, 2, 3, 4]

Есть итераторы Enumerable#collect и Enumerable#map, которые имеют схожую функциональность Итераторы map и collect — одно и то же!

array.collect! { |item| block }  #=> array
array.map! { |item| block }      #=> array

Выполняет выражение block для каждого элемента массива array, вычисленное выражение подставляется вместо текущего элемента. Метод map! перезапишет текущий массив в своей переменной.

a = ["a", "b", "c", "d"]
a.map! {|x| x + "!" } #=> ["a!", "b!", "c!", "d!"]
a  #=>  ["a!", "b!", "c!", "d!"]

Есть итераторы Enumerable#collect и Enumerable#map, которые имеют схожую функциональность Итераторы map! и collect! — одно и то же!

array.min  #=> obj

Возвращает объект в ary с минимальным значением. Первая форма предполагает, что все объекты реализуют Comparable; вторая использует блок для возврата <=> b.

array.nitems  #=> int

Возвращает количество элементов массива array, значение которых не равноnil. Может быть нулевым (для пустого массива или массива, который заполненnil.

[ 1, nil, 3, nil, 5 ].nitems  #=> 3

array.pack(aTemplateString)  #=> aBinaryString

Упаковывает содержимое массива array в двоичную последовательность (в виде строки) в соответствии с опциями в строке aTemplateString (см. таблицу ниже). После опцийA, a, иZ может идти число, которое указывает на ширину результирующего поля. Для остальных, число после опций означает — количество элементов массива которые необходимо обработать в соответствии с указанной опцией. Если в вместо числа после директивы стоит символ* («звездочка»), то все оставшиеся элементы массива необходимо обработать в соответствии с этой опцией. Любую из опцийs, S, i, I, l и L можно завершать_ (знаком подчеркивания) для того, чтобы использовать размер для базовой платформы; иначе, будет использован платформонезависимый размер. В строке aTemplateString пробелы игнорируются.

a = ["a", "b", "c"]
n = [ 65, 66, 67 ]
a.pack("A3A3A3")  #=> "a  b  c  "
a.pack("a3a3a3")  #=> "a\000\000b\000\000c\000\000"
n.pack("ccc")     #=> "ABC"

Опции методаpack.

Данный метод обычно используется совместно с методом String#unpack, который выполняет обратные действия

array.pop  #=> obj или nil

Удаляет последний элемент из массива

array

и возвращает его. Если на момент вызова массив был пуст, то возвращаетnil.

a = ["a", "b", "c"]
a.pop  #=> "c"
a      #=> ["a", "b"]

array.push(obj, ... )  #=> array

Добавить элемент — добавляет передаваемый объект (или несколько объектов) в конец массива. Возвращает массив с выполненным преобразованием.

a = ["a", "b", "c"]
a.push("d", "e", "f")  #=> ["a", "b", "c", "d", "e", "f"]
a                      #=> ["a", "b", "c", "d", "e", "f"]

Добавляет каждый аргумент как один элемент, даже если это другой массив:

a = [:jay, "shri", 108]
a1 = a.push([:om, :tat], [:sat, :rama])
a1 # => [:jay, "shri", 108, [:om, :tat], [:sat, :rama]]

Методы append и push — одно и то же! Данный метод обычно используют совместно с методами shift, pop и unshift

array.rassoc(key) #=> an_array или nil

Ищет в двумерном массиве массив, второй элемент которого равен key (для сравнения используется метод==). Возвращает первый найденный массив (то есть, ассоциированный массив) или nil, если таковой найти не удалось

a = [[1, "one"], [2, "two"], [3, "three"], ["ii", "two"]]
a.rassoc("two")   #=> [2, "two"]
a.rassoc("four")  #=> nil

Так же существует метод assoc, который имеет схожий функционал

array.reject { |item| block }  #=> an_array

Метод возвращает новый массив , содержащий элементы , которые не соответствуют условию. Вы можете думать об этом как о фильтре, который удаляет ненужные элементы. Вот пример, который отклоняет все записи, содержащие буквы a:).

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
results = sharks.reject {|item| item.include?("a")}
print results                          #=> ["Tiger"]

Полезно взглянуть на итераторы delete_if и reject!, которые отличается лишь тем, что изменяют исходный массив Данный метод реализован на базе метода Enumerable#reject

array.reject! {|item| block }  #=> array или nil

Подобно итератору delete_if удаляет из массива array элементы, для которых значение внутри блока block равно true, но возвращает nil, если изменений в массиве сделано не было.

a = [1, 2, 3, 4, 5]
a.reject!{ |item| item > 2 }  #=> [1, 2]
a                             #=> [1, 2]
a.reject!{ |item| item > 2 }  #=> nil

Полезно посмотреть описание итератора delete_if, который делает примерно тоже самое, но название которого лучше запоминается

array.replace(other_array) #=> self

Заменяет содержимое массива array содержимым массива other_array.

a = ["a", "b", "c", "d", "e"]
a.replace(["x", "y", "z"])  #=> ["x", "y", "z"]
a                           #=> ["x", "y", "z"]

Данный метод работает как присваивание, но может быть использован при построении цепочки методов (которую присваивание обычно разрывает). Также незаменим при необходимости изменения содержимого массива, передающегося в функцию или блок как аргумент: def set_123(a) a.replace([1, 2, 3]) end При обычном присваивании изменилась бы только ссылка a, а в вызывающем функцию коде массив остался бы неизменным.

array.reverse  #=> an_array

Возвращает новый массив, в котором элементы массива array стоят в обратном порядке.

["a", "b", "c"].reverse  #=> ["c", "b", "a"]
[1].reverse              #=> [1]

array.reverse!  #=> array

Изменяет порядок элементов в массиве array на обратный.

a = ["a", "b", "c"]
a.reverse!  #=> ["c", "b", "a"]
a           #=> ["c", "b", "a"]

array.reverse_each {|item| block }

Работает точно также, как и итератор each, но элементы массива array обрабатываются в обратном порядке.

a = ["a", "b", "c"]
a.reverse_each { |x| print x, " " }

результат:

c b a

Достичь точно такого же результата можно вот так: array.reverse.each { |item| block }

array.rindex(obj) #=> int или nil

Возвращает индекс последнего вхождения элемента в массив array, который== obj. Возвращаетnil, если такой элемент не был найден Простым языком - находит obj с конца.

a = ["a", "b", "b", "b", "c"]
a.rindex("b")  #=> 3
a.rindex("z")  #=> nil

Советуем взглянуть на метод index, который не только похож по названию, но, в некоторых случаях, работает точно также, как иrindex

array.rotate #=> an_array
array.rotate(count) #=> an_array

Возвращает новый массив, сформированный из себя(self) с элементами, повернутыми от одного конца к другому. Если аргумент не указан, возвращает новый массив, который похож на self, за исключением того, что первый элемент был повернут в последнюю позицию.

a = [:foo, 'bar', 2, 'bar']
a1 = a.rotate
a1 # => ["bar", 2, "bar", :foo]

Когда задано неотрицательное целое число счетчик(count), возвращает новый массив с элементами count, повернутыми от начала до конца:

a = [:foo, 'bar', 2]
a1 = a.rotate(2)
a1 # => [2, :foo, "bar"]

Если count большое, в качестве счетчика используется count% array.size:

a = [:foo, 'bar', 2]
a1 = a.rotate(20)
a1 # => [2, :foo, "bar"]

Если count равно нулю, возвращает копию self без изменений:

a = [:foo, 'bar', 2]
a1 = a.rotate(0)
a1 # => [:foo, "bar", 2]

Когда задано отрицательное целое число, вращается в противоположном направлении, от конца к началу:

a = [:foo, 'bar', 2]
a1 = a.rotate(-2)
a1 # => ["bar", 2, :foo]

Если count мало (далеко от нуля), в качестве count используется count% array.size:

a = [:foo, 'bar', 2]
a1 = a.rotate(-5)
a1 # => ["bar", 2, :foo]

Полезно взглянуть на rotate!, которые отличается лишь тем, что изменяют исходный массив

array.rotate! #=> array
array.rotate!(count) #=> array

Поворачивает себя(self) на месте, перемещая элементы с одного конца на другой; возвращает self. Если аргумент не указан, поворачивает первый элемент в последнюю позицию:

a = [:foo, 'bar', 2, 'bar']
a.rotate! # => ["bar", 2, "bar", :foo]

Когда задано неотрицательное целое число счетчик(count), вращает элементы count от начала до конца:

a = [:foo, 'bar', 2]
a.rotate!(2)
a # => [2, :foo, "bar"]

Если count большое, в качестве count используется count% array.size:

a = [:foo, 'bar', 2]
a.rotate!(20)
a # => [2, :foo, "bar"]

Если count равен нулю, возвращается без изменений:

a = [:foo, 'bar', 2]
a.rotate!(0)
a # => [:foo, "bar", 2]

Когда задано отрицательное целое число, вращается в противоположном направлении, от конца к началу:

a = [:foo, 'bar', 2]
a.rotate!(-2)
a # => ["bar", 2, :foo]

Если count мало (далеко от нуля), в качестве count используется count% array.size:

a = [:foo, 'bar', 2]
a.rotate!(-5)
a # => ["bar", 2, :foo]

array.sample  #=> obj or nil
array.sample(n) #=> an_array
array.sample(random: rng) #=> obj
array.sample(n, random: rng) #=> an_array

Выбирает случайный элемент или n случайных элементов из массива. Элементы выбираются с использованием случайных и уникальных индексов в массиве, чтобы гарантировать, что элемент не повторяется, если массив уже содержит повторяющиеся элементы. Если массив пуст, первая форма возвращает ноль, а вторая форма возвращает пустой массив.

arr = [1, 2, 3, "R", "A", "M", "A"]
arr.sample  #=> R
arr.sample(4)  #=> ["R", 2, 1, "A"]
arr.sample(4)  #=> [2, 3, "M", 1]

Необязательный аргумент rng будет использоваться в качестве генератора случайных чисел.

arr.sample(random: Random.new(1))     #=> 3
arr.sample(4, random: Random.new(1))  #=> [3, 1, "A", "A"]

array.select {|item| block } #=> an_array

Выполняет выражение в block для каждого элемента массива array и возвращает массив, который состоит из элементов, для которых выражение в block принимает значение true.

a = %w{ a b c d e f }
a.select {|v| v =~ /[aeiou]/}  #=> ["a", "e"]

a = %w{ 1 2 3 }
a.select { |el| el.even? } #=> [2]

Перебирает массив и составляет новый массив из тех элементов, для которых условие, описанное в блоке выполнится как true [1, 2, 3].select { |el| el.even? } вернёт результат [2].

Есть итераторы Enumerable#select и #Enumerable#find_all, которые имеют схожую функциональность

array.shift  #=> obj или nil

Удаляет первый элемент из массива array и возвращает его (как бы «сдвигает» массив влево на один элемент). Если на момент вызова массив был пуст, то возвращаетnil.

args = ["-m", "-q", "filename"]
args.shift  #=> "-m"
args        #=> ["-q", "filename"]

Данный метод обычно используют совместно с методами push, pop и unshift

array.shuffle  #=> an_array
array.shuffle(random: rng) #=> an_array

Перемешивает элементы массива в случайном порядке.

arr = ["R", "A", "M", "A"]
arr.shuffle  #=> ["A", "A", "R", "M"]
arr #=> ["R", "A", "M", "A"]

Необязательный аргумент rng будет использоваться в качестве генератора случайных чисел.

arr.shuffle(random: Random.new(1))  #=> ["R", "A", "M", "A"]

array.length  #=> int
array.size    #=> int

Возвращает количество элементов в array. Может быть нулевым (для пустого массива).

[1, 2, 3, 4, 5].size   #=> 5

Методы length и size — одно и то же!

array[index]                #=> obj      or nil
array[start, length]        #=> an_array or nil
array[range]                #=> an_array or nil
array.slice(index)          #=> obj      or nil
array.slice(start, length)  #=> an_array or nil
array.slice(range)          #=> an_array or nil

Получение значения элемента — возвращает элемент с индексом index, или подмассив длины length, начиная с индекса start, или подмассив, который располагается в диапазоне range. Отрицательная индексация предполагает отчет с конца массива (по индексу -1 располагается последний элемент). Возвращаетnil, если индекс выходит за диапазон допустимых значений.

a = ["a", "b", "c", "d", "e"]
a.slice(2) +  a.slice(0) + a.slice[1]  #=> "cab"
a.slice[6]                             #=> nil
a.slice(1, 2)                          #=> ["b", "c"]
a.slice(1..3)                          #=> ["b", "c", "d"]
a.slice(4..7)                          #=> ["e"]
a.slice(6..10)                         #=> nil
a.slice(-3, 3)                         #=> ["c", "d", "e"]
# Специальные случаи:
a.slice(5)                             #=> nil
a.slice(5, 1)                          #=> []
a.slice(5..10)                         #=> []

Методы slice и [] — одно и тоже! Существует метод at, который обладает схожей, но меньшей функциональностью

array.slice!(index)         #=> obj или nil
array.slice!(start, length) #=> sub_array или nil
array.slice!(range)         #=> sub_array или nil

Удаляет элемент или элементы массива array по индексу (иногда с продолжительностью length) или диапазону. Возвращает удаляемые объект, подмассив илиnil (если указанный индекс выходит за предел допустимых значений).

def slice!(*args)
  result = self[*args]
  self[*args] = nil
  result
end

a = ["a", "b", "c"]
a.slice!(1)    #=> "b"
a              #=> ["a", "c"]
a.slice!(-1)   #=> "c"
a              #=> ["a"]
a.slice!(100)  #=> nil
a              #=> ["a"]

Частными реализациями данного метода являются методы pop (array.slice!(-1) ) и shift (array.slice!(0) )

array.sort  #=> an_array 
array.sort { |a, b| block }  #=> an_array

Возвращает новый массив, который получен путем сортировки массива array (по возрастанию). Элементы массива должны допускать сравнение при помощи метода <=>, если это не обеспечивается, то можно использовать необязательный блок. Блок предназначенный для сравнения параметров a и b, должен возвращать значения -1, 0, или +1.

a = ["d", "a", "e", "c", "b"]
a.sort                   #=> ["a", "b", "c", "d", "e"]
a.sort {|x, y| y <=> x }  #=> ["e", "d", "c", "b", "a"]

Более интересная и чаще используемая форма сортировки производится при помощи итератора Enumerable#sort_by

array.sort!                   #=> array
array.sort! { |a, b| block }  #=> array

Сортирует массив array (по возрастанию). Элементы массива должны допускать сравнение при помощи метода <=>, если это не обеспечивается, то можно использовать необязательный блок. Блок предназначенный для сравнения параметров a и b, должен возвращать значения -1, 0, или +1.

a = ["d", "a", "e", "c", "b"]
a.sort!                   #=> ["a", "b", "c", "d", "e"]
a.sort! {|x,y| y <=> x }  #=> ["e", "d", "c", "b", "a"]

Более интересная и чаще используемая форма сортировки производится при помощи метода Enumerable#sort_by

array.to_a #=> array

Возвращает указатель на self. Если вызывается от потомка классаArray, то конвертирует указанный объект в массив (объект классаArray).

array.to_ary #=> array

Возвращает указатель на self. По сути, ничего не делает.

array.to_s  #=> string

Возвращает результат self.join.

["a", "e", "i", "o"].to_s  #=> "aeio"

array.transpose #=> an_array

Подразумевает, что array является массивом массивов (то есть с размерностью больше, чем один) и меняет местами столбцы со строками (транспонирует).

a = [[1,2], [3,4], [5,6]]
a.transpose  #=> [[1, 3, 5], [2, 4, 6]]

array.uniq  #=> an_array

Возвращает новый массив, который получен из массива array путем удаления всех повторяющихся элементов (то есть остаются только «уникальные» элементы).

a = ["a", "a", "b", "b", "c"]
a.uniq   #=> ["a", "b", "c"]

array.uniq!  #=> array или nil

Удаляет из массива array все повторяющиеся элементы (то есть остаются только «uniq'альные элементы»). Возвращаетnil, если повторяющиеся элементы в массиве array отсутствовали.

a = ["a", "a", "b", "b", "c"]
a.uniq!  #=> ["a", "b", "c"]
b = ["a", "b", "c"]
b.uniq!  #=> nil

array.unshift(obj, ...)  #=> array

Добавляет элементы в начало массива array (со сдвигом вправо уже существующих).

a = ["b", "c", "d"]
a.unshift("a")   #=> ["a", "b", "c", "d"]
a.unshift(1, 2)  #=> [ 1, 2, "a", "b", "c", "d"]
a                #=> [ 1, 2, "a", "b", "c", "d"]

array.values_at(selector,... )  #=> an_array

Возвращает массив, который состоит из элементов массива array, которые соответствуют передаваемым селекторам. Селекторы могут быть целыми числами (индексами) или целочисленными диапазонами.

a = %w{ a b c d e f }
a.values_at(1, 3, 5)
a.values_at(1, 3, 5, 7)
a.values_at(-1, -3, -5, -7)
a.values_at(1..3, 2...5)

Для подобных целей также используются методы select и [] («батарейка»). Вот только в «батарейке» нельзя указывать несколько непоследовательных индексов или диапазонов, а select отбирает элементы по условию (а не по индексу)

array.zip(arg, ...)                   #=> an_array
array.zip(arg, ...) {| arr | block }  #=> nil

Преобразует аргументы в массивы (при помощи методаto_a). Объединяет каждый элемент массива array с соответствующим массивом, переданным в качестве аргумента. В результате этого создается двумерный массив с array.size строками и сn столбцами, гдеn — максимальная из длин аргументов-массивов. Если длина какого либо из аргументов-массивов меньшеn, то он расширяется до длиныn (дополняетсяnil). Если задан блок, то получаемые массивы передаются в блок в качестве параметра, иначе — возвращается двумерный массив.

a = [4, 5, 6]
b = [7, 8, 9]
[1,2,3].zip(a, b)  #=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
[1,2].zip(a,b)     #=> [[1, 4, 7], [2, 5, 8]]
a.zip([1,2],[8])   #=> [[4,1,8], [5,2,nil], [6,nil,nil]]

Обычно используется совместно с методом assoc, то естьzip подготавливает для него массив, по которому будет осуществляться ассоциация