跳至内容 跳至搜索

无差异访问哈希

实现一个哈希，其中键 :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}

但此类旨在用于字符串或符号是预期键的情况，并且将两者理解为相同很方便。例如，Ruby on Rails 中的 params 哈希。

请注意，核心扩展定义了 Hash#with_indifferent_access

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

这可能很方便。

要在 Rails 之外访问此类，请使用以下命令要求核心扩展

require "active_support/core_ext/hash/indifferent_access"

这将反过来要求此文件。

方法
#
A
C
D
E
F
H
I
K
M
N
R
S
T
U
V
W

类公共方法

[](*args)

来源：显示 | 在 GitHub 上

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

new(constructor = nil)

来源：显示 | 在 GitHub 上

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 70
def initialize(constructor = nil)
  if 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
  elsif constructor.nil?
    super()
  else
    super(constructor)
  end
end

实例公共方法

[](key)

与 Hash#[] 相同，其中作为参数传递的键可以是字符串或符号

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

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

来源：显示 | 在 GitHub 上

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

[]=(key, value)

将新值分配给哈希

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

此值可以使用 :key 或 'key' 稍后获取。

也称为：regular_writer，store

来源：显示 | 在 GitHub 上

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

assoc(key)

与 Hash#assoc 相同，其中作为参数传递的键可以是字符串或符号

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

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

来源：显示 | 在 GitHub 上

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

compact()

来源：显示 | 在 GitHub 上

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

deep_symbolize_keys()

来源：显示 | 在 GitHub 上

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

default(key = (no_key = true))

与 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'

来源：显示 | 在 GitHub 上

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

delete(key)

从哈希中删除指定的键。

来源：显示 | 在 GitHub 上

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

dig(*args)

与 Hash#dig 相同，其中作为参数传递的键可以是字符串或符号

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

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

来源：显示 | 在 GitHub 上

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

dup()

返回哈希的浅层副本。

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

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

来源：显示 | 在 GitHub 上

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 264
def dup
  self.class.new(self).tap do |new_hash|
    set_defaults(new_hash)
  end
end

except(*keys)

返回一个包含除给定键以外所有内容的无差异访问哈希。

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

来源：显示 | 在 GitHub 上

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

extractable_options?()

返回 true，以便 Array#extract_options! 找到此类的成员。

来源：显示 | 在 GitHub 上

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

fetch(key, *extras)

与 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"

来源：显示 | 在 GitHub 上

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

fetch_values(*indices, &block)

返回指定索引处值的数组，但在找不到其中一个键时也会引发异常。

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"

来源：显示 | 在 GitHub 上

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

has_key?(key)

别名：key?

include?(key)

别名：key?

key?(key)

检查哈希中是否有与传入的参数匹配的键

hash = ActiveSupport::HashWithIndifferentAccess.new
hash['key'] = 'value'
hash.key?(:key)  # => true
hash.key?('key') # => true
也称为：include?，has_key?，member?

来源：显示 | 在 GitHub 上

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

member?(key)

别名：key?

merge(*hashes, &block)

此方法与 update 具有相同的语义，只是它不会修改接收方，而是返回一个包含合并结果的新无差异访问哈希。

来源：显示 | 在 GitHub 上

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

merge!(*other_hashes, &block)

别名：update

nested_under_indifferent_access()

来源：显示 | 在 GitHub 上

# 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)

来源：显示 | 在 GitHub 上

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

replace(other_hash)

用 other_hash 的内容替换此哈希的内容。

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

来源：显示 | 在 GitHub 上

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 298
def replace(other_hash)
  super(self.class.new(other_hash))
end

reverse_merge(other_hash)

与 merge 相同，但反过来：将接收方合并到参数中，并返回一个新的无差异访问哈希作为结果

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

来源：显示 | 在 GitHub 上

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 283
def reverse_merge(other_hash)
  super(self.class.new(other_hash))
end

reverse_merge!(other_hash)

与 reverse_merge 的语义相同，但会就地修改接收方。

也称为：with_defaults!

来源：显示 | 在 GitHub 上

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 289
def reverse_merge!(other_hash)
  super(self.class.new(other_hash))
end

select(*args, &block)

来源: 显示 | 在 GitHub 上

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

slice(*keys)

来源: 显示 | 在 GitHub 上

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

slice!(*keys)

来源: 显示 | 在 GitHub 上

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

store(key, value)

别名：[]=

symbolize_keys()

也称为: to_options

来源: 显示 | 在 GitHub 上

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

to_hash()

转换为带字符串键的普通哈希。

来源: 显示 | 在 GitHub 上

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

to_options()

别名: symbolize_keys

to_options!()

来源: 显示 | 在 GitHub 上

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

to_proc()

来源: 显示 | 在 GitHub 上

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

transform_keys(hash = NOT_GIVEN, &block)

来源: 显示 | 在 GitHub 上

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 340
def transform_keys(hash = NOT_GIVEN, &block)
  return to_enum(:transform_keys) if NOT_GIVEN.equal?(hash) && !block_given?
  dup.tap { |h| h.transform_keys!(hash, &block) }
end

transform_keys!(hash = NOT_GIVEN, &block)

来源: 显示 | 在 GitHub 上

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

  if hash.nil?
    super
  elsif NOT_GIVEN.equal?(hash)
    keys.each { |key| self[yield(key)] = delete(key) }
  elsif block_given?
    keys.each { |key| self[hash[key] || yield(key)] = delete(key) }
  else
    keys.each { |key| self[hash[key] || key] = delete(key) }
  end

  self
end

transform_values(&block)

来源: 显示 | 在 GitHub 上

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

update(*other_hashes, &block)

在原地更新接收者，合并传入的哈希作为参数。

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!

来源: 显示 | 在 GitHub 上

# File activesupport/lib/active_support/hash_with_indifferent_access.rb, line 132
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

values_at(*keys)

返回指定索引处的值数组。

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

来源: 显示 | 在 GitHub 上

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

with_defaults(other_hash)

别名: reverse_merge

with_defaults!(other_hash)

别名: reverse_merge!

with_indifferent_access()

来源: 显示 | 在 GitHub 上

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

without(*keys)

别名: except