Программирование на языке Ruby

8.1.15. Удаление заданных элементов из массива

В Ruby легко удалить элементы из массива - для этого даже существует много способов. Чтобы удалить элемент с известным индексом, достаточно вызвать метод delete_at:

 a = [10, 12, 14, 16, 18]
 a.delete_at(3) # Возвращает 16.
 # а равно [10, 12, 14, 18]
 a.delete_at(9) # Возвращает nil {вне диапазона).

Все элементы с заданным значением поможет удалить метод delete. Он возвращает значения удаленных элементов или nil, если искомый элемент не найден:

 b = %w(spam spam bacon spam eggs ham spam)
 b.delete("spam") # Возвращает "spam"
 # b равно ["bacon", "eggs", "ham"]
 b.delete("caviar") # Возвращает nil

Метод delete принимает также блок. Это не вполне согласуется с интуицией; если объект не найден, происходит вычисление блока (при этом могут выполняться разнообразные операции) и возвращается вычисленное значение.

 с = ["alpha", "beta", "gamma", "delta"]
 c.delete("delta") { "Nonexistent" }
 # Возвращается "delta" (блок не вычисляется).
 с.delete("omega") { "Nonexistent" }
 # Возвращается "Nonexistent".

Метод delete_if передает каждый элемент массива в блок и удаляет те элементы, для которых вычисление блока дает true. Примерно так же ведет себя метод reject! с тем отличием, что последний может возвращать nil, когда массив не изменяется.

 email = ["job offers", "greetings", "spam", "news items"]
 # Удалить слова из четырех букв
 email.delete_if {|x| x.length==4 }
 # email равно ["job offers", "greetings", "news items"]

Метод slice! получает доступ к тем же элементам, что и slice, но, помимо возврата их значений, еще и удаляет из массива:

 x = [0, 2, 4, 6, 8, 10, 12, 14, 16]
 а = x.slice!(2) # 4
 # x is now [0, 2, 6, 8, 10, 12, 14, 16]
 b = x.slice!(2,3) # [6, 8, 10]
 # x is now [0, 2, 12, 14, 16]
 с = x.slice!(2..3) # [12, 14]
 # x is now [0, 2, 16]

Для удаления элементов из массива можно также пользоваться методами shift и pop (дополнительную информацию об их исходном предназначении вы найдете в разделе 9.2).

 x = [1, 2, 3, 4, 5]
 x.рор # Удалить последний элемент.
 # x is now [1, 2, 3, 4]
 x.shift # Удалить первый элемент.
 # x is now [2, 3, 4]

Метод reject принимает блок и формирует новый массив без тех элементов, для которых блок возвращает true:

 arr = [1,2,3,4,5,6,7,8]
 odd = arr.reject {|x| x % 2 == 0 } # [1,3,5,7]

Наконец, метод clear удаляет из массива все элементы. Это эквивалентно присваиванию переменной пустого массива, но чуть-чуть эффективнее:

 x = [1, 2, 3]
 x.clear
# x равно []

8.1.16. Конкатенирование массивов и добавление в конец массива

Часто нужно добавить в конец существующего массива отдельный элемент или целый массив. В Ruby это можно сделать разными способами.

Оператор << добавляет объект в конец массива; в качестве значения он возвращает сам массив, поэтому можно объединять несколько таких операций в цепочку.

 x = [1, 5, 9]
 x << 13 # x равно [1, 5, 9, 13]
 x << 17 << 21 # x равно [1, 5, 9, 13, 17, 21].

Аналогичную операцию выполняют методы unshift и push, которые добавляют элемент в начало и в конец массива соответственно (см. также следующий раздел данной главы).

Массивы можно конкатенировать методом concat или с помощью операторов + и +=:

 x = [1,2]
 y = [3,4]
 z = [5,6]
 b = y + z # [3,4,5,6]
 b += x # [3,4,5,6,1,2]
 z.concat у # z равно [5,6,3,4]

Имейте в виду, что оператор += всегда создает новый объект. Также не забывайте, что оператор << добавляет в конец новый элемент, который сам может быть массивом.

 a = [1,2]
 b = [3,4]
 a += b # [1,2,3,4]

 a = [1,2]
 b = [3,4]
 а << b # [1,2, [3,4]]

 a = [1,2]
 b = [3,4]
 а = a.concat(b) # [1,2,3,4]

8.1.17. Использование массива в качестве стека или очереди

Базовые операции со стеком называются push и pop, они добавляют и удаляют элементы в конец массива. Базовые операции с очередью — это shift (удаляет элемент из начала массива) и unshift (добавляет элемент в начало массива). Для добавления в конец массива можно также пользоваться оператором << (по существу синоним push).

Постарайтесь не запутаться. Методы shift и unshift модифицируют массив в начале, a push, pop и << — в конце.

Эта тема будет продолжена в разделе 9.2.

8.1.18. Обход массива

Как и следовало ожидать, в классе Array есть стандартный итератор each. Но имеются и другие полезные итераторы.

Метод reverse_each обходит массив в обратном порядке. Результат такой же, как если бы мы вызвали сначала метод reverse, а потом each, но работает быстрее.