Powtórz zagnieżdżony skrót zawierający hasz i/lub Array

Question

Mam hasz, próbuję wyodrębnić klucze i wartości dla niego. Hash ma zagnieżdżony skrót i/lub tablicę skrótów.

Po sprawdzeniu tej witryny i kilku próbek otrzymałem klucz i wartości. Ale ma trudności z wydobyciem, jeśli jest zbiorem skrótów.

Przykład:

{ 
    :key1 => 'value1', 
    :key2 => 'value2', 
    :key3 => { 
    :key4 => [{:key4_1 => 'value4_1', :key4_2 => 'value4_2'}], 
    :key5 => 'value5' 
    }, 
    :key6 => { 
    :key7 => [1,2,3], 
    :key8 => { 
     :key9 => 'value9' 
    } 
    } 
} 

tej pory mam poniżej kod z how do i loop over a hash of hashes in ruby i Iterate over an deeply nested level of hashes in Ruby

def ihash(h) 
    h.each_pair do |k,v| 
    if v.is_a?(Hash) || v.is_a?(Array) 
     puts "key: #{k} recursing..." 
     ihash(v) 
    else 
     # MODIFY HERE! Look for what you want to find in the hash here 
     puts "key: #{k} value: #{v}" 
    end 
    end 
end 

Ale to nie na v.is_hash?(Array) lub v.is_a?(Array).

Czy brakuje mi czegoś?

Answer 1

To nie jest do końca jasne, co możesz, ale zarówno Array i Hash wdrożyć each (która w przypadku Hash jest aliasem dla each_pair).

Tak, aby uzyskać dokładnie taką moc, co można uzyskać, jeśli metoda będzie działać, można wdrożyć go tak:

def iterate(h) 
    h.each do |k,v| 
    # If v is nil, an array is being iterated and the value is k. 
    # If v is not nil, a hash is being iterated and the value is v. 
    # 
    value = v || k 

    if value.is_a?(Hash) || value.is_a?(Array) 
     puts "evaluating: #{value} recursively..." 
     iterate(value) 
    else 
     # MODIFY HERE! Look for what you want to find in the hash here 
     # if v is nil, just display the array value 
     puts v ? "key: #{k} value: #{v}" : "array value #{k}" 
    end 
    end 
end 

Answer 2

Dzwonisz do ihash (v), jeśli v jest tablicą lub hasłem. Wywołanie metody each_pair nie powiedzie się dla tablic.

Answer 3

Można pominąć rekurencji i użyć czegoś więcej tak:

a = {} 
a[0] = { first: "first" } 
a[1] = [{ second: "second_1" }, { second: "second_2" }] 

a.each_pair do |k1, v1| 
    puts "======== key: #{k1}, value: ========" 

    if v1.class == Hash 
    v1.each_pair do |k2, v2| 
     puts "key_2: #{k2}, value: #{v2}" 
    end 
    else 
    v1.each do |h| 
     h.each_pair do |k2, v2| 
     puts "hash #{v1.index(h)} => key_2: #{k2}, value: #{v2}" 
     end 
    end 
    end 
end 

wyjściowa:

======== key: 0, value: ======== 
key_2: first, value: first 
======== key: 1, value: ======== 
hash 0 => key_2: second, value: second_1 
hash 1 => key_2: second, value: second_2