Ruby Reference
Printing in Ruby
To print to output in ruby, use the built-in method print
. To print with a newline at the end, use puts
.
Strings & Symbols
Strings can be declared with single or double quotes.
word1 = "hello"
word2 = 'hello'
Only double quotes allow interpolation of variables or code.
placeholder = "string interpolation"
"I can use #{placeholder} in double-quoted strings"
#=> "I can use string interpolation in double-quoted strings"
+
is used to concatenate strings together:
"hello " + "world" #=> "hello world"
Strings in Ruby can be accessed and edited like arrays:
str = "cat"
str[0] #=> "c"
Symbols in Ruby are immutable and are marked with a colon :
, like in :word
. Symbols are also often used as the keys in hashes.
Arrays and Hashes
Arrays are created with the square bracket syntax []
.
arr = [1, 2, 3, 4, 5]
arr[2] #=> 3
misc_array= [1, "hello", false]
Arrays can be accessed by index from the beginning or end:
arr[-1] #=> 5
Add an item to the end of an array with <<
, or
or set the value of a specific index:
arr << 6 #=> [1, 2, 3, 4, 5, 6]
arr[3] = 17
arr[8] = 7
arr #=> [1, 2, 3, 17, 5, 6, nil, nil, 7]
More methods for getting Array info:
arr.length #=> 6
arr.first #=> 1
arr.include?(3) #=> true
Ranges
Ranges are used for creating ordered sequences and are created with ..
syntax:
rang = 1..5
rang.to_a #=> [1, 2, 3, 4, 5]
arr[1..3] #=> [2, 3, 4]
Hashes
A Hash can be created with the curly-braces {}
syntax:
ha = {'color' => 'green', 'number' => 5}
ha.keys #=> ['color', 'number']
ha.values #=> ['green', 5]
hash['price'] = 72 #insertion, with any key
Hashes provide 'instant' lookups, and return nil
if the provided key isn't found:
hash['color'] #=> 'green'
hash['missing'] #=> nil
Often, symbols are used as keys, and Ruby provides a shortcut syntax, so these are equivalent:
ha2 = {:color => "blue", :number => 7}
ha2 = {color: "blue", number: 7}
ha2[:color] #=> "blue"
Both Arrays and Hashes are Enumerable.
Math and Logic
Ruby arithmetic operators:
1 + 1 #=> 2
10 * 2 #=> 20
35 / 5 #=> 7
10.0 / 4.0 #=> 2.5
4 % 3 #=> 1
2 ** 5 #=> 32
Equality and Comparisons
1 == 1 #=> true
2 != 1 #=> true
! true #=> false
not true #=> false
Logical Operators
true && true #=> true
false || true #=> true
true and false #=> false
true or false #=> true
Everything in ruby is considered true
except for false
and nil
:
!nil #=> true
!false #=> true
!1 #=> false
!0 #=> false
An or statement will return the first true value it encounters:
nil || 7 #=> 7
nil || false || 8 #=> 8
1 || 2 #=> 1
Control Structures
If Statement
energy = 4
if energy > 5
puts "Great!"
elsif energy == 4
puts "OK"
else
puts "Uh Oh!"
end
OK
Since energy
is 4, the code prints out "OK".
Ruby Loops
While loop example:
counter = 1
while counter <= 5
puts "iteration #{counter}"
counter += 1
end
...which prints:
iteration 1 iteration 2 iteration 3 iteration 4 iteration 5
The for loop goes through collections, such as a range, array or hash. This code will produce the same output as the while loop.
for counter in 1..5
puts "iteration #{counter}"
end
Methods
Here's a basic Ruby method with one parameter:
def double(x)
x * 2
end
Methods implicitly return the value of the last statement:
double 2 #=> 4
Multiple Parameters are separated with commas:
def sum(x,y)
x + y
end
sum 3, 4 #=> 7
Yield Block
You can pass around pieces of code with a block, which is marked with a do
and end
.
*(A block is similar to lambdas found in other languages.)
#method that takes block
def take_block
puts "before block"
yield
puts "after block"
end
# call method and pass it a block
take_block do
puts "i am block"
end
This will print out:
before block i am block after block
yield
calls the block that was passed into the method. Blocks can be surrounded with curly braces {}
instead of do
and end
:
take_block { puts "i am block" }
Each block parameters
Blocks can also take in parameters from the method they are passed to, which is what the each
method does:
(1..3).each do |index|
puts "number #{index}"
end
Output:
number 1 number 2 number 3
each
is used by the other ruby collections, such as arrays and hashes:
array.each do |element|
puts "#{element} is part of the array"
end
hash.each do |key, value|
puts "#{key} is #{value}"
end
map
maps all the items in a collection to new values, e.g. to return an array where each number has been doubled:
[1, 2, 3, 4].map do |n|
n*2
end
#=> [2, 4, 6, 8]
This tutorial is based in part on LearnXinYminutes and is licensed under the Creative Commons Attribution-ShareAlike 3.0 License.