ENDS 12/4: Get 50% off your Pro annual membership using code [CYBER23](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=CYBER23)


As we've seen, hashes are an important Ruby data structure. Here, we'll learn about the (chunky) bacon to hashes' eggs: symbols!

Hashes and Symbols

Great work!

We've often found we only want the key or value associated with a key/value pair, and it's kind of a pain to put both into our block and only work with one. Can we iterate over *just* keys or *just* values?

This is Ruby. Of course we can.

Ruby includes two hash methods, `.each_key` and `.each_value`, that do exactly what you'd expect:
```rb
my_hash = { one: 1, two: 2, three: 3 }

my_hash.each_key { |k| print k, " " }
# ==> one two three

my_hash.each_value { |v| print v, " " }
# ==> 1 2 3
```
Let's wrap up our study of Ruby hashes and symbols by testing these methods out.

More Methods, More Solutions

Remember, there are always many ways of accomplishing something in Ruby. Converting strings to symbols is no different!

Besides using `.to_sym`, you can also use `.intern`. This will internalize the string into a symbol and works just like `.to_sym`:

```rb
"hello".intern
# ==> :hello
```
When you're looking at someone else's code, you might see `.to_sym` or `.intern` (or both!) when converting strings to symbols.

Many Paths to the Same Summit

Recall that hashes are [collections](https://www.codecademy.com/courses/learn-ruby/lessons/ruby-data-structures/exercises/introduction-to-hashes) of key-value pairs, where a unique key is associated with some value. For example:

```rb
breakfast = { 
  "bacon" => "tasty",
  "eggs" => "tasty",
  "oatmeal" => "healthy",
  "OJ" => "juicy"
}
```
Remember that keys must be unique, but values can repeat. That's why we can have more than one key share the value "tasty.")

We can create hashes several ways, but two of the most popular are 

1. **hash literal notation**:

```rb
new_hash = { "one" => 1 }
```
and 

2\. **hash constructor notation**:

```rb
new_hash = Hash.new
```

The Story So Far

Symbols always start with a colon (`:`). They must be valid Ruby variable names, so the first character after the colon has to be a letter or underscore (`_`); after that, any combination of letters, numbers, and underscores is allowed.

Make sure you don't put any spaces in your symbol name—if you do, Ruby will get confused.

```rb
:my symbol # Don't do this!
:my_symbol # Do this instead.
```

Symbol Syntax

However, the hash syntax changed in Ruby 1.9. Just when you were getting comfortable!

The good news is that the changed syntax is easier to type than the old hash rocket syntax, and if you're used to JavaScript objects or Python dictionaries, it will look very familiar:

```rb
new_hash = { 
  one: 1,
  two: 2,
  three: 3
}
```

The two changes are:

1. You put the colon at the end of the symbol, not at the beginning;
2. You don't need the hash rocket anymore.

It's important to note that even though these keys have colons at the end instead of the beginning, they're still symbols!

```rb
puts new_hash
# => { :one => 1, :two => 2, :three => 3 }
```
From now on, we'll use the 1.9 hash syntax when giving examples or providing default code. You'll want to be familiar with the hash rocket style when reading other people's code, which might be older.

The Hash Rocket Has Landed

You don't have to settle for `nil` as a default value, however. If you create your hash using the `Hash.new` syntax, you can specify a default like so:

```rb
my_hash = Hash.new("Trady Blix")
```
Now if you try to access a nonexistent key in `my_hash`, you'll get `"Trady Blix"` as a result.

You can always read more hashy goodness in the <a href="http://www.ruby-doc.org/core-1.9.3/Hash.html" target="_blank">official Ruby documentation</a>

Setting Your Own Default

We can also iterate over hashes using the `.each` method. For example, we could do

```rb
my_hash.each do |key, value|
  puts my_hash[key]
end
```
This will print out a list of values from `my_hash`, each on its own line.

Iterating Over Hashes

The hash syntax you've seen so far (with the `=>` symbol between keys and values) is sometimes nicknamed the **hash rocket** style.

```rb
numbers = {
  :one => 1,
  :two => "two",
  :three => 3,
}
```

This is because the `=>` looks like a tiny rocket!

Let's build a hash from the ground up using symbols as keys.

All Aboard the Hash Rocket!

You can think of a Ruby symbol as a sort of name. It's important to remember that symbols aren't strings:

```rb
"string" == :string # false
```
Above and beyond the different syntax, there's a key behavior of symbols that makes them different from strings. While there can be multiple different strings that all have the same value, there's only one copy of any particular symbol at a given time.

What's a Symbol?

Converting between strings and symbols is a snap. 

```rb
:sasquatch.to_s
# ==> "sasquatch"

"sasquatch".to_sym
# ==> :sasquatch
```

The `.to_s` and `.to_sym` methods are what you're looking for!

Converting Between Symbols and Strings

Symbols pop up in a lot of places in Ruby, but they're primarily used either as hash keys or for referencing method names. (We'll see how symbols can reference methods in a later lesson.)

```rb
sounds = {
  :cat => "meow",
  :dog => "woof",
  :computer => 10010110,
}
```

Symbols make good hash keys for a few reasons:

1. They're immutable, meaning they can't be changed once they're created;
2. Only one copy of any symbol exists at a given time, so they save memory;
3. Symbol-as-keys are faster than strings-as-keys because of the above two reasons.

What are Symbols Used For?

We mentioned that hash lookup is faster with symbol keys than with string keys. Here, we'll prove it!

The code in the editor uses some new syntax, so don't worry about understanding all of it just yet. It builds two alphabet hashes: one that pairs string letters with their place in the alphabet ( "a" with 1, "b" with 2...) and one that uses symbols (`:a` with 1, `:b` with 2...). We'll look up the letter "r" 100,000 times to see which process runs faster!

It's good to keep in mind that the numbers you'll see are only fractions of a second apart, and we did the hash lookup *100,000 times* each. It's not much of a performance increase to use symbols in this case, but it's definitely there!

Dare to Compare

What happens if you try to access a key that doesn't exist, though?

In many languages, you'll get an error of some kind. Not so in Ruby: you'll instead get the special value `nil`.

Along with `false`, `nil` is one of two non-`true` values in Ruby. (Every other object is regarded as "truthy," meaning that if you were to type `if 2` or `if "bacon"`, the code in that `if` statement would be run.)

It's important to realize that `false` and `nil` are **not** the same thing: `false` means "not true," while `nil` is Ruby's way of saying "nothing at all."

Nil: a Formal Introduction

We know how to grab a specific value from a hash by specifying the associated key, but what if we want to filter a hash for values that meet certain criteria? For that, we can use `.select`.

```rb
grades = { alice: 100,
  bob: 92,
  chris: 95,
  dave: 97
}

grades.select { |name, grade| grade <  97 }
# ==> { :bob => 92, :chris => 95 }

grades.select { |k, v| k == :alice }
# ==> { :alice => 100 }
```

1. In the example above, we first create a `grades` hash that maps symbols to integers.
2. Then we call the `.select` method and pass in a block of code. The block contains an expression for selecting matching key/value pairs. It returns a hash containing `:bob` and `:chris`.
3. Finally, we call the `.select` method again. Our block looks only for the key `:alice`. This is an inefficient method of getting a key/value pair, but it shows that `.select` does not modify the hash.

(Here we're using "name" or "k" to stand for the key and "grade" or "v" to stand for the value, but as usual with blocks, you can call your variables whatever you like.)

Becoming More Selective

We can certainly use strings as Ruby hash keys; as we've seen, there's always more than one way to do something in Ruby. However, the Rubyist's approach would be to use **symbols**.