Хэл Фултон - Программирование на языке Ruby

с = ["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 равно []

Часто нужно добавить в конец существующего массива отдельный элемент или целый массив. В 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]

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

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

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

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

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

words = %w(Son I am able she said)

str = ""

words.reverse_each { |W| str += "#{w} "}

# str равно "said she able am I Son "

Если нужно только перебрать все индексы, можно воспользоваться итератором each_index. Конструкция x.each_indexэквивалентна (0..(x.size-1)).each(то есть обходу всего диапазона индексов).

Итератор each_with_index(подмешанный из модуля Comparable) передает в блок как сам элемент, так и его индекс.

x = ["alpha", "beta", "gamma"]

x.each_with_index do |x,i|

puts "Элемент #{i} равен #{x}"

end

# Выводятся три строки.

Предположим, что нужно обойти массив в случайном порядке. Ниже представлен итератор random_each(который просто вызывает метод randomize, описанный в разделе 8.1.10).