реализует простейший случай получения ссылки на элемент. Поскольку он может принимать только один целочисленный параметр, то работает чуть быстрее.
a = [1, 2, 3, 4, 5, 6]
b = а[0] # 1
с = a.at(0) # 1
d = а[-2] # 5
е = a.at(-2) # 5
f = а[9] # nil
g = a.at(9) # nil
h = a[3,3] # [4, 5, 6]
i = a[2..4] # [3, 4, 5]
j = a[2...4] # [3, 4]
a[1] = 8 # [1, 8, 3, 4, 5, 6]
a[1,3] = [10, 20, 30] # [1, 10, 20, 30, 5, 6]
a[0..3] = [2, 4, 6, 8] # [2, 4, 6, 8, 5, 6]
a[-1] = 12 # [2, 4, 6, 8, 5, 12]
В
следующем примере ссылка на элемент, расположенный за концом массива, приводит к росту массива. Отметим, что подмассив можно заменить другим массивом, содержащим больше элементов, чем было. В этом случае массив также автоматически вырастет.
k = [2, 4, 6, 8, 10]
k[1..2] = [3, 3, 3] # [2, 3, 3, 3, 8, 10]
k[7] = 99 # [2, 3, 3, 3, 8, 10, nil, 99]
Наконец, если одному элементу присвоить в качестве значения массив, то на место этого элемента будет вставлен вложенный массив (в отличие от присваивания диапазону):
m = [1, 3, 5, 7, 9]
m[2] = [20, 30] # [1,3, [20, 30], 7, 9]
# С другой стороны... m = [1, 3, 5, 7, 9]
m[2..2] = [20, 30] # [1, 3, 20, 30, 7, 9]
Метод
slice
— синоним метода
[]
:
x = [0, 2, 4, 6, 8, 10, 12]
а = x.slice(2) # 4
b = x.slice(2,4) # [4, 6, 8, 10]
с = x.slice(2..4) # [4, 6, 8]
Специальные методы
first
и
last
возвращают первый и последний элемент массива соответственно. Если массив пуст, они возвращают
nil
:
x = %w[alpha beta gamma delta epsilon]
a = x.first # "alpha"
b = x.last # "epsilon"
Мы уже видели ранее, что иногда ссылка на элементы может возвращать целый подмассив. Но существуют и другие способы обратиться к нескольким элементам.
Метод
values_at
принимает список индексов и возвращает массив, содержащий только указанные элементы. Его можно использовать в тех случаях, когда диапазон не годится (так как нужные элементы находятся не в соседних позициях).
В более ранних версиях Ruby метод
values_at
назывался
indices
(синоним
indexes
). Теперь эти названия
не используются.
x = [10, 20, 30, 40, 50, 60]
y = x.values_at(0, 1, 4) # [10, 20, 50]
z = x.values_at(0..2,5) # [10, 20, 30, 60]
8.1.3. Определение размера массива
Метод
length
и его синоним
size
возвращают число элементов в массиве. (Как всегда, эта величина на единицу больше индекса последнего элемента.)
x = ["а", "b", "с", "d"]
а = x.length # 4
b = x.size # 4
Метод
nitems
отличается от предыдущих тем, что не учитывает элементы равные
nil
:
у = [1, 2, nil, nil, 3, 4]
с = у.size # 6
d = у.length # 6
е = y.nitems # 4
8.1.4. Сравнение массивов
При сравнении массивов возможны неожиданности — будьте осторожны!
Для сравнения массивов служит метод экземпляра
<=>
. Он работает так же, как в других контекстах, то есть возвращает -1 (меньше), 0 (равно) или 1 (больше). Методы
==
и
!=
опираются на реализацию метода
<=>
.
Массивы сравниваются поэлементно; первая же пара несовпадающих элементов определяет результат всего сравнения. (Предпочтение отдается левее расположенным элементам, как при сравнении двух длинных целых чисел «на глазок», когда мы сравниваем по одной цифре за раз.)
а = [1, 2, 3, 9, 9]
b = [1, 2, 4, 1, 1]
с = а <=> b # -1 (то есть а < b)
Если все элементы равны, то массивы считаются равными. Если один массив длиннее другого и все элементы вплоть до длины более короткого массива равны, то более длинный массив считается большим.
d = [1, 2, 3]
е = [1, 2, 3, 4]
f = [1, 2, 3]
if d < е # false
puts "d меньше e"
end
if d == f
puts "d равно f" # Печатается "d равно f"
end
Поскольку класс
Array
не подмешивает модуль
Comparable
, то обычные операторы сравнения
<
,
>
,
<=
и
>=
для массивов не определены. Но при желании их легко определить самостоятельно: