Come faccio a confrontare due hash?

Sto cercando di confrontare due Ruby Hash usando il seguente codice:

#!/usr/bin/env ruby require "yaml" require "active_support" file1 = YAML::load(File.open('./en_20110207.yml')) file2 = YAML::load(File.open('./locales/en.yml')) arr = [] file1.select { |k,v| file2.select { |k2, v2| arr << "#{v2}" if "#{v}" != "#{v2}" } } puts arr 

L’output sullo schermo è il file completo da file2. So per certo che i file sono diversi, ma lo script non sembra raccoglierlo.

Puoi confrontare gli hash direttamente per l’uguaglianza:

 hash1 = {'a' => 1, 'b' => 2} hash2 = {'a' => 1, 'b' => 2} hash3 = {'a' => 1, 'b' => 2, 'c' => 3} hash1 == hash2 # => true hash1 == hash3 # => false hash1.to_a == hash2.to_a # => true hash1.to_a == hash3.to_a # => false 


Puoi convertire gli hash in array, quindi ottenere la loro differenza:

 hash3.to_a - hash1.to_a # => [["c", 3]] if (hash3.size > hash1.size) difference = hash3.to_a - hash1.to_a else difference = hash1.to_a - hash3.to_a end Hash[*difference.flatten] # => {"c"=>3} 

Semplificando ulteriormente:

Assegnazione della differenza tramite una struttura ternaria:

  difference = (hash3.size > hash1.size) \ ? hash3.to_a - hash1.to_a \ : hash1.to_a - hash3.to_a => [["c", 3]] Hash[*difference.flatten] => {"c"=>3} 

Fare tutto in un’unica operazione e liberarsi della variabile difference :

  Hash[*( (hash3.size > hash1.size) \ ? hash3.to_a - hash1.to_a \ : hash1.to_a - hash3.to_a ).flatten] => {"c"=>3} 

Puoi provare la gem hashdiff , che consente un confronto approfondito tra hash e array nell’hash.

Quanto segue è un esempio:

 a = {a:{x:2, y:3, z:4}, b:{x:3, z:45}} b = {a:{y:3}, b:{y:3, z:30}} diff = HashDiff.diff(a, b) diff.should == [['-', 'a.x', 2], ['-', 'a.z', 4], ['-', 'b.x', 3], ['~', 'b.z', 45, 30], ['+', 'b.y', 3]] 

Se vuoi ottenere la differenza tra due hash, puoi farlo:

 h1 = {:a => 20, :b => 10, :c => 44} h2 = {:a => 2, :b => 10, :c => "44"} result = {} h1.each {|k, v| result[k] = h2[k] if h2[k] != v } p result #=> {:a => 2, :c => "44"} 

Rails sta deprecando il metodo diff .

Per un veloce one-liner:

 hash1.to_s == hash2.to_s 

Potresti usare una semplice intersezione di array, in questo modo puoi sapere cosa differisce in ogni hash.

  hash1 = { a: 1 , b: 2 } hash2 = { a: 2 , b: 2 } overlapping_elements = hash1.to_a & hash2.to_a exclusive_elements_from_hash1 = hash1.to_a - overlapping_elements exclusive_elements_from_hash2 = hash2.to_a - overlapping_elements 

Questo è stato risposto in ” Confrontare gli hash ruby “. Rails aggiunge un metodo diff agli hash. Funziona bene.

Ho avuto lo stesso problema e ho inviato una richiesta di pull ai binari

  • Funziona con hash profondamente annidato
  • Funziona con matrici di hash

https://github.com/elfassy/rails/commit/5f3410e04fe8c4d4745397db866c9633b80ccec6

Se hai bisogno di una differenza rapida e sporca tra gli hash che supporta correttamente nil in valori puoi usare qualcosa di simile

 def diff(one, other) (one.keys + other.keys).uniq.inject({}) do |memo, key| unless one.key?(key) && other.key?(key) && one[key] == other[key] memo[key] = [one.key?(key) ? one[key] : :_no_key, other.key?(key) ? other[key] : :_no_key] end memo end end 

Se vuoi un diff ben formattato, puoi farlo:

 # Gemfile gem 'awesome_print' # or gem install awesome_print 

E nel tuo codice:

 require 'ap' def my_diff(a, b) as = a.ai(plain: true).split("\n").map(&:strip) bs = b.ai(plain: true).split("\n").map(&:strip) ((as - bs) + (bs - as)).join("\n") end puts my_diff({foo: :bar, nested: {val1: 1, val2: 2}, end: :v}, {foo: :bar, n2: {nested: {val1: 1, val2: 3}}, end: :v}) 

L’idea è di usare una stampa impressionante per formattare e diffare l’output. Il diff non sarà esatto, ma è utile per scopi di debug.

… e ora in forma di modulo da applicare a una varietà di classi di raccolta (Hash tra di loro). Non è un’ispezione approfondita, ma è semplice.

 # Enable "diffing" and two-way transformations between collection objects module Diffable # Calculates the changes required to transform self to the given collection. # @param b [Enumerable] The other collection object # @return [Array] The Diff: A two-element change set representing items to exclude and items to include def diff( b ) a, b = to_a, b.to_a [a - b, b - a] end # Consume return value of Diffable#diff to produce a collection equal to the one used to produce the given diff. # @param to_drop [Enumerable] items to exclude from the target collection # @param to_add [Enumerable] items to include in the target collection # @return [Array] New transformsd collection equal to the one used to create the given change set def apply_diff( to_drop, to_add ) to_a - to_drop + to_add end end if __FILE__ == $0 # Demo: Hashes with overlapping keys and somewhat random values. Hash.send :include, Diffable rng = Random.new a = (:a..:q).to_a.reduce(Hash[]){|h,k| h.merge! Hash[k, rng.rand(2)] } b = (:i..:z).to_a.reduce(Hash[]){|h,k| h.merge! Hash[k, rng.rand(2)] } raise unless a == Hash[ b.apply_diff(*b.diff(a)) ] # change b to a raise unless b == Hash[ a.apply_diff(*a.diff(b)) ] # change a to b raise unless a == Hash[ a.apply_diff(*a.diff(a)) ] # change a to a raise unless b == Hash[ b.apply_diff(*b.diff(b)) ] # change b to b end 

Che ne dici di un altro approccio più semplice:

 require 'fileutils' FileUtils.cmp(file1, file2)