7

I want to get the union/intersect/difference from two arrays of hashes for example: 

array1 = [{:name =>'Guy1', :age => 45},{:name =>'Guy2', :age => 45}]
array2 = [{:name =>'Guy1', :age => 45},{:name =>'Guy3', :age => 45}]

...

p array1 - array2 

=> [{:name=>"Guy2", :age=>45}]


p array2 - array1
=> [{:name=>"Guy3", :age=>45}]


p array1 | array2 
=> [{:name=>"Guy1", :age=>45}, {:name=>"Guy2", :age=>45}, {:name=>"Guy3", :age=>45}]

however when I want to only compare based on the names and ignore the ages without needing to remove them from the hashes for example:

array1 = [{:name =>'Guy1', :age => 45},{:name =>'Guy2', :age => 45}]
array2 = [{:name =>'Guy1', :age => 46},{:name =>'Guy3', :age => 45}]

In this case i'm not getting the results that I want b/c the ages are different.

array1 - array2 

=> [{:name=>"Guy1", :age=>45}, {:name=>"Guy2", :age=>45}]

array2 - array1
=> [{:name=>"Guy1", :age=>46}, {:name=>"Guy3", :age=>45}]

array1 | array2 
=> [{:name=>"Guy1", :age=>45}, {:name=>"Guy2", :age=>45}, {:name=>"Guy1", :age=>46}, {:name=>"Guy3", :age=>45}]

Is there a way to get the union/intersect/difference and ignore the age key?

edit: for a better example:

array1 = [{:name =>'Guy1', :age => 45},{:name =>'Guy2', :age => 45}]
array2 = [{:name =>'Guy1'},{:name =>'Guy3'}]

p array1 - array2
p array2 - array1
p array1 | array2
p array1 & array2

Thanks in advance for the help!

Mark Thomas
  • 37,131
  • 11
  • 74
  • 101
Seth Pollack
  • 269
  • 2
  • 13

3 Answers3

7

Here's a quick and dirty way of getting the union:

(array1 + array2).uniq{|a| a[:name]}

However, I would recommend creating your own subclass of Hash so you can safely override eql? as Cary Swoveland points out is what the set-like operators rely on. Note that you also need to limit the hash method to only provide the hashing function on the name field.

class Guy < Hash

  def eql?(other_hash)
    self[:name] == other_hash[:name]
  end

  def hash
    self[:name].hash
  end

end

Then these Guy objects will work in all of the set operations:

array1 = [ Guy[name:'Guy1', age: 45], Guy[name:'Guy2', age: 45] ]
array2 = [ Guy[name:'Guy1', age: 46], Guy[name:'Guy3', age: 45] ]

array1 - array2
#=> [{:name=>"Guy2", :age=>45}]

array2 - array1
#=> [{:name=>"Guy3", :age=>45}]

array1 | array2
#=> [{:name=>"Guy1", :age=>45}, {:name=>"Guy2", :age=>45}, {:name=>"Guy3", :age=>
45}]

array1 & array2
#=> [{:name=>"Guy1", :age=>45}]
Mark Thomas
  • 37,131
  • 11
  • 74
  • 101
  • Even subclassing can be dangerous, but, yes, better than fiddling with class `Hash`. If `f` and `g` are `Guy` objects, one could inadvertently use `f.eql?(g)` when `f == g` was intended (changing `eql?` does not affect `=`), which could result in a fairly nasty bug. – Cary Swoveland May 09 '14 at 17:35
0

For the difference:

diff_arr = array1.map{|a| a[:name]} - array2.map{|a| a[:name]}

diff_arr.map{|a| array1.map{|s| s if s[:name] == a }}.flatten.compact

Intersection

intersec_arr = array1.map{|a| a[:name]} & array2.map{|a| a[:name]}

intersec_ar.map{|a| array1.map{|s| s if s[:name] == a }}.flatten.compact
cvibha
  • 693
  • 5
  • 9
0

All three class Array methods referenced use Hash#eql? to compare two elements that are both hashes. (Hash#eql? checks to see if the hashcodes for the two hashes are equals.) Therefore, we need only (temporarily) redefine Hash#eql?.

array1 = [{:name =>'Guy1', :age => 45}, {:name =>'Guy2', :age => 45}]
array2 = [{:name =>'Guy1'},             {:name =>'Guy3'}] 

class Hash
  alias old_eql? eql?
  def eql?(h) self[:name] == h[:name] end
end

array1 - array2
  #=> [{:name=>"Guy2", :age=>45}]
array2 - array1
  #=> [{:name=>"Guy3"}]
array1 | array2
  #=> [{:name=>"Guy1", :age=>45}, {:name=>"Guy2", :age=>45}, {:name=>"Guy3"}]
array1 & array2
  #=> [{:name=>"Guy1", :age=>45}]

class Hash
  alias eql? old_eql? # Restore eql?
  undef_method :old_eql?
end

Note that this is one of those few situations where self must be explicit. If we wrote:

[:name] == h[:name]

instead of:

self[:name] == h[:name]

Ruby would assume that we are comparing the array [:name] with h[:name].

Cary Swoveland
  • 106,649
  • 6
  • 63
  • 100
  • 2
    I wouldn't recommend this approach due to the monkey patching of a core class `Hash`. However, if the OP were to create a new class, e.g. `class Guys < Hash` and override `eql?` then I would enthusiastically recommend this approach! (Perhaps you can edit/amend this answer?) – Mark Thomas May 09 '14 at 12:12
  • Also, this doesn't work. I think you're forgetting something (see my answer for a hint). – Mark Thomas May 09 '14 at 13:22
  • Good points, @Mark. I mainly put forward this solution because I thought it had educational value. When writing it I knew I was skating on thin ice; I should have at least added some cautionary words. Even subclassing `Hash` can be dangerous--as I will mention in a comment to your answer--but less so than tinkering with `Hash`. I will address your second point in a separate comment. – Cary Swoveland May 09 '14 at 17:15
  • @Mark, I noticed that the docs for all three methods, [Array#-](), `Array#|` and `Array#&` all the mention, "It compares elements using their hash and eql? methods for efficiency." I know `Hash@eql?` uses `Hash#hash`, but it didn't make sense to me that the `Array` methods would depend on `Hash#hash` (as well as `Hash.eql?`), and I was too lazy to check the source code. I concluded the sentence was just poorly worded. Test results were OK without redefining `Hash#hash`. Do you (or anyone else) know if `Hash#hash` needs to be redefined, and if so, why? – Cary Swoveland May 09 '14 at 17:25
  • Yes, `Hash#hash` needs to be redefined. It didn't work for me any other way (in 1.9.3 irb). Here's a reference: http://javieracero.com/blog/the-key-to-ruby-hashes-is-eql-hash – Mark Thomas May 09 '14 at 17:46