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

а = {}

а["flat"] = 3 # {"flat"=>3}

а.[]=("curved",2) # {"flat"=>3,"curved"=>2}

a.store("angled",5) # {"flat"=>3,"curved"=>2,"angled"=>5}

Метод store— просто синоним []=, оба могут принимать два аргумента, как показано в примере выше.

Метод fetchаналогичен методу [], но возбуждает исключение IndexError, когда ключ отсутствует. Есть у него и необязательный второй аргумент (или блок) для указания значения по умолчанию (см. раздел 8.2.2).

a["flat"] # 3

а.[]("flat") # 3

a.fetch("flat") # 3

a["bent"] # nil

Предположим, что мы не уверены, существует ли объект Hash, но хотели бы избежать очистки имеющегося хэша. Очевидное решение — проверить, определен ли интересующий нас объект:

unless defined? а

а={}

end

a["flat"] = 3

Но есть и другой способ:

а ||= {}

a["flat"] = 3

# Или даже так:

(а ||= {})["flat"] = 3

Тот же вопрос можно поставить для отдельных ключей, когда новое значение следует присваивать, лишь если такого ключа еще нет:

a=Hash.new(99)

а[2] # 99

а # {}

а[2] ||= 5 # 99

а # {}

b=Hash.new

b # {}

b[2] # nil

b[2] ||= 5 # 5

b # {2=>5}

Отметим, что nil может выступать и в качестве ключа, и в качестве значения:

b={}

b[2] # nil b[3]=nil

b # {3=>nil}

b[2].nil? # true

b[3].nil? # true b[nil]=5

b # {3=>nil,nil=>5}

b[nil] # 5

b[b[3]] # 5

Удалить пары ключ-значение из хэша можно с помощью методов clear, delete, delete_if, reject, reject!и shift.

Метод clearудаляет из хэша все пары. Эффект такой же, как от присваивания переменной нового пустого хэша, но работает чуть быстрее.

Метод shiftудаляет незаданную пару ключ-значение и возвращает ее в виде массива из двух элементов или nil, если никаких ключей не осталось.

a = {1=>2, 3=>4}

b = a.shift # [1,2]

# а равно {3=>4}

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

a = (1=>1, 2=>4, 3=>9, 4=>16)

a.delete(3) # 9

# a is now {1=>1, 2 =>4, 4=>16)

a.delete(5) # в этом случае nil.

delete(6) { "не найдено" } # "не найдено".

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

В классе Hashимеется стандартный итератор each, а кроме него итераторы each_key, each_pairи each_value( each_pair— синоним each).

{"а"=>3, "b"=>2}.each do |key, val|

print val, " из ", key, "; " # 3 из a; 2 из b;

end

Остальные два итератора передают в блок только ключ или только значение:

{"а"=>3,"b"=>2}.each_key do |key|

print "ключ = #{key};" # Печатается: ключ = a; key = b;

end

{"a"=>3,"b"=>2).each_value do |value|

print "значение = #{value};" # Печатается: значение = 3; val = 2;

end

Инвертирование хэша осуществляется в Ruby тривиально с помощью метода invert:

а = {"fred"=>"555-1122","jane"=>"555-7779"}

b = a.invert

b["555-7779"] # "jane"

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

Определить, было ли присвоено значение некоторому ключу, позволяет метод has_key?или любой из его синонимов include?, key?, member?:

а = {"а"=>1,"b"=>2}

a.has_key? "с" # false

a.include? "а" # true

a.key? 2 # false

a.member? "b" # true

Можно также воспользоваться методом empty?, чтобы узнать, остался ли в хэше хотя бы один ключ. А метод lengthи его синоним sizeпозволяют узнать, сколько ключей имеется в хэше:

a.empty? # false

a.length # 2

Можно проверить также, существует ли указанное значение. Для этого предназначены методы has_value?или value?: