Just like strings and

numbers, Ruby gives us a lot of methods we can use to work with hashes.

These methods can operate on keys and values at the same time.

Let's take a look at how some of them work now, using work spaces.

Okay, now that we know how to create and work with hashes, let's go ahead and

start learning about some different hash methods.

And I'm gonna create a file for this and we're gonna call it hashmethods.rb.

Now let's go ahead and set up a hash to work with.

And we'll have the keys of hash, item, and that's bread.

And we only want one.

And the brand is Treehouse Bread Company.

Okay, now, let's go ahead and just print out the hash.

Let's just run this and make sure everything is working and nothing's crazy.

So click down into the console, and type ruby and then hash_methods.rb,

and there is a printout of our hash.

Now I'm gonna get these hash methods from the Ruby Hash documentation.

Some of the methods that we're going to look for here, the first one is length.

And that will return the number of key value pairs in the hash.

Let's go ahead and see how that works now.

And we'll just say hash dot length.

And print it out.

And let's run this again and see what happens.

All right, the hash has a length of three.

And you know what let's change that to print.

So it's all on the same line.

Clearing my screen on the bottom there with Ctrl+L, and there we go,

we have a length of 3.

Another neat method is something called invert and

that will transpose the keys and values into a new hash.

And let's go ahead and print that to the screen as well.

I'm gonna save that and run that again and now if we look, here's our original hash.

But when we run the invert method, it changes all the keys and values.

And it does not change the original hash.

The next method that we can take a look at is called shift.

Now if I click on the methods list here in the hash documentation.

This will remove a key value pair from the hash and

return it as a two item array with the key and value.

Let's go back to our workspace and see how that works.

So we're gonna print out the hash after shifting it as well.

And we can use the inspect method to print out the hash.

Let me clear out my screen on the bottom again, with Ctrl + L and run this again.

Now, we've called hash.shift and this returns item and

bread in an array form, but are we really sure it's an array?

Let's go ahead and call the inspect method on that to make sure.

So when we run that again, we can see this comes back as an array,

and our hash now does not have the item Item is the key.

Let's go ahead and put the item back in the hash.

So we'll say item, hash, item is bread.

Now let's go back and look at some more methods.

The last method that we're gonna look at is called merge.

Now merge gives an argument of another hash and returns a new hash.

That sounds a little confusing, so let's go ahead and see how it works.

And we can just print this out now.

So here's our hash, let's print that out.

And now, let's print this out and merge it with a couple other hashes.

Now we call the merge method and then we pass in another hash.

And then we'll go ahead and

print the original hash out again, just to see what it looks like.

Clear my screen since this is getting to be a lot of output and we'll run it again.

So now we've printed out Merged with this particular hash and

what we get back is a new hash.

You know what, that's a little hard to read.

Let's change this to puts and run it again.

So here's our original hash.

Now we merge it with calories of 100 and we get back this hash,

which contains another hash with calories of 100 added on to the original hash.

But, if we look back at that original hash, it does not have the calories key.

This is because merge will create a new hash.

Now you might wonder what would happen,

if we called merge with a key that already exists inside the hash.

Let's go ahead and see what happens.

And we'll just merge that with a different item name.

Now let's clear the screen here and run it again and see what happens.

Now when we do it, we'll see that the new hash comes back

with only one key of item which points to eggs.

Which is the last thing that we called in with merge.

When merge has a conflicting hash key, the hash that's sent into merge

receives precedence and will overwrite the existing key value pair.

Using the documentation linked in the teacher notes section of this video, try

looking up and practicing with different hash methods on your own using workspaces.