web-dev-qa-db-ja.com

2つのハッシュを比較するにはどうすればよいですか？

次のコードを使用して、2つのRubyハッシュを比較しようとしています。

#!/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

画面への出力は、file2からの完全なファイルです。ファイルが異なるという事実は知っていますが、スクリプトはそれを拾っていないようです。

rubyhash
95
dennismonsewicz

ハッシュを同等に直接比較できます：

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

ハッシュを配列に変換し、それらの違いを取得できます。

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}

さらに簡素化：

三元構造を介して差異を割り当てる：

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

すべてを1つの操作で行い、difference変数を削除します。

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

hashdiff gemを試すことができます。これにより、ハッシュ内のハッシュと配列を詳細に比較できます。

次に例を示します。

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]]
31
liu fengyun

2つのハッシュの違いを知りたい場合、これを行うことができます。

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"}
15
Guilherme Bernal

Railsは 非推奨diff メソッドです。

簡単なワンライナーの場合：

hash1.to_s == hash2.to_s
10
Evan

単純な配列の交差を使用することができます。これにより、各ハッシュの違いを知ることができます。

    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
4
ErvalhouS

私は同じ問題を抱えており、プルリクエストをRailsに送信しました

  • 深くネストされたハッシュで動作します
  • ハッシュの配列で動作します

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

1
montrealmike

値のnilを正しくサポートするハッシュ間の迅速でダーティな差分が必要な場合は、次のようなものを使用できます

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
1
dolzenko

適切にフォーマットされた差分が必要な場合、これを行うことができます：

# Gemfile
gem 'awesome_print' # or gem install awesome_print

そしてあなたのコードで：

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})

アイデアは、素晴らしい印刷を使用してフォーマットし、出力を比較することです。差分は正確ではありませんが、デバッグの目的には役立ちます。

1
Benjamin Crouzier

これは「 Compareing Ruby hashhes 」で回答されました。 Railsは、ハッシュに diff method を追加します。うまくいきます。

1
Wolfram Arnold

...そして今では module の形式で、さまざまなコレクションクラス（それらの間のハッシュ）に適用されます。詳細な検査ではありませんが、簡単です。

# 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 transformed 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
1
Iron Savior

ハッシュto_jsonと文字列として比較する両方についてはどうですか？しかし、それを念頭に置いて

require "json"
h1 = {a: 20}
h2 = {a: "20"}

h1.to_json==h1.to_json
=> true
h1.to_json==h2.to_json
=> false
0
stbnrivas