Comments on: Ruby Equality And Object Comparison

By: The more you know | steveshaw.ca

The more you know | steveshaw.ca — Mon, 01 Aug 2011 21:45:57 +0000

[...] define a comparison in the whatever.rb model class: def <=> (another) self.name <=> another.name [...]

By: Pedro Salgado

Pedro Salgado — Wed, 27 Apr 2011 17:27:28 +0000

(on my 3 previous comments, some characters were removed so here is another attempt)
A shorter version and more complete version of the code above could be done using

def <=>(another_sock)
return self.size <=> another_sock.size
end

I also found that sometimes you may want to compare against other classes so this would work better.

def <=>(other)
if other.instance_of? self.class
return self.size <=> other.size
elsif other.instance_of? Fixnum or other.instance_of? Integer or other.instance_of? Float
return self.size <=> other
end
raise ArgumentError.new(‘comparison of %s with %s failed!’ % [self.class, other.class])
end

By: Pedro Salgado

Pedro Salgado — Wed, 27 Apr 2011 17:27:04 +0000

(on my 2 previous comments, some characters were removed so here is another attempt)
A shorter version and more complete version of the code above could be done using

def <=>(another_sock)
return self.size <=> another_sock.size
end

I also found that sometimes you may want to compare against other classes so this would work better.

def (other)
if other.instance_of? self.class
return self.size <=> other.size
elsif other.instance_of? Fixnum or other.instance_of? Integer or other.instance_of? Float
return self.size <=> other
end
raise ArgumentError.new(‘comparison of %s with %s failed!’ % [self.class, other.class])
end

By: Pedro Salgado

Pedro Salgado — Wed, 27 Apr 2011 17:26:29 +0000

(on my previous comment, some characters were removed so here is another attempt)

A shorter version and more complete version of the code above could be done using

def (another_sock)
return self.size <=> another_sock.size
end

I also found that sometimes you may want to compare against other classes so this would work better.

By: Pedro Salgado

Pedro Salgado — Wed, 27 Apr 2011 17:24:10 +0000

A shorter version and more complete version of the code above could be done using

def (another_sock)
return self.size another_sock.size
end

I also found that sometimes you may want to compare against other classes so this would work better.

def (other)
if other.instance_of? self.class
return self.size other.size
elsif other.instance_of? Fixnum or other.instance_of? Integer or other.instance_of? Float
return self.size other
end
raise ArgumentError.new(‘comparison of %s with %s failed!’ % [self.class, other.class])
end

By: Sahil Verma

Sahil Verma — Thu, 31 Mar 2011 16:33:02 +0000

So in summary regarding equality:

* equal? is reference equality
* == is value equality
* eql? is value and type equality

By: Tarun Mittal

Tarun Mittal — Tue, 07 Sep 2010 10:24:46 +0000

A great post mann.. Cleared almost all my doubts.. And comment by apeiros was actually useful. Am new to ruby, and have started reading your posts. Thanks a lot :)

By: Alan Skorkin

Alan Skorkin — Fri, 02 Oct 2009 05:30:56 +0000

I see what you’re getting, like I said I am not a rails expert (yet :)), so was just giving my view on what I thought was happening, would be happy to hear a definitive answer from someone with skillz :).

By: Mat Brown

Mat Brown — Fri, 02 Oct 2009 04:45:15 +0000

Not keeping an object store for performance reasons? I’m not sure how performance benefits by re-instantiating the same object over and over – which may be why every (other?) serious ORM I’ve worked with guarantees one instance per row per session. And have fun with situations like this:

blog.name = “My Blog”
blog.posts.first.blog.name #=> Not “My Blog”!

By: Alan Skorkin

Alan Skorkin — Thu, 17 Sep 2009 08:57:00 +0000

I am not a Rails expert, but from what I see this is what I think is happening. I don’t believe active record keeps a table of references to objects which should be the same objects. Here is what I mean:

1) As far as your == method is concerned they are the same object
2) When you look up a parent object from a child object, active record does not have an internal table to know that the parent object you get from the child is pointing to the same object as the parent object you already have
3) Essentially whenever you get to a particular object through a different means, what you’re actually seeing will be a clone of the object as far as Ruby is concerned, so it will have a different object id
4) As far as Active Record is concerned, it is the same object and if you look up the database id property on the two objects, just like you did the object_id property I think you will find they are the same. Which is why == reports true

I wouldn’t worry too much about it, chances are they are doing it this way for performance reasons. If I think about it I can see how it may be difficult to implement active record in such a way as to keep object_id consistent.