Comparable

5:14 with Jason Seifer

For our first stop on the Ruby Core Module tour, we're going to check out the `Comparable` module. The `Comparable` module allows you to make your classes sortable and gives you convenience methods.

Teacher's Notes
Video Transcript
Downloads

Code Samples

By including the Comparable class and defining the spaceship operator( <=> ), we get access to comparison functionality in our classes:

class Player
  include Comparable

  attr_accessor :name, :score

  def <=>(other_player)
    score <=> other_player.score
  end

  def initialize(name, score)
    @name = name
    @score = score
  end
end

player1 = Player.new("Jason", 100)
player2 = Player.new("Kenneth", 80)

puts "player1 > player2: %s" % (player1 > player2)
puts "player1 < player2: %s" % (player1 < player2)

0:05
Ruby as a programming language comes with some different modules
0:09
as part of its distribution.
0:11
There are two parts to this, Ruby Core and the Ruby Standard Library.
0:16
The difference between them is as follows,
0:19
Ruby Core contains Ruby language features, while the Ruby standard
0:23
library contains different libraries you can use in your Ruby programs.
0:29
Something in Ruby Core may only implement a few different core pieces of behavior,
0:34
such as file access.
0:36
While something in the standard library would implement a suite of behavior,
0:40
such as logging functionality.
0:42
We're going to take a look now at the comparable module.
0:46
The comparable module is a mix-in that provides behavior to help in
0:49
ordering your classes.
0:52
Let's take a look at how it works now using work spaces.
0:57
Okay, so let's go ahead and take a look at the Comparable module.
1:01
Now this is part of Ruby Core, and if you head over to the teacher notes,
1:06
you'll find a link to the Ruby Comparable module documentation.
1:11
And if we look at the documentation, it tells us exactly what Comparable does.
1:16
It's used by classes whose objects may be ordered, and
1:21
it must define this operator right here.
1:25
We haven't seen this before, it's called the spaceship operator.
1:28
And it says it compares the receiver against another object,
1:32
returning -1, 0, +1, depending on whether or
1:38
not the receiver is less than, equal to, or greater than the other object.
1:43
So what in the world does that mean?
1:45
Well, if it is less then the other object it's being compared to,
1:50
we return minus one.
1:53
If it's equal to it returns zero, or if it's greater than, it returns plus one.
1:58
Now using that, we get some interesting behavior that we can view here.
2:04
So, this documentation isn’t that great,
2:06
lets go ahead and take a look at how it works, using a player class.
2:12
So, right here we have this comparable.rb file open in a workspace, and
2:17
we have this player class right here.
2:20
And this is pretty simple, the player object has a name and
2:23
a score associated with it.
2:26
When we initialize the player class, we initialize the name, and the score.
2:32
Now, all we have right here is this simple output statement saying,
2:36
player1 is greater than player2.
2:40
And all this %s right here, means its a format string,
2:46
and anything that's evaluated right here will be returned as a string.
2:49
So we're just kind of trying to evaluate the statement, player1 > player2.
2:53
Now let's go ahead and run this, and see what happens.
2:59
We have undefined method greater than for this player class, and that makes
3:04
sense because we haven't done anything with the Comparable module just yet.
3:11
So, here's how we do it.
3:12
We can say include Comparable.
3:18
Now, that will include the Comparable module into our player class.
3:24
Mixing in all of the different methods that the Comparable module gives us.
3:29
And let's run this again and see what happens.
3:31
Once again we got a failure, but this is a different error.
3:35
It says comparison of player with player failed, and why did it fail?
3:42
It's because we didn't implement this spaceship operator.
3:47
So, let's go ahead and implement that now, and we define that like any other method.
3:56
And we can do a little short circuit here, and
4:01
we can just say score is the spaceship operator to the other_player.score.
4:10
So if one of us has a score of 100 and the other has a score of 80,
4:15
that should return one,
4:18
because one is greater than the other side of this operand.
4:24
So I'll clear my screen here and run this again, and you'll see we now have this
4:29
method, saying player1 is greater than player2, that evaluates to true.
4:35
And the same thing will work, if we do it with the less than sign here.
4:42
We now get that method for free, and if we look back in the documentation for
4:46
Comparable, we get all of these different methods right here.
4:50
Less than, less than or equal to, equal to, greater than, greater than or
4:54
equal to, and between.
4:57
So, we could also see if something was between something else.
5:01
And the nice thing about this is, we didn't have to write
5:04
any code to see whether or not this was greater than something else.
5:08
By just defining this one spaceship operator,
5:11
we were able to get all of this behavior for free.

You need to sign up for Treehouse in order to download course files.

Ruby Modules

Comparable

Links

Code Samples

Sign in