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
Ruby makes heavy use of blocks in the built in types and the standard library. In this video, we explore Arrays and Hashes.
Documentation Links
Code Samples
Given the following array:
array = [1, 2, 3]
Array#each
array.each { |item| print "-#{item}-" }
Prints out:
-1--2--3-
Array#select:
array.select { |item| item > 2 }
This returns a new array with the following:
[3]
Array#delete_if
array.delete_if { |item| item == 1 }
The array is now:
[2, 3]
Array#reject
array.reject { |item| item % 3 == 0 }
The above returns a new array: [1, 2]
Array#count
array.count
The above returns 3. But count can also be passed a block:
array.count { |item| item % 3 == 0 }
The above statement returns 1.
Hashes
Given the following hash:
hash = { 'name' => 'Jason', 'location' => 'Treehouse' }
Hash#each
hash.each do |key, value|
puts "key: #{key} value: #{value}"
end
Prints the following:
key: name value: Jason
key: location value: Treehouse
Hash#each_key:
hash.each_key{ |key| puts "key: #{key}" }
Prints the following:
key: name
key: location
Hash#each_value:
hash.each_value { |val| puts "val: #{val}" }
Prints the following:
val: Jason
val: Treehouse
Hash#keep_if
hash.keep_if{ |key, val| key == "name" }
The hash is now:
{ 'name' => 'Jason' }
Hash#reject
hash.reject { |key, val| key == "name" }
The hash is now:
{}
Hash#select
hash.select { |key, val| key == "name" }
Returns a new hash:
{ 'name' => 'Jason' }
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
The next thing we're going to take
a look at is the array class.
0:00
Now, here's the array class documentation,
and
0:02
we've already seen some
of these methods before.
0:07
Here's the each method, each item and
then a block, returns an array.
0:10
Let's go ahead and practice that.
0:16
We'll just say we have an array
of three numbers here.
0:17
And now, we can say array.each |item | ,
0:23
and then, we'll just print a dash and
0:28
the item,
which does exactly what we expect.
0:32
There’s some more cool methods that we
have on array, though, that we can use.
0:38
Let’s take a look at the select method.
0:44
Select, if we look at the documentation,
returns a new array containing all
0:48
elements of the array for which
the given block returns a true value.
0:53
So, let's go ahead and
take a look at that.
1:01
We have our array, which we know contains
the numbers one, two, and three.
1:04
So, if we wanted to, we could use this
select method pass the block here,
1:09
and then, let's select any
item that's greater than two.
1:16
And we'll notice this returns an array
consisting of the number three,
1:22
which makes sense, because that
is the only item in the array for
1:28
which this Boolean value returned true,
1:33
and if we take a look at the array,
it is unmodified.
1:35
It still contains one, two and three.
1:39
Now, if we go back to the documentation
here, in addition to select,
1:44
we've got reject, which also takes
a block and returns a new array.
1:52
And it kind of does the opposite of
select, which returns a new array
1:56
containing the items in the array for
which the block is not true.
2:00
So, let's go ahead and
see how that one works.
2:05
And for this one, we'll reject any
item that is divisible by three.
2:13
And we're testing that by using
the modulus operator, and
2:20
saying the remainder of the item,
when divided by 3, is zero.
2:23
We can see that we get back one and two.
2:29
Another interesting method that
we have on array is count,
2:32
which is going to count
the numbers of items in the array.
2:35
And we can see that returns three,
which makes sense.
2:39
This array has three different items.
2:42
But, we could also pass
a block to the count method.
2:46
The count method will also take a block,
and for anything that passes the block,
2:52
it will return a count of those items.
2:57
So, we can do the same thing here for
items divisible by three.
3:02
The count of them in this array is one,
which is exactly what we expect.
3:05
So, I'm gonna clear my screen here,
and we're gonna move on to hashes.
3:10
Let's go ahead and
create a new hash with two keys.
3:19
And if we look at the hash documentation,
and
3:27
check out the each method,
we can see that we have each and
3:30
each pair which is basically
the exact same method.
3:35
This takes a key in the value and a block.
3:40
So, I'm just gonna
demonstrate the each method.
3:44
We can say hash.each, and then do,
key and value, here's our block.
3:46
I'm using the do and end syntax for this.
3:54
And we'll just print this to the screen.
3:58
And then we can close our block here.
4:03
And you'll notice inside of IRB, it's
not evaluating these lines immediately,
4:07
because it knows there's a do and
end block here.
4:11
So, here we're just iterating through,
and showing the key and
4:15
the value, and the key and the value.
4:18
Now, we've seen that,
we can do hash.each_key
4:22
It prints out each key, and
we also have hash.each_value.
4:32
Which does exactly what we would expect.
4:42
Clear my screen here, and let's take
a look at a couple of other methods here.
4:44
Specifically, let's take
a look at the keep if method.
4:51
This also takes a key, a value and
a block, and this deletes every key
4:56
value pair from the hash for
which the block evaluates to false.
5:01
So, how does that look?
5:06
Let's take a look at our hash.
5:07
And let's say hash.keep_if, and then,
we'll pass it a key and a value,
5:10
and we'll just say,
we'll keep this if the key is "name".
5:17
And that returns
{"name"=>"Jason"} as a hash.
5:24
Now, if we take a look at our original
hash, we can see that that was modified.
5:29
And then, there is the inverse of that,
with reject, and
5:32
we can say hash.reject { |key, value|,
and the key is equal to "name".
5:37
So, that's gonna reject it from the hash.
5:44
We have an empty hash here,
that was returned, but
5:47
if we look at the hash itself,
it still contains the key name as "Jason".
5:51
And just, redo this hash here.
5:57
And hash also supports the select method,
and say hash.select.
6:10
{|key, value| and the key is equal
to "name", and if we look at the hash,
6:18
the select method returned a new hash and
left the original intact.
6:25
If you'd like to see any of these,
you can open up the library_blocks.rb file
6:32
and examples are printed out inside here,
with the return value, and
6:39
a little bit of a description
in the comments.
6:44
If you don't have this in your workspace,
you can go ahead and
6:47
click the launch workspace
button on the right.
6:52
Great job.
6:55
Try checking through some of
the Ruby documentation for
6:57
block methods on your own now,
using workspaces.
6:59
There are links to some of them in
the teacher notes to get you started.
7:03
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