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

Blocks in the Wild: Strings and Integers

4:58 with Jason Seifer

Ruby makes heavy use of blocks in the built in types and the standard library. In this video, we explore Strings and Integers.

Code Samples

String#each_char:

string = "Treehouse"
string.each_char{|c| print "#{c}-"}

This prints out: 

"T-r-e-e-h-o-u-s-e"

String#each_line:

haiku = <<-EOF
A string with three lines
Is considered multi line
Ruby code haiku
EOF

haiku.each_line{ |line| puts "* #{line}" }

Prints the following:

* A string with three lines
* Is considered multi line
* Ruby code haiku

Integer#down_to:

5.downto(3) { |number| print number }

Prints out the following:

543
  • 0:00

    [SOUND] Ruby makes heavy use of blocks in

  • 0:04

    the built in types and the standard library.

  • 0:10

    We've encountered some block methods before but now that we know more about

  • 0:14

    blocks let's take a fresh look at some of the built in types using workspaces.

  • 0:20

    So now that we know more about blocks, let's go ahead and

  • 0:23

    take a look at some of the methods that take blocks from classes that we've

  • 0:28

    seen in the Ruby standard library.

  • 0:33

    First, let's go ahead and take a look at Strings.

  • 0:36

    Here is the documentation for the string class.

  • 0:40

    And if we scroll down here on the left, let's go ahead and

  • 0:43

    look at this each_char method.

  • 0:46

    Now when we look at the documentation for something that takes a block, or

  • 0:50

    any method really, we can see that it will show you what arguments the method takes.

  • 0:56

    Now when we look at this we can see that this takes a block with one argument.

  • 1:02

    The block is here and

  • 1:05

    this arrow means that it returns a string.

  • 1:10

    So let's go ahead and open up our workspace, and I've already launched one.

  • 1:15

    I've got it inside of IRB.

  • 1:18

    So let's go ahead and take a string here and we'll just say it's a string.

  • 1:21

    And we'll set it to Treehouse, and

  • 1:25

    let's go ahead and practice that each char method.

  • 1:27

    Let's say sting.each_char, and then we send in the block.

  • 1:32

    We know it takes one argument, we're just gonna call it c, and

  • 1:37

    let's print that out, with a dash right after it.

  • 1:45

    So now we can see that this prints out Treehouse, each character of the string

  • 1:51

    and it returns a string itself which happens to be the original string.

  • 1:58

    Now that's useful because we can do something after that.

  • 2:02

    We can kinda chain these methods if we want to.

  • 2:04

    And this doesn't really have anything to do with the block, it's just kinda cool.

  • 2:08

    We could call upcase on that and then we can see that the actual return is

  • 2:12

    TREEHOUSE which is the rightmost method that's called.

  • 2:17

    Now let's go ahead and look at another method here.

  • 2:20

    In addition to each_char, let's look at each_line.

  • 2:24

    This is another method that takes a block and

  • 2:27

    lines are separated by a new line character.

  • 2:31

    So let's go ahead and test that out in IRB.

  • 2:33

    So let's go ahead and create multi-line string here.

  • 2:36

    I'm just gonna call it haiku.

  • 2:39

    And we're gonna use the here doc format to create the string.

  • 2:55

    So, here we have our multiline string.

  • 2:58

    And then just to demonstrate the each_line method, we can call each_line.

  • 3:04

    And we remember from the documentation, it takes a block with one argument.

  • 3:09

    And let's go ahead and just print that out with an asterisk in front of it.

  • 3:16

    And now we can see our multi-line string was printed out with an asterisk in front

  • 3:20

    of it, just like we expect.

  • 3:22

    And then just like the each)char method, a string is returned.

  • 3:29

    So, I'm gonna clear my screen here.

  • 3:30

    And then the next method that we're gonna take a look at is on Integer.

  • 3:37

    And this is a neat one.

  • 3:38

    We can take any number and use this downto method, well, any integer.

  • 3:44

    And this takes one argument to the method itself.

  • 3:50

    And it takes a block also with one argument.

  • 3:55

    They have an example here in the documentation, which is 5.downto(1).

  • 3:59

    Here's a number, print the number, and then two dots.

  • 4:04

    And that will produce this output.

  • 4:06

    Let's go ahead and see if we can recreate something like that.

  • 4:10

    We can say 5.downto(3) and we'll call that number.

  • 4:17

    And let's go ahead and just print the number.

  • 4:21

    That should print out the numbers five, four, and three right after each other.

  • 4:26

    There we go. And

  • 4:27

    then we'll notice here this also returns the original integer that we send in.

  • 4:33

    Now numbers are different, we can't do something like (5.1).downto(3),

  • 4:41

    because the floating point numbers don't have the downto method.

  • 4:48

    And then something else to note when you're working with blocks,

  • 4:51

    it's not necessary to put all these spaces here,

  • 4:54

    that's just the style that I'm using to make it easier to see

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

Sign up