将内部哈希中的键转换为外部/父哈希中的键

Question

I have a hash, say,

account = { 
  name: "XXX", 
  email: "xxx@yyy.com", 
  details: { 
    phone: "9999999999", 
    dob: "00-00-00", 
    address: "zzz" 
  } 
}

Now I want to convert account to a hash like this:

account = { 
  name: "XXX", 
  email: "xxx@yyy.com", 
  phone: "9999999999", 
  dob: "00-00-00", 
  address: "zzz"
}

I'm a beginner and would like to know if there is any function to do it? (Other than merging the nested hash and then deleting it)

Answer 1

You could implement a generic flatten_hash method which works roughly similar to Array#flatten in that it allows to flatten Hashes of arbitrary depth.

def flatten_hash(hash, &block)
  hash.dup.tap do |result|
    hash.each_pair do |key, value|
      next unless value.is_a?(Hash)

      flattened = flatten_hash(result.delete(key), &block) 
      result.merge!(flattened, &block)
    end
  end
end

Here, we are still performing the delete / merge sequence, but it would be required in any such implementation anyway, even if hidden below further abstractions.

You can use this method as follows:

account = { 
  name: "XXX", 
  email: "xxx@yyy.com", 
  details: { 
    phone: "9999999999", 
    dob: "00-00-00", 
    address: "zzz" 
  } 
}

flatten(account)
# => {:name=>"XXX", :email=>"xxx@yyy.com", :phone=>"9999999999", :dob=>"00-00-00", :address=>"zzz"}

Note that with this method, any keys in lower-level hashes overwrite existing keys in upper-level hashes by default. You can however provide a block to resolve any merge conflicts. Please refer to the documentation of Hash#merge! to learn how to use this.

Answer 2

这将达到目的：

account.map{|k,v| k==:details ? v : {k => v}}.reduce({}, :merge)

Answer 3

Case 1: Each value of account may be a hash whose values are not hashes

account.flat_map { |k,v| v.is_a?(Hash) ? v.to_a : [[k,v]] }.to_h
  #=> {:name=>"XXX", :email=>"xxx@yyy.com", :phone=>"9999999999",
  #    :dob=>"00-00-00", :address=>"zzz"}

Case 2: account may have nested hashes

def doit(account)
  recurse(account.to_a).to_h
end

def recurse(arr)
  arr.each_with_object([]) { |(k,v),a|
    a.concat(v.is_a?(Hash) ? recurse(v.to_a) : [[k,v]]) }
end

account = { 
  name: "XXX", 
  email: "xxx@yyy.com", 
  details: { 
    phone: "9999999999", 
    dob: { a: 1, b: { c: 2, e: { f: 3 } } },
    address: "zzz" 
  } 
}

doit account
  #=> {:name=>"XXX", :email=>"xxx@yyy.com", :phone=>"9999999999", :a=>1,
  # :c=>2, :f=>3, :address=>"zzz"}

Explanation for Case 1

The calculations progress as follows.

One way to think of Enumerable#flat_map , as it is used here, is that if, for some method g ,

[a, b, c].map { |e| g(e) } #=> [f, g, h]

where a , b , c , f , g and h are all arrays, then

[a, b, c].flat_map { |e| g(e) } #=> [*f, *g, *h]

Let's start by creating an enumerator to pass elements to the block.

enum = account.to_enum
  #=> #<Enumerator: {:name=>"XXX", :email=>"xxx@yyy.com",
  #     :details=>{:phone=>"9999999999", :dob=>"00-00-00",
  #     :address=>"zzz"}}:each>

enum generates an element which is passed to the block and the block variables are set equal to those values.

k, v = enum.next
  #=> [:name, "XXX"]
k #=> :name
v #=> "XXX"
v.is_a?(Hash)
  #=> false
a = [[k,v]]
  #=> [[:name, "XXX"]]

k, v = enum.next
  #=> [:email, "xxx@yyy.com"]
v.is_a?(Hash)
  #=> false
b = [[k,v]]
  #=> [[:email, "xxx@yyy.com"]]

k,v = enum.next
  #=> [:details, {:phone=>"9999999999", :dob=>"00-00-00", :address=>"zzz"}]
v.is_a?(Hash)
  #=> true
c = v.to_a
  #=> [[:phone, "9999999999"], [:dob, "00-00-00"], [:address, "zzz"]]

d = account.flat_map { |k,v| v.is_a?(Hash) ? v.to_a : [[k,v]] }
  #=> [*a, *b, *c]
  #=> [[:name, "XXX"], [:email, "xxx@yyy.com"], [:phone, "9999999999"],
  #    [:dob, "00-00-00"], [:address, "zzz"]]

d.to_h
  #=> <the return value shown above>