The Ruby Programming Language

Lecture Notes for CS142
Winter Quarter 2009
John Ousterhout

• Overall comments on the language:
  • Scripting language (closer to Javascript than Java)
  • Pure object oriented: absolutely everything is an object
  • Even more dynamic, flexible than Javascript (also, probably slower)
  • Kitchen sink
• Simple code example:

  sum = 0
  i = 1
  while i <= 10 do
      sum += i*i
      i = i + 1
  end
  puts "Sum of squares is #{sum}\n"
  

• Syntactic differences from Java/Javascript/C:
  • Newline terminates statements (semicolons OK too)
  • do...end instead of {...}.
  • Optional parentheses in method invocation
• Built-in datatypes:
  • Numbers:
    • Integer (Fixnum and Bignum)
    • Float
    • Complex
    • BigDecimal
    • Rational
  • Strings:
    • Single quotes
    • Double quotes
    • %q, %Q
    • Here documents: <<END ...
  • Symbols:
    • Notation: :foo
    • A string constant, more efficient in many situations
    • Typically used for unique identifiers such as variable and method names, hash keys, etc.
  • true, false, nil
  • Arrays:

    x = Array.new
    y = ["Alice", 23, 7.3]
    

    • -1 index refers to last element
  • Hashes:

    x = Hash.new
    y = {"name" => "Alice", "age" => 23}
    

  • Range: [1..20]
• Variables:
  • Like Javascript, no declarations
  • $foo: global variable
  • @foo: instance variable in an object
  • @@foo: class variable
  • MAX_USERS: constant (by convention)
  • Anything else is a local variable
• Operators and expressions: fairly similar to Java/Javascript.
• Statements:

  if x < 10 then
    ...
  elsif x < 20 
    ...
  else
    ...
  end
  
  while x < 10 do
    ...
  end
  
  array = [14, 22, 34, 46, 92]
  for value in array do
    ...
  end
  

  • No Java-like for loop
  • for works for any object with an each iterator method
• Iterators, blocks, and yield:
  • Ruby makes it possible to define new control structures, especially iterators.
  • Example:

    [1, 2, 3, 4].each do |x|
      print x + "\n"
    end
    

  • each is a method implemented by the Array class; it iterates over the elements of its array.
  • do ... end is a block: a chunk of code passed to the each method and invoked for each element of the array.
  • Blocks usually have arguments: x
  • Defining an iterator:

    def oddNumbers(count)
      number = 1
      while count > 0 do
        yield(number)
        number += 2
        count -= 1
      end
    end
    
    oddNumbers(5) do |i|
      print(i, "\n")
    end
    

  • yield invokes the block passed to the method.
  • A block is a closure: it has access to all variables visible at the point of its declaration
• Methods:
  • Factorial example:

    def fac(x)
      if x <= 0 then
        return 1
      end
      return x*fac(x-1)
    end
    

  • Every method is associated with an object (default: private method of Object class).
  • Methods always return values:
    • Result of last expression
    • Default: nil.
  • Optional parentheses in method invocation (can be confusing)

    puts "Hello world"
    f (3+2)+1
    

  • Default values for arguments:

    def inc(value, amount=1)
        value+amount
    end
    

  • Variable-length argument lists:

    def max(first, *rest)
      max = first
      rest.each do |x|
        if (x > max) then
            max = x
        end
      end
      return max
    end
    

  • Name-value arguments: use a hash.
  • Can omit curly braces to supply value for last argument:

    def create_widget(size, properties)
        ...
    end
    
    create_widget(6, {:name => "Alice", :age => 31})
    create_widget(6, :name => "Alice", :age => 31)
    

  • Blocks:
    • Any method can be passed a block.
    • Blocks are anonymous.
• Classes:
  • Example:

    class Point
      def initialize(x, y)
        @x = x
        @y = y
      end
      
      def x
        @x
      end
      
      def x=(value)
        @x = value
      end
    end
    
    p = Point.new(3,4)
    p.x => 3
    p.x = 44;
    

  • initialize method called during object construction
  • No direct access to instance variables: instead, define methods foo and foo=.
  • Methods can be public, protected, or private.
  • Inheritance: class Child < Parent
  • Duck typing like Javascript
• Module: a group of methods that can be shared by many classes;
  • Similar to multiple inheritance or mixins.
  • Like the implementation of a Java interface.
  • Example: Enumerable
    • Your class implements each method.
    • Mix in the Enumerable module to get many additional methods.

      class MyClass
        include Enumerable
        ...
        def each
          ...
        end
      end
      

    • Example Enumerable methods:
      • sort
      • map: create a new collection by applying a block to each element
      • select: create a new collection of elements that meet certain criteria
      • min, max
• Metaprogramming: programs that help you write programs
  • Reflection: like Java and Javascript, can examine the state and structure of a Ruby program while it is running.
  • eval: can create new programs on-the-fly and execute them.
  • Can define new classes, methods, and modules on-the-fly.
  • method_missing: can catch invocations of undefined methods:
    • Define new methods "just-in-time" when referenced.
    • Simulate the existence of a large variety of methods.
  • And much more... facilities for domain specific languages, etc.