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

b = a.invert

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

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

8.2.7. Поиск ключей и значений в хэше

Определить, было ли присвоено значение некоторому ключу, позволяет метод 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?:

a.has_value? 2 # true

a.value? 99    # false

8.2.8. Копирование хэша в массив

Чтобы преобразовать весь хэш в массив, пользуйтесь методом to_a. В получившемся массиве ключи станут элементами с четными индексами (начиная с 0), а значения — с нечетными:

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

h.to_a # ["а",1,"b",2]

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

h.keys   # ["а","b"]

h.values # [1,2]

Наконец, можно поместить в массив только значения, соответствующие заданному списку ключей. Этот метод работает для хэшей примерно так же, как одноименный метод для массивов. (Кроме того, как и в случае массивов, метод values_at заменяет устаревшие методы indices и indexes.)

h = {1=>"one", 2=>"two", 3=>"three", 4=>"four", "cinco"=>"five"}

h.values_at(3,"cinco",4) # ["three","five","four"]

h.values_at(1,3)         # ["one","three"]

8.2.9. Выборка пар ключ-значение по заданному критерию

К классу Hash подмешан модуль Enumerable, поэтому можно обращаться к методам detect (find), select (find_all), grep, min, max и reject (как и для массивов).

Метод detect (синоним find) находит одну пару ключ-значение. Он принимает блок (которому передается по одной паре за раз) и возвращает первую пару, для которой вычисление блока дает true.

names = {"fred"=>"jones","jane"=>"tucker", "joe"=>"tucker","mary"=>"SMITH"}

# Найти tucker.

names.detect {|k,v| v=="tucker" } # ["joe","tucker"]

# Найти имена, записанные прописными буквами.

names.find {|k,v| v==v.upcase }   # ["mary", "SMITH"]

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

Метод select (синоним find_all) возвращает все пары, удовлетворяющие условию, а не только первую:

names.select {|k,v| v=="tucker" }

# [["joe", "tucker"], ["jane", "tucker"]]

names.find_all (|k,v| k.count("r")>0}

# [["mary", "SMITH"], ["fred", "jones"]]

8.2.10. Сортировка хэша

Хэши по природе своей не упорядочены ни по ключам, ни по значениям. Чтобы отсортировать хэш, Ruby преобразует его в массив, который затем сортирует. Понятно, что и результатом является массив.

names = {"Jack"=>"Ruby","Monty"=>"Python",

         "Blaise"=>"Pascal", "Minnie"=>"Perl"} list = names.sort

# list равно:

# [["Blaise","Pascal"], ["Jack","Ruby"],

# ["Minnie","Perl"], ["Monty","Python"]]

8.2.11. Объединение двух хэшей

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

dict = {"base"=>"foundation", "pedestal"=>"base"}

added = {"base"=>"non-acid", "salt"=>"NaCl"}

new_dict = diet.merge(added)

# {"base" =>"non-acid", "pedestal" =>"base", "salt"=>"NaCl"}

У метода merge есть синоним update.

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

dict = {"base"=>"foundation", "pedestal"=>"base"}

added = {"base"=>"non-acid", "salt" =>"NaCl"}

new_dict = diet.merge(added) {|key,old,new| old < new ? old : new }

# {"salt"=>"NaCl", "pedestal"=>"base", "base"=>"foundation"}

Таким образом, при использовании блока результат может получиться не такой, как в случае, когда блок не задан. Имеются также методы merge! и update!, которые изменяют вызывающий объект «на месте».

8.2.12. Создание хэша из массива

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

Array =[2,3,4,5,6,7]

hash = Hash[*array]

# hash равно: {2=>3, 4=>5, 6=>7}

8.2.13. Вычисление разности и пересечения хэшей

Ключи хэша можно скопировать в отдельный массив, а к получившимся из разных хэшей массивам применить методы & и - класса Array. Результатом являются пересечение и разность множеств ключей. Соответствующие им значения можно получить с помощью метода each, примененного к хэшу, содержащему все образованные таким способом ключи.

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

b = {"x"=>99,"у"=>88,"z"=>77}

intersection = a.keys & b.keys

difference = a.keys - b.keys

с = a.dup.update(b)

inter = {}

intersection.each {|k| inter[k]=c[k] }

# inter равно {"z"=>77}

diff={}

difference.each {|k| diff[k]=c[k] }

# diff равно {"а"=>1, "b"=>2}

8.2.14. Хэш как разреженная матрица

Часто в массиве или матрице заполнена лишь небольшая часть элементов. Можно хранить их как обычно, но такое расходование памяти неэкономно. Хэш позволяет хранить только реально существующие значения.

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

values = Hash.new(0)

values[1001] = 5

values[2010] = 7

values[9237] = 9

x = values[9237] # 9

y = values[5005] # 0

Ясно, что обычный массив в таком случае содержал бы более 9000 неиспользуемых элементов, что не всегда приемлемо.

А если нужно реализовать разреженную матрицу размерности два или более? В этом случае можно было бы использовать массивы в качестве ключей:

cube = Hash.new(0)

cube[[2000,2000,2000]] = 2

z = cube[[36,24,36]] # 0

Здесь обычная матрица содержала бы миллиарды элементов.

8.2.15. Реализация хэша с повторяющимися ключами

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

В листинге 8.1 предложено частичное решение. Оно неполно по двум причинам. Во-первых, мы не стали реализовывать всю желательную функциональность, ограничившись лишь некоторым достаточно представительным подмножеством. Во-вторых, внутреннее устройство Ruby таково, что литеральный хэш всегда является экземпляром класса Hash, и, хотя мы наследуем классу Hash, литерал все равно не сможет содержать повторяющихся ключей (мы подумаем об этом позже).

class HashDup

 def initialize(*all)

  raise IndexError if all.size % 2 != 0

  @store = {}

  if all[0] # не nil

   keyval = all.dup

   while !keyval.empty?

    key = keyval.shift

    if @store.has_key?(key)

     @store[key] += [keyval.shift]

    else

     @store[key] = [keyval.shift]

    end

   end

  end

 end

 def store(k,v)

  if @store.has_key?(k)

   @store[k] += [v]

  else

   @store[k] = [v]

  end

 end

 def [](key)

  @store[key]

 end

 def []=(key,value)

  self.store(key,value)

 end

 def to_s

  @store.to_s

 end

 def to_a

  @store.to_a

 end

 def inspect

  @store.inspect

 end

 def keys

  result=[]

  @store.each do |k,v|

   result += ([k]*v.size)

  end

  result

 end

 def values

  @store.values.flatten

 end

 def each

  @store.each {|k,v| v.each {|y| yield k,y}}