Bummer! This is just a preview. You need to be signed in with a Basic account to view the entire video.

Preview

Start a free Basic trial
to watch this video

Sign up for Treehouse

Build a Monster Class: Part 4

2:49 with Jason Seifer

In this stage, we'll be working towards creating our own class that uses blocks, arrays, hashes, and more. In this video, we'll learn a neat trick about yielding to blocks.

Code Samples

The following code will return the current object in context to a block:

yield self if block_given?

This is useful in cases where you would like to have access to the class inside of a block.

  • 0:00

    So we're done with our Monster program,

  • 0:02

    but I wanted to show you something really cool that you can do with blocks.

  • 0:07

    So, here we have our different actions and

  • 0:13

    we're calling them within the context of a block.

  • 0:16

    Let's just see what the last thing that we have here, okay, monster.hide.

  • 0:20

    Let's go to this hide method, and we yield to the block,

  • 0:25

    which means we're coming out of this method, and calling that block.

  • 0:30

    So, it jumps from here, in this hide method,

  • 0:34

    down to monster.hide, right here, and executes this block of code.

  • 0:42

    Something that's kind of neat that we can do is yield arguments to the block.

  • 0:48

    Now we know that from earlier lessons that we can provide arguments to the block.

  • 0:54

    So, we'll just say if a block is given here,

  • 0:59

    let's provide this argument and what argument would that be?

  • 1:04

    Well, if wanted to we could provide the actions variable and

  • 1:08

    then we would have access to that in the block, but

  • 1:12

    let's do something a little more interesting and yield self.

  • 1:18

    Self is the instance of the monster.

  • 1:23

    So we'll get the monster instance inside of the block.

  • 1:26

    Which means.

  • 1:33

    We could put this in as an argument called monster.

  • 1:38

    And in here, we would have access to the monster variable.

  • 1:43

    And actually, let's just put that in as m.

  • 1:47

    And let's print out the actions here, just to see what it looks like.

  • 1:58

    Printed out the scoreboard.

  • 1:59

    Let's go back up.

  • 2:01

    And this is pretty neat right here, screams, scares, runs, and hides.

  • 2:07

    And let's go ahead and just prove that we can get access to all the methods in here.

  • 2:13

    We define an inspect method.

  • 2:19

    We'll just say inspect is the name and the actions.

  • 2:32

    Clear my screen.

  • 2:33

    Run this one more time.

  • 2:36

    And here we go,

  • 2:37

    we've implemented an inspect method that we call from inside of this block.

  • 2:43

    This is not something you totally need to do, but it is pretty cool and

  • 2:46

    something that you will see in Ruby programs.

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

Sign up