класс Hash

Родитель:: Объект
Включенные модули:: Enumerable

Хэш сопоставляет каждый уникальный ключ со специфическим значением.

У хэша есть определённые сходства с Array, но:

Индекс Array всегда является Integer.
Ключ хэша может быть (почти) любым объектом.

Синтаксис данных хэша

Старый синтаксис данных хэша использует «стрелку хэша», =>:

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

В качестве альтернативы, но только для ключа хэша, который является Symbol, можно использовать новый синтаксис в стиле JSON, где каждое слово без кавычек становится символом:

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

Также можно использовать String вместо слова без кавычек:

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

И можно смешивать стили:

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

Однако попытка использовать синтаксис в стиле JSON для ключа, который не является словом без кавычек или строкой, является ошибкой:

# Raises SyntaxError (syntax error, unexpected ':', expecting =>):
h = {0: 'zero'}

Hash значение может быть опущено, что означает, что значение будет извлечено из контекста по имени ключа:

x = 0
y = 100
h = {x:, y:}
h # => {:x=>0, :y=>100}

Общие применения

Можно использовать хэш для присвоения имён объектам:

person = {name: 'Matz', language: 'Ruby'}
person # => {:name=>"Matz", :language=>"Ruby"}

Можно использовать хэш для присвоения имён аргументам методов:

def some_method(hash)
  p hash
end
some_method({foo: 0, bar: 1, baz: 2}) # => {:foo=>0, :bar=>1, :baz=>2}

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

some_method(foo: 0, bar: 1, baz: 2) # => {:foo=>0, :bar=>1, :baz=>2}

Можно использовать хэш для инициализации объекта:

class Dev
  attr_accessor :name, :language
  def initialize(hash)
    self.name = hash[:name]
    self.language = hash[:language]
  end
end
matz = Dev.new(name: 'Matz', language: 'Ruby')
matz # => #<Dev: @name="Matz", @language="Ruby">

Создание хэша

Можно явно создать объект хэша с помощью:

литерала хэша.

Можно преобразовать некоторые объекты в хэши с помощью:

Метода Hash.

Можно создать хэш, вызвав метод Hash.new.

Создать пустой хэш:

h = Hash.new
h # => {}
h.class # => Hash

Можно создать хэш, вызвав метод Hash.[].

Создать пустой хэш:

h = Hash[]
h # => {}

Создать хэш с начальными записями:

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

Можно создать хэш, используя его литеральную форму (фигурные скобки).

Создать пустой хэш:

h = {}
h # => {}

Создать хэш с начальными записями:

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

Основы значений хэша

Простейший способ извлечения значения хэша (метод экземпляра []):

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

Простейший способ создания или обновления значения хэша (метод экземпляра []=):

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

Простейший способ удаления записи хэша (метод экземпляра delete):

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

Порядок записей

Объект хэша представляет свои записи в порядке их создания. Это видно в:

Итерационных методах, таких как each, each_key, each_pair, each_value.
Других методах, чувствительных к порядку, таких как shift, keys, values.
Строке String, возвращаемой методом inspect.

У нового хэша есть начальный порядок в соответствии с заданными записями:

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

Новые записи добавляются в конец:

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

Обновление значения не влияет на порядок:

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

Но повторное создание удалённой записи может повлиять на порядок:

h.delete(:foo)
h[:foo] = 5
h # => {:bar=>1, :baz=>3, :foo=>5}

Ключи хэша

Равенство ключей хэша

Два объекта рассматриваются как один и тот же ключ хэша, когда их значение hash идентично, и два объекта eql? друг другу.

Изменение активного ключа хэша

Изменение ключа хэша во время его использования повреждает индекс хэша.

У этого хэша ключи являются массивами:

a0 = [ :foo, :bar ]
a1 = [ :baz, :bat ]
h = {a0 => 0, a1 => 1}
h.include?(a0) # => true
h[a0] # => 0
a0.hash # => 110002110

Изменение элемента массива a0[0] изменяет его значение хэша:

a0[0] = :bam
a0.hash # => 1069447059

И повреждает индекс хэша:

h.include?(a0) # => false
h[a0] # => nil

Можно восстановить индекс хэша, используя метод rehash:

h.rehash # => {[:bam, :bar]=>0, [:baz, :bat]=>1}
h.include?(a0) # => true
h[a0] # => 0

String ключ всегда безопасен. Это потому, что незамороженная String, переданная в качестве ключа, будет заменена дублированным и замороженным строковым значением:

s = 'foo'
s.frozen? # => false
h = {s => 0}
first_key = h.keys.first
first_key.frozen? # => true

Ключи хэша, определённые пользователем

Чтобы быть используемыми в качестве ключей хэша, объекты должны реализовывать методы hash и eql?. Примечание: это требование не применяется, если хэш использует compare_by_identity, так как сравнение будет тогда полагаться на идентификатор объекта ключей, а не на hash и eql?.

Object определяет базовые реализации для hash и eq? так, чтобы каждый объект являлся уникальным ключом. Как правило, определяемые пользователем классы должны переопределять эти методы, чтобы обеспечить осмысленное поведение, или, например, унаследовать Struct, у которого есть полезные определения для них.

Типичная реализация hash основана на данных объекта, в то время как eql? обычно является псевдонимом переопределённого метода ==:

class Book
  attr_reader :author, :title

  def initialize(author, title)
    @author = author
    @title = title
  end

  def ==(other)
    self.class === other &&
      other.author == @author &&
      other.title == @title
  end

  alias eql? ==

  def hash
    [self.class, @author, @title].hash
  end
end

book1 = Book.new 'matz', 'Ruby in a Nutshell'
book2 = Book.new 'matz', 'Ruby in a Nutshell'

reviews = {}

reviews[book1] = 'Great reference!'
reviews[book2] = 'Nice and compact!'

reviews.length #=> 1

Значения по умолчанию

Методы [], values_at и dig должны возвращать значение, связанное с определённым ключом. Если такой ключ не найден, это значение будет определяться его функцией по умолчанию (если она есть), или же значением по умолчанию (вначале «nil»).

Вы можете получить значение по умолчанию с помощью метода default:

h = Hash.new
h.default # => nil

Вы можете установить значение по умолчанию, передав аргумент в метод Hash.new или с помощью метода default=

h = Hash.new(-1)
h.default # => -1
h.default = 0
h.default # => 0

Это значение по умолчанию возвращается для [], values_at и dig, когда ключ не найден:

counts = {foo: 42}
counts.default # => nil (default)
counts[:foo] = 42
counts[:bar] # => nil
counts.default = 0
counts[:bar] # => 0
counts.values_at(:foo, :bar, :baz) # => [42, 0, 0]
counts.dig(:bar) # => 0

Обратите внимание, что значение по умолчанию используется без дублирования. Не рекомендуется устанавливать значение по умолчанию в изменяемый объект:

synonyms = Hash.new([])
synonyms[:hello] # => []
synonyms[:hello] << :hi # => [:hi], but this mutates the default!
synonyms.default # => [:hi]
synonyms[:world] << :universe
synonyms[:world] # => [:hi, :universe], oops
synonyms.keys # => [], oops

Для использования изменяемого объекта в качестве значения по умолчанию рекомендуется использовать функцию по умолчанию

Функция по умолчанию `Proc`

Когда для хэша установлена функция по умолчанию (т.е., не nil), значение по умолчанию, возвращаемое методом [], определяется только функцией по умолчанию.

Вы можете получить функцию по умолчанию с помощью метода default_proc:

h = Hash.new
h.default_proc # => nil

Вы можете установить функцию по умолчанию, вызвав Hash.new с блоком или вызвав метод default_proc=

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

Когда функция по умолчанию установлена (т.е., не nil) и вызывается метод [] с несуществующим ключом, [] вызывает функцию по умолчанию с объектом хэша и отсутствующим ключом, а затем возвращает возвращаемое значение функции:

h = Hash.new { |hash, key| "Default value for #{key}" }
h[:nosuch] # => "Default value for nosuch"

Обратите внимание, что в приведённом выше примере не создаётся запись для ключа :nosuch:

h.include?(:nosuch) # => false

Однако сама функция может добавить новую запись:

synonyms = Hash.new { |hash, key| hash[key] = [] }
synonyms.include?(:hello) # => false
synonyms[:hello] << :hi # => [:hi]
synonyms[:world] << :universe # => [:universe]
synonyms.keys # => [:hello, :world]

Обратите внимание, что установка функции по умолчанию очищает значение по умолчанию и наоборот.

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

Что здесь

Сначала, что где-то ещё. Класс Hash:

Наследует от класса Object.
Включает модуль Enumerable, который предоставляет десятки дополнительных методов.

Здесь класс Hash предоставляет методы, полезные для:

Класс Hash также включает методы из модуля Enumerable.

Методы для создания хэша

::[]: Возвращает новый хэш, заполненный заданными объектами.
::new: Возвращает новый пустой хэш.
::try_convert: Возвращает новый хэш, созданный из данного объекта.

Методы для установки состояния хэша

compare_by_identity: Устанавливает self на использование только идентичности при сравнении ключей.
default=: Устанавливает значение по умолчанию.
default_proc=: Устанавливает функцию по умолчанию.
rehash: Перестраивает таблицу хэша, пересчитывая индекс хэша для каждого ключа.

Методы для запросов

any?: Возвращает значение, если какой-либо элемент удовлетворяет заданному критерию.
compare_by_identity?: Возвращает значение, если хеш учитывает только идентичность при сравнении ключей.
default: Возвращает значение по умолчанию или значение по умолчанию для заданного ключа.
default_proc: Возвращает процедуру по умолчанию.
empty?: Возвращает значение, если нет записей.
eql?: Возвращает значение, если заданный объект равен self.
hash: Возвращает целочисленный код хеша.
has_value?: Возвращает значение, если заданный объект является значением в self.
include?, has_key?, member?, key?: Возвращает значение, если заданный объект является ключом в self.
length, size: Возвращает количество записей.
value?: Возвращает значение, если заданный объект является значением в self.

Методы для сравнения

<: Возвращает значение, если self является надлежащим подмножеством заданного объекта.
<=: Возвращает значение, если self является подмножеством заданного объекта.
==: Возвращает значение, если заданный объект равен self.
>: Возвращает значение, если self является надлежащим надмножеством заданного объекта
>=: Возвращает значение, если self является надмножеством заданного объекта.

Методы для извлечения

[]: Возвращает значение, связанное с заданным ключом.
assoc: Возвращает массив из 2 элементов, содержащий заданный ключ и его значение.
dig: Возвращает объект вложенных объектов, заданный данным ключом и дополнительными аргументами.
fetch: Возвращает значение для заданного ключа.
fetch_values: Возвращает массив, содержащий значения, связанные с заданными ключами.
key: Возвращает ключ для первой найденной записи со значением заданным в аргументе.
keys: Возвращает массив, содержащий все ключи в self.
rassoc: Возвращает массив из 2 элементов, содержащий ключ и значение первой найденной записи со значением заданным в аргументе.
values: Возвращает массив, содержащий все значения в self.
values_at: Возвращает массив, содержащий значения для заданных ключей.

Методы для присваивания

[]=, store: Связывает заданный ключ со значением.
merge: Возвращает хеш, сформированный путем слияния каждого заданного хеша в копию self.
merge!, update: Объединяет каждый заданный хеш в self.
replace: Заменяет все содержимое self содержимым заданного хеша.

Методы для удаления

Эти методы удаляют записи из self:

clear: Удаляет все записи из self.
compact!: Удаляет все записи со значением nil из self.
delete: Удаляет запись для заданного ключа.
delete_if: Удаляет записи, выбранные заданным блоком.
filter!, select!: Оставляет только те записи, которые выбраны заданным блоком.
keep_if: Оставляет только те записи, которые выбраны заданным блоком.
reject!: Удаляет записи, выбранные заданным блоком.
shift: Удаляет и возвращает первую запись.

Эти методы возвращают копию self с удаленными записями:

compact: Возвращает копию self со всеми записями со значением nil удаленными.
except: Возвращает копию self с удаленными записями для указанных ключей.
filter, select: Возвращает копию self только с теми записями, которые выбраны заданным блоком.
reject: Возвращает копию self с удаленными записями, как указано заданным блоком.
slice: Возвращает хеш, содержащий записи для заданных ключей.

Методы для итерации

each, each_pair: Вызывает заданный блок для каждой пары ключ-значение.
each_key: Вызывает заданный блок для каждого ключа.
each_value: Вызывает заданный блок для каждого значения.

Методы для преобразования

inspect, to_s: Возвращает новую String, содержащую записи хеша.
to_a: Возвращает новый массив из массивов по 2 элемента; каждый вложенный массив содержит пару ключ-значение из self.
to_h: Возвращает self если это хеш; если это подкласс хеша, возвращает хеш, содержащий записи из self.
to_hash: Возвращает self.
to_proc: Возвращает процедуру, которая отображает заданный ключ на его значение.

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

transform_keys: Возвращает копию self с измененными ключами.
transform_keys!: Изменяет ключи в self
transform_values: Возвращает копию self с измененными значениями.
transform_values!: Изменяет значения в self.

Другие методы

flatten: Возвращает массив, который является одномерным сглаживанием self.
invert: Возвращает хеш с каждой парой ключ-значение, инвертированной.

Методы публичного класса

Hash[] → new_empty_hash Показать исходный код

Hash[hash] → new_hash

Hash[ [*2_element_arrays] ] → new_hash

Hash[*objects] → new_hash

static VALUE
rb_hash_s_create(int argc, VALUE *argv, VALUE klass)
{
    VALUE hash, tmp;

    if (argc == 1) {
        tmp = rb_hash_s_try_convert(Qnil, argv[0]);
        if (!NIL_P(tmp)) {
            if (!RHASH_EMPTY_P(tmp)  && rb_hash_compare_by_id_p(tmp)) {
                /* hash_copy for non-empty hash will copy compare_by_identity
                   flag, but we don't want it copied. Work around by
                   converting hash to flattened array and using that. */
                tmp = rb_hash_to_a(tmp);
            }
            else {
                hash = hash_alloc(klass);
                if (!RHASH_EMPTY_P(tmp))
                    hash_copy(hash, tmp);
                return hash;
            }
        }
        else {
            tmp = rb_check_array_type(argv[0]);
        }

        if (!NIL_P(tmp)) {
            long i;

            hash = hash_alloc(klass);
            for (i = 0; i < RARRAY_LEN(tmp); ++i) {
                VALUE e = RARRAY_AREF(tmp, i);
                VALUE v = rb_check_array_type(e);
                VALUE key, val = Qnil;

                if (NIL_P(v)) {
                    rb_raise(rb_eArgError, "wrong element type %s at %ld (expected array)",
                             rb_builtin_class_name(e), i);
                }
                switch (RARRAY_LEN(v)) {
                  default:
                    rb_raise(rb_eArgError, "invalid number of elements (%ld for 1..2)",
                             RARRAY_LEN(v));
                  case 2:
                    val = RARRAY_AREF(v, 1);
                  case 1:
                    key = RARRAY_AREF(v, 0);
                    rb_hash_aset(hash, key, val);
                }
            }
            return hash;
        }
    }
    if (argc % 2 != 0) {
        rb_raise(rb_eArgError, "odd number of arguments for Hash");
    }

    hash = hash_alloc(klass);
    rb_hash_bulk_insert(argc, argv, hash);
    hash_verify(hash);
    return hash;
}

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

Без аргументов возвращает новый пустой Hash.

Когда единственный аргумент — Hash, возвращает новый Hash, заполненный записями из переданного Hash, исключая значение по умолчанию или proc.

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

Когда единственный аргумент — Array массивов из 2 элементов, возвращает новый объект Hash, где каждый массив из 2 элементов образует пару ключ-значение:

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

Когда количество аргументов — чётное число, возвращает новый объект Hash, где каждая последующая пара аргументов образует пару ключ-значение:

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

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

new(default_value = nil) → new_hash Показать исходный код

new {|hash, key| ... } → new_hash

static VALUE
rb_hash_initialize(int argc, VALUE *argv, VALUE hash)
{
    rb_hash_modify(hash);

    if (rb_block_given_p()) {
        rb_check_arity(argc, 0, 0);
        SET_PROC_DEFAULT(hash, rb_block_proc());
    }
    else {
        rb_check_arity(argc, 0, 1);

        VALUE options, ifnone;
        rb_scan_args(argc, argv, "01:", &ifnone, &options);
        if (NIL_P(ifnone) && !NIL_P(options)) {
            ifnone = options;
            rb_warn_deprecated_to_remove("3.4", "Calling Hash.new with keyword arguments", "Hash.new({ key: value })");
        }
        RHASH_SET_IFNONE(hash, ifnone);
    }

    return hash;
}

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

Начальное значение по умолчанию и начальный proc для нового hash зависят от того, какой из вышеперечисленных вариантов был использован. См. Значения по умолчанию.

Если ни аргумент, ни блок не заданы, инициализирует и значение по умолчанию, и proc по умолчанию в nil:

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

Если аргумент default_value задан, но блок нет, инициализирует значение по умолчанию заданным default_value, а proc по умолчанию — nil:

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

Если задан блок, но нет аргумента, сохраняет блок как proc по умолчанию, а значение по умолчанию устанавливает в nil:

h = Hash.new {|hash, key| "Default value for #{key}" }
h.default # => nil
h.default_proc.class # => Proc
h[:nosuch] # => "Default value for nosuch"

ruby2_keywords_hash(hash) → hash Показать исходный код

static VALUE
rb_hash_s_ruby2_keywords_hash(VALUE dummy, VALUE hash)
{
    Check_Type(hash, T_HASH);
    VALUE tmp = rb_hash_dup(hash);
    if (RHASH_EMPTY_P(hash) && rb_hash_compare_by_id_p(hash)) {
        rb_hash_compare_by_id(tmp);
    }
    RHASH(tmp)->basic.flags |= RHASH_PASS_AS_KEYWORDS;
    return tmp;
}

Создаёт копию заданного hash и добавляет флаг 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

ruby2_keywords_hash?(hash) → true or false Показать исходный код

static VALUE
rb_hash_s_ruby2_keywords_hash_p(VALUE dummy, VALUE hash)
{
    Check_Type(hash, T_HASH);
    return RBOOL(RHASH(hash)->basic.flags & RHASH_PASS_AS_KEYWORDS);
}

Проверяет, помечен ли данный hash флагом 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

try_convert(obj) → obj, new_hash, or nil Показать исходный код

static VALUE
rb_hash_s_try_convert(VALUE dummy, VALUE hash)
{
    return rb_check_hash_type(hash);
}

Если obj является объектом Hash, возвращает obj.

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

Возвращает nil если obj не отвечает на :to_hash.

Вызывает исключение, если obj.to_hash не возвращает объект Hash.

Общедоступные методы экземпляров

hash < other_hash → true или false Показать исходный код

static VALUE
rb_hash_lt(VALUE hash, VALUE other)
{
    other = to_hash(other);
    if (RHASH_SIZE(hash) >= RHASH_SIZE(other)) return Qfalse;
    return hash_le(hash, other);
}

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

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

hash <= other_hash → true или false Показать исходный код

static VALUE
rb_hash_le(VALUE hash, VALUE other)
{
    other = to_hash(other);
    if (RHASH_SIZE(hash) > RHASH_SIZE(other)) return Qfalse;
    return hash_le(hash, other);
}

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

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

hash == object → true или false Показать исходный код

static VALUE
rb_hash_equal(VALUE hash1, VALUE hash2)
{
    return hash_equal(hash1, hash2, FALSE);
}

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

object это объект Hash.
hash и object имеют одинаковые ключи (независимо от порядка).
Для каждого ключа key, hash[key] == object[key].

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

Равенство:

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

hash > other_hash → true или false Показать исходный код

static VALUE
rb_hash_gt(VALUE hash, VALUE other)
{
    other = to_hash(other);
    if (RHASH_SIZE(hash) <= RHASH_SIZE(other)) return Qfalse;
    return hash_le(other, hash);
}

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

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

hash >= other_hash → true или false Показать исходный код

static VALUE
rb_hash_ge(VALUE hash, VALUE other)
{
    other = to_hash(other);
    if (RHASH_SIZE(hash) < RHASH_SIZE(other)) return Qfalse;
    return hash_le(other, hash);
}

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

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

hash[key] → значение Показать исходный код

VALUE
rb_hash_aref(VALUE hash, VALUE key)
{
    st_data_t val;

    if (hash_stlike_lookup(hash, key, &val)) {
        return (VALUE)val;
    }
    else {
        return rb_hash_default_value(hash, key);
    }
}

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

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

Если key не найдено, возвращает значение по умолчанию (см. Значения по умолчанию):

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

hash[key] = значение → значение Показать исходный код

VALUE
rb_hash_aset(VALUE hash, VALUE key, VALUE val)
{
    bool iter_p = hash_iterating_p(hash);

    rb_hash_modify(hash);

    if (RHASH_TYPE(hash) == &identhash || rb_obj_class(key) != rb_cString) {
        RHASH_UPDATE_ITER(hash, iter_p, key, hash_aset, val);
    }
    else {
        RHASH_UPDATE_ITER(hash, iter_p, key, hash_aset_str, val);
    }
    return val;
}

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

Если данный key существует, заменяет его значение на данное value; порядок не меняется (см. Порядок элементов):

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

Если key не существует, добавляет key и value; новая запись добавляется в конец списка (см. Порядок элементов):

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

Также алиасируется как: store

any? → true или false Показать исходный код

any?(object) → true или false

any? {|key, value| ... } → true или false

static VALUE
rb_hash_any_p(int argc, VALUE *argv, VALUE hash)
{
    VALUE args[2];
    args[0] = Qfalse;

    rb_check_arity(argc, 0, 1);
    if (RHASH_EMPTY_P(hash)) return Qfalse;
    if (argc) {
        if (rb_block_given_p()) {
            rb_warn("given block not used");
        }
        args[1] = argv[0];

        rb_hash_foreach(hash, any_p_i_pattern, (VALUE)args);
    }
    else {
        if (!rb_block_given_p()) {
            /* yields pairs, never false */
            return Qtrue;
        }
        if (rb_block_pair_yield_optimizable())
            rb_hash_foreach(hash, any_p_i_fast, (VALUE)args);
        else
            rb_hash_foreach(hash, any_p_i, (VALUE)args);
    }
    return args[0];
}

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

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

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

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

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

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

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

См. также: Enumerable#any?

assoc(key) → новый_массив или nil Показать исходный код

static VALUE
rb_hash_assoc(VALUE hash, VALUE key)
{
    VALUE args[2];

    if (RHASH_EMPTY_P(hash)) return Qnil;

    if (RHASH_ST_TABLE_P(hash) && RHASH_ST_TABLE(hash)->type != &identhash) {
        VALUE value = Qundef;
        st_table assoctable = *RHASH_ST_TABLE(hash);
        assoctable.type = &(struct st_hash_type){
            .compare = assoc_cmp,
            .hash = assoctable.type->hash,
        };
        VALUE arg = (VALUE)&(struct assoc_arg){
            .tbl = &assoctable,
            .key = (st_data_t)key,
        };

        if (RB_OBJ_FROZEN(hash)) {
            value = assoc_lookup(arg);
        }
        else {
            hash_iter_lev_inc(hash);
            value = rb_ensure(assoc_lookup, arg, hash_foreach_ensure, hash);
        }
        hash_verify(hash);
        if (!UNDEF_P(value)) return rb_assoc_new(key, value);
    }

    args[0] = key;
    args[1] = Qnil;
    rb_hash_foreach(hash, assoc_i, (VALUE)args);
    return args[1];
}

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

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

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

clear → self Показать исходный код

VALUE
rb_hash_clear(VALUE hash)
{
    rb_hash_modify_check(hash);

    if (hash_iterating_p(hash)) {
        rb_hash_foreach(hash, clear_i, 0);
    }
    else if (RHASH_AR_TABLE_P(hash)) {
        ar_clear(hash);
    }
    else {
        st_clear(RHASH_ST_TABLE(hash));
        compact_after_delete(hash);
    }

    return hash;
}

Удаляет все записи хэша; возвращает self.

compact → новый_хэш Показать исходный код

static VALUE
rb_hash_compact(VALUE hash)
{
    VALUE result = rb_hash_dup(hash);
    if (!RHASH_EMPTY_P(hash)) {
        rb_hash_foreach(result, delete_if_nil, result);
        compact_after_delete(result);
    }
    else if (rb_hash_compare_by_id_p(hash)) {
        result = rb_hash_compare_by_id(result);
    }
    return result;
}

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

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

compact! → self или nil Показать исходный код

static VALUE
rb_hash_compact_bang(VALUE hash)
{
    st_index_t n;
    rb_hash_modify_check(hash);
    n = RHASH_SIZE(hash);
    if (n) {
        rb_hash_foreach(hash, delete_if_nil, hash);
        if (n != RHASH_SIZE(hash))
            return hash;
    }
    return Qnil;
}

Возвращает self со всеми его nil-значениями удалены (на месте):

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

Возвращает nil, если записи не были удалены.

END_OF_DOCUMENT_MARKER

default_proc → proc or nil Показать исходный код

static VALUE
rb_hash_default_proc(VALUE hash)
{
    if (FL_TEST(hash, RHASH_PROC_DEFAULT)) {
        return RHASH_IFNONE(hash);
    }
    return Qnil;
}

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

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

default_proc = proc → proc Показать исходный код

VALUE
rb_hash_set_default_proc(VALUE hash, VALUE proc)
{
    VALUE b;

    rb_hash_modify_check(hash);
    if (NIL_P(proc)) {
        SET_DEFAULT(hash, proc);
        return proc;
    }
    b = rb_check_convert_type_with_id(proc, T_DATA, "Proc", idTo_proc);
    if (NIL_P(b) || !rb_obj_is_proc(b)) {
        rb_raise(rb_eTypeError,
                 "wrong default_proc type %s (expected Proc)",
                 rb_obj_classname(proc));
    }
    proc = b;
    SET_PROC_DEFAULT(hash, proc);
    return 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

delete(key) → value or nil Показать исходный код

delete(key) {|key| ... } → object

static VALUE
rb_hash_delete_m(VALUE hash, VALUE key)
{
    VALUE val;

    rb_hash_modify_check(hash);
    val = rb_hash_delete_entry(hash, key);

    if (!UNDEF_P(val)) {
        compact_after_delete(hash);
        return val;
    }
    else {
        if (rb_block_given_p()) {
            return rb_yield(key);
        }
        else {
            return Qnil;
        }
    }
}

Удаляет запись для заданного key и возвращает связанное с ним значение.

Если блок не задан и 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}

delete_if {|key, value| ... } → self Показать исходный код

delete_if → new_enumerator

VALUE
rb_hash_delete_if(VALUE hash)
{
    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    rb_hash_modify_check(hash);
    if (!RHASH_TABLE_EMPTY_P(hash)) {
        rb_hash_foreach(hash, delete_if_i, hash);
        compact_after_delete(hash);
    }
    return hash;
}

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

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

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

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

dig(key, *identifiers) → object Показать исходный код

static VALUE
rb_hash_dig(int argc, VALUE *argv, VALUE self)
{
    rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
    self = rb_hash_aref(self, *argv);
    if (!--argc) return self;
    ++argv;
    return rb_obj_dig(argc, argv, self, Qnil);
}

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

Вложенные Hashes:

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

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

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) # => h
h.dig(:hello, :world, :foo, :bar, 2) # => :c

each {|key, value| ... } → self

each → new_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, если блок не задан:

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

Вывод:

foo: 0
bar: 1
baz: 2

Псевдоним для: each_pair

each_key {|key| ... } → self Показать исходный код

each_key → new_enumerator

static VALUE
rb_hash_each_key(VALUE hash)
{
    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    rb_hash_foreach(hash, each_key_i, 0);
    return hash;
}

Вызывает заданный блок для каждого ключа; возвращает self:

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

Вывод:

foo
bar
baz

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

h = {foo: 0, bar: 1, baz: 2}
e = h.each_key # => #<Enumerator: {:foo=>0, :bar=>1, :baz=>2}:each_key>
h1 = e.each {|key| puts key }
h1 # => {:foo=>0, :bar=>1, :baz=>2}

Вывод:

foo
bar
baz

each_pair {|key, value| ... } → self Показать исходный код

each_pair → new_enumerator

static VALUE
rb_hash_each_pair(VALUE hash)
{
    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    if (rb_block_pair_yield_optimizable())
        rb_hash_foreach(hash, each_pair_i_fast, 0);
    else
        rb_hash_foreach(hash, each_pair_i, 0);
    return hash;
}

Вызывает заданный блок для каждой пары ключ-значение; возвращает 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, если блок не задан:

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

Вывод:

foo: 0
bar: 1
baz: 2

Также алиас для: each

each_value {|value| ... } → self Показать исходный код

each_value → new_enumerator

static VALUE
rb_hash_each_value(VALUE hash)
{
    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    rb_hash_foreach(hash, each_value_i, 0);
    return hash;
}

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

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

Вывод:

0
1
2

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

h = {foo: 0, bar: 1, baz: 2}
e = h.each_value # => #<Enumerator: {:foo=>0, :bar=>1, :baz=>2}:each_value>
h1 = e.each {|value| puts value }
h1 # => {:foo=>0, :bar=>1, :baz=>2}

Вывод:

0
1
2

empty? → true or false Показать исходный код

static VALUE
rb_hash_empty_p(VALUE hash)
{
    return RBOOL(RHASH_EMPTY_P(hash));
}

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

{}.empty? # => true
{foo: 0, bar: 1, baz: 2}.empty? # => false

eql? object → true or false Показать исходный код

static VALUE
rb_hash_eql(VALUE hash1, VALUE hash2)
{
    return hash_equal(hash1, hash2, TRUE);
}

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

object это объект Hash.
hash и object имеют одинаковые ключи (независимо от порядка).
Для каждого ключа key, h[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

except(*keys) → a_hash Показать исходный код

static VALUE
rb_hash_except(int argc, VALUE *argv, VALUE hash)
{
    int i;
    VALUE key, result;

    result = hash_dup_with_compare_by_id(hash);

    for (i = 0; i < argc; i++) {
        key = argv[i];
        rb_hash_delete(result, key);
    }
    compact_after_delete(result);

    return result;
}

Возвращает новый Hash, исключая записи для заданных keys:

h = { a: 100, b: 200, c: 300 }
h.except(:a)          #=> {:b=>200, :c=>300}

Любые заданные keys которые не найдены, игнорируются.

fetch(key) → object Показать исходный код

fetch(key, default_value) → object

fetch(key) {|key| ... } → object

static VALUE
rb_hash_fetch_m(int argc, VALUE *argv, VALUE hash)
{
    VALUE key;
    st_data_t val;
    long block_given;

    rb_check_arity(argc, 1, 2);
    key = argv[0];

    block_given = rb_block_given_p();
    if (block_given && argc == 2) {
        rb_warn("block supersedes default value argument");
    }

    if (hash_stlike_lookup(hash, key, &val)) {
        return (VALUE)val;
    }
    else {
        if (block_given) {
            return rb_yield(key);
        }
        else if (argc == 1) {
            VALUE desc = rb_protect(rb_inspect, key, 0);
            if (NIL_P(desc)) {
                desc = rb_any_to_s(key);
            }
            desc = rb_str_ellipsize(desc, 65);
            rb_key_err_raise(rb_sprintf("key not found: %"PRIsVALUE, desc), hash, key);
        }
        else {
            return argv[1];
        }
    }
}

Возвращает значение для данного key, если оно найдено.

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

Если key не найден и блок не был задан, возвращает default_value:

{}.fetch(:nosuch, :default) # => :default

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

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

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

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

fetch_values(*keys) → new_array Показать исходный код

fetch_values(*keys) {|key| ... } → new_array

static VALUE
rb_hash_fetch_values(int argc, VALUE *argv, VALUE hash)
{
    VALUE result = rb_ary_new2(argc);
    long i;

    for (i=0; i<argc; i++) {
        rb_ary_push(result, rb_hash_fetch(hash, argv[i]));
    }
    return result;
}

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

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

Возвращает новый пустой Array, если аргументов нет.

Когда задан блок, вызывает блок с каждым отсутствующим ключом, рассматривая возвращаемое значение блока как значение для этого ключа:

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

Когда блок не задан, выводит исключение, если какой-либо заданный ключ не найден.

filter

Псевдоним для: select

filter!

Псевдоним для: select!

END_OF_DOCUMENT_MARKER

flatten → new_array Показать исходный код

flatten(level) → new_array

static VALUE
rb_hash_flatten(int argc, VALUE *argv, VALUE hash)
{
    VALUE ary;

    rb_check_arity(argc, 0, 1);

    if (argc) {
        int level = NUM2INT(argv[0]);

        if (level == 0) return rb_hash_to_a(hash);

        ary = rb_ary_new_capa(RHASH_SIZE(hash) * 2);
        rb_hash_foreach(hash, flatten_i, ary);
        level--;

        if (level > 0) {
            VALUE ary_flatten_level = INT2FIX(level);
            rb_funcallv(ary, id_flatten_bang, 1, &ary_flatten_level);
        }
        else if (level < 0) {
            /* flatten recursively */
            rb_funcallv(ary, id_flatten_bang, 0, 0);
        }
    }
    else {
        ary = rb_ary_new_capa(RHASH_SIZE(hash) * 2);
        rb_hash_foreach(hash, flatten_i, ary);
    }

    return ary;
}

Возвращает новый объект Array, представляющий собой одноуровневое развёртывание self.

По умолчанию вложенные массивы не разворачиваются:

h = {foo: 0, bar: [:bat, 3], baz: 2}
h.flatten # => [:foo, 0, :bar, [:bat, 3], :baz, 2]

Указывает глубину рекурсивного развёртывания с помощью аргумента Integer level:

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

При отрицательном значении level разворачивает все вложенные массивы:

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

При нулевом значении level возвращает эквивалент to_a :

h = {foo: 0, bar: [:bat, 3], baz: 2}
h.flatten(0) # => [[:foo, 0], [:bar, [:bat, 3]], [:baz, 2]]
h.flatten(0) == h.to_a # => true

has_key?(key) → true или false

Возвращает true , если key является ключом в self, в противном случае false.

Псевдоним для: include?

has_value?(value) → true или false Показать исходный код

static VALUE
rb_hash_has_value(VALUE hash, VALUE val)
{
    VALUE data[2];

    data[0] = Qfalse;
    data[1] = val;
    rb_hash_foreach(hash, rb_hash_search_value, (VALUE)data);
    return data[0];
}

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

Также псевдоним для: value?

hash → целое число Показать исходный код

static VALUE
rb_hash_hash(VALUE hash)
{
    st_index_t size = RHASH_SIZE(hash);
    st_index_t hval = rb_hash_start(size);
    hval = rb_hash_uint(hval, (st_index_t)rb_hash_hash);
    if (size) {
        rb_hash_foreach(hash, hash_i, (VALUE)&hval);
    }
    hval = rb_hash_end(hval);
    return ST2FIX(hval);
}

Возвращает хэш-код хэша как Integer.

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

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

include?(key) → true или false Показать исходный код

VALUE
rb_hash_has_key(VALUE hash, VALUE key)
{
    return RBOOL(hash_stlike_lookup(hash, key, NULL));
}

Возвращает true , если key является ключом в self, в противном случае false.

Также псевдоним для: member?, has_key?, key?

initialize_copy

Также псевдоним для: replace

inspect → new_string Показать исходный код

static VALUE
rb_hash_inspect(VALUE hash)
{
    if (RHASH_EMPTY_P(hash))
        return rb_usascii_str_new2("{}");
    return rb_exec_recursive(inspect_hash, hash, 0);
}

Возвращает новую String со строками записей хэша:

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

Также псевдоним для: to_s

invert → new_hash Показать исходный код

static VALUE
rb_hash_invert(VALUE hash)
{
    VALUE h = rb_hash_new_with_size(RHASH_SIZE(hash));

    rb_hash_foreach(hash, rb_hash_invert_i, h);
    return h;
}

Возвращает новый объект Hash, в котором каждый ключ-значение инвертирован:

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}

keep_if {|key, value| ... } → self Показать исходный код

keep_if → new_enumerator

static VALUE
rb_hash_keep_if(VALUE hash)
{
    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    rb_hash_modify_check(hash);
    if (!RHASH_TABLE_EMPTY_P(hash)) {
        rb_hash_foreach(hash, keep_if_i, hash);
    }
    return hash;
}

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

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

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

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

key(value) → key или nil Показать исходный код

static VALUE
rb_hash_key(VALUE hash, VALUE value)
{
    VALUE args[2];

    args[0] = value;
    args[1] = Qnil;

    rb_hash_foreach(hash, key_i, (VALUE)args);

    return args[1];
}

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

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

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

key?(key) → true или false

Возвращает true , если key является ключом в self, в противном случае false.

Псевдоним для: include?

keys → new_array Показать исходный код

VALUE
rb_hash_keys(VALUE hash)
{
    st_index_t size = RHASH_SIZE(hash);
    VALUE keys =  rb_ary_new_capa(size);

    if (size == 0) return keys;

    if (ST_DATA_COMPATIBLE_P(VALUE)) {
        RARRAY_PTR_USE(keys, ptr, {
            if (RHASH_AR_TABLE_P(hash)) {
                size = ar_keys(hash, ptr, size);
            }
            else {
                st_table *table = RHASH_ST_TABLE(hash);
                size = st_keys(table, ptr, size);
            }
        });
        rb_gc_writebarrier_remember(keys);
        rb_ary_set_len(keys, size);
    }
    else {
        rb_hash_foreach(hash, keys_i, keys);
    }

    return keys;
}

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

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

length → целое число

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

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

Псевдоним для: size

member?(key) → true или false

Возвращает true , если key является ключом в self, в противном случае false.

Псевдоним для: include?

merge → copy_of_self Показать исходный код

merge(*other_hashes) → new_hash

merge(*other_hashes) { |key, old_value, new_value| ... } → new_hash

static VALUE
rb_hash_merge(int argc, VALUE *argv, VALUE self)
{
    return rb_hash_update(argc, argv, copy_compare_by_id(rb_hash_dup(self), self));
}

Возвращает новый Hash, сформированный путём слияния каждого из other_hashes в копию self.

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

С аргументами и без блока:

Возвращает новый объект Hash, образованный путём слияния каждого последующего Hash в other_hashes в 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}

С аргументами и блоком:

Возвращает новый объект Hash, являющийся результатом слияния self и каждого заданного хэша.
Заданные хэши сливаются слева направо.
Каждая запись нового ключа добавляется в конец.
Для каждого дублирующегося ключа:
- Вызывает блок со значением ключа и старым и новым значениями.
- Возвращаемое значение блока становится новым значением для записи.

Пример:

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

Без аргументов:

Возвращает копию self.
Блок, если задан, игнорируется.

Пример:

h = {foo: 0, bar: 1, baz: 2}
h.merge # => {:foo=>0, :bar=>1, :baz=>2}
h1 = h.merge { |key, old_value, new_value| raise 'Cannot happen' }
h1 # => {:foo=>0, :bar=>1, :baz=>2}

merge! → self

merge!(*other_hashes) → self

merge!(*other_hashes) { |key, old_value, new_value| ... } → self

Объединяет каждый из other_hashes в self; возвращает self.

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

С аргументами и без блока:

Возвращает 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}

С аргументами и блоком:

Возвращает self, после объединения заданных хэш-таблиц.
Заданные хэш-таблицы объединяются слева направо.
Каждый новый элемент с ключом добавляется в конец.
Для каждого дублирующегося ключа:
- Вызывает блок с ключом и старыми и новыми значениями.
- Возвращаемое значение блока становится новым значением для элемента.

Пример:

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

Без аргументов:

Возвращает self, без изменений.
Блок, если задан, игнорируется.

Пример:

h = {foo: 0, bar: 1, baz: 2}
h.merge # => {:foo=>0, :bar=>1, :baz=>2}
h1 = h.merge! { |key, old_value, new_value| raise 'Cannot happen' }
h1 # => {:foo=>0, :bar=>1, :baz=>2}

Псевдоним для: update

rassoc(value) → new_array or nil Показать исходный код

static VALUE
rb_hash_rassoc(VALUE hash, VALUE obj)
{
    VALUE args[2];

    args[0] = obj;
    args[1] = Qnil;
    rb_hash_foreach(hash, rassoc_i, (VALUE)args);
    return args[1];
}

Возвращает новый массив из 2-х элементов Array, состоящий из ключа и значения первого найденного элемента, чьё значение равно == значению (см. Порядок элементов):

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

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

rehash → self Показать исходный код

VALUE
rb_hash_rehash(VALUE hash)
{
    VALUE tmp;
    st_table *tbl;

    if (hash_iterating_p(hash)) {
        rb_raise(rb_eRuntimeError, "rehash during iteration");
    }
    rb_hash_modify_check(hash);
    if (RHASH_AR_TABLE_P(hash)) {
        tmp = hash_alloc(0);
        rb_hash_foreach(hash, rb_hash_rehash_i, (VALUE)tmp);

        hash_ar_free_and_clear_table(hash);
        ar_copy(hash, tmp);
    }
    else if (RHASH_ST_TABLE_P(hash)) {
        st_table *old_tab = RHASH_ST_TABLE(hash);
        tmp = hash_alloc(0);

        hash_st_table_init(tmp, old_tab->type, old_tab->num_entries);
        tbl = RHASH_ST_TABLE(tmp);

        rb_hash_foreach(hash, rb_hash_rehash_i, (VALUE)tmp);

        hash_st_free(hash);
        RHASH_ST_TABLE_SET(hash, tbl);
        RHASH_ST_CLEAR(tmp);
    }
    hash_verify(hash);
    return hash;
}

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

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

reject {|key, value| ... } → new_hash Показать исходный код

reject → new_enumerator

static VALUE
rb_hash_reject(VALUE hash)
{
    VALUE result;

    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    result = hash_dup_with_compare_by_id(hash);
    if (!RHASH_EMPTY_P(hash)) {
        rb_hash_foreach(result, delete_if_i, result);
        compact_after_delete(result);
    }
    return result;
}

Возвращает новый объект Hash, чьи элементы — все элементы из self, для которых блок возвращает false или nil:

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

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

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

reject! {|key, value| ... } → self or nil Показать исходный код

reject! → new_enumerator

static VALUE
rb_hash_reject_bang(VALUE hash)
{
    st_index_t n;

    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    rb_hash_modify(hash);
    n = RHASH_SIZE(hash);
    if (!n) return Qnil;
    rb_hash_foreach(hash, delete_if_i, hash);
    if (n == RHASH_SIZE(hash)) return Qnil;
    return hash;
}

Возвращает self, оставшиеся элементы которого — те, для которых блок возвращает false или nil:

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

Возвращает nil если не было удалено ни одного элемента.

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

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

replace(other_hash) → self

Заменяет всё содержимое self содержимым other_hash; возвращает self:

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

Псевдоним для: initialize_copy

select {|key, value| ... } → new_hash Показать исходный код

select → new_enumerator

static VALUE
rb_hash_select(VALUE hash)
{
    VALUE result;

    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    result = hash_dup_with_compare_by_id(hash);
    if (!RHASH_EMPTY_P(hash)) {
        rb_hash_foreach(result, keep_if_i, result);
        compact_after_delete(result);
    }
    return result;
}

Возвращает новый объект Hash, чьи элементы — те, для которых блок возвращает истинное значение:

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

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

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

Также алиасируется как: filter

select! {|key, value| ... } → self or nil Показать исходный код

select! → new_enumerator

static VALUE
rb_hash_select_bang(VALUE hash)
{
    st_index_t n;

    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    rb_hash_modify_check(hash);
    n = RHASH_SIZE(hash);
    if (!n) return Qnil;
    rb_hash_foreach(hash, keep_if_i, hash);
    if (n == RHASH_SIZE(hash)) return Qnil;
    return hash;
}

Возвращает self, чьи элементы — те, для которых блок возвращает истинное значение:

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

Возвращает nil если не было удалено ни одного элемента.

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

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

Также алиасируется как: filter!

shift → [key, value] or nil Показать исходный код

static VALUE
rb_hash_shift(VALUE hash)
{
    struct shift_var var;

    rb_hash_modify_check(hash);
    if (RHASH_AR_TABLE_P(hash)) {
        var.key = Qundef;
        if (!hash_iterating_p(hash)) {
            if (ar_shift(hash, &var.key, &var.val)) {
                return rb_assoc_new(var.key, var.val);
            }
        }
        else {
            rb_hash_foreach(hash, shift_i_safe, (VALUE)&var);
            if (!UNDEF_P(var.key)) {
                rb_hash_delete_entry(hash, var.key);
                return rb_assoc_new(var.key, var.val);
            }
        }
    }
    if (RHASH_ST_TABLE_P(hash)) {
        var.key = Qundef;
        if (!hash_iterating_p(hash)) {
            if (st_shift(RHASH_ST_TABLE(hash), &var.key, &var.val)) {
                return rb_assoc_new(var.key, var.val);
            }
        }
        else {
            rb_hash_foreach(hash, shift_i_safe, (VALUE)&var);
            if (!UNDEF_P(var.key)) {
                rb_hash_delete_entry(hash, var.key);
                return rb_assoc_new(var.key, var.val);
            }
        }
    }
    return Qnil;
}

Удаляет первый элемент хеш-таблицы (см. Порядок элементов); возвращает массив из 2-х элементов Array, содержащий удалённый ключ и значение:

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

Возвращает nil если хеш-таблица пуста.

size → integer Показать исходный код

VALUE
rb_hash_size(VALUE hash)
{
    return INT2FIX(RHASH_SIZE(hash));
}

Возвращает количество элементов в self:

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

Также алиасируется как: length

slice(*keys) → new_hash Показать исходный код

static VALUE
rb_hash_slice(int argc, VALUE *argv, VALUE hash)
{
    int i;
    VALUE key, value, result;

    if (argc == 0 || RHASH_EMPTY_P(hash)) {
        return copy_compare_by_id(rb_hash_new(), hash);
    }
    result = copy_compare_by_id(rb_hash_new_with_size(argc), hash);

    for (i = 0; i < argc; i++) {
        key = argv[i];
        value = rb_hash_lookup2(hash, key, Qundef);
        if (!UNDEF_P(value))
            rb_hash_aset(result, key, value);
    }

    return result;
}

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

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

Любые заданные keys которые не найдены, игнорируются.

store(key, value)

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

Если заданный key существует, заменяет его значение на заданное value; порядок не изменяется (см. Порядок элементов):

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

Если key не существует, добавляет key и value; новый элемент последним в порядке (см. Порядок элементов):

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

Псевдоним для: []=

to_a → new_array Показать исходный код

static VALUE
rb_hash_to_a(VALUE hash)
{
    VALUE ary;

    ary = rb_ary_new_capa(RHASH_SIZE(hash));
    rb_hash_foreach(hash, to_a_i, ary);

    return ary;
}

Возвращает новый Array из 2-х элементов Array объектов; каждый вложенный Array содержит пару ключ-значение из self:

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

to_h → self or new_hash Показать исходный код

to_h {|key, value| ... } → new_hash

static VALUE
rb_hash_to_h(VALUE hash)
{
    if (rb_block_given_p()) {
        return rb_hash_to_h_block(hash);
    }
    if (rb_obj_class(hash) != rb_cHash) {
        const VALUE flags = RBASIC(hash)->flags;
        hash = hash_dup(hash, rb_cHash, flags & RHASH_PROC_DEFAULT);
    }
    return hash;
}

Для экземпляра Hash, возвращает self.

Для подкласса Hash, возвращает новую Hash, содержащую содержимое self.

Когда задан блок, возвращает новый объект Hash, чьё содержимое основано на блоке; блок должен возвращать объект из 2-х элементов Array, определяющий пару ключ-значение, которая будет включена в возвращаемый массив:

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

to_hash → self Показать исходный код

static VALUE
rb_hash_to_hash(VALUE hash)
{
    return hash;
}

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

END_OF_DOCUMENT_MARKER

to_proc → proc Показать исходный код

static VALUE
rb_hash_to_proc(VALUE hash)
{
    return rb_func_lambda_new(hash_proc_call, hash, 1, 1);
}

Возвращает объект 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

to_s

Псевдоним для: inspect

transform_keys {|key| ... } → new_hash Показать исходный код

transform_keys(hash2) → new_hash

transform_keys(hash2) {|other_key| ...} → new_hash

transform_keys → new_enumerator

static VALUE
rb_hash_transform_keys(int argc, VALUE *argv, VALUE hash)
{
    VALUE result;
    struct transform_keys_args transarg = {0};

    argc = rb_check_arity(argc, 0, 1);
    if (argc > 0) {
        transarg.trans = to_hash(argv[0]);
        transarg.block_given = rb_block_given_p();
    }
    else {
        RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    }
    result = rb_hash_new();
    if (!RHASH_EMPTY_P(hash)) {
        if (transarg.trans) {
            transarg.result = result;
            rb_hash_foreach(hash, transform_keys_hash_i, (VALUE)&transarg);
        }
        else {
            rb_hash_foreach(hash, transform_keys_i, result);
        }
    }

    return result;
}

Возвращает новый объект Hash; каждая запись имеет:

Ключ, предоставленный блоком.
Значение из self.

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

Преобразование ключей:

h = {foo: 0, bar: 1, baz: 2}
h1 = h.transform_keys {|key| key.to_s }
h1 # => {"foo"=>0, "bar"=>1, "baz"=>2}

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

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

Перезаписывает значения для дублирующих ключей:

h = {foo: 0, bar: 1, baz: 2}
h1 = h.transform_keys {|key| :bat }
h1 # => {:bat=>2}

Возвращает новый Enumerator, если блок не указан:

h = {foo: 0, bar: 1, baz: 2}
e = h.transform_keys # => #<Enumerator: {:foo=>0, :bar=>1, :baz=>2}:transform_keys>
h1 = e.each { |key| key.to_s }
h1 # => {"foo"=>0, "bar"=>1, "baz"=>2}

transform_keys! {|key| ... } → self Показать исходный код

transform_keys!(hash2) → self

transform_keys!(hash2) {|other_key| ...} → self

transform_keys! → new_enumerator

static VALUE
rb_hash_transform_keys_bang(int argc, VALUE *argv, VALUE hash)
{
    VALUE trans = 0;
    int block_given = 0;

    argc = rb_check_arity(argc, 0, 1);
    if (argc > 0) {
        trans = to_hash(argv[0]);
        block_given = rb_block_given_p();
    }
    else {
        RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    }
    rb_hash_modify_check(hash);
    if (!RHASH_TABLE_EMPTY_P(hash)) {
        long i;
        VALUE new_keys = hash_alloc(0);
        VALUE pairs = rb_ary_hidden_new(RHASH_SIZE(hash) * 2);
        rb_hash_foreach(hash, flatten_i, pairs);
        for (i = 0; i < RARRAY_LEN(pairs); i += 2) {
            VALUE key = RARRAY_AREF(pairs, i), new_key, val;

            if (!trans) {
                new_key = rb_yield(key);
            }
            else if (!UNDEF_P(new_key = rb_hash_lookup2(trans, key, Qundef))) {
                /* use the transformed key */
            }
            else if (block_given) {
                new_key = rb_yield(key);
            }
            else {
                new_key = key;
            }
            val = RARRAY_AREF(pairs, i+1);
            if (!hash_stlike_lookup(new_keys, key, NULL)) {
                rb_hash_stlike_delete(hash, &key, NULL);
            }
            rb_hash_aset(hash, new_key, val);
            rb_hash_aset(new_keys, new_key, Qnil);
        }
        rb_ary_clear(pairs);
        rb_hash_clear(new_keys);
    }
    compact_after_delete(hash);
    return hash;
}

То же, что и Hash#transform_keys, но изменяет получатель на месте вместо возвращения нового хэша.

transform_values {|value| ... } → new_hash Показать исходный код

transform_values → new_enumerator

static VALUE
rb_hash_transform_values(VALUE hash)
{
    VALUE result;

    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    result = hash_dup_with_compare_by_id(hash);
    SET_DEFAULT(result, Qnil);

    if (!RHASH_EMPTY_P(hash)) {
        rb_hash_stlike_foreach_with_replace(result, transform_values_foreach_func, transform_values_foreach_replace, result);
        compact_after_delete(result);
    }

    return result;
}

Возвращает новый объект Hash; каждая запись имеет:

Ключ из self.
Значение, предоставленное блоком.

Преобразование значений:

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

Возвращает новый Enumerator, если блок не указан:

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

transform_values! {|value| ... } → self Показать исходный код

transform_values! → new_enumerator

static VALUE
rb_hash_transform_values_bang(VALUE hash)
{
    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
    rb_hash_modify_check(hash);

    if (!RHASH_TABLE_EMPTY_P(hash)) {
        rb_hash_stlike_foreach_with_replace(hash, transform_values_foreach_func, transform_values_foreach_replace, hash);
    }

    return hash;
}

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

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

Возвращает новый Enumerator, если блок не указан:

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

update

Также псевдоним для: merge!

value?(value) → true or false

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

Псевдоним для: has_value?

values → new_array Показать исходный код

VALUE
rb_hash_values(VALUE hash)
{
    VALUE values;
    st_index_t size = RHASH_SIZE(hash);

    values = rb_ary_new_capa(size);
    if (size == 0) return values;

    if (ST_DATA_COMPATIBLE_P(VALUE)) {
        if (RHASH_AR_TABLE_P(hash)) {
            rb_gc_writebarrier_remember(values);
            RARRAY_PTR_USE(values, ptr, {
                size = ar_values(hash, ptr, size);
            });
        }
        else if (RHASH_ST_TABLE_P(hash)) {
            st_table *table = RHASH_ST_TABLE(hash);
            rb_gc_writebarrier_remember(values);
            RARRAY_PTR_USE(values, ptr, {
                size = st_values(table, ptr, size);
            });
        }
        rb_ary_set_len(values, size);
    }

    else {
        rb_hash_foreach(hash, values_i, values);
    }

    return values;
}

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

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

values_at(*keys) → new_array Показать исходный код

static VALUE
rb_hash_values_at(int argc, VALUE *argv, VALUE hash)
{
    VALUE result = rb_ary_new2(argc);
    long i;

    for (i=0; i<argc; i++) {
        rb_ary_push(result, rb_hash_aref(hash, argv[i]));
    }
    return result;
}

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

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

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

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

Ruby Core © 1993–2022 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.

класс Hash

Синтаксис данных хэша

Общие применения

Создание хэша

Основы значений хэша

Порядок записей

Ключи хэша

Равенство ключей хэша

Изменение активного ключа хэша

Ключи хэша, определённые пользователем

Значения по умолчанию

Функция по умолчанию Proc

Что здесь

Методы для создания хэша

Методы для установки состояния хэша

Методы для запросов

Методы для сравнения

Методы для извлечения

Методы для присваивания

Методы для удаления

Методы для итерации

Методы для преобразования

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

Другие методы

Функция по умолчанию `Proc`