Ruby is dynamic, flexible and robust programming language. It is also very easy language to start with. If you are new to programming Ruby will help you start the easy way. Take the next step on your journey to learn Ruby. Learn about topics such as hashes, symbols and control flow.
Getting Started With Ruby the Easy Way Part 1 (Comments, Variables, Strings).
Getting Started With Ruby the Easy Way Part 2 (Data Types Pt1).
Getting Started With Ruby the Easy Way Part 4 (Control Flow Pt2).
Getting Started With Ruby the Easy Way Part 5 (Control Flow Pt3).
Getting Started With Ruby the Easy Way Part 6 (Methods).
Getting Started With Ruby the Easy Way Part 7 (Recursion, Scope, OOP Pt1).
Getting Started With Ruby the Easy Way Part 8 (OOP Pt2).
Getting Started With Ruby the Easy Way Part 9 (OOP Pt3).
Getting Started With Ruby the Easy Way Part 10 (OOP Pt4 and Beyond).
In the the first part, you’ve learned about the first two primary data types available in Ruby, strings and constants. Then, in the second part, you’ve learned about the another four, integers, floats, booleans and arrays. There are eight of them in total. This means that there are two more you need to learn about. Namely, hashes and symbols
.
Hashes are another very useful data type. Ruby developers like to use them in cases when arrays are not sufficient to get the job done. This is due to the fact that hashes, to some degree, look similar to arrays. They too allow you to store other objects, in any data type. Just like arrays. In arrays, you store data using indexes. This is where hashes are different.
When you want to store some data in a hash, you do it in the form of a key/value
pair. When you want to retrieve, or access, specific data (the value
) you don’t use index. Instead, you use specific key
you previously assigned to that value
. One way to think about hashes is to imagine areal dictionary. Here, the original word is a key
. The translation of that word is a value
.
For example, let’s say you have a dictionary that translates from English to Spanish. You want to translate the word “computer”. In that case, the word “computer” is the key
while the Spanish version, “computadora”, is the value
. You would use the “computer” key
to retrieve the “computadora” value
from the hypothetical hash called “dictionary”.
When you want to create a new hash, and populate it with data, the syntax is simple. You assign a key
to a value
using =>
. Some Ruby developers like to call this a “hashrocket”. When you want the hash to contain more than one pair, you separate these pairs with commas (,
). Then, you wrap all these pairs with curly braces ({}
). This is the next difference between hashes and arrays. Arrays use square brackets ([]
) and hashes curly braces ({}
).
This is not actually the only way to create a hash. You can also create it using Hash
object and new
method. This will create new empty hash. Then, when you want to add a new key/value
pair you use the name of the hash, followed by square brackets with the key
inside, followed by assignment operator (=
), followed by the value
you want to assign to that key
.
This is almost the same thing you do in case you work with an array. At this moment, you are the only difference is that you are replacing the array index
inside the brackets with a key
. Remember that you can use any kind of data type, or object, as a key
. And, you can store any kind of data type or object as a value. When you want to retrieve the value
?
Then, you use the same syntax, but omit the assignment part. Meaning, you use the name of the hash, followed by square brackets with specific key
. Another way to retrieve a value
is using fetch
method with the key
as an argument, inside the parentheses. If you try to retrieve a value from pair that doesn’t exist, Ruby will return nil
. What if you want to change existing value
?
You use the same syntax as you would if you would want to create a new key/value
pair. Now, you will just override the existing value
in existing pair, instead of adding a new pair. That was creating, retrieving and changing. What if you want to delete some pair? There are two options you can choose from. First, you can delete a pair by just changing the value
to nil
, using specific key
. Second option is calling the delete
method, with the key
as an argument inside the parentheses.
Just like with arrays, there are a lot of things your can do with hashes. For example, you can merge hashes together using merge
method. You can also retrieve all values
using keys
method. This will return the values
inside the hash in the form of an array. You can also use length
or size
when you want to find out how many key/value
pairs specific hash contains. You can find all available methods in Ruby docs for hashes.
Side note: Starting with Ruby 1.9, there is another, “modern”, syntax you can use to create a hash. You can replace the “hashrocket” (_=>_
) with colons (_:_
). However, there is a catch. Using colons will tell Ruby that you want the _keys_
to be _symbols_
. This also means that you can’t use this “modern” syntax if you want to use _symbols_
for _keys_
.
There is one more, important, thing to remember. When you use modern syntax you have to use _symbols_
to retrieve data from hash. This is logical. Ruby created all _keys_
as _symbols_
. Therefore, when you want to retrieve any _value_
assign to specific _key_
you also have to use a _symbol_
.
##
## Create an empty hash
emptyHashExample = Hash.new
## or
emptyHashExample = {}
puts emptyHashExample ## Outputs: {}
##
## Add new key/value pairs an empty hash
emptyHashExample["one"] = "uno"
emptyHashExample["two"] = "dos"
emptyHashExample["three"] = "tres"
## Print the content of emptyHashExample to console
puts emptyHashExample ## Outputs: {"one"=>"uno", "two"=>"dos", "three"=>"tres"}
puts emptyHashExample["one"] ## Outputs: uno
##
## Create hash with content
germanHashExample = {
"one"=>"ein",
"two"=>"zwei",
"three"=>"drei"
}
## Print the content of germanHashExample to console
puts germanHashExample ## Outputs: {"one"=>"ein", "two"=>"zwei", "three"=>"drei"}
puts germanHashExample["three"] ## Outputs: drei
## or with "modern" syntax, using ":"
germanHashExample = {
one: "ein",
two: "zwei",
three: "drei"
}
## Print the content of germanHashExample to console
## Notice that when you use the modern syntax you also
## have to use `symbols` when you want to retrieve the data
## germanHashExample[:two] instead of germanHashExample["two"]
## using germanHashExample["two"] will return nothing.
puts germanHashExample ## Outputs: {:one=>"ein", :two=>"zwei", :three=>"drei"}
puts germanHashExample[:two] ## Outputs: zwei
##
## Change the content of existing hash
hashExample = {
"one"=>"Change this."
}
puts hashExample ## Outputs: {"one"=>"Change this"}
## change the value of "one"
hashExample["one"] = "This is a new value"
puts hashExample ## Outputs: {"one"=>"This is a new value"}
##
## Delete content from hash
hashExample = {
"name"=>"Anthony",
"age"=>35
}
puts hashExample ## Outputs: {"name"=>"Anthony", "age"=>35}
## delete the "age" pair
hashExample.delete("age")
puts hashExample ## Outputs: {"name"=>"Anthony"}
## or if you use the modern syntax
hashExample = {
name: "Anthony",
age: 35
}
puts hashExample ## Outputs: {:name=>"Anthony", :age=>35}
hashExample.delete(:age) ## you must use symbol (notice the ":")
puts hashExample ## Outputs: {:name=>"Anthony"}
##
## Merge two hashes
hashOne = {
"foo"=>"bar"
}
hashTwo = {
"bar"=>"bazz"
}
## merge hashOne and hashTwo into a new hash, hashThree
hashThree = hashOne.merge(hashTwo)
puts hashThree ## Outputs: {"foo"=>"bar", "bar"=>"bazz"}
##
## Print all keys stored in the hash
hashFoo = {
"foo"=>"bar",
"bar"=>"bazz"
}
puts hashFoo.keys
## Outputs:
## foo
## bar
hashFoo = {
"foo"=>"bar",
"bar"=>"bazz"
}
##
## Print all values stored in the hash
puts hashFoo.values
## Outputs:
## bar
## bazz
##
## Get the length or size of a hash
hashFoo = {
"foo"=>"bar",
"bar"=>"bazz"
}
puts hashFoo.size ## Outputs: 2
puts hashFoo.length ## Outputs: 2
#ruby #programming #design development