class ActiveSupport::HashWithIndifferentAccess

Родительский класс:: Hash

Хэш с независимым доступом к типу ключа

Реализует хэш, в котором ключи :foo и "foo" считаются одинаковыми.

rgb = ActiveSupport::HashWithIndifferentAccess.new

rgb[:black] = '#000000'
rgb[:black]  # => '#000000'
rgb['black'] # => '#000000'

rgb['white'] = '#FFFFFF'
rgb[:white]  # => '#FFFFFF'
rgb['white'] # => '#FFFFFF'

Внутри символы преобразуются в строки, когда используются в качестве ключей во всём интерфейсе записи (при вызове []=, merge и т. д.). Это преобразование является частью публичного интерфейса. Например, если задать:

hash = ActiveSupport::HashWithIndifferentAccess.new(a: 1)

гарантируется, что ключ будет возвращён в виде строки:

hash.keys # => ["a"]

Технически допускаются и другие типы ключей:

hash = ActiveSupport::HashWithIndifferentAccess.new(a: 1)
hash[0] = 0
hash # => {"a"=>1, 0=>0}

но этот класс предназначен для случаев, когда ожидаются строки или символы в качестве ключей и удобно считать их эквивалентными. Например, хэш params в Ruby on Rails.

Обратите внимание: основные расширения определяют Hash#with_indifferent_access:

rgb = { black: '#000000', white: '#FFFFFF' }.with_indifferent_access

это может быть полезно.

Чтобы использовать этот класс вне Rails, подключите основное расширение:

require "active_support/core_ext/hash/indifferent_access"

которое, в свою очередь, подключит этот файл.

Открытые методы класса

[] (*args) Показать исходный код

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 85
def self.[](*args)
  new.merge!(Hash[*args])
end

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

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 70
def initialize(constructor = nil)
  if constructor.nil?
    super()
  elsif constructor.respond_to?(:to_hash)
    super()
    update(constructor)

    hash = constructor.is_a?(Hash) ? constructor : constructor.to_hash
    self.default = hash.default if hash.default
    self.default_proc = hash.default_proc if hash.default_proc
  else
    super(constructor)
  end
end

Вызывает метод суперкласса

Открытые методы экземпляра

[] (key) Показать исходный код

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 184
def [](key)
  super(convert_key(key))
end

То же, что и Hash#[], где переданный в качестве аргумента ключ может быть строкой или символом:

counters = ActiveSupport::HashWithIndifferentAccess.new
counters[:foo] = 1

counters['foo'] # => 1
counters[:foo]  # => 1
counters[:zoo]  # => nil

Вызывает метод суперкласса

[]= (key, value) Показать исходный код

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 101
def []=(key, value)
  regular_writer(convert_key(key), convert_value(value, conversion: :assignment))
end

Присваивает хэшу новое значение:

hash = ActiveSupport::HashWithIndifferentAccess.new
hash[:key] = 'value'

Позже это значение можно получить с помощью :key или 'key'.

Если значение представляет собой Hash или содержит один либо несколько хэшей, они будут преобразованы в HashWithIndifferentAccess.

Также имеет псевдоним: regular_writer

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

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 197
def assoc(key)
  super(convert_key(key))
end

То же, что и Hash#assoc, где переданный в качестве аргумента ключ может быть строкой или символом:

counters = ActiveSupport::HashWithIndifferentAccess.new
counters[:foo] = 1

counters.assoc('foo') # => ["foo", 1]
counters.assoc(:foo)  # => ["foo", 1]
counters.assoc(:zoo)  # => nil

Вызывает метод суперкласса

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

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 390
def compact
  dup.tap(&:compact!)
end

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

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 334
def deep_symbolize_keys; to_hash.deep_symbolize_keys! end

default (key = (no_key = true)) Показать исходный код

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 239
def default(key = (no_key = true))
  if no_key
    super()
  else
    super(convert_key(key))
  end
end

То же, что и Hash#default, где переданный в качестве аргумента ключ может быть строкой или символом:

hash = ActiveSupport::HashWithIndifferentAccess.new(1)
hash.default                   # => 1

hash = ActiveSupport::HashWithIndifferentAccess.new { |hash, key| key }
hash.default                   # => nil
hash.default('foo')            # => 'foo'
hash.default(:foo)             # => 'foo'

Вызывает метод суперкласса

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

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 317
def delete(key)
  super(convert_key(key))
end

Удаляет указанный ключ из хэша.

Вызывает метод суперкласса

dig (*args) Показать исходный код

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 224
def dig(*args)
  args[0] = convert_key(args[0]) if args.size > 0
  super(*args)
end

То же, что и Hash#dig, где переданный в качестве аргумента ключ может быть строкой или символом:

counters = ActiveSupport::HashWithIndifferentAccess.new
counters[:foo] = { bar: 1 }

counters.dig('foo', 'bar')     # => 1
counters.dig(:foo, :bar)       # => 1
counters.dig(:zoo)             # => nil

Вызывает метод суперкласса

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

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 280
def dup
  copy_defaults(self.class.new(self))
end

Возвращает поверхностную копию хэша.

hash = ActiveSupport::HashWithIndifferentAccess.new({ a: { b: 'b' } })
dup  = hash.dup
dup[:a][:c] = 'c'

hash[:a][:c] # => "c"
dup[:a][:c]  # => "c"

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

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 325
def except(*keys)
  dup.except!(*keys)
end

Возвращает хэш с доступом без учёта типа ключа, содержащий все элементы, кроме указанных ключей.

hash = { a: "x", b: "y", c: 10 }.with_indifferent_access
hash.except(:a, "b") # => {c: 10}.with_indifferent_access
hash                 # => { a: "x", b: "y", c: 10 }.with_indifferent_access

Также имеет псевдоним: without

extractable_options? () Показать исходный код

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 58
def extractable_options?
  true
end

Возвращает true, чтобы Array#extract_options! распознавал элементы этого класса.

fetch (key, *extras) Показать исходный код

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 211
def fetch(key, *extras)
  super(convert_key(key), *extras)
end

То же, что и Hash#fetch, где переданный в качестве аргумента ключ может быть строкой или символом:

counters = ActiveSupport::HashWithIndifferentAccess.new
counters[:foo] = 1

counters.fetch('foo')          # => 1
counters.fetch(:bar, 0)        # => 0
counters.fetch(:bar) { |key| 0 } # => 0
counters.fetch(:zoo)           # => KeyError: key not found: "zoo"

Вызывает метод суперкласса

fetch_values (*indices, &block) Показать исходный код

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 267
def fetch_values(*indices, &block)
  indices.map! { |key| convert_key(key) }
  super
end

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

hash = ActiveSupport::HashWithIndifferentAccess.new
hash[:a] = 'x'
hash[:b] = 'y'
hash.fetch_values('a', 'b') # => ["x", "y"]
hash.fetch_values('a', 'c') { |key| 'z' } # => ["x", "z"]
hash.fetch_values('a', 'c') # => KeyError: key not found: "c"

Вызывает метод суперкласса

has_key? (key)

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

include? (key)

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

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

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 167
def key?(key)
  super(convert_key(key))
end

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

hash = ActiveSupport::HashWithIndifferentAccess.new
hash['key'] = 'value'
hash.key?(:key)  # => true
hash.key?('key') # => true

Вызывает метод суперкласса

Также имеет псевдонимы: include?, has_key?, member?

member? (key)

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

merge (*hashes, &block) Показать исходный код

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 287
def merge(*hashes, &block)
  dup.update(*hashes, &block)
end

Этот метод имеет ту же семантику, что и update, но не изменяет получатель, а возвращает новый хэш с доступом без учёта типа ключа, содержащий результат объединения.

merge! (*other_hashes, &block)

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

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

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 66
def nested_under_indifferent_access
  self
end

regular_update (*other_hashes, &block)

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

regular_writer (key, value)

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

reject (*args, &block) Показать исходный код

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 342
def reject(*args, &block)
  return to_enum(:reject) unless block_given?
  dup.tap { |hash| hash.reject!(*args, &block) }
end

replace (other_hash) Показать исходный код

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 312
def replace(other_hash)
  super(cast(other_hash))
end

Заменяет содержимое этого хэша содержимым other_hash.

h = { "a" => 100, "b" => 200 }
h.replace({ "c" => 300, "d" => 400 }) # => {"c"=>300, "d"=>400}

Вызывает метод суперкласса

reverse_merge (other_hash) Показать исходный код

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 297
def reverse_merge(other_hash)
  super(cast(other_hash))
end

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

hash = ActiveSupport::HashWithIndifferentAccess.new
hash['a'] = nil
hash.reverse_merge(a: 0, b: 1) # => {"a"=>nil, "b"=>1}

Вызывает метод суперкласса Hash#reverse_merge

Также имеет псевдоним: with_defaults

reverse_merge! (other_hash) Показать исходный код

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 303
def reverse_merge!(other_hash)
  super(cast(other_hash))
end

Имеет ту же семантику, что и reverse_merge, но изменяет получатель на месте.

Вызывает метод суперкласса Hash#reverse_merge!

Также имеет псевдоним: with_defaults!

select (*args, &block) Показать исходный код

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 337
def select(*args, &block)
  return to_enum(:select) unless block_given?
  dup.tap { |hash| hash.select!(*args, &block) }
end

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

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 380
def slice(*keys)
  keys.map! { |key| convert_key(key) }
  self.class.new(super)
end

Вызывает метод суперкласса

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

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 385
def slice!(*keys)
  keys.map! { |key| convert_key(key) }
  super
end

Вызывает метод суперкласса Hash#slice!

store (key, value, convert_value: true) Показать исходный код

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 115
def store(key, value, convert_value: true)
  value = convert_value(value, conversion: :assignment) if convert_value
  regular_writer(convert_key(key), value)
end

Присваивает хэшу новое значение:

hash = ActiveSupport::HashWithIndifferentAccess.new
hash[:key] = 'value'

Позже это значение можно получить с помощью :key или 'key'.

Если значение представляет собой Hash или содержит один либо несколько хэшей, они будут преобразованы в HashWithIndifferentAccess, если не задано ‘convert_value: false`.

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

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 332
def symbolize_keys; to_hash.symbolize_keys! end

Также имеет псевдоним: to_options

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

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 395
def to_hash
  copy = Hash[self]
  copy.transform_values! { |v| convert_value_to_hash(v) }
  copy_defaults(copy)
end

Преобразует в обычный хэш со строковыми ключами.

to_options ()

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

to_options! () Показать исходный код

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 335
def to_options!; self end

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

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 401
def to_proc
  proc { |key| self[key] }
end

transform_keys (hash = NOT_GIVEN, &block) Показать исходный код

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 354
def transform_keys(hash = NOT_GIVEN, &block)
  if NOT_GIVEN.equal?(hash)
    if block_given?
      self.class.new(super(&block))
    else
      to_enum(:transform_keys)
    end
  else
    self.class.new(super)
  end
end

Вызывает метод суперкласса

transform_keys! (hash = NOT_GIVEN, &block) Показать исходный код

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 366
def transform_keys!(hash = NOT_GIVEN, &block)
  if NOT_GIVEN.equal?(hash)
    if block_given?
      replace(copy_defaults(transform_keys(&block)))
    else
      return to_enum(:transform_keys!)
    end
  else
    replace(copy_defaults(transform_keys(hash, &block)))
  end

  self
end

transform_values (&block) Показать исходный код

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 347
def transform_values(&block)
  return to_enum(:transform_values) unless block_given?
  dup.tap { |hash| hash.transform_values!(&block) }
end

update (*other_hashes, &block) Показать исходный код

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 148
def update(*other_hashes, &block)
  if other_hashes.size == 1
    update_with_single_argument(other_hashes.first, block)
  else
    other_hashes.each do |other_hash|
      update_with_single_argument(other_hash, block)
    end
  end
  self
end

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

hash_1 = ActiveSupport::HashWithIndifferentAccess.new
hash_1[:key] = 'value'

hash_2 = ActiveSupport::HashWithIndifferentAccess.new
hash_2[:key] = 'New Value!'

hash_1.update(hash_2) # => {"key"=>"New Value!"}

hash = ActiveSupport::HashWithIndifferentAccess.new
hash.update({ "a" => 1 }, { "b" => 2 }) # => { "a" => 1, "b" => 2 }

Аргументы могут быть экземплярами ActiveSupport::HashWithIndifferentAccess или обычного Hash. В обоих случаях при объединении учитывается семантика доступа без учёта типа ключа.

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

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

hash_1[:key] = 10
hash_2['key'] = 12
hash_1.update(hash_2) { |key, old, new| old + new } # => {"key"=>22}

Также имеет псевдонимы: regular_update, merge!

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

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 253
def values_at(*keys)
  keys.map! { |key| convert_key(key) }
  super
end

Возвращает массив значений по указанным индексам:

hash = ActiveSupport::HashWithIndifferentAccess.new
hash[:a] = 'x'
hash[:b] = 'y'
hash.values_at('a', 'b') # => ["x", "y"]

Вызывает метод суперкласса

with_defaults (other_hash)

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

with_defaults! (other_hash)

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

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

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 62
def with_indifferent_access
  dup
end

without (*keys)

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