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)
Методы класса
Методы объекта
[]=, [], &, |, *, +, -, <<, <=>, ==, abbrev, assoc, at, clear, collect!, collect, compact!, compact, concat, 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, nitems, pack, pop, push, rassoc, reject!, reject, replace, reverse!, reverse_each, reverse, rindex, select, shift, 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(size=0, obj=nil) Array.new(array) 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#&
array & other_array
Пересечение множеств — возвращает новый массив, состоящий из элементов, которые есть в обоих массивах, но без дубликатов.
[ 1, 1, 3, 5 ] & [ 1, 2, 3 ] #=> [ 1, 3 ]
[править] Array#|
array | other_array -> an_array
Объединение множеств — возвращает новый массив, который объединяет элементы массивов array и other_array, но с удаленными дубликатами.
[ "a", "b", "c" ] | [ "c", "d", "a" ]
#=> [ "a", "b", "c", "d" ]
[править] Array#*
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#+
array + other_array -> an_array
Сцепление — возвращает новый массив, созданный из двух массивов путем добавления одного к другому.
[ 1, 2, 3 ] + [ 4, 5 ] #=> [ 1, 2, 3, 4, 5 ]
[править] Array#-
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, 6 ] <=> [ 1, 2 ] #=> +1
[править] Array#==
array == other_array -> bool
Равенство — два массива считаются равными, если количество элементов и соответствующие пары элементов равны (используется метод ==).
[ "a", "c" ] == [ "a", "c", 7 ] #=> false
[ "a", "c", 7 ] == [ "a", "c", 7 ] #=> true
[ "a", "c", 7 ] == [ "a", "d", "f" ] #=> 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] #=> []
|
[править] Array#[]=
maccuB[uHgekc] = obj -> obj maccuB[cTapT, pa3mep] = obj или an_array или nil -> obj или an_array или nil maccuB[guana3oH] = obj или an_array или nil -> obj или an_array или nil
Распределение элементов — помещает элемент в maccuB по uHgekcу, или заменяет подмассив некоторого pa3mepа, начиная с индекса cTapT, или заменяет подмассив в определенном guana3oHе. Если индексация превышает текущий размер массива, то массив увеличивается автоматически. Отрицательная индексация подразумевает отсчет с конца массива. Если для второго случая использовать pa3mep равный 0, то указанные элементы будут вставлены перед элементом с индексом cTapT. Если все параметры для второго и третьего случая задать равными nil, то из maccuBа будут удалены все элементы. Ошибка 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
maccuB.abbrev(pattern = nil)
Вычисляет набор однозначных сокращений для строк в maccuBe. Если в качестве pattern передается правило или строка, то будут обрабатываться только строки, которые соответствуют правилу или начинаются с данной строки.
%w{ car cone }.abbrev #=> { "ca" => "car", "car" => "car",
"co" => "cone", "con" => cone",
"cone" => "cone" }
require 'abbrev'[править] 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#at
array.at(index) -> obj или nil
Возвращает элемент массива array с индексом index. Отрицательная индексация подразумевает отсчет с конца массива. возвращает nil, если индекс выходит за пределы допустимого дианазона.
a = [ "a", "b", "c", "d", "e" ]
a.at(0) #=> "a"
a.at(-1) #=> "e"
|
|
[править] 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#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#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, и в третьей форме вызова будет возвращено значение блока block (в который передается запрашиваемый индекс в качестве параметра). Отрицательная индексация подразумевает отсчет с конца массива.
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, то это эквивалентно lenght=array.lenght. Последние три формы вызова заполняют массив значением выражения в блоке 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, который не только похож по названию, но, в некоторых случаях, работает точно также, как и index |
[править] 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.
[править] 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
|
[править] Array#map
array.collect {|item| block } -> an_array
array.map {|item| block } -> an_array
Выполняет выражение block для каждого элемента массива array. Создает новый массив, который состоит из значений, которые получены при вычислении выражения block.
a = [ "a", "b", "c", "d" ]
a.map {|x| x + "!" } #=> ["a!", "b!", "c!", "d!"]
a #=> ["a", "b", "c", "d"]
|
|
[править] Array#map!
array.collect! {|item| block } -> array
array.map! {|item| block } -> array
Выполняет выражение block для каждого элемента массива array, вычисленное выражение подставляется вместо текущего элемента.
a = [ "a", "b", "c", "d" ]
a.map! {|x| x + "!" }
a #=> [ "a!", "b!", "c!", "d!" ]
|
|
[править] 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.
| Опция | Описание |
|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Данный метод обычно используется совместно с методом String#unpack, который выполняет обратные действия |
[править] Array#pop
array.pop -> obj или nil
Удаляет последний элемент из массива array и возвращает его. Если на момент вызова массив был пуст, то возвращает nil.
a = [ "a", "m", "z" ]
a.pop #=> "z"
a #=> ["a", "m"]
[править] 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"]
[править] 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
Возвращает новый массив, состоящий из элементов массива array, для которых значение внутри блока block равно false (или nil).
a = [1,2,3,4,5]
a.reject{ |item| item > 2 } #-> [1,2]
a #-> [1,2,3,4,5]
|
|
[править] 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) -> array
Заменяет содержимое массива array содержимым массива other_array.
a = [ "a", "b", "c", "d", "e" ]
a.replace([ "x", "y", "z" ]) #=> ["x", "y", "z"]
a #=> ["x", "y", "z"]
|
Данный метод работает как присваивание, но может быть использован при построении цепочки методов (которую присваивание обычно разрывает) |
.
[править] 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#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"]
|
Есть итераторы Enumerable#select и #Enumerable#find_all, которые имеют схожую функциональность |
[править] Array#shift
array.shift -> obj or nil
Удаляет первый элемент из массива array и возвращает его (как бы «сдвигает» массив влево на один элемент). Если на момент вызова массив был пуст, то возвращает nil.
args = [ "-m", "-q", "filename" ]
args.shift #=> "-m"
args #=> ["-q", "filename"]
|
Данный метод обычно используют совместно с методами push, pop и unshift |
[править] Array#size
array.length -> int array.size -> int
Возвращает количество элементов в array. Может быть нулевым (для пустого массива).
[ 1, 2, 3, 4, 5 ].size #=> 5
|
[править] 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) #=> []
|
[править] Array#slice!
array.slice!(index) -> obj или nil array.slice!(start, length) -> sub_array или nil array.slice!(range) -> sub_array или nil
Удаляет элемент или элементы массива array по индексу (иногда с продолжительностью lenght) или диапазону. Возвращает удаляемые объект, подмассив или 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 путем удаления всех повторяющихся элементов (то есть остаются только «uniq'альные элементы»).
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 подготавливает для него массив, по которому будет осуществляться ассоциация |
