Skip to content

Overview of Ruby

Everything Is An Object

In Ruby everything is an object. From the IRB shell lets run a couple of examples.

irb(main):001:0> 1.odd?
=> true

Notice the output is true. We are able to call methods on the literal 1.

irb(main):002:0> 1.even?
=> false

We can also call methods on strings literals as follows :

irb(main):003:0> "Hello World".reverse
=> "dlroW olleH"

and we can also find the length of the string :

irb(main):004:0> "Hello World".length
=> 11


Comments in Ruby can be single line or multiple line :

  • Single line comments start with a # symbol.
  • Multiple line comments use =begin and =end

Single line comment

Anything after the # is ignored.

# This is an example of a comment
puts "Hello World" # This comment come after a line of code

Multiple line comments

This is an example
of a multiple line comment.
These type of comments are rare

Blocks and Iterators

Iterators are methods that act as loop constructs in Ruby. Blocks are pieces of code without names. When working with Ruby you will encounter blocks and iterators, let see some examples.

irb(main):005:0> 1.upto(5)
=> #<Enumerator: 1:upto(5)>

The upto is an iterator. We can use to count up to the value in brackets. We can can combine the upto iterator with a block as follows :

each iterator

The each iterator is used to iterate through a collection.

Define an array

a = [1,2]
=> [1, 2]

Get an iterator

irb(main):016:0> a.each
=> #<Enumerator: [1, 2]:each>
=> #<Enumerator: [1, 2]:map>


We can use Blocks in combination with iterators. The blocks are either single line or multiple line.

Single line blocks

Single line blocks start with { and end with } e.g { puts "Hello World" } is a single line block.

Multiple line blocks

Multiple line block start with a do and finish with and end keyword, e.g

    puts "Hello World"

With a single line block :

1.upto(2) { puts "Hello" }
=> 1

With a multi-line line block

1.upto(2) do
    p "Hello World"

We can also generate an iterator from a range and use a block on it as follows :

irb(main):033:0> (1..2).each { p "Hello World" }
"Hello World"
"Hello World"
=> 1..2

Passing arguments to blocks

We can pass arguments to blocs using the || symbols after the first { bracket as follows :

(1..3).each {|value| p "Hello World #{value}" }

Running this in IRB :

irb(main):034:0> (1..3).each {|value| p "Hello World #{value}" }
"Hello World 1"
"Hello World 2"
"Hello World 3"
=> 1..3

The #{} is string interpolation in Ruby. In this case the value for index will be concatenated with the rest of the string.

We can also use the arguments using the multi-line line block syntax as well. The || will come after the do statement as follows :

(1..3).each do |value|
    p "Hello #{value}"

With IRB :

irb(main):035:0> (1..3).each do |index|
irb(main):036:1* p "Hello #{index}"
irb(main):037:1> end
"Hello 1"
"Hello 2"
"Hello 3"
=> 1..3

We can get the powers of numbers between 1 and 10 using arguments passed within an iterator as follows :

(1..10).map { |i| 2 ** i }

In IRB we get the following :

irb(main):038:0> (1..10).map { |i| 2 ** i }
=> [2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]

The ** is the mathematical power operator.

Read a file line by line using block and iterators

We can also take advantage of the each iterator and use a block to output the contents of a text file as follows :

File.readlines("pgadmin.log").each { |line| p line }

The file pgadmin.log should be in your current directory you are tunning IRB from.


Modules are used to define a namespace. This creates a sandbox that groups together methods, classes and constants. They are also included to extended class behavior.

Create a module

We use the module keyword to create a module as follows

module Greeter
    def greet
        puts "Hello World"

Include the module in a class

We can now add functionality to a class using the module as follows :

class Person
    include Greeter

using the include keyword, we can now include all the functionality provided by the module into the class. Now the Person class can now greet.

Instantiate a new Person object

We can now call greet method after creating a new Person object

p =

If we run from within IRB, we get the Hello World as below :

p =
=> #<Person:0x007ffc4d9ff730>
irb(main):013:0> p.greet
Hello World

Duck Typing

In Ruby, objects are defined by what they can do. The type of an object is defined by its methods and attributes. Objects are not defined by their type. If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck.

We use the responds_to? method to check what methods the object responds to as follows :

irb(main):019:0> (1..5).respond_to? :each
=> true

We can see the the (1..5) can respond to the each method, therefore we can call each on the object.