⚡ CYBER NOVEMBER SALE ⚡ 50% off any plan for 6 months, exclusive to new subscribers.

Join the Treehouse affiliate program and earn 25% recurring commission!

Well done!

You have completed Ruby Modules!

Sign up for Treehouse Back to Library

Preview

Sign up for Treehouse Continue

Enumerable

7:49 with Jason Seifer

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.

Teacher's Notes
Questions?
Video Transcript
Downloads
Workspaces

Links

Ruby Enumerable Rdoc

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 up

Related 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 up

You need to sign up for Treehouse in order to set up Workspace

Sign up