класс Hash

Возвращает новый объект Hash, заполненный переданными объектами, если они есть. См. Hash::new.

Если аргумент не передан, возвращает новый пустой хеш.

Если передан один аргумент other_hash, являющийся хешем, возвращает новый хеш, инициализированный записями из этого хеша (но не его default или default_proc):

h = {foo: 0, bar: 1, baz: 2}
Hash[h] # => {foo: 0, bar: 1, baz: 2}

Если передан один аргумент 2_element_arrays, являющийся массивом массивов из двух элементов, возвращает новый хеш, в котором каждый переданный массив из двух элементов образует запись «ключ-значение»:

Hash[ [ [:foo, 0], [:bar, 1] ] ] # => {foo: 0, bar: 1}

Если передано чётное число аргументов objects, возвращает новый хеш, в котором каждая следующая пара аргументов образует запись «ключ-значение»:

Hash[:foo, 0, :bar, 1] # => {foo: 0, bar: 1}

Вызывает ArgumentError, если список аргументов не соответствует ни одному из перечисленных выше вариантов.

См. также Методы создания хеша.

Возвращает новый пустой объект Hash.

Инициализирует значения Hash#default и Hash#default_proc, определяющие поведение в случае, когда заданный ключ не найден; см. Ключ не найден?.

По умолчанию хеш содержит значения nil как для default, так и для default_proc:

h = Hash.new        # => {}
h.default           # => nil
h.default_proc      # => nil

Если передан аргумент default_value, задаёт значение default для хеша:

h = Hash.new(false) # => {}
h.default           # => false
h.default_proc      # => nil

Если передан блок, задаёт значение default_proc:

h = Hash.new {|hash, key| "Hash #{hash}: Default value for #{key}" }
h.default      # => nil
h.default_proc # => #<Proc:0x00000289b6fa7048 (irb):185>
h[:nosuch]     # => "Hash {}: Default value for nosuch"

Вызывает ArgumentError, если переданы и default_value, и блок.

Если необязательный именованный аргумент capacity передан с положительным целочисленным значением n, инициализирует хеш ёмкостью, достаточной для размещения n записей без изменения размера.

См. также Методы создания хеша.

Создаёт копию заданного хеша и добавляет флаг ruby2_keywords. Этот метод не предназначен для обычного использования; он нужен для отладки, исследований и некоторых действительно необходимых случаев, например десериализации аргументов.

h = {k: 1}
h = Hash.ruby2_keywords_hash(h)
def foo(k: 42)
  k
end
foo(*[h]) #=> 1 with neither a warning or an error

Проверяет, установлен ли для заданного хеша флаг Module#ruby2_keywords (или Proc#ruby2_keywords). Этот метод не предназначен для обычного использования; он нужен для отладки, исследований и некоторых действительно необходимых случаев, например сериализации аргументов.

ruby2_keywords def foo(*args)
  Hash.ruby2_keywords_hash?(args.last)
end
foo(k: 1)   #=> true
foo({k: 1}) #=> false

Если object является хешем, возвращает object.

В противном случае, если object отвечает на вызов :to_hash, вызывает object.to_hash; возвращает результат, если он является хешем, или вызывает TypeError, если это не так.

В противном случае, если object не отвечает на вызов :to_hash, возвращает nil.

Возвращает, являются ли записи self собственным подмножеством записей other:

h = {foo: 0, bar: 1}
h < {foo: 0, bar: 1, baz: 2} # => true   # Proper subset.
h < {baz: 2, bar: 1, foo: 0} # => true   # Order may differ.
h < h                        # => false  # Not a proper subset.
h < {bar: 1, foo: 0}         # => false  # Not a proper subset.
h < {foo: 0, bar: 1, baz: 2} # => false  # Different key.
h < {foo: 0, bar: 1, baz: 2} # => false  # Different value.

См. Включение хешей.

Вызывает TypeError, если other_hash не является хешем и не может быть преобразован в хеш.

Связанные материалы: см. Методы сравнения.

Возвращает, являются ли записи self подмножеством записей other:

h0 = {foo: 0, bar: 1}
h1 = {foo: 0, bar: 1, baz: 2}
h0 <= h0 # => true
h0 <= h1 # => true
h1 <= h0 # => false

См. Включение хешей.

Вызывает TypeError, если other_hash не является хешем и не может быть преобразован в хеш.

Связанные материалы: см. Методы сравнения.

Возвращает, равны ли self и object.

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

• object является объектом Hash (или может быть преобразован в него).

• self и object имеют одинаковые ключи (независимо от порядка).

• Для каждого ключа key выполняется self[key] == object[key].

В противном случае возвращает false.

Примеры:

h =  {foo: 0, bar: 1}
h == {foo: 0, bar: 1} # => true   # Equal entries (same order)
h == {bar: 1, foo: 0} # => true   # Equal entries (different order).
h == 1                            # => false  # Object not a hash.
h == {}                           # => false  # Different number of entries.
h == {foo: 0, bar: 1} # => false  # Different key.
h == {foo: 0, bar: 1} # => false  # Different value.

Связанные материалы: см. Методы сравнения.

Возвращает true, если записи self являются собственным надмножеством записей other_hash, и false в противном случае:

h = {foo: 0, bar: 1, baz: 2}
h > {foo: 0, bar: 1}         # => true   # Proper superset.
h > {bar: 1, foo: 0}         # => true   # Order may differ.
h > h                        # => false  # Not a proper superset.
h > {baz: 2, bar: 1, foo: 0} # => false  # Not a proper superset.
h > {foo: 0, bar: 1}         # => false  # Different key.
h > {foo: 0, bar: 1}         # => false  # Different value.

См. Включение хешей.

Вызывает TypeError, если other_hash не является хешем и не может быть преобразован в хеш.

Связанные материалы: см. Методы сравнения.

Возвращает true, если записи self являются надмножеством записей other_hash, и false в противном случае:

h0 = {foo: 0, bar: 1, baz: 2}
h1 = {foo: 0, bar: 1}
h0 >= h1 # => true
h0 >= h0 # => true
h1 >= h0 # => false

См. Включение хешей.

Вызывает TypeError, если other_hash не является хешем и не может быть преобразован в хеш.

Связанные материалы: см. Методы сравнения.

Ищет ключ хеша, эквивалентный заданному key; см. Эквивалентность ключей хеша.

Если ключ найден, возвращает его значение:

{foo: 0, bar: 1, baz: 2}
h[:bar] # => 1

В противном случае возвращает значение по умолчанию (см. Значение хеша по умолчанию).

Связанные материалы: []=; см. также Методы получения.

Связывает заданное object с заданным key; возвращает object.

Ищет ключ хеша, эквивалентный заданному key; см. Эквивалентность ключей хеша.

Если ключ найден, заменяет его значение на заданное object; порядок не изменяется (см. Порядок записей):

h = {foo: 0, bar: 1}
h[:foo] = 2 # => 2
h[:foo]     # => 2

Если key не найден, создает новую запись для заданных key и object; новая запись будет последней в порядке (см. Порядок записей):

h = {foo: 0, bar: 1}
h[:baz] = 2 # => 2
h[:baz]     # => 2
h           # => {:foo=>0, :bar=>1, :baz=>2}

Связанные материалы: []; см. также Методы присваивания.

Возвращает true, если какой-либо элемент удовлетворяет заданному условию; в противном случае возвращает false.

Если self не содержит элементов, возвращает false, а аргумент и блок не используются; иначе работает описанным ниже образом.

Без аргумента и блока возвращает true, если self не пуст, и false в противном случае.

С аргументом entry и без блока возвращает true, если для любого ключа key выполняется self.assoc(key) == entry, и false в противном случае:

h = {foo: 0, bar: 1, baz: 2}
h.assoc(:bar)     # => [:bar, 1]
h.any?([:bar, 1]) # => true
h.any?([:bar, 0]) # => false

Без аргумента, но с блоком, вызывает блок для каждой пары ключ-значение; возвращает true, если блок возвращает истинное значение, и false в противном случае:

h = {foo: 0, bar: 1, baz: 2}
h.any? {|key, value| value < 3 } # => true
h.any? {|key, value| value > 3 } # => false

Если заданы и аргумент entry, и блок, выводит предупреждение и игнорирует блок.

Связанные материалы: Enumerable#any? (этот метод переопределяет его); см. также Методы получения.

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

h = {foo: 0, bar: 1, baz: 2}
h.assoc(:bar) # => [:bar, 1]

Если ключ не найден, возвращает nil.

Связанные материалы: см. Методы получения.

Удаляет все записи из self; возвращает опустошенный self.

Связанные материалы: см. Методы удаления.

Возвращает копию self без записей со значением nil:

h = {foo: 0, bar: nil, baz: 2, bat: nil}
h.compact # => {foo: 0, baz: 2}

Связанные материалы: см. Методы удаления.

Если self содержит записи со значением nil, возвращает self без записей со значением nil; в противном случае возвращает nil:

h = {foo: 0, bar: nil, baz: 2, bat: nil}
h.compact!
h          # => {foo: 0, baz: 2}
h.compact! # => nil

Связанные материалы: см. Методы удаления.

Настраивает self на сравнение ключей по идентичности (а не только по равенству); возвращает self:

По умолчанию два ключа считаются одинаковыми тогда и только тогда, когда они являются равными объектами (согласно методу eql?):

h = {}
h['x'] = 0
h['x'] = 1 # Overwrites.
h # => {"x"=>1}

После вызова этого метода два ключа считаются одинаковыми тогда и только тогда, когда они являются одним и тем же объектом:

h.compare_by_identity
h['x'] = 2 # Does not overwrite.
h # => {"x"=>1, "x"=>2}

Связанные материалы: compare_by_identity?; см. также Методы сравнения.

Возвращает, был ли вызван метод compare_by_identity:

h = {}
h.compare_by_identity? # => false
h.compare_by_identity
h.compare_by_identity? # => true

Связанные материалы: compare_by_identity; см. также Методы сравнения.

Возвращает значение по умолчанию для заданного key. Возвращаемое значение определяется либо процедурой по умолчанию, либо значением по умолчанию. См. Значение хеша по умолчанию.

Без аргумента возвращает текущее значение по умолчанию:

h = {}
h.default # => nil

Если задан key, возвращает значение по умолчанию для key независимо от того, существует ли этот ключ:

h = Hash.new { |hash, key| hash[key] = "No key #{key}"}
h[:foo] = "Hello"
h.default(:foo) # => "No key foo"

Устанавливает значение по умолчанию равным value; возвращает value:

h = {}
h.default # => nil
h.default = false # => false
h.default # => false

См. Значение хеша по умолчанию.

Возвращает процедуру по умолчанию для self (см. Значение хеша по умолчанию):

h = {}
h.default_proc # => nil
h.default_proc = proc {|hash, key| "Default value for #{key}" }
h.default_proc.class # => Proc

Устанавливает процедуру по умолчанию для self равной proc (см. Значение хеша по умолчанию):

h = {}
h.default_proc # => nil
h.default_proc = proc { |hash, key| "Default value for #{key}" }
h.default_proc.class # => Proc
h.default_proc = nil
h.default_proc # => nil

Если запись для заданного key найдена, удаляет ее и возвращает связанное с ней значение; в противном случае возвращает nil или вызывает заданный блок.

Если блок не задан и key найден, удаляет запись и возвращает ее значение:

h = {foo: 0, bar: 1, baz: 2}
h.delete(:bar) # => 1
h # => {foo: 0, baz: 2}

Если блок не задан и key не найден, возвращает nil.

Если блок задан и key найден, игнорирует блок, удаляет запись и возвращает ее значение:

h = {foo: 0, bar: 1, baz: 2}
h.delete(:baz) { |key| raise 'Will never happen'} # => 2
h # => {foo: 0, bar: 1}

Если блок задан и key не найден, вызывает блок и возвращает результат его выполнения:

h = {foo: 0, bar: 1, baz: 2}
h.delete(:nosuch) { |key| "Key #{key} not found" } # => "Key nosuch not found"
h # => {foo: 0, bar: 1, baz: 2}

Связанные материалы: см. Методы удаления.

Если блок задан, вызывает его для каждой пары ключ-значение, удаляет каждую запись, для которой блок возвращает истинное значение, и возвращает self:

h = {foo: 0, bar: 1, baz: 2}
h.delete_if {|key, value| value > 0 } # => {foo: 0}

Если блок не задан, возвращает новый Enumerator.

Связанные материалы: см. Методы удаления.

Находит и возвращает объект во вложенных объектах, указанных с помощью key и identifiers.

Вложенные объекты могут быть экземплярами различных классов. См. Методы Dig.

Вложенные хеши:

h = {foo: {bar: {baz: 2}}}
h.dig(:foo) # => {bar: {baz: 2}}
h.dig(:foo, :bar) # => {baz: 2}
h.dig(:foo, :bar, :baz) # => 2
h.dig(:foo, :bar, :BAZ) # => nil

Вложенные хеши и массивы:

h = {foo: {bar: [:a, :b, :c]}}
h.dig(:foo, :bar, 2) # => :c

Если такой объект не найден, возвращает значение хеша по умолчанию:

h = {foo: {bar: [:a, :b, :c]}}
h.dig(:hello) # => nil
h.default_proc = -> (hash, _key) { hash }
h.dig(:hello, :world)
# => {:foo=>{:bar=>[:a, :b, :c]}}

Связанные материалы: Методы получения.

Если блок задан, вызывает его для каждого ключа; возвращает self:

h = {foo: 0, bar: 1, baz: 2}
h.each_key {|key| puts key }  # => {foo: 0, bar: 1, baz: 2}

Результат:

foo
bar
baz

Если блок не задан, возвращает новый Enumerator.

Связанные материалы: см. Методы перебора.

Если блок задан, вызывает его для каждой пары ключ-значение; возвращает self:

h = {foo: 0, bar: 1, baz: 2}
h.each_pair {|key, value| puts "#{key}: #{value}"} # => {foo: 0, bar: 1, baz: 2}

Результат:

foo: 0
bar: 1
baz: 2

Если блок не задан, возвращает новый Enumerator.

Связанные материалы: см. Методы перебора.

Если блок задан, вызывает его для каждого значения; возвращает self:

h = {foo: 0, bar: 1, baz: 2}
h.each_value {|value| puts value } # => {foo: 0, bar: 1, baz: 2}

Результат:

0
1
2

Если блок не задан, возвращает новый Enumerator.

Связанные материалы: см. Методы перебора.

Возвращает true, если в хеше нет записей, и false в противном случае:

{}.empty? # => true
{foo: 0}.empty? # => false

Связанные материалы: см. Методы проверки.

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

• Заданный object является объектом Hash.

• self и object имеют одинаковые ключи (независимо от порядка).

• Для каждого ключа key выполняется self[key].eql?(object[key]).

В противном случае возвращает false.

h1 = {foo: 0, bar: 1, baz: 2}
h2 = {foo: 0, bar: 1, baz: 2}
h1.eql? h2 # => true
h3 = {baz: 2, bar: 1, foo: 0}
h1.eql? h3 # => true

Связанные материалы: см. Методы проверки.

Возвращает копию self без записей для заданных keys; все keys, которые не найдены, игнорируются:

h = {foo:0, bar: 1, baz: 2} # => {:foo=>0, :bar=>1, :baz=>2}
h.except(:baz, :foo)        # => {:bar=>1}
h.except(:bar, :nosuch)     # => {:foo=>0, :baz=>2}

Связанные материалы: см. Методы удаления.

Если блок не задан, возвращает значение для заданного key, если оно найдено;

h = {foo: 0, bar: 1, baz: 2}
h.fetch(:bar)  # => 1

Если ключ не найден, возвращает default_value, если он задан, или в противном случае вызывает KeyError:

h.fetch(:nosuch, :default) # => :default
h.fetch(:nosuch)           # Raises KeyError.

Если блок задан, вызывает его с key и возвращает результат выполнения блока:

{}.fetch(:nosuch) {|key| "No key #{key}"} # => "No key nosuch"

Обратите внимание, что этот метод не использует значения ни default, ни default_proc.

Связанные материалы: см. Методы получения.

Если все заданные keys найдены, возвращает новый массив со значениями, связанными с заданными keys:

h = {foo: 0, bar: 1, baz: 2}
h.fetch_values(:baz, :foo) # => [2, 0]

Если какие-либо заданные keys не найдены и блок задан, вызывает блок для каждого ненайденного ключа и использует результат выполнения блока как значение для этого ключа:

h.fetch_values(:bar, :foo, :bad, :bam) {|key| key.to_s}
# => [1, 0, "bad", "bam"]

Если какие-либо заданные keys не найдены и блок не задан, вызывает KeyError.

Связанные материалы: см. Методы получения.

При положительном целом числе depth возвращает новый массив, полученный рекурсивным уплощением self до заданного уровня depth.

На каждом уровне рекурсии:

• Каждый элемент, значением которого является массив, «уплощается» (то есть заменяется отдельными элементами этого массива); см. Array#flatten.

• Каждый элемент, значением которого не является массив, остается без изменений, даже если его значение — объект с методом экземпляра flatten (например, хеш).

Примеры; обратите внимание, что запись foo: {bar: 1, baz: 2} никогда не уплощается.

h = {foo: {bar: 1, baz: 2}, bat: [:bam, [:bap, [:bah]]]}
h.flatten(1) # => [:foo, {:bar=>1, :baz=>2}, :bat, [:bam, [:bap, [:bah]]]]
h.flatten(2) # => [:foo, {:bar=>1, :baz=>2}, :bat, :bam, [:bap, [:bah]]]
h.flatten(3) # => [:foo, {:bar=>1, :baz=>2}, :bat, :bam, :bap, [:bah]]
h.flatten(4) # => [:foo, {:bar=>1, :baz=>2}, :bat, :bam, :bap, :bah]
h.flatten(5) # => [:foo, {:bar=>1, :baz=>2}, :bat, :bam, :bap, :bah]

При отрицательном целом числе depth уплощает все уровни:

h.flatten(-1) # => [:foo, {:bar=>1, :baz=>2}, :bat, :bam, :bap, :bah]

При depth, равном нулю, возвращает результат, эквивалентный to_a:

h.flatten(0) # => [[:foo, {:bar=>1, :baz=>2}], [:bat, [:bam, [:bap, [:bah]]]]]

Связанные материалы: см. Методы преобразования.

Возвращает, является ли value значением в self.

Связанные методы: Методы для проверки.

Возвращает целочисленный хеш-код хеша.

Два хеша имеют одинаковый хеш-код, если их содержимое одинаково (независимо от порядка):

h1 = {foo: 0, bar: 1, baz: 2}
h2 = {baz: 2, bar: 1, foo: 0}
h2.hash == h1.hash # => true
h2.eql? h1 # => true

Связанные методы: см. Методы для проверки.

Возвращает, является ли key ключом в self:

h = {foo: 0, bar: 1, baz: 2}
h.include?(:bar) # => true
h.include?(:BAR) # => false

Связанные методы: Методы для проверки.

Возвращает новую строку, содержащую записи хеша:

h = {foo: 0, bar: 1, baz: 2}
h.inspect # => "{foo: 0, bar: 1, baz: 2}"

Связанные методы: см. Методы преобразования.

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

h = {foo: 0, bar: 1, baz: 2}
h1 = h.invert
h1 # => {0=>:foo, 1=>:bar, 2=>:baz}

Перезаписывает повторяющиеся новые ключи (см. Порядок записей):

h = {foo: 0, bar: 0, baz: 0}
h.invert # => {0=>:baz}

Связанные методы: см. Методы преобразования ключей и значений.

Если передан блок, вызывает его для каждой пары ключ-значение; сохраняет запись, если блок возвращает истинное значение, иначе удаляет её; возвращает self:

h = {foo: 0, bar: 1, baz: 2}
h.keep_if { |key, value| key.start_with?('b') } # => {bar: 1, baz: 2}

Если блок не передан, возвращает новый Enumerator.

Связанные методы: см. Методы удаления.

Возвращает ключ первой найденной записи с заданным значением value (см. Порядок записей):

h = {foo: 0, bar: 2, baz: 2}
h.key(0) # => :foo
h.key(2) # => :bar

Возвращает nil, если такое значение не найдено.

Связанные методы: см. Методы получения.

Возвращает новый массив, содержащий все ключи в self:

h = {foo: 0, bar: 1, baz: 2}
h.keys # => [:foo, :bar, :baz]

Связанные методы: см. Методы получения.

Каждый аргумент other_hash в other_hashes должен быть хешем.

Если переданы аргументы other_hashes и не передан блок, возвращает новый хеш, созданный путём слияния каждого последующего other_hash с копией self; возвращает эту копию; для каждой последующей записи в other_hash:

• Если ключ новый, запись добавляется в конец self.

• Если ключ повторяется, запись перезаписывает запись в self, не меняя её позицию.

Пример:

h = {foo: 0, bar: 1, baz: 2}
h1 = {bat: 3, bar: 4}
h2 = {bam: 5, bat:6}
h.merge(h1, h2) # => {foo: 0, bar: 4, baz: 2, bat: 6, bam: 5}

Если переданы аргументы other_hashes и блок, действует описанное выше, за исключением того, что при повторяющемся ключе перезаписывающая запись получает значение не из записи в other_hash, а из блока:

• Блок вызывается с повторяющимся ключом и значениями из обоих хешей: self и other_hash.

• Возвращаемое блоком значение становится новым значением записи в self.

Пример:

h = {foo: 0, bar: 1, baz: 2}
h1 = {bat: 3, bar: 4}
h2 = {bam: 5, bat:6}
h.merge(h1, h2) { |key, old_value, new_value| old_value + new_value }
# => {foo: 0, bar: 5, baz: 2, bat: 9, bam: 5}

Если аргументы не переданы, возвращает копию self; переданный блок игнорируется.

Связанные методы: см. Методы присваивания.

Выполняет поиск в self первой записи, значение которой равно == заданному value; см. Порядок записей.

Если запись найдена, возвращает её ключ и значение в виде массива из двух элементов; если запись не найдена, возвращает nil:

h = {foo: 0, bar: 1, baz: 1}
h.rassoc(1) # => [:bar, 1]

Связанные методы: см. Методы получения.

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

Хеш-таблица становится недействительной, если хеш-значение ключа изменилось после создания записи. См. Изменение активного ключа хеша.

Если передан блок, возвращает копию self, из которой удалена одна или несколько записей; вызывает блок для каждой пары ключ-значение; исключает запись из копии, если блок возвращает истинное значение, и включает её в противном случае:

h = {foo: 0, bar: 1, baz: 2}
h.reject {|key, value| key.start_with?('b') }
# => {foo: 0}

Если блок не передан, возвращает новый Enumerator.

Связанные методы: см. Методы удаления.

Если передан блок, вызывает его с ключом и значением каждой записи; удаляет запись из self, если блок возвращает истинное значение.

Возвращает self, если были удалены какие-либо записи, и nil в противном случае:

h = {foo: 0, bar: 1, baz: 2}
h.reject! {|key, value| value < 2 } # => {baz: 2}
h.reject! {|key, value| value < 2 } # => nil

Если блок не передан, возвращает новый Enumerator.

Связанные методы: см. Методы удаления.

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

h = {foo: 0, bar: 1, baz: 2}
h.select {|key, value| value < 2 } # => {foo: 0, bar: 1}

Если блок не передан, возвращает новый Enumerator.

Связанные методы: см. Методы удаления.

Если передан блок, вызывает его с ключом и значением каждой записи; удаляет из self каждую запись, для которой блок возвращает false или nil.

Возвращает self, если были удалены какие-либо записи, и nil в противном случае:

h = {foo: 0, bar: 1, baz: 2}
h.select! {|key, value| value < 2 } # => {foo: 0, bar: 1}
h.select! {|key, value| value < 2 } # => nil

Если блок не передан, возвращает новый Enumerator.

Связанные методы: см. Методы удаления.

Удаляет и возвращает первую запись self в виде массива из двух элементов; см. Порядок записей:

h = {foo: 0, bar: 1, baz: 2}
h.shift # => [:foo, 0]
h       # => {bar: 1, baz: 2}

Возвращает nil, если self пуст.

Связанные методы: см. Методы удаления.

Возвращает количество записей в self:

{foo: 0, bar: 1, baz: 2}.size # => 3

Связанные методы: см. Методы для проверки.

Возвращает новый хеш, содержащий записи из self для заданных keys; игнорирует ключи, которые не найдены:

h = {foo: 0, bar: 1, baz: 2}
h.slice(:baz, :foo, :nosuch) # => {baz: 2, foo: 0}

Связанные методы: см. Методы удаления.

Возвращает все элементы self в виде массива, состоящего из массивов по два элемента; каждый вложенный массив содержит пару ключ-значение из self:

h = {foo: 0, bar: 1, baz: 2}
h.to_a # => [[:foo, 0], [:bar, 1], [:baz, 2]]

Связанные методы: см. Методы преобразования.

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

h = {foo: 0, bar: 1, baz: 2}
h.to_h {|key, value| [value, key] }
# => {0 => :foo, 1 => :bar, 2 => :baz}

Если блок не передан, возвращает self, если self является экземпляром Hash; если self является подклассом Hash, возвращает новый хеш, содержащий содержимое self.

Связанные методы: см. Методы преобразования.

Возвращает self.

Связанные методы: см. Методы преобразования.

Возвращает объект Proc, который сопоставляет ключ его значению:

h = {foo: 0, bar: 1, baz: 2}
proc = h.to_proc
proc.class # => Proc
proc.call(:foo) # => 0
proc.call(:bar) # => 1
proc.call(:nosuch) # => nil

Связанные методы: см. Методы преобразования.

Если передан аргумент, блок или оба сразу, на основе self, аргумента и/или блока формирует новый хеш new_hash; все его ключи, некоторые из них или ни один могут отличаться от ключей в self.

Если передан блок, но не аргумент, ключи new_hash определяются только блоком.

Для каждой пары ключ-значение old_key/value в self вызывает блок с old_key; возвращаемое блоком значение становится new_key; задаёт new_hash[new_key] = value; повторяющийся ключ перезаписывает существующий:

h = {foo: 0, bar: 1, baz: 2}
h.transform_keys {|old_key| old_key.to_s }
# => {"foo" => 0, "bar" => 1, "baz" => 2}
h.transform_keys {|old_key| 'xxx' }
# => {"xxx" => 2}

Если передан аргумент other_hash, но не блок, в new_hash могут появиться новые ключи из other_hash и неизменённые ключи из self.

Для каждой пары ключ-значение old_key/old_value в self ищет ключ old_key в other_hash:

• Если old_key найден, его значение other_hash[old_key] используется как new_key; задаёт new_hash[new_key] = value; повторяющийся ключ перезаписывает существующий:

  h = {foo: 0, bar: 1, baz: 2}
  h.transform_keys(baz: :BAZ, bar: :BAR, foo: :FOO)
  # => {FOO: 0, BAR: 1, BAZ: 2}
  h.transform_keys(baz: :FOO, bar: :FOO, foo: :FOO)
  # => {FOO: 2}
  

• Если old_key не найден, задаёт new_hash[old_key] = value; повторяющийся ключ перезаписывает существующий:

  h = {foo: 0, bar: 1, baz: 2}
  h.transform_keys({})
  # => {foo: 0, bar: 1, baz: 2}
  h.transform_keys(baz: :foo)
  # => {foo: 2, bar: 1}
  

Неиспользованные ключи в other_hash игнорируются:

h = {foo: 0, bar: 1, baz: 2}
h.transform_keys(bat: 3)
# => {foo: 0, bar: 1, baz: 2}

Если переданы и аргумент other_hash, и блок, новые ключи в new_hash задаются с помощью other_hash или блока, а неизменённые ключи берутся из self.

Для каждой пары old_key и value в self:

• Если в other_hash есть ключ old_key (со значением new_key), блок для этого ключа не вызывается; задаёт new_hash[new_key] = value; повторяющийся ключ перезаписывает существующий:

  h = {foo: 0, bar: 1, baz: 2}
  h.transform_keys(baz: :BAZ, bar: :BAR, foo: :FOO) {|key| fail 'Not called' }
  # => {FOO: 0, BAR: 1, BAZ: 2}
  

• Если в other_hash нет ключа old_key, вызывает блок с old_key и использует его возвращаемое значение как new_key; задаёт new_hash[new_key] = value; повторяющийся ключ перезаписывает существующий:

  h = {foo: 0, bar: 1, baz: 2}
  h.transform_keys(baz: :BAZ) {|key| key.to_s.reverse }
  # => {"oof" => 0, "rab" => 1, BAZ: 2}
  h.transform_keys(baz: :BAZ) {|key| 'ook' }
  # => {"ook" => 1, BAZ: 2}
  

Если не переданы ни аргумент, ни блок, возвращает новый Enumerator.

Связанные методы: см. Методы преобразования ключей и значений.

Если передан аргумент, блок или оба сразу, формирует ключи на основе аргумента, блока и self; все ключи в self, некоторые из них или ни один могут измениться.

Если передан блок, но не аргумент, формирует ключи только на основе блока; все ключи в self, некоторые из них или ни один могут измениться.

Для каждой пары ключ-значение old_key/value в self вызывает блок с old_key; возвращаемое блоком значение становится new_key; удаляет запись для old_key: self.delete(old_key); задаёт self[new_key] = value; повторяющийся ключ перезаписывает существующий:

h = {foo: 0, bar: 1, baz: 2}
h.transform_keys! {|old_key| old_key.to_s }
# => {"foo" => 0, "bar" => 1, "baz" => 2}
h = {foo: 0, bar: 1, baz: 2}
h.transform_keys! {|old_key| 'xxx' }
# => {"xxx" => 2}

Если передан аргумент other_hash, но не блок, формирует ключи для self на основе other_hash и self; все ключи в self, некоторые из них или ни один могут измениться.

Для каждой пары ключ-значение old_key/old_value в self ищет ключ old_key в other_hash:

• Если old_key найден, использует значение other_hash[old_key] как new_key; удаляет запись для old_key: self.delete(old_key); задаёт self[new_key] = value; повторяющийся ключ перезаписывает существующий:

  h = {foo: 0, bar: 1, baz: 2}
  h.transform_keys!(baz: :BAZ, bar: :BAR, foo: :FOO)
  # => {FOO: 0, BAR: 1, BAZ: 2}
  h = {foo: 0, bar: 1, baz: 2}
  h.transform_keys!(baz: :FOO, bar: :FOO, foo: :FOO)
  # => {FOO: 2}
  

• Если old_key не найден, ничего не делает:

  h = {foo: 0, bar: 1, baz: 2}
  h.transform_keys!({})
  # => {foo: 0, bar: 1, baz: 2}
  h.transform_keys!(baz: :foo)
  # => {foo: 2, bar: 1}
  

Неиспользованные ключи в other_hash игнорируются:

h = {foo: 0, bar: 1, baz: 2}
h.transform_keys!(bat: 3)
# => {foo: 0, bar: 1, baz: 2}

Если переданы и аргумент other_hash, и блок, формирует ключи на основе other_hash, блока и self; все ключи в self, некоторые из них или ни один могут измениться.

Для каждой пары old_key и value в self:

• Если в other_hash есть ключ old_key (со значением new_key), блок для этого ключа не вызывается; удаляет запись для old_key: self.delete(old_key); задаёт self[new_key] = value; повторяющийся ключ перезаписывает существующий:

  h = {foo: 0, bar: 1, baz: 2}
  h.transform_keys!(baz: :BAZ, bar: :BAR, foo: :FOO) {|key| fail 'Not called' }
  # => {FOO: 0, BAR: 1, BAZ: 2}
  

• Если в other_hash нет ключа old_key, вызывает блок с old_key и использует его возвращаемое значение как new_key; удаляет запись для old_key: self.delete(old_key); задаёт self[new_key] = value; повторяющийся ключ перезаписывает существующий:

  h = {foo: 0, bar: 1, baz: 2}
  h.transform_keys!(baz: :BAZ) {|key| key.to_s.reverse }
  # => {"oof" => 0, "rab" => 1, BAZ: 2}
  h = {foo: 0, bar: 1, baz: 2}
  h.transform_keys!(baz: :BAZ) {|key| 'ook' }
  # => {"ook" => 1, BAZ: 2}
  

Если не переданы ни аргумент, ни блок, возвращает новый Enumerator.

Связанные методы: см. Методы преобразования ключей и значений.

Если передан блок, возвращает новый хеш new_hash; для каждой пары key/value в self вызывает блок с value и сохраняет его результат как new_value; добавляет в new_hash запись key/new_value:

h = {foo: 0, bar: 1, baz: 2}
h1 = h.transform_values {|value| value * 100}
h1 # => {foo: 0, bar: 100, baz: 200}

Если блок не передан, возвращает новый Enumerator.

См. также: методы преобразования ключей и значений.

Если передан блок, изменяет значения в self в соответствии с блоком; возвращает self.

Для каждой записи key/old_value в self вызывает блок с old_value, сохраняет его возвращаемое значение как new_value и устанавливает self[key] = new_value:

h = {foo: 0, bar: 1, baz: 2}
h.transform_values! {|value| value * 100} # => {foo: 0, bar: 100, baz: 200}

Если блок не передан, возвращает новый Enumerator.

См. также: методы преобразования ключей и значений.

Обновляет значения и/или добавляет записи в self; возвращает self.

Каждый аргумент other_hash в other_hashes должен быть хешем.

Если блок не передан, для каждой последующей записи key/new_value в каждом последующем other_hash:

• Если key содержится в self, устанавливает self[key] = new_value, сохраняя исходную позицию:

  h0 = {foo: 0, bar: 1, baz: 2}
  h1 = {bar: 3, foo: -1}
  h0.update(h1) # => {foo: -1, bar: 3, baz: 2}
  

• Если key не содержится в self, добавляет запись в конец self:

  h = {foo: 0, bar: 1, baz: 2}
  h.update({bam: 3, bah: 4}) # => {foo: 0, bar: 1, baz: 2, bam: 3, bah: 4}
  

Если передан блок, для каждой последующей записи key/new_value в каждом последующем other_hash:

• Если key содержится в self, получает old_value из self[key], вызывает блок с key, old_value и new_value, а затем устанавливает self[key] = new_value, сохраняя исходную позицию:

  season = {AB: 75, H: 20, HR: 3, SO: 17, W: 11, HBP: 3}
  today = {AB: 3, H: 1, W: 1}
  yesterday = {AB: 4, H: 2, HR: 1}
  season.update(yesterday, today) {|key, old_value, new_value| old_value + new_value }
  # => {AB: 82, H: 23, HR: 4, SO: 17, W: 12, HBP: 3}
  

• Если key не содержится в self, добавляет запись в конец self:

  h = {foo: 0, bar: 1, baz: 2}
  h.update({bat: 3}) { fail 'Cannot happen' }
  # => {foo: 0, bar: 1, baz: 2, bat: 3}
  

См. также: методы присваивания.

Возвращает новый массив, содержащий все значения из self:

h = {foo: 0, bar: 1, baz: 2}
h.values # => [0, 1, 2]

См. также: методы получения данных.

Возвращает новый массив, содержащий значения для указанных keys:

h = {foo: 0, bar: 1, baz: 2}
h.values_at(:baz, :foo) # => [2, 0]

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

h.values_at(:hello, :foo) # => [nil, 0]

См. также: методы получения данных.