Programming Intro

An introduction to Programming in Ruby using irb

Getting started

irb is the Interactive RuBy shell. You can type Ruby code and it will be evaluated immediately. You can try some code that will seem familiar:

1 + 1
try a few different calculations
now try this one

"c" + "ode"
why was this different? in Ruby everything is an object and each object has behaviors it knows how to do. Numbers know how to add. However "c" is not a number, so it behaves differently even when it gets the same message (+). Programmers call "c" or "ode" a "string." A string is series of letters that could be a word or a sentence. In Ruby the string behavior triggered by the (+) message is concatenation.
Operators like + - * / are special since we want to use them like we did in grade school.
Most messages (which are also called methods) are called by adding the message name after a .

"code".upcase "code".reverse
Another thing to notice about Ruby is that everything evaluates to something

4 4 + 4 (4+4).zero?
Notice how parentheses can change behavior. Parentheses cause the stuff inside to be evaluated first, otherwise the '.' has the highest precedence. Remember "Please Excuse My Dear Aunt Sally?" The same rules apply, with . at the beginning.

"c" + "ode".upcase ("c" + "ode").upcase

Variables

Variables can hold a value >> a = 4 >> a >> b = 2 >> a + b In Ruby (unlike languages like C or Java), variables can be of any type and can change type >> a = "cat" But types do matter. For example, this is an error: >> "cat" + 4 TypeError: can't convert Fixnum into String from (irb):4:in `+' from (irb):4 But this works: >> "cat" + 4.to_s Variables are useful when you start writing reusable code.

Defining Classes and Methods

We define a new type of object by writing something called a "class." The behavior of the object is defined in blocks of code we call "methods."

As an example we'll create a Calculator kind of object that knows how to describe itself in text. At first, that is all it will know how to do.

class Calculator    
  def describe
   "I am a really neat calculator!"
  end   
end

save this in a file in your text editor called "calculator.rb" then start irb in the same directory

>> load "calculator.rb"
>> c = Calculator.new
>> c.describe

next we'll add a method that performs a calculation

def add(a, b)
  a + b
end

then restart irb and try it:

>> load "calculator.rb"
>> c = Calculator.new
>> c.add(1,2)
>> c.add(56,45)

The same code can be reused with different inputs

Now, why might we have a calculator object when Ruby can already do built in calculations. Suppose we wanted to keep track of when we did different calculations, how many each calculator had done. We might have two calculators and have each store the number of calculations it had performed. Each object can actually keep its own data with it, even though the code that defines each object is identical. We call each object an "instance" of the class and so we call this object data and "instance variable"

class Calculator
  def initialize
    @num_calculations = 0
  end
  def how_many
    @num_calculations
  end
  def describe
    "I am a really neat calculator!"
  end
  def add(a, b)
    @num_calculations = @num_calculations + 1
    a + b
  end
end

Arrays

>> my_fruits = ["kiwi", "strawberry", "plum"]
=> ["kiwi", "strawberry", "plum"]
>> my_fruits = my_fruits + ["lychee"]
=> ["kiwi", "strawberry", "plum", "lychee"]
>> my_fruits = my_fruits - ["lychee"]
=> ["kiwi", "strawberry", "plum"]

Hashes

>> states = {"CA" => "California", "DE" => "Delaware"}
=> {"DE"=>"Delaware", "CA"=>"California"}
>> states["DE"]
=> "Delaware"

Repeating yourself

>> puts fruits[0]
kiwi
=> nil
>> puts fruits[1]
strawberry
=> nil
>> puts fruits[2]
plum
=> nil

Easier to write this: >> fruits.each do |f| * puts f >> end kiwi strawberry plum

(Omit asterisk before 'puts f' and code below, it denotes start of new line and not part of the code)

Conditions

if true puts "you will see this" end

if false puts "you won't see this" end

puts "you will see this" if true

Truth

Everything is true except for

false
nil

Therefore

0 is true
"" is true

Equality

Testing for equality is different from setting equality:

a = 4 puts "four" if a == 4

Another example:

>> fruits.each do |f|
*   puts f if f == "plum"
>> end
plum

Other Pages