Itérer sur une profondément imbriqués niveau de hachages en Ruby

J'ai donc une table de hachage, et pour chaque niveau de la table de hachage, je veux le ranger sa clé et la valeur. Le problème est, une valeur peut être un autre tableau de hachage. En outre, le hash peut contenir des paires clé-valeur où la valeur est encore un autre tableau de hachage, etc, etc. Aussi, je ne sais pas comment profondément imbriqués chaque hachage sera. Pour donner un exemple:

{
  :key1 => 'value1',
  :key2 => 'value2',
  :key3 => {
     :key4 => 'value4',
     :key5 => 'value5'
   },
    :key6 => {
      :key7 => 'value7',
      :key8 => {
        :key9 => 'value9'
      }
    }
  }

..Et ainsi de suite. Ce que je veux faire est d'enregistrer chaque touche, la valeur de la paire et de l'id de son parent. I figure ce sera probablement fait de manière récursive, je suis juste pas comment parce que je suis familier avec les fonctions récursives. Je sais comment parcourir les données normalement:

  myHash.each {|key, value|
    ...Do something with the key and value ...
  }

Et donc je suppose que l'appel récursif sera quelque chose comme ceci:

def save_pair (myHash)
  myHash.each {|key, value|
    if(value.class != Hash) ? Pair.create(key, value) : save_pair(value)
  }
end

Ce n'est pas testé, et je ne sais toujours pas comment intégrer sauver le parent id indépendamment.

InformationsquelleAutor varatis | 2012-01-05

Si je comprends l'objectif, alors vous devriez être en mesure de passer dans le parent de votre méthode de sauvegarde. Pour le haut niveau, il sera nul. Le tableau suivant illustre l'idée selon laquelle puts est utilisé en tant que titulaire de place pour le "sauver".

def save_pair(parent, myHash)
  myHash.each {|key, value|
    value.is_a?(Hash) ? save_pair(key, value) :
            puts("parent=#{parent.nil? ? 'none':parent}, (#{key}, #{value})")
  }
end

Voici un exemple de l'appel à elle:

hash = Hash.new
hash["key1"] = "value1"
hash["key2"] = "value2"
hash["key3"] = Hash.new
hash["key3"]["key4"] = "value4"
hash["key3"]["key5"] = "value5"
hash["key6"] = Hash.new
hash["key6"]["key7"] = "value7"
hash["key6"]["key8"] = Hash.new
hash["key6"]["key8"]["key9"] = "value9"

save_pair(nil, hash)

Vos réglages fonctionnent parfaitement. Merci beaucoup!

InformationsquelleAutor Mark Wilkins

Je sais que c'est une réponse tardive, mais j'ai juste mis en place une non-récursive solution à votre problème et de la pensée, c'est le partage de la valeur.

class Hash
  def deep_traverse(&block)
    stack = self.map{ |k,v| [ [k], v ] }
    while not stack.empty?
      key, value = stack.pop
      yield(key, value)
      if value.is_a? Hash
        value.each{ |k,v| stack.push [ key.dup << k, v ] }
      end
    end
  end
end

Alors, pour en revenir à votre problème, vous pouvez le faire:

h = {
  :key1 => 'value1',
  :key2 => 'value2',
  :key3 => {
     :key4 => 'value4',
     :key5 => 'value5'
  },
  :key6 => {
    :key7 => 'value7',
    :key8 => {
      :key9 => 'value9'
    }
  }
}
h.deep_traverse{ |path,value| p [ path, value ] }
# => [[:key6], {:key7=>"value7", :key8=>{:key9=>"value9"}}]
#    [[:key6, :key8], {:key9=>"value9"}]
#    [[:key6, :key8, :key9], "value9"]
#    [[:key6, :key7], "value7"]
#    [[:key3], {:key4=>"value4", :key5=>"value5"}]
#    [[:key3, :key5], "value5"]
#    [[:key3, :key4], "value4"]
#    [[:key2], "value2"]
#    [[:key1], "value1"]

Il y a aussi un gist version.

C'est exactement mon besoin! Merci!!!!
Si vous voulez que cela fonctionne avec toutes les collections, object.respond_to? :each ou my_object.class.include? Enumerable peut être utilisé avec moins de hachage modification spécifique.

InformationsquelleAutor sebastian

class Hash
  def each_with_parent(parent=nil, &blk)
    each do |k, v|
      Hash === v ? v.each_with_parent(k, &blk) : blk.call([parent, k, v])
    end
  end
end

h = { :a => 1, :b => { :c => 3, :d => 4, :e => { :f => 5 } } }

h.each_with_parent { |i| p i }
# [nil, :a, 1]
# [:b, :c, 3]
# [:b, :d, 4]
# [:e, :f, 5]

Est-il possible de réaffecter les résultats de la boucle de la table de hachage?
pouvez-vous me montrer un exemple?
J'ai réussi en remplaçant k par v dans v.each_with_parent(k, &blk) et en faisant p[k] = c. to_i l'intérieur de la boucle. J'ai essayé de reformater au format json (changer les cordes pour les booléens/les entiers).

InformationsquelleAutor maprihoda

Ici est récursive (lire amélioration de la) version de Hash::each(Hash::each_pair) avec bloc et énumérateur support:

module HashRecursive
    refine Hash do
        def each(recursive=false, &block)
            if recursive
                Enumerator.new do |yielder|
                    self.map do |key, value|
                        value.each(recursive=true).map{ |key_next, value_next| yielder << [[key, key_next].flatten, value_next] } if value.is_a?(Hash)
                        yielder << [[key], value]
                    end
                end.entries.each(&block)
            else
                super(&block)
            end
        end
        alias_method(:each_pair, :each)
    end
end

using HashRecursive

Ici l'utilisation exemples de Hash::each avec et sans recursive drapeau:

hash = {
    :a => {
        :b => {
            :c => 1,
            :d => [2, 3, 4]
        },
        :e => 5
    },
    :f => 6
}

p hash.each, hash.each {}, hash.each.size
# #<Enumerator: {:a=>{:b=>{:c=>1, :d=>[2, 3, 4]}, :e=>5}, :f=>6}:each>
# {:a=>{:b=>{:c=>1, :d=>[2, 3, 4]}, :e=>5}, :f=>6}
# 2

p hash.each(true), hash.each(true) {}, hash.each(true).size
# #<Enumerator: [[[:a, :b, :c], 1], [[:a, :b, :d], [2, 3, 4]], [[:a, :b], {:c=>1, :d=>[2, 3, 4]}], [[:a, :e], 5], [[:a], {:b=>{:c=>1, :d=>[2, 3, 4]}, :e=>5}], [[:f], 6]]:each>
# [[[:a, :b, :c], 1], [[:a, :b, :d], [2, 3, 4]], [[:a, :b], {:c=>1, :d=>[2, 3, 4]}], [[:a, :e], 5], [[:a], {:b=>{:c=>1, :d=>[2, 3, 4]}, :e=>5}], [[:f], 6]]
# 6

hash.each do |key, value|
    puts "#{key} => #{value}"
end
# a => {:b=>{:c=>1, :d=>[2, 3, 4]}, :e=>5}
# f => 6

hash.each(true) do |key, value|
    puts "#{key} => #{value}"
end
# [:a, :b, :c] => 1
# [:a, :b, :d] => [2, 3, 4]
# [:a, :b] => {:c=>1, :d=>[2, 3, 4]}
# [:a, :e] => 5
# [:a] => {:b=>{:c=>1, :d=>[2, 3, 4]}, :e=>5}
# [:f] => 6

hash.each_pair(recursive=true) do |key, value|
    puts "#{key} => #{value}" unless value.is_a?(Hash)
end
# [:a, :b, :c] => 1
# [:a, :b, :d] => [2, 3, 4]
# [:a, :e] => 5
# [:f] => 6

Ici est un exemple de la question elle-même:

hash = {
    :key1   =>  'value1',
    :key2   =>  'value2',
    :key3   =>  {
        :key4   =>  'value4',
        :key5   =>  'value5'
    },
    :key6   =>  {
        :key7   =>  'value7',
        :key8   =>  {
            :key9   =>  'value9'
        }
    }
}

hash.each_pair(recursive=true) do |key, value|
    puts "#{key} => #{value}" unless value.is_a?(Hash)
end
# [:key1] => value1
# [:key2] => value2
# [:key3, :key4] => value4
# [:key3, :key5] => value5
# [:key6, :key7] => value7
# [:key6, :key8, :key9] => value9

Également prendre un coup d'oeil à ma version récursive de Hash::merge(Hash::merge!) ici.

InformationsquelleAutor MOPO3OB

1

Je vous conseille d'utiliser #deep_locate de hashie gem
https://www.rubydoc.info/github/intridea/hashie/Hashie/Extensions/DeepLocate#deep_locate-instance_method

peu hacky toujours return false pas à la recherche de
```
hash.extend(Hashie::Extensions::DeepLocate)
hash.deep_locate -> (key, value, object) do 
  # what you want to do here!
  # key: hash key
  # value: hash value
  # object: hash_object
  false # prevent to stop seeking
end
```
InformationsquelleAutor Matsumoto Kazuya

Avez-vous essayé quelque chose comme ça?

trios = []

def save_trio(hash, parent = nil)
  hash.each do |key, value|
    value.kind_of?(Hash) ? save_trio(value, key) : trios << {:key => key, :value => value, :parent => parent}
  end
end

save_trio(myHash)

InformationsquelleAutor christianblais

Il doit faire pour JSON bien. Des améliorations mineures à la Marque de code où il convertit tout en majuscules dans une donnée de hachage:

def capitalize_hash(myHash)
    myHash.each {|key, value|
        puts "isHash: #{value.is_a?(Hash)}: " + value.to_s
        value.is_a?(Hash) ? capitalize_hash(value) : ( value.is_a?(Array) ? (myHash[key] = capitalize_array(value)) : (myHash[key] = value.try(:upcase)))
    }
end

def capitalize_array(myArray)
    myArray.each {|value|
        puts "isHash: #{value.is_a?(Hash)}: " + value.to_s
        value.is_a?(Array) ? capitalize_array(value) : ( value.is_a?(Hash) ? capitalize_hash(value) : value.try(:upcase))
    }
end

InformationsquelleAutor GG.

Vous devez vous connecter pour publier un commentaire.