addition = lambda {|a, b| return a + b }s

puts addition.call(5, 6)

BEGIN {
   code
}

Declares code to be called before the program is run.

END {
   code
}

Declares code to be called at the end of the program.

Variables in a Ruby Class:

Ruby provides four types of variables:

• Local Variables: Local variables are the variables that are defined in a method. Local variables are not available outside the method. You will see more detail about method in subsequent chapter. Local variables begin with a lowercase letter or _.

• Instance Variables: Instance variables are available across methods for any particular instance or object. That means that instance variables change from object to object. Instance variables are preceded by the at sign (@) followed by the variable name.

• Class Variables: Class variables are available across different objects. A class variable belongs to the class and is a characteristic of a class. They are preceded by the sign @@ and are followed by the variable name.

• Global Variables: Class variables are not available across classes. If you want to have a single variable, which is available across classes, you need to define a global variable. The global variables are always preceded by the dollar sign ($).

class Customer
   @@no_of_customers=0
   def initialize(id, name, addr)
      @cust_id=id
      @cust_name=name
      @cust_addr=addr
   end
end

• self: The receiver object of the current method.

• true: Value representing true.

• false: Value representing false.

• nil: Value representing undefined.

• __FILE__: The name of the current source file.

• __LINE__: The current line number in the source file.

Array

ary = [  "fred", 10, 3.14, "This is a string", "last element", ]
ary.each do |i|
   puts i
end

Hash

hsh = colors = { "red" => 0xf00, "green" => 0x0f0, "blue" => 0x00f }
hsh.each do |key, value|
   print key, " is ", value, "\n"
end

books["Gra­vity's Rainb­ow"] = :sple­ndid
=> :splendid

Range

More comparisons

defined? is a special operator that takes the form of a method call to determine whether or not the passed expression is defined. It returns a description string of the expression, or nil if the expression isn't defined.

foo = 42
defined? foo    # => "local-variable"
defined? $_     # => "global-variable"
defined? bar    # => nil
defined? puts        # => "method"
defined? puts(bar)   # => nil   (bar is not defined here)
defined? unpack      # => nil 

Module

case/when

 
case expr0
when expr1, expr2
   stmt1
when expr3, expr4
   stmt2
else
   stmt3
end
is basically similar to the following:
_tmp = expr0
if expr1 === _tmp || expr2 === _tmp
   stmt1
elsif expr3 === _tmp || expr4 === _tmp
   stmt2
else
   stmt3
end
 
$age =  5
case $age
when 0 .. 2
    puts "baby"
when 3 .. 6
    puts "little child"
when 7 .. 12
    puts "child"
when 13 .. 18
    puts "youth"
else
    puts "adult"
end

Loop

Methods

Yield

Yield: block calling like method calling or method pass as parameter
def test
   yield 5
   puts "You are in the method test"
   yield 100
end
test {|i| puts "You are in the block #{i}"}

names = Array.new(20)

#!/usr/bin/ruby

digits = Array(0..9)

num = digits.at(6)

puts "#{num}"

This will produce following result:

Following are the public array methods ( Assuming array is an array object ):

months = Hash.new

The collect iterator returns all the elements of a collection.

a = [1,2,3,4,5]
b = Array.new
b = a.collect
puts b

a = [1,2,3,4,5]
b = a.collect{|x| 10*x}
puts b

Exception

begin  
# -  
rescue OneTypeOfException  
# -  
rescue AnotherTypeOfException  
# -  
else  
# Other exceptions
ensure
# Always will be executed
end

raise 

OR

raise "Error Message" 

OR

raise ExceptionType, "Error Message"

OR

raise ExceptionType, "Error Message" condition