Ruby

Ruby
The programming language
that made Rails possible

The Oath
“I do solemnly swear:
I will not consider this an exhaustive Ruby lesson
and I will study Ruby more as I progress in Rails,
so James will not come take my keyboard away!”

irb
The secret weapon of the Rubyists

The REPL

Ruby comes with a Read-Eval-Print-Loop tool called irb

The REPL

In short, you feed it some Ruby and it prints results

The REPL

This is an excellent way to learn the language

The REPL

It becomes a powerful data management tool when
used with Rails

The REPL

It becomes a powerful data management tool when
used with Rails
Do yourself a favor and start playing with irb a lot

Using irb

$ irb
>> 1 + 2
=> 3
>> "james".capitalize
=> "James"
>> %w[y b u R].reverse
=> ["R", "u", "b", "y"]
>> _.join("-")
=> "R-u-b-y"
>> exit

Using irb
Run irb to launch it
$ irb
>> 1 + 2
=> 3
=> "James"
=> ["R", "u", "b", "y"]
>> _.join("-")
=> "R-u-b-y"
>> exit

Using irb
$ irb
You enter Ruby >> 1 + 2
expressions => 3
=> "James"
=> ["R", "u", "b", "y"]
>> _.join("-")
=> "R-u-b-y"
>> exit

Using irb
$ irb
expressions => 3
=> "James"
irb responds with the >> %w[y b u R].reverse
results as you type => ["R", "u", "b", "y"]
>> _.join("-")
=> "R-u-b-y"
>> exit

Using irb
$ irb
expressions => 3
=> "James"
>> _.join("-")
=> "R-u-b-y"
_ holds the last result >> exit

Using irb
$ irb
expressions => 3
=> "James"
>> _.join("-")
=> "R-u-b-y"
_ holds the last result >> exit

Use exit() to quit

Data Types
The building blocks of Ruby

Data Types and Structures
Ruby has data types common to most programming
languages: String, Integer, Float, …

Ruby has two primary data structures: Array and Hash

These structures are very versatile and can serve as
sets, queues, stacks, …

Ruby has some other data types, like Time

Ruby has some other data types, like Time
All of the above are full objects in Ruby

String “ta lot of escapesn#{1 + 2}” ‘less ( or ’)’
255 0377
Integer
0xFF 0b11111111
0.00003
Float
3.0e-5
[“James”, “Edward”, “Gray”, “II”]
Array
%w[James Edward Gray II]
Hash {“name” => “James”, “age” => 33}
Symbol :ﬁrst_name
Regexp /AJ(?:ames )?E(?:dward )?G(?:ray )?(?:II|2)z/
Time.now
Time
Time.local(2010, 3, 10) Time.utc(2010, 3, 10)

Working With Strings
>> space = "textra space n"
=> "textra space n"
>> space.strip
=> "extra space"
>> space.rstrip
=> "textra space"

>> "James".delete("aeiou")
=> "Jms"

>> date = "March 2010"
=> "March 2010"
>> date[0..4]
=> "March"
>> date[-2..-1]
=> "10"
>> date[/d+/]
=> "2010"

String provides: =>
>>
"textra space n"
space.strip
=> "extra space"
>> space.rstrip
=> "textra space"

=> "Jms"

=> "March 2010"
>> date[0..4]
=> "March"
>> date[-2..-1]
=> "10"
>> date[/d+/]
=> "2010"

String provides: =>
>>
"textra space n"
space.strip
=> "extra space"
Case changing >>
=>
space.rstrip
"textra space"

=> "Jms"

=> "March 2010"
>> date[0..4]
=> "March"
>> date[-2..-1]
=> "10"
>> date[/d+/]
=> "2010"

String provides: =>
>>
"textra space n"
space.strip
=> "extra space"
Case changing >>
=>
space.rstrip
"textra space"

Whitespace stripping >> "James".delete("aeiou")
=> "Jms"

=> "March 2010"
>> date[0..4]
=> "March"
>> date[-2..-1]
=> "10"
>> date[/d+/]
=> "2010"

String provides: =>
>>
"textra space n"
space.strip
=> "extra space"
Case changing >>
=>
space.rstrip
"textra space"

=> "Jms"

General editing >>
=>
date = "March 2010"
"March 2010"
>> date[0..4]
=> "March"
>> date[-2..-1]
=> "10"
>> date[/d+/]
=> "2010"

String provides: =>
>>
"textra space n"
space.strip
=> "extra space"
Case changing >>
=>
space.rstrip
"textra space"

=> "Jms"

General editing >>
=>
date = "March 2010"
"March 2010"
>> date[0..4]
Indexing => "March"
>> date[-2..-1]
=> "10"
>> date[/d+/]
=> "2010"

String provides: =>
>>
"textra space n"
space.strip
=> "extra space"
Case changing >>
=>
space.rstrip
"textra space"

=> "Jms"

General editing >>
=>
date = "March 2010"
"March 2010"
>> date[0..4]
Indexing => "March"
>> date[-2..-1]
=> "10"
… >> date[/d+/]
=> "2010"

Working With Arrays
>> a = [0, 1]
=> [0, 1]
>> a << 2 << 3 << 4
=> [0, 1, 2, 3, 4]
>> a.pop
=> 4
>> a
=> [0, 1, 2, 3]

>> a[1]
=> 1
>> a[1..-1]
=> [1, 2, 3]

>> a & [0, 2, 4, 6]
=> [0, 2]
>> a | [42]
=> [0, 1, 2, 3, 42]

Working With Arrays
>> a = [0, 1]
Array provides: =>
>>
[0, 1]
a << 2 << 3 << 4
=> [0, 1, 2, 3, 4]
>> a.pop
=> 4
>> a
=> [0, 1, 2, 3]

>> a[1]
=> 1
>> a[1..-1]
=> [1, 2, 3]

>> a & [0, 2, 4, 6]
=> [0, 2]
>> a | [42]
=> [0, 1, 2, 3, 42]

Working With Arrays
>> a = [0, 1]
Array provides: =>
>>
[0, 1]
a << 2 << 3 << 4
=> [0, 1, 2, 3, 4]
Adding elements >>
=>
a.pop
4
>> a
=> [0, 1, 2, 3]

>> a[1]
=> 1
>> a[1..-1]
=> [1, 2, 3]

>> a & [0, 2, 4, 6]
=> [0, 2]
>> a | [42]
=> [0, 1, 2, 3, 42]

Working With Arrays
>> a = [0, 1]
Array provides: =>
>>
[0, 1]
a << 2 << 3 << 4
=> [0, 1, 2, 3, 4]
Adding elements >>
=>
a.pop
4
>> a
Removing elements => [0, 1, 2, 3]

>> a[1]
=> 1
>> a[1..-1]
=> [1, 2, 3]

>> a & [0, 2, 4, 6]
=> [0, 2]
>> a | [42]
=> [0, 1, 2, 3, 42]

Working With Arrays
>> a = [0, 1]
Array provides: =>
>>
[0, 1]
a << 2 << 3 << 4
=> [0, 1, 2, 3, 4]
Adding elements >>
=>
a.pop
4
>> a

>> a[1]
Indexing =>
>>
1
a[1..-1]
=> [1, 2, 3]

>> a & [0, 2, 4, 6]
=> [0, 2]
>> a | [42]
=> [0, 1, 2, 3, 42]

Working With Arrays
>> a = [0, 1]
Array provides: =>
>>
[0, 1]
a << 2 << 3 << 4
=> [0, 1, 2, 3, 4]
Adding elements >>
=>
a.pop
4
>> a

>> a[1]
Indexing =>
>>
1
a[1..-1]
=> [1, 2, 3]
Set operations
>> a & [0, 2, 4, 6]
=> [0, 2]
>> a | [42]
=> [0, 1, 2, 3, 42]

Working With Arrays
>> a = [0, 1]
Array provides: =>
>>
[0, 1]
a << 2 << 3 << 4
=> [0, 1, 2, 3, 4]
Adding elements >>
=>
a.pop
4
>> a

>> a[1]
Indexing =>
>>
1
a[1..-1]
=> [1, 2, 3]
Set operations
>> a & [0, 2, 4, 6]
=> [0, 2]
… >> a | [42]
=> [0, 1, 2, 3, 42]

Working With Hashes
>> h = {:a => 1, :b => 2}
=> {:a=>1, :b=>2}
>> h[:b]
=> 2
>> h[:c] = 3
=> 3
>> h
=> {:a=>1, :b=>2, :c=>3}

>> h.keys
=> [:a, :b, :c]
>> h.values
=> [1, 2, 3]

>> h.include? :c
=> true
>> h.include? :d
=> false

Working With Hashes
>> h = {:a => 1, :b => 2}
Hash provides: =>
>>
{:a=>1, :b=>2}
h[:b]
=> 2
>> h[:c] = 3
=> 3
>> h
=> {:a=>1, :b=>2, :c=>3}

>> h.keys
=> [:a, :b, :c]
>> h.values
=> [1, 2, 3]

>> h.include? :c
=> true
>> h.include? :d
=> false

Working With Hashes
>> h = {:a => 1, :b => 2}
Hash provides: =>
>>
{:a=>1, :b=>2}
h[:b]
=> 2
Key-value storage >>
=>
h[:c] = 3
3
>> h
=> {:a=>1, :b=>2, :c=>3}

>> h.keys
=> [:a, :b, :c]
>> h.values
=> [1, 2, 3]

>> h.include? :c
=> true
>> h.include? :d
=> false

Working With Hashes
>> h = {:a => 1, :b => 2}
Hash provides: =>
>>
{:a=>1, :b=>2}
h[:b]
=> 2
=>
h[:c] = 3
3
>> h
Key addition/removal => {:a=>1, :b=>2, :c=>3}

>> h.keys
=> [:a, :b, :c]
>> h.values
=> [1, 2, 3]

>> h.include? :c
=> true
>> h.include? :d
=> false

Working With Hashes
>> h = {:a => 1, :b => 2}
Hash provides: =>
>>
{:a=>1, :b=>2}
h[:b]
=> 2
=>
h[:c] = 3
3
>> h

>> h.keys
Indexing =>
>>
[:a, :b, :c]
h.values
=> [1, 2, 3]

>> h.include? :c
=> true
>> h.include? :d
=> false

Working With Hashes
>> h = {:a => 1, :b => 2}
Hash provides: =>
>>
{:a=>1, :b=>2}
h[:b]
=> 2
=>
h[:c] = 3
3
>> h

>> h.keys
Indexing =>
>>
[:a, :b, :c]
h.values
=> [1, 2, 3]
Queries
>> h.include? :c
=> true
>> h.include? :d
=> false

Working With Hashes
>> h = {:a => 1, :b => 2}
Hash provides: =>
>>
{:a=>1, :b=>2}
h[:b]
=> 2
=>
h[:c] = 3
3
>> h

>> h.keys
Indexing =>
>>
[:a, :b, :c]
h.values
=> [1, 2, 3]
Queries
>> h.include? :c
=> true
… >> h.include? :d
=> false

Type Conversions
>> pi = "3.1415"
=> "3.1415"
>> pi.to_f
=> 3.1415
>> pi.to_i
=> 3

>> num = 42
=> 42
>> num.to_s
=> "42"
>> num.to_s(16)
=> "2a"

>> animals = "chickens,cows,Rubyists"
=> "chickens,cows,Rubyists"
>> animals.split(",")
=> ["chickens", "cows", "Rubyists"]
>> animals.split(",", 2)
=> ["chickens", "cows,Rubyists"]
>> animals.split(",").join(" | ")
=> "chickens | cows | Rubyists"

Type Conversions
Ruby has many >> pi = "3.1415"
=> "3.1415"
conversion methods >> pi.to_f
=> 3.1415
>> pi.to_i
=> 3

>> num = 42
=> 42
>> num.to_s
=> "42"
>> num.to_s(16)
=> "2a"


Type Conversions
=> "3.1415"
=> 3.1415
>> pi.to_i
Strings can become => 3

Integers or Floats >>
=>
num = 42
42
>> num.to_s
=> "42"
>> num.to_s(16)
=> "2a"


Type Conversions
=> "3.1415"
=> 3.1415
>> pi.to_i

=>
num = 42
42
>> num.to_s
=> "42"
Numbers can >> num.to_s(16)
=> "2a"
Stringiﬁed in a base >> animals = "chickens,cows,Rubyists"

Type Conversions
=> "3.1415"
=> 3.1415
>> pi.to_i

=>
num = 42
42
>> num.to_s
=> "42"
=> "2a"
Strings become >>
=>
animals.split(",")
["chickens", "cows", "Rubyists"]

Arrays, and go back >>
=>
animals.split(",", 2)
["chickens", "cows,Rubyists"]

Type Conversions
=> "3.1415"
=> 3.1415
>> pi.to_i

=>
num = 42
42
>> num.to_s
=> "42"
=> "2a"
Strings become >>
=>
animals.split(",")
["chickens", "cows", "Rubyists"]

Arrays, and go back >>
=>
animals.split(",", 2)
["chickens", "cows,Rubyists"]
…

Flow Control
Conditional logic

The if statement

num = rand(10)
print "#{num}: "
if num == 7
puts "Lucky!"
elsif num <= 3
puts "A little low."
else
puts "A boring number."
end
# >> 2: A little low.

The if statement
Ruby has if/elsif/else
conditionals num = rand(10)
print "#{num}: "
if num == 7
puts "Lucky!"
elsif num <= 3
else
end

The if statement
print "#{num}: "
The code is run if the if num == 7
puts "Lucky!"
condition is true elsif num <= 3
else
end

The if statement
print "#{num}: "
The code is run if the if num == 7
puts "Lucky!"
condition is true elsif num <= 3
In Ruby, false and nil else
are false and all other end
objects are true (0, “”,
etc.)

When Things go Wrong

>> 42 / 0
ZeroDivisionError: divided by 0
from (irb):1:in `/'
from (irb):1
from :0

Ruby “raises” errors
(called Exceptions)
when things go wrong
>> 42 / 0
from (irb):1:in `/'
from (irb):1
from :0

(called Exceptions)
Error objects have a >> 42 / 0
type, message, and from (irb):1:in `/'
from (irb):1
backtrace from :0

(called Exceptions)
Error objects have a >> 42 / 0
type, message, and from (irb):1:in `/'
from (irb):1
backtrace from :0

By default, processing
stops if the error isn’t
“rescued”

Exception Handling

>> begin
>> n = 42 / 0
>> rescue ZeroDivisionError => error
>> n=0
>> end
=> 0
>> n
=> 0

Exception Handling

Put code that might
raise errors between >> begin
>> n = 42 / 0
begin … end >>
>>
rescue ZeroDivisionError => error
n=0
>> end
=> 0
>> n
=> 0

Exception Handling

Put code that might
raise errors between >> begin
>> n = 42 / 0
begin … end >>
>>
rescue ZeroDivisionError => error
n=0
>> end
Add rescue clauses =>
>>
0
n

for the error types you => 0

want to handle

Objects and Methods
In Ruby, very nearly everything is an object

Everything is an Object

>> -42.abs
=> 42
>> 3.times { puts "Howdy" }
Howdy
Howdy
Howdy
=> 3


With a few very minor
exceptions, everything >> -42.abs
=> 42
in Ruby is an Object >> 3.times { puts "Howdy" }
Howdy
Howdy
Howdy
=> 3


With a few very minor
exceptions, everything >> -42.abs
=> 42
in Ruby is an Object >> 3.times { puts "Howdy" }
Howdy
Howdy
Even a number literal is Howdy
an Object and you can => 3

call methods on it

Instance Variables
Private, per object storage

class Name
def initialize(first = nil)
self.first = first
end

def first=(first)
@first = first
end

def first
@first
end
end

Instance Variables

class Name
def initialize(first = nil)
self.first = first
end dana = Name.new("Dana")
james = Name.new
def first=(first) james.first = "James"
@first = first puts dana.first
end puts james.first
# >> Dana
def first # >> James
@first
end
end

Instance Variables

Single Inheritance
class Parent
def greet
@greeting ||= "Hello!"
end
end
class Child < Parent
def initialize
@greeting = "Yo!"
end
end
puts Parent.new.greet
puts Child.new.greet
# >> Hello!
# >> Yo!

Single Inheritance
A Class can declare class Parent
def greet
one parent @greeting ||= "Hello!"
end
end
def initialize
@greeting = "Yo!"
end
end
# >> Hello!
# >> Yo!

Single Inheritance
def greet
end
A child inherits all end
behavior from all def initialize
@greeting = "Yo!"
ancestors end
end
# >> Hello!
# >> Yo!

Single Inheritance
def greet
end
A child inherits all end
behavior from all def initialize
@greeting = "Yo!"
ancestors end
end
Ruby’s Object is the puts Parent.new.greet
highest parent for all # >> Hello!
Classes # >> Yo!

Questions and
Dangerous Methods

Questions and
Dangerous Methods
>> 0.zero?
=> true
>> 0.0.zero?
=> true
>> 0.00001.zero?
=> false

>> s = "string"
=> "string"
>> s.upcase
=> "STRING"
>> s
=> "string"
>> s.upcase!
=> "STRING"
>> s
=> "STRING"

Questions and
Dangerous Methods
Ruby has some >>
=>
0.zero?
true
method name >>
=>
0.0.zero?
true
conventions >>
=>
0.00001.zero?
false

>> s = "string"
=> "string"
>> s.upcase
=> "STRING"
>> s
=> "string"
>> s.upcase!
=> "STRING"
>> s
=> "STRING"

Questions and
Dangerous Methods
Ruby has some >>
=>
0.zero?
true
method name >>
=>
0.0.zero?
true
conventions >>
=>
0.00001.zero?
false

Question methods >>
=>
s = "string"
"string"
(answering true or >> s.upcase
=> "STRING"
false) end in ? >> s
=> "string"
>> s.upcase!
=> "STRING"
>> s
=> "STRING"

Questions and
Dangerous Methods
Ruby has some >>
=>
0.zero?
true
method name >>
=>
0.0.zero?
true
conventions >>
=>
0.00001.zero?
false

Question methods >>
=>
s = "string"
"string"
(answering true or >> s.upcase
=> "STRING"
false) end in ? >> s
=> "string"
>> s.upcase!
Dangerous methods => "STRING"
>> s
end in ! => "STRING"

“Mixins”
A uniquely Ruby way to share methods

Modules
module Netstring
def to_netstring(*args)
str = to_s(*args)
"#{str.length}:#{str},"
end
end

class String
include Netstring
end
class Integer < Numeric
include Netstring
end

p "James".to_netstring
p 42.to_netstring(2)
# >> "5:James,"
# >> "6:101010,"

Modules
module Netstring
Ruby doesn’t have str = to_s(*args)
multiple inheritance end
end

class String
include Netstring
end
class Integer < Numeric
include Netstring
end

# >> "5:James,"
# >> "6:101010,"

Modules
module Netstring
end

Instead, we can “mix” a class String
include Netstring
Module of methods end
“in”to a Class class Integer < Numeric
include Netstring
end

# >> "5:James,"
# >> "6:101010,"

Modules
module Netstring
end

Instead, we can “mix” a class String
include Netstring
Module of methods end
“in”to a Class class Integer < Numeric
include Netstring
end
We call these p "James".to_netstring
Modules “mixins” p
#
42.to_netstring(2)
>> "5:James,"
# >> "6:101010,"

Blocks and Iterators
Rubyists turn their noses up at loops

Blocks

def until_successful
loop do
break if yield == :success
end
end

until_successful {
puts "Called."
:success if rand(3).zero?
}
# >> Called.
# >> Called.
# >> Called.
# >> Called.

Blocks
In Ruby, you can pass def until_successful
a block (some code) to loop do
a called method end
end

until_successful {
puts "Called."
:success if rand(3).zero?
}
# >> Called.
# >> Called.
# >> Called.
# >> Called.

Blocks
a called method end
end

Block code is in until_successful {
puts "Called."
{ … } or do … end :success if rand(3).zero?
}
# >> Called.
# >> Called.
# >> Called.
# >> Called.

Blocks
a called method end
end

Block code is in until_successful {
puts "Called."
{ … } or do … end :success if rand(3).zero?
}
That method can run # >> Called.
# >> Called.
the passed code with # >> Called.
# >> Called.
yield

for (…; …; …) {

}

Rubyists Don’t “Loop”
We “iterate” instead

The each() Iterator

name = %w[James Edward Gray II]
name.each do |word|
puts word.reverse
end
# >> semaJ
# >> drawdE
# >> yarG
# >> II

The each() Iterator

Let Ruby manage name = %w[James Edward Gray II]
indexes for you name.each do |word|
puts word.reverse
end
# >> semaJ
# >> drawdE
# >> yarG
# >> II

The each() Iterator

Let Ruby manage name = %w[James Edward Gray II]
indexes for you name.each do |word|
puts word.reverse
end
each() will call the # >> semaJ
# >> drawdE
block once with every # >> yarG
# >> II
item of the collection

The map() Iterator

nums = *1..5
p nums
p nums.map { |n| n ** 2 }
# >> [1, 2, 3, 4, 5]
# >> [1, 4, 9, 16, 25]

The map() Iterator
map() is used to
transform your
collection
nums = *1..5
p nums
# >> [1, 2, 3, 4, 5]
# >> [1, 4, 9, 16, 25]

The map() Iterator
map() is used to
transform your
collection
nums = *1..5
Each item of the p nums
collection is passed # >> [1, 2, 3, 4, 5]
into the block and the # >> [1, 4, 9, 16, 25]

result of the block
replaces that item in a
new collection

The select() Iterator

nums = *1..10
p nums
p nums.select { |n| n % 2 == 0 }
# >> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# >> [2, 4, 6, 8, 10]


select() can be used
to ﬁlter a collection

nums = *1..10
p nums
# >> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# >> [2, 4, 6, 8, 10]


select() can be used
to ﬁlter a collection
Each item is passed nums = *1..10

into the block and if the p nums
# >> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
block conditional # >> [2, 4, 6, 8, 10]

evaluates to a true
value the item is placed
in the new collection

And Much, Much More!
I have barely scratched the surface of Ruby

Ruby is a Rich Language
Over 140 methods on String and over 70 on Array

Automatic “big math” conversions

A very capable case statement (multi-branch conditional)

Custom per object behaviors

Over 30 iterators

Over 30 iterators
Powerful reﬂection capabilities

Learning Ruby
from Ruby Lab
Your book has instructions on how to use irb to
learn more about Ruby from the language itself

Ruby

More Related Content

What's hot

Viewers also liked

Similar to Ruby

More from James Gray

Recently uploaded

Ruby