This course will be retired on June 1, 2025.
Heads up! To view this whole video, sign in with your Courses account or enroll in your free 7-day trial. Sign In Enroll
Preview
Start a free Courses trial
to watch this video
Enumerable is one of the most widely used modules in Ruby. The Enumerable module is going to be familiar. It gives us methods that we've worked in Array and Hash such as map, include?, find, and more.
Links
Code Samples
Here is our simple Player class, which implements the Comparable module:
class Player
include Comparable
attr_accessor :name, :score
def <=>(other_player)
score <=> other_player.score
end
def initialize(name, score)
@name, @score = name, score
end
end
Here is our Game class, which implements the Enumerable module:
class Game
include Enumerable
attr_accessor :players
def each(&block)
players.each(&block)
end
def initialize
@players = []
end
def add_player(player)
players.push(player)
end
def score
score = 0
players.each do |player|
score += player.score
end
score
end
end
Now we create some Player and Game instances to work with:
player1 = Player.new("Jason", 100)
player2 = Player.new("Kenneth", 80)
player3 = Player.new("Nick", 95)
player4 = Player.new("Craig", 20)
game1 = Game.new
game1.add_player(player1)
game1.add_player(player2)
game2 = Game.new
game2.add_player(player3)
game2.add_player(player4)
By defining the each method and including the Enumerable module, we can now do some fun things, like iterate through players on the game instance:
game1.each do |player|
puts "Player: #{player.name}, score: #{player.score}"
end
We now get methods for free, such as select, which will let us grab high scores:
high_scores = game1.select do |player|
player.score > 80
end
puts high_scores.inspect
We can see if any score is over 80 using the any? method:
puts game1.any?{|player| player.score > 80}
We can also use the find method to return the first item that returns true for the block:
players = game1.find{|player| player.score > 80}
puts "Players with a score > 80", players.inspect
Related Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign upRelated Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign up
Enumerable is one of the most
widely used modules in Ruby.
0:00
We could do a whole course just
on the Enumerable module, but
0:05
we're only gonna take
a quick look at it today.
0:09
The Enumerable module is
going to be very familiar.
0:13
It gives us methods that we've
worked with in arrays and
0:17
hashes such as map, include, and find.
0:20
Let's take a look at how Enumerable
works now using Work Spaces.
0:25
So, let's go ahead and
quickly launch an irb console and
0:30
just take a look at this hash.
0:34
So, just gonna create a regular
hash right here with two keys.
0:37
And two values, saying my name is
Jason and my location is Treehouse.
0:42
Now, we've worked with hashes a little bit
before during the Ruby curriculum, but
0:49
let's just do a little refresher here.
0:53
If we want to know if a hash has a certain
key, we can use this include method.
0:55
And then, pass it the key that
we wanna see if it's there.
1:01
So, if we look at name that's there,
if we look at location that's there,
1:04
if we look at age, that is not there.
1:10
And then, we have a few more
methods that we can work with.
1:15
We could ask the hash if any of the items,
keys or values.
1:18
The value is equal to Jason and
we get true.
1:24
Or, we could ask the hash
if all of the values,
1:30
Are Jason, and we get false.
1:38
And then we could even do something
like selecting all of the different hash
1:41
values, where the value's
length is greater than five.
1:46
And we only get that one hash key and
value back.
1:55
Now this a little bit of a refresher.
1:59
If we look at the documentation for
Ruby Hash we can see
2:02
that some of these here,
like each key each pair or
2:08
even include, it returns true if
the given key is present in the hash.
2:13
All of these methods come
from this Enumerable module,
2:18
or the Enumerable mixin.
2:23
Now what's really nice,
is since Enumerable is a module,
2:26
we can include Enumerable
in our own classes.
2:31
And then get access to all
of those methods ourself.
2:35
So all these methods like any,
all, include, and
2:41
find, find all, select,
those are all part of Enumerable.
2:46
Let's go ahead and see how that works.
2:50
If we read the documentation, it says the
class must provide a method called each,
2:53
which yields successive
members of the collection.
2:58
So I'm going to go ahead and
exit out of IRB here and clear the screen,
3:03
and I'm going to open up
this enumerable.rb example.
3:06
Now if we look at this
code this has two classes,
3:12
a player and a game and
these are really simple.
3:16
The player class includes
the comparable module and
3:20
defines that spaceship operator
with the player's score.
3:24
And it has two attributes name and score.
3:27
Now we also have this game class and
the game class has players.
3:30
It sets players to an empty array
when the game is initialized and
3:34
then we can use the add player method
to push players onto that array.
3:39
And then we can also get the score of
this game, it just assembles the score of
3:45
all the different players, so
I've created a couple different
3:50
game instances here and a few different
player instances with different scores.
3:56
Game1 has two players.
4:01
Game2 also has two players.
4:03
So we're just gonna run this and
see what the game looks like.
4:04
And we see we got this game instance and
it's got an array of players.
4:09
So now let's go ahead and
implement the Enumerable module.
4:14
And what we want to do is iterate
through all of these game's players.
4:19
So, we can say game1.any.
4:24
We want to have access to this any method.
4:25
We'll say player.
4:30
Player.score is greater than 80.
4:32
Now we know this should return true
because Kenneth only has 80 points.
4:36
We want greater than 80.
4:42
But Jason has 100 points.
4:43
Not trying to brag.
4:45
Now if I were to run this right
now we would see this fail out.
4:46
And it says undefined method any for
this game.
4:51
And that's because we haven't
included Enumerable yet.
4:54
So if we do that, we include Enumerable,
and we're gonna run this and
4:59
it's going to fail again.
5:04
Clear my screen there, and
it says undefined method each for game.
5:06
So let's go ahead and
implement this each method.
5:14
If we were to back to the Enumerable
documentation, we can see the class must
5:17
provide a method called each, which yield
successive members of the collection.
5:23
So we'll go ahead and
define this each method.
5:30
And we're gonna do something
a little bit advanced here.
5:36
We're gonna say that each
method takes a block, and
5:38
we're going to say that
just goes out to players.
5:41
Now, remember players is an array,
so it has this each method.
5:48
And all we are doing is passing this
block as a variable to that each method.
5:53
This is called pretzeling, and we're just
passing around this block like a variable.
5:59
So once we do that,
6:06
this any method that we have at
the bottom here should start working.
6:08
And let's go ahead and print that out.
6:13
And it looks like we get true, so one of
the players does have a score above 80.
6:14
Now since we defined this each method,
we now have access
6:22
to all of these different
methods inside of Enumerable.
6:27
And it makes it very very powerful.
6:33
So we could do any, we could find
all of the different players.
6:36
So let's go ahead and do that.
6:40
Let's go ahead and
say players is game1.find_all player.
6:45
Player.score is greater than 80.
6:52
[SOUND] And
then let's put there's with base score,
6:56
greater than 80 and
inspect that player's variable.
7:02
Al right, and find all returns an array.
7:08
If we just wanted to find the first one,
we could change that to find.
7:14
And then if we run that again, we can see
it just returns one player instance and
7:19
does not have an array.
7:24
On your own, go ahead and check out this
documentation and try playing around
7:26
with a bunch of different methods
inside of the Enumerable module.
7:31
There's a link in the documentation and
go ahead and
7:36
try checking out Detect,
Collect, Any and All, and
7:39
all of those different methods,
and give it a try in Work Spaces.
7:44
You need to sign up for Treehouse in order to download course files.
Sign upYou need to sign up for Treehouse in order to set up Workspace
Sign up