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

class Array

# Предполагается, что метод randomize определен.

def random_each

temp = self.randomize

temp.each {|x| yield x}

end

end

dwarves = %w(Sleepy Dopey Happy Sneezy Grumpy Bashful Doc)

list = ""

dwarves.random_each (|x| list += "#{x} "}

# list равен:

# "Bashful Dopey Sleepy Happy Grumpy Doc Sneezy "

# (Ha вашей машине порядок может быть другим.)

Часто требуется вставить разделители между элементами массива, но не перед первым и не после последнего. Для этого предназначены метод joinи оператор *.

been_there = ["Veni", "vidi", "vici."]

journal = been_there.join(", ") # "Veni, vidi, vici."

letters = ["Phi","Mu","Alpha"]

musicians = letters.join(" ") # "Phi Mu Alpha"

people = ["Bob","Carol","Ted","Alice"] movie = people * " and "

# movie равно "Bob and Carol and Ted and Alice"

Если необходимо обрабатывать последний элемент особым образом, например вставить перед ним слово «and», это можно сделать вручную:

list = %w[A В С D Е F]

with_commas = list[0..-2]*", " + ", and " + list[-1]

# with_commas равно "А, В, C, D, E, and F"

Чтобы переставить элементы массива в обратном порядке, воспользуйтесь методами reverseили reverse!:

inputs = ["red", "green", "blue"]

outputs = inputs.reverse # ["green","blue","red"]

priorities = %w(eat sleep code)

priorities.reverse! # ["code","sleep","eat"]

Чтобы удалить из массива повторяющиеся экземпляры, воспользуйтесь методом uniq(или его вариантом для модификации на месте uniq!):

breakfast = %w[spam spam eggs ham eggs spam]

lunch = breakfast.uniq # ["spam","eggs","ham"]

breakfast.uniq! # Массив breakfast изменился.

Предположим, что есть два массива и надо построить из них третий, который содержит массивы из двух элементов, взятых из соответственных позиций исходных массивов. В последних версиях Ruby модуль Enumerableсодержит метод zip:

a = [1, 2, 3, 4]

b = ["a", "b", "c", "d"]

с = a.zip(b)

# с равно [[1,"а" ] , [2,"b"], [3,"с"], [4,"d"]]

# Чтобы устранить вложенность, воспользуйтесь методом flatten

d = с.flatten

# d равно [1, "а", 2, "b", 3, "с", 4, "d"]

Для массивов нет метода count, как для строк (чтобы подсчитать число вхождений каждого элемента). Поэтому создадим свой собственный:

class Array

def count

k=Hash.new(0)

self.each{|x| k[x]+=1 }

k

end

end

meal = %w[spam spam eggs ham eggs spam]

items = meal.count

# items равно {"ham" => 1, "spam" => 3, "eggs" => 2}

spams = items["spam"] # 3

Обратите внимание, что метод возвращает хэш.

Массив нужен для того, чтобы ассоциировать целое число (индекс) с данными. А если нужно инвертировать это отношение, то есть ассоциировать данные с индексом? Иными словами, породить хэш? Это можно сделать так:

class Array

def invert

h={}

self.each_with_index{|x,i| h[x]=i}

h

end

end

a = ["red","yellow","orange"]

h = a.invert # {"orange"=>2, "yellow"=>1, "red"=>0}

Предположим, что необходимо отсортировать массив, которому соответствуют «параллельные» массивы, то есть в соответственных позициях находятся логически связанные данные. Не хотелось бы, чтобы в результате сортировки это соответствие нарушилось.

В представленном ниже решении мы сортируем массив и сохраняем получившийся набор индексов. Затем список индексов (который сам является массивом) можно применить к любому другому массиву, чтобы расставить его элементы в том же порядке.

class Array

def sort_index

d=[]

self.each_with_index{|x, i| d[i]=[x,i]}

if block_given?

d.sort {|x,у| yield x[0],y[0]}.collect{|x| x[1]}

else

d.sort.collect{|x| x[1]}

end

end

def sort_with(ord=[])

return nil if self.length!=ord.length

self.values_at(*ord)

end

end

a = [21, 33, 11, 34, 36, 24, 14]

b = a.sort_index

a2 = a.sort_with(b)

c = a.sort_index {|x,y| x%2 <=> y%2 }

a3 = a.sort_with(c)

p a # [21, 33, 11, 34, 36, 24, 14]

p b # [2,6,0,5,1,3,4]

p a2 # [11, 14, 21, 24, 33, 34, 36]

p c # [6, 5, 4, 3, 2, 1, 0]

p a3 # [14, 24, 36, 34, 11, 33, 21]

Когда массив растет и в нем создаются новые элементы, по умолчанию им присваивается значение nil: