Ruby on Rails 5.2 - Hash

कक्षा हैश




ruby

कक्षा हैश

जनक:
Object

पब्लिक क्लास के तरीके

# File activesupport/lib/active_support/core_ext/hash/conversions.rb, line 134
def from_trusted_xml(xml)
  from_xml xml, []
end

XML से Hash.from_xml तरह ही एक Hash बनाता है, लेकिन यह भी Symbol और YAML की अनुमति देता है।

from_xml (xml, disallowed_types = nil) स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/hash/conversions.rb, line 129
def from_xml(xml, disallowed_types = nil)
  ActiveSupport::XMLConverter.new(xml, disallowed_types).to_h
end

जब कोई नोड नाम है और मूल्य इसकी सामग्री है, तो जोड़े का एक संग्रह Hash देता है

xml = <<-XML
  <?xml version="1.0" encoding="UTF-8"?>
    <hash>
      <foo type="integer">1</foo>
      <bar type="integer">2</bar>
    </hash>
XML

hash = Hash.from_xml(xml)
# => {"hash"=>{"foo"=>1, "bar"=>2}}

यदि XML में type="yaml" या type="symbol" गुण हैं, तो DisallowedType उठाया गया है। इस XML को पार्स करने के लिए Hash.from_trusted_xml का उपयोग करें।

कस्टम disallowed_types को एक सरणी के रूप में भी पास किया जा सकता है।

xml = <<-XML
  <?xml version="1.0" encoding="UTF-8"?>
    <hash>
      <foo type="integer">1</foo>
      <bar type="string">"David"</bar>
    </hash>
XML

hash = Hash.from_xml(xml, ['integer'])
# => ActiveSupport::XMLConverter::DisallowedType: Disallowed type attribute: "integer"

ध्यान दें कि कस्टम अस्वीकृत प्रकारों को पास करना डिफ़ॉल्ट प्रकारों को ओवरराइड करेगा, जो कि Symbol और YAML हैं।

सार्वजनिक प्रवृत्ति के तरीके

assert_valid_keys (* valid_keys) स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/hash/keys.rb, line 77
def assert_valid_keys(*valid_keys)
  valid_keys.flatten!
  each_key do |k|
    unless valid_keys.include?(k)
      raise ArgumentError.new("Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}")
    end
  end
end

हैश मैच में सभी कुंजियों को मान्य करता है *valid_keys , एक बेमेल पर ArgumentError को *valid_keys

ध्यान दें कि कुंजी को HashWithIndifferentAccess तुलना में अलग तरह से व्यवहार किया जाता है, जिसका अर्थ है कि स्ट्रिंग और प्रतीक कुंजियाँ मेल नहीं खाएंगी।

{ name: 'Rob', years: '28' }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key: :years. Valid keys are: :name, :age"
{ name: 'Rob', age: '28' }.assert_valid_keys('name', 'age') # => raises "ArgumentError: Unknown key: :name. Valid keys are: 'name', 'age'"
{ name: 'Rob', age: '28' }.assert_valid_keys(:name, :age)   # => passes, raises nothing
कॉम्पैक्ट () दिखाएँ स्रोत
# File activesupport/lib/active_support/core_ext/hash/compact.rb, line 12
def compact
  select { |_, value| !value.nil? }
end

गैर nil मानों वाला हैश लौटाता है।

hash = { a: true, b: false, c: nil }
hash.compact        # => { a: true, b: false }
hash                # => { a: true, b: false, c: nil }
{ c: nil }.compact  # => {}
{ c: true }.compact # => { c: true }
कॉम्पैक्ट! () स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/hash/compact.rb, line 25
def compact!
  reject! { |_, value| value.nil? }
end

गैर- nil मानों के साथ वर्तमान हैश बदल देता है। यदि कोई परिवर्तन नहीं किया गया है तो रिटर्न देता है, अन्यथा हैश लौटाता है।

hash = { a: true, b: false, c: nil }
hash.compact!        # => { a: true, b: false }
hash                 # => { a: true, b: false }
{ c: true }.compact! # => nil
# File activesupport/lib/active_support/core_ext/object/deep_dup.rb, line 43
def deep_dup
  hash = dup
  each_pair do |key, value|
    if key.frozen? && ::String === key
      hash[key] = value.deep_dup
    else
      hash.delete(key)
      hash[key.deep_dup] = value.deep_dup
    end
  end
  hash
end

हैश की एक गहरी प्रति लौटाता है।

hash = { a: { b: 'b' } }
dup  = hash.deep_dup
dup[:a][:c] = 'c'

hash[:a][:c] # => nil
dup[:a][:c]  # => "c"
deep_merge (other_hash, & block) स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/hash/deep_merge.rb, line 18
def deep_merge(other_hash, &block)
  dup.deep_merge!(other_hash, &block)
end

self और other_hash साथ एक नया हैश लौटाता है।

h1 = { a: true, b: { c: [1, 2, 3] } }
h2 = { a: false, b: { x: [3, 4, 5] } }

h1.deep_merge(h2) # => { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }

हश # के साथ मानक पुस्तकालय में विलय के रूप में, एक ब्लॉक को विलय के मूल्यों के लिए प्रदान किया जा सकता है:

h1 = { a: 100, b: 200, c: { c1: 100 } }
h2 = { b: 250, c: { c1: 200 } }
h1.deep_merge(h2) { |key, this_val, other_val| this_val + other_val }
# => { a: 100, b: 450, c: { c1: 300 } }
deep_merge! (other_hash, & block) स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/hash/deep_merge.rb, line 23
def deep_merge!(other_hash, &block)
  merge!(other_hash) do |key, this_val, other_val|
    if this_val.is_a?(Hash) && other_val.is_a?(Hash)
      this_val.deep_merge(other_val, &block)
    elsif block_given?
      block.call(key, this_val, other_val)
    else
      other_val
    end
  end
end

deep_merge समान, लेकिन self को संशोधित करता है।

# File activesupport/lib/active_support/core_ext/hash/keys.rb, line 113
def deep_stringify_keys
  deep_transform_keys(&:to_s)
end

एक नया हैश लौटाता है जिसमें सभी कुंजियों को स्ट्रिंग में परिवर्तित किया जाता है। इसमें रूट हैश और सभी नेस्टेड हैश और सरणियों से कुंजियां शामिल हैं।

hash = { person: { name: 'Rob', age: '28' } }

hash.deep_stringify_keys
# => {"person"=>{"name"=>"Rob", "age"=>"28"}}
deep_stringify_keys! () स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/hash/keys.rb, line 120
def deep_stringify_keys!
  deep_transform_keys!(&:to_s)
end

विनाशकारी रूप से सभी कुंजियों को स्ट्रिंग्स में कनवर्ट करता है। इसमें रूट हैश और सभी नेस्टेड हैश और सरणियों से कुंजियां शामिल हैं।

# File activesupport/lib/active_support/core_ext/hash/keys.rb, line 132
def deep_symbolize_keys
  deep_transform_keys { |key| key.to_sym rescue key }
end

जब तक वे to_sym जवाब देते हैं, तब तक प्रतीकों में परिवर्तित सभी कुंजी के साथ एक नया हैश to_sym । इसमें रूट हैश और सभी नेस्टेड हैश और सरणियों से कुंजियां शामिल हैं।

hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }

hash.deep_symbolize_keys
# => {:person=>{:name=>"Rob", :age=>"28"}}
deep_symbolize_keys! () स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/hash/keys.rb, line 139
def deep_symbolize_keys!
  deep_transform_keys! { |key| key.to_sym rescue key }
end

विनाशकारी रूप से सभी कुंजियों को प्रतीकों में परिवर्तित कर देता है, जब तक वे to_sym जवाब to_sym । इसमें रूट हैश और सभी नेस्टेड हैश और सरणियों से कुंजियां शामिल हैं।

deep_transform_keys (& block) स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/hash/keys.rb, line 94
def deep_transform_keys(&block)
  _deep_transform_keys_in_object(self, &block)
end

ब्लॉक ऑपरेशन द्वारा परिवर्तित सभी कुंजियों के साथ एक नया हैश लौटाता है। इसमें रूट हैश और सभी नेस्टेड हैश और सरणियों से कुंजियां शामिल हैं।

hash = { person: { name: 'Rob', age: '28' } }

hash.deep_transform_keys{ |key| key.to_s.upcase }
# => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}
deep_transform_keys! (और ब्लॉक) दिखाएँ स्रोत
# File activesupport/lib/active_support/core_ext/hash/keys.rb, line 101
def deep_transform_keys!(&block)
  _deep_transform_keys_in_object!(self, &block)
end

ब्लॉक ऑपरेशन का उपयोग करके विनाशकारी रूप से सभी कुंजियों को परिवर्तित करता है। इसमें रूट हैश और सभी नेस्टेड हैश और सरणियों से कुंजियां शामिल हैं।

को छोड़कर (* कुंजियाँ) दिखाएँ स्रोत
# File activesupport/lib/active_support/core_ext/hash/except.rb, line 12
def except(*keys)
  dup.except!(*keys)
end

एक हैश देता है जिसमें दी गई चाबियों को छोड़कर सब कुछ शामिल है।

hash = { a: true, b: false, c: nil }
hash.except(:c)     # => { a: true, b: false }
hash.except(:a, :b) # => { c: nil }
hash                # => { a: true, b: false, c: nil }

यह सब कुछ मापदंडों के एक सेट को सीमित करने के लिए उपयोगी है, लेकिन कुछ ज्ञात टॉगल:

@person.update(params[:person].except(:admin))
के सिवाय! (* की) शो सोर्स
# File activesupport/lib/active_support/core_ext/hash/except.rb, line 20
def except!(*keys)
  keys.each { |key| delete(key) }
  self
end

दिए गए कीज़ को हैश से हटाकर वापस कर देता है।

hash = { a: true, b: false, c: nil }
hash.except!(:c) # => { a: true, b: false }
hash             # => { a: true, b: false }
निकालने! (* की) शो सोर्स
# File activesupport/lib/active_support/core_ext/hash/slice.rb, line 45
def extract!(*keys)
  keys.each_with_object(self.class.new) { |key, result| result[key] = delete(key) if has_key?(key) }
end

दिए गए कुंजी से मेल खाते कुंजी / मान जोड़े को निकालता है और वापस करता है।

{ a: 1, b: 2, c: 3, d: 4 }.extract!(:a, :b) # => {:a=>1, :b=>2}
{ a: 1, b: 2 }.extract!(:a, :x)             # => {:a=>1}
extractable_options? () स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/array/extract_options.rb, line 9
def extractable_options?
  instance_of?(Hash)
end

डिफ़ॉल्ट रूप से, Hash केवल उदाहरण ही निकालने योग्य हैं। Hash उपवर्ग इस विधि को लागू कर सकते हैं और खुद को अर्क योग्य घोषित करने के लिए सही हैं। यदि कोई Hash निकालने योग्य है, तो Array#extract_options! यह Array से पॉप करता है जब यह Array का अंतिम तत्व होता है।

nested_under_indifferent_access ()

जब ऑब्जेक्ट को किसी ऑब्जेक्ट के तहत नेस्टेड किया जाता है जिसे with_indifferent_access प्राप्त with_indifferent_access । इस विधि को वर्तमान ऑब्जेक्ट पर with_indifferent_access ऑब्जेक्ट द्वारा बुलाया जाएगा और इसे डिफ़ॉल्ट रूप से with_indifferent_access किया जाता है। यदि कोई ActiveSupport::HashWithIndifferentAccess करना वांछनीय नहीं होगा, तो Hash उप-वर्ग self को वापस करने के लिए इस विधि को अधिलेखित कर सकते हैं।

b = { b: 1 }
{ a: b }.with_indifferent_access['a'] # calls b.nested_under_indifferent_access
# => {"b"=>1}
इसके लिए उपनाम: with_indifferent_access
# File activesupport/lib/active_support/core_ext/hash/reverse_merge.rb, line 14
def reverse_merge(other_hash)
  other_hash.merge(self)
end

कॉल करने वाले को other_hash में other_hash । उदाहरण के लिए,

options = options.reverse_merge(size: 25, velocity: 10)

के बराबर है

options = { size: 25, velocity: 10 }.merge(options)

यह डिफ़ॉल्ट मान के साथ एक विकल्प हैश को इनिशियलाइज़ करने के लिए विशेष रूप से उपयोगी है।

के रूप में भी उपनाम: with_defaults
reverse_merge! (other_hash) स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/hash/reverse_merge.rb, line 20
def reverse_merge!(other_hash)
  replace(reverse_merge(other_hash))
end

विनाशकारी reverse_merge

इसके अलावा उपनाम: with_defaults! , with_defaults!
रिवर्स_अपडेट (other_hash)
इसके लिए उपनाम: reverse_merge!
टुकड़ा (* कुंजियाँ) दिखाएँ स्रोत
# File activesupport/lib/active_support/core_ext/hash/slice.rb, line 23
def slice(*keys)
  keys.each_with_object(Hash.new) { |k, hash| hash[k] = self[k] if has_key?(k) }
end

केवल दिए गए कुंजी को शामिल करने के लिए एक हैश स्लाइस करता है। दिए गए कुंजियों वाले हैश लौटाता है।

{ a: 1, b: 2, c: 3, d: 4 }.slice(:a, :b)
# => {:a=>1, :b=>2}

यह एक विधि को पास करने से पहले वैध कुंजी के लिए एक विकल्प हैश को सीमित करने के लिए उपयोगी है:

def search(criteria = {})
  criteria.assert_valid_keys(:mass, :velocity, :time)
end

search(options.slice(:mass, :velocity, :time))

यदि आपके पास कुंजियों की एक सरणी है जिसे आप सीमित करना चाहते हैं, तो आपको उन्हें अलग करना चाहिए:

valid_keys = [:mass, :velocity, :time]
search(options.slice(*valid_keys))
स्लाइस! (* की) शो सोर्स
# File activesupport/lib/active_support/core_ext/hash/slice.rb, line 32
def slice!(*keys)
  omit = slice(*self.keys - keys)
  hash = slice(*keys)
  hash.default      = default
  hash.default_proc = default_proc if default_proc
  replace(hash)
  omit
end

केवल दिए गए कुंजी के साथ हैश की जगह। हटाए गए कुंजी / मान जोड़े वाले हैश लौटाता है।

{ a: 1, b: 2, c: 3, d: 4 }.slice!(:a, :b)
# => {:c=>3, :d=>4}
# File activesupport/lib/active_support/core_ext/hash/keys.rb, line 39
def stringify_keys
  transform_keys(&:to_s)
end

एक नया हैश लौटाता है जिसमें सभी कुंजियों को स्ट्रिंग में परिवर्तित किया जाता है।

hash = { name: 'Rob', age: '28' }

hash.stringify_keys
# => {"name"=>"Rob", "age"=>"28"}
# File activesupport/lib/active_support/core_ext/hash/keys.rb, line 45
def stringify_keys!
  transform_keys!(&:to_s)
end

विनाशकारी रूप से सभी कुंजियों को स्ट्रिंग्स में कनवर्ट करता है। stringify_keys रूप में भी, लेकिन self को संशोधित करता है।

प्रतीक__ () स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/hash/keys.rb, line 56
def symbolize_keys
  transform_keys { |key| key.to_sym rescue key }
end

जब तक वे to_sym जवाब देते हैं, तब तक प्रतीकों में परिवर्तित सभी कुंजी के साथ एक नया हैश to_sym

hash = { 'name' => 'Rob', 'age' => '28' }

hash.symbolize_keys
# => {:name=>"Rob", :age=>"28"}
इसके रूप में भी उपनाम: to_options
# File activesupport/lib/active_support/core_ext/hash/keys.rb, line 63
def symbolize_keys!
  transform_keys! { |key| key.to_sym rescue key }
end

विनाशकारी रूप से सभी कुंजियों को प्रतीकों में परिवर्तित कर देता है, जब तक वे to_sym जवाब to_symsymbolize_keys रूप में एक ही symbolize_keys , लेकिन self को संशोधित करता है।

इसके रूप में भी उपनाम: to_options!
to_options ()
इसके लिए उपनाम: symbolize_keys
to_options! ()
इसके लिए उपनाम: symbolize_keys!
to_param (नाम स्थान = शून्य)
अन्य के लिए उपनाम: to_query
to_query (नाम स्थान = nil) स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/object/to_query.rb, line 77
def to_query(namespace = nil)
  query = collect do |key, value|
    unless (value.is_a?(Hash) || value.is_a?(Array)) && value.empty?
      value.to_query(namespace ? "#{namespace}[#{key}]" : key)
    end
  end.compact

  query.sort! unless namespace.to_s.include?("[]")
  query.join("&")
end

URL क्वेरी स्ट्रिंग के रूप में उपयोग के लिए उपयुक्त रिसीवर का एक स्ट्रिंग प्रतिनिधित्व लौटाता है:

{name: 'David', nationality: 'Danish'}.to_query
# => "name=David&nationality=Danish"

मुख्य नामों को संलग्न करने के लिए एक वैकल्पिक नामस्थान पास किया जा सकता है:

{name: 'David', nationality: 'Danish'}.to_query('user')
# => "user%5Bname%5D=David&user%5Bnationality%5D=Danish"

क्वेरी स्ट्रिंग के अनुरूप स्ट्रिंग जोड़े "की = वैल्यू" को आरोही क्रम में लेक्सिकोग्राफिक रूप से सॉर्ट किया जाता है।

इस विधि to_param रूप में भी to_param किया to_param

इसके अलावा to_param : to_param
to_xml (विकल्प = {}) {| बिल्डर | ...} स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/hash/conversions.rb, line 75
def to_xml(options = {})
  require "active_support/builder" unless defined?(Builder)

  options = options.dup
  options[:indent]  ||= 2
  options[:root]    ||= "hash"
  options[:builder] ||= Builder::XmlMarkup.new(indent: options[:indent])

  builder = options[:builder]
  builder.instruct! unless options.delete(:skip_instruct)

  root = ActiveSupport::XmlMini.rename_key(options[:root].to_s, options)

  builder.tag!(root) do
    each { |key, value| ActiveSupport::XmlMini.to_tag(key, value, options) }
    yield builder if block_given?
  end
end

अपने रिसीवर के XML प्रतिनिधित्व वाले स्ट्रिंग को लौटाता है:

{ foo: 1, bar: 2 }.to_xml
# =>
# <?xml version="1.0" encoding="UTF-8"?>
# <hash>
#   <foo type="integer">1</foo>
#   <bar type="integer">2</bar>
# </hash>

ऐसा करने के लिए, विधि जोड़े पर छोरों और नोड्स का निर्माण करती है जो मूल्यों पर निर्भर करती हैं । एक जोड़ी key को देखते हुए, value :

  • यदि value एक हैश है तो key साथ एक पुनरावर्ती कॉल है :root

  • यदि value एक सरणी है तो key साथ एक पुनरावर्ती कॉल है :root , और key एकवचन :children

  • यदि value एक कॉल करने योग्य वस्तु है, तो उसे एक या दो तर्कों की अपेक्षा करनी चाहिए। एरीटी के आधार पर, कॉल करने योग्य options हैश के साथ key रूप में पहले तर्क के साथ लगाया जाता है :root , और दूसरा तर्क के रूप में key एकवचन। कॉल करने योग्य options[:builder] का उपयोग करके नोड जोड़ सकते हैं।

    {foo: lambda { |options, key| options[:builder].b(key) }}.to_xml
    # => "<b>foo</b>"
    
  • यदि value to_xml प्रतिक्रिया करता है, तो विधि को key साथ लागू किया जाता है :root

    class Foo
      def to_xml(options)
        options[:builder].bar 'fooing!'
      end
    end
    
    { foo: Foo.new }.to_xml(skip_instruct: true)
    # =>
    # <hash>
    #   <bar>fooing!</bar>
    # </hash>
    
  • अन्यथा, टैग के रूप में key के साथ एक नोड पाठ नोड के रूप में value एक स्ट्रिंग प्रतिनिधित्व के साथ बनाया जाता है। यदि value nil एक विशेषता "शून्य" को "सही" पर सेट किया जाता है। जब तक विकल्प :skip_types मौजूद नहीं है और यह सच है, एक विशेषता "प्रकार" को निम्नलिखित मैपिंग के अनुसार जोड़ा जाता है:

    XML_TYPE_NAMES = {
      "Symbol"     => "symbol",
      "Integer"    => "integer",
      "BigDecimal" => "decimal",
      "Float"      => "float",
      "TrueClass"  => "boolean",
      "FalseClass" => "boolean",
      "Date"       => "date",
      "DateTime"   => "dateTime",
      "Time"       => "dateTime"
    }
    

डिफ़ॉल्ट रूप से रूट नोड "हैश" है, लेकिन यह :root विकल्प के माध्यम से कॉन्फ़िगर करने योग्य है।

डिफ़ॉल्ट XML बिल्डर बिल्डर का नया उदाहरण है Builder::XmlMarkup । आप अपने बिल्डर को :builder विकल्प से कॉन्फ़िगर कर सकते हैं। विधि भी विकल्पों को स्वीकार करती है जैसे :dasherize और दोस्तों, उन्हें बिल्डर को भेज दिया जाता है।

transform_keys () {| कुंजी | ...} स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/hash/keys.rb, line 14
def transform_keys
  return enum_for(:transform_keys) { size } unless block_given?
  result = {}
  each_key do |key|
    result[yield(key)] = self[key]
  end
  result
end

block ऑपरेशन का उपयोग करके परिवर्तित सभी कुंजियों के साथ एक नया हैश लौटाता है।

hash = { name: 'Rob', age: '28' }

hash.transform_keys { |key| key.to_s.upcase } # => {"NAME"=>"Rob", "AGE"=>"28"}

यदि आप एक block प्रदान नहीं करते हैं, तो यह अन्य तरीकों से पीछा करने के लिए एक एन्यूमरेटर लौटाएगा:

hash.transform_keys.with_index { |k, i| [k, i].join } # => {"name0"=>"Rob", "age1"=>"28"}
transform_keys! () {| कुंजी | ...} स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/hash/keys.rb, line 25
def transform_keys!
  return enum_for(:transform_keys!) { size } unless block_given?
  keys.each do |key|
    self[yield(key)] = delete(key)
  end
  self
end

block ऑपरेशंस का उपयोग करते हुए विनाशकारी रूप से सभी कुंजियों को परिवर्तित करता है। transform_keys रूप में भी लेकिन self को संशोधित करता है।

transform_values () {| मूल्य | ...} स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/hash/transform_values.rb, line 13
def transform_values
  return enum_for(:transform_values) { size } unless block_given?
  return {} if empty?
  result = self.class.new
  each do |key, value|
    result[key] = yield(value)
  end
  result
end

हर मूल्य के लिए एक बार रनिंग block के परिणामों के साथ एक नया हैश लौटाता है। चाबियाँ अपरिवर्तित हैं।

{ a: 1, b: 2, c: 3 }.transform_values { |x| x * 2 } # => { a: 2, b: 4, c: 6 }

यदि आप एक block प्रदान नहीं करते हैं, तो यह अन्य तरीकों से पीछा करने के लिए एक एन्यूमरेटर लौटाएगा:

{ a: 1, b: 2 }.transform_values.with_index { |v, i| [v, i].join.to_i } # => { a: 10, b: 21 }
transform_values! () {| मूल्य | ...} स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/hash/transform_values.rb, line 25
def transform_values!
  return enum_for(:transform_values!) { size } unless block_given?
  each do |key, value|
    self[key] = yield(value)
  end
end

block ऑपरेशंस का उपयोग करके विनाशकारी रूप से सभी मूल्यों को परिवर्तित करता है। रूपांतरों के समान है, लेकिन self को संशोधित करता है।

with_defaults (other_hash)
अन्य के लिए उपनाम: reverse_merge
with_defaults! (other_hash)
इसके लिए उपनाम: reverse_merge!
with_indifferent_access () स्रोत दिखाएं
# File activesupport/lib/active_support/core_ext/hash/indifferent_access.rb, line 9
def with_indifferent_access
  ActiveSupport::HashWithIndifferentAccess.new(self)
end

एक ActiveSupport::HashWithIndifferentAccess देता है ActiveSupport::HashWithIndifferentAccess अपने रिसीवर से बाहर:

{ a: 1 }.with_indifferent_access['a'] # => 1
इसके रूप में भी उपनाम: nested_under_indifferent_access