Перейти к содержанию

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

Материал из Викиучебника — открытых книг для открытого мира

Класс 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::[](...)

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

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

Array::new

[править]

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#<<

[править]

array << obj  #=> array

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

[1, 2] << "c" << "d" << [3, 4]  #=> [1, 2, "c", "d", [3, 4]]
Информация

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

Array#<=>

[править]

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#==

[править]

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#[]

[править]

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#[]=

[править]

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

[править]

array.abbrev(pattern = nil)

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

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

Array#assoc

[править]

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

[править]

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

[править]

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

[править]

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

[править]

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

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

Информация

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

Array#clear

[править]

array.clear  #=> array

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

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

Array#collect

[править]

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"]
Информация

Array#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!"]
Информация


Array#combination

[править]

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

[править]

array.compact  #=> an_array

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

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

Array#compact!

[править]

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

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

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

Array#concat

[править]

array.concat(other_array)  #=> array

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

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

Array#count

[править]

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

[править]

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

[править]

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

[править]

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

[править]

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

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

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

результат:

a -- b -- c --
Информация
  • Данный итератор возвращает в качестве результата исходный массив. Это следует учитывать при построении цепочки методов
  • Следует использовать данный метод только тогда, когда задачу невозможно решить при помощи других итераторов

Array#each_index

[править]

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

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

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

результат:

0 -- 1 -- 2 --

Array#empty?

[править]

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

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

[].empty?  #=> true

Array#eql?

[править]

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

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

Array#fetch

[править]

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

[править]

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

[править]

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

[править]

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

[править]

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

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

Array#hash

[править]

array.hash  #=> fixnum

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

Array#include?

[править]

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

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

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

Array#index

[править]

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

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

a = ["a", "b", "c"]
a.index("b")  #=> 1
a.index("z")  #=> nil
Информация

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

Array#indexes

[править]

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

Array#indices

[править]

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

Array#insert

[править]

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

[править]

array.inspect  #=> string

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

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

Array#join

[править]

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

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

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

Array#last

[править]

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

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

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

Array#length

[править]

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

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

[ 1, 2, 3, 4, 5 ].length  #=> 5
Информация

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

Array#map

[править]

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]
Информация

Array#map!

[править]

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!"]
Информация

Array#min

[править]

array.min  #=> obj

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

Array#nitems

[править]

array.nitems  #=> int

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

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

Array#pack

[править]

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.

Опция Описание
@
Переместиться на абсолютную позицию
A
Строка ASCII (дополненная пробелами до указанной ширины)
a
Строка ASCII (дополненная нулевыми символами до указанной ширины)
B
Двоичная строка (возрастающая двоичная последовательность)
b
Двоичная строка (убывающая двоичная последовательность)
C
Беззнаковый 8-битный символ (char)
c
8-битный символ (char)
D, d
Число с плавающей точкой двойной точности, собственный формат («нативный»)
E
Число с плавающей точкой двойной точности, прямой порядок двоичной последовательности
e
Число с плавающей точкой одинарной точности, прямой порядок двоичной последовательности
F, f
Число с плавающей точкой одинарной точности, собственный формат («нативный»)
G
Число с плавающей точкой двойной точности, «сетевая» (обратная) двоичная последовательность
g
Число с плавающей точкой одинарной точности, «сетевая» (обратная) двоичная последовательность
H
Двоичная строка (верхний полубайт идет первым)
h
Двоичная строка (нижний полубайт идет первым)
I
Беззнаковое целое (unsigned integer)
i
Целое (integer)
L
Большое беззнаковое целое (usigned long)
l
Большое целое (long)
M
Строка готовая к печати, закодированная MIME (см. RFC2045)
m
Строка закодированная Base64 (см. RFC4648)
N
Большое целое (long),«сетевая» (обратная) двоичная последовательность
n
Короткое целое (short), «сетевая» (обратная) двоичная последовательность
P
Указатель на структуру (строка фиксированной длины)
p
Указатель на строку (с завершающим нулевым символом)
Q, q
64-битное число
S
Беззнаковое короткое целое (unsigned short)
s
Короткое целое (short)
U
UTF-8
u
Строка UU-кодированная
V
Длинное целое (long), прямой порядок байт
v
Короткое целое (short), прямой порядок байт
w
BER-упакованное целое
X
Символ возврата коретки
x
Нулевой символ
Z
Тоже самое, что и директиваa, исключая то, что нулевой символ добавляется со* («звездочкой»)
Информация

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

Array#pop

[править]

array.pop  #=> obj или nil

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

array

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

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

Array#push

[править]

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

[править]

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

[править]

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!

[править]

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

[править]

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

[править]

array.reverse  #=> an_array

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

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

Array#reverse!

[править]

array.reverse!  #=> array

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

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

Array#reverse_each

[править]

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

[править]

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

[править]

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

[править]

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

[править]

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

[править]

array.shift  #=> obj или nil

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

args = ["-m", "-q", "filename"]
args.shift  #=> "-m"
args        #=> ["-q", "filename"]
Информация

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

Array#shuffle

[править]

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#size

[править]

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

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

[1, 2, 3, 4, 5].size   #=> 5
Информация

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

Array#slice

[править]

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!

[править]

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

[править]

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.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.to_a #=> array


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

Array#to_ary

[править]

array.to_ary #=> array

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

Array#to_s

[править]

array.to_s  #=> string

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

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

Array#transpose

[править]

array.transpose #=> an_array

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

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

Array#uniq

[править]

array.uniq  #=> an_array

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

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

Array#uniq!

[править]

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

[править]

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

[править]

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

[править]

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 подготавливает для него массив, по которому будет осуществляться ассоциация