Learn to Program(3)

Learn to Program(3)

9. Classes
Objects in Ruby are always capitalized. String, Integer, Float, Array...
a = Array.new([1,3,3])
b = String.new('carl')
c = Time.new

puts a.to_s
puts b.to_s
puts c.to_s

results are :
[1, 3, 3]
carl
2011-08-10 16:39:01 +0800

9.1 The Time Class
time = Time.new
time2 = time + 60 # one minute later
puts time
puts time2

puts Time.mktime(1982,4,5)
puts Time.mktime(1982,4,5,23,50,59)

9.2 The Hash Class
Hashes are a lot like arrays. It is just like the Map class in Java.

colorArray = []
colorHash  = {}

colorArray[0] = 'red'
colorArray[1] = 'green'
colorHash['strings'] = 'red'
colorHash['numbers'] = 'green'
colorHash['keywords']= 'blue'

colorArray.each do |color|
  puts color
end
colorHash.each do |codeType,color|
  puts codeType + ": " + color
end

9.3 Extending Classes
It seems a miracle to extends the class here.
class Integer
  def to_eng
    if self == 5
      english = 'five'
    end
    if self == 6
      english = 'six'
    end
    english
  end
end

puts 5.to_eng
puts 6.to_eng

9.4 Creating Classes
class Die
  def roll
    1 + rand(6)
  end
end
dice = [Die.new,Die.new,Die.new]
dice.each do |die|
  puts die.roll
end

9.5 Instance Variables
An instance of a class is just an object of that class. So instance variables are just an object's variables.To tell instance variables from
local variables, they have @ in front of their names:
class Die
  def roll
    @number = 1 + rand(6)
  end
  def show
    @number
  end
end

die = Die.new
die.roll
puts die.show
die.roll
puts die.show

We can initial the class first.
class Die
def initialize
  roll
end
...snip...
end

When an object is created, its initialize method (if it has one defined) is always called.

10. Blocks and Procs
It is the ability to take a block of code (code in between do and end), wrap it up in an object (called a proc), store it in a variable or pass it to a method, and run the code in the block whenever you feel like.

toast = Proc.new do
  puts 'Cheers!'
end
toast.call
toast.call

Proc which is supposed to be short for 'procedure'. It rhymes with 'block'.
It is even more like a method, because blocks can take parameters.

doyoulike = Proc.new do |goodthing|
  puts 'I really like ' + goodthing + '!'
end
doyoulike.call 'chocolate'

In particular, you can't pass methods into other methods, but you can pass procs into methods.
Methods can't return other methods, but they can return procs.

The root reason is procs are objects, methods are not.

10.1 Methods Which Take Procs
def doSelfImportantly someProc
  puts 'Everybody just HOLD ON!  I have something to do...'
  someProc.call
  puts 'Ok everyone, I\'m done.  Go on with what you were doing.'
end

sayHello = Proc.new do
  puts 'hello'
end

sayGoodbye = Proc.new do
  puts 'goodbye'
end

doSelfImportantly sayHello
doSelfImportantly sayGoodbye

Complex example.

def doUntilFalse firstInput, someProc
  input  = firstInput
  output = firstInput
 
  while output
    input  = output
    output = someProc.call input
  end
 
  input
end

buildArrayOfSquares = Proc.new do |array|
  lastNumber = array.last
  if lastNumber <= 0
    false
  else
    array.pop                         #  Take off the last number...
    array.push lastNumber*lastNumber  #  ...and replace it with its square...
    array.push lastNumber-1           #  ...followed by the next smaller number.
  end
end

alwaysFalse = Proc.new do |justIgnoreMe|
  false
end

puts doUntilFalse([5], buildArrayOfSquares).inspect
puts doUntilFalse('I\'m writing this at 3:00 am; someone knock me out!', alwaysFalse)

The inspect method is a lot like to_s.

10.2 Methods Which Return Procs
def compose proc1, proc2
  Proc.new do |x|
    proc2.call(proc1.call(x))
  end
end

squareIt = Proc.new do |x|
  x * x
end

doubleIt = Proc.new do |x|
  x + x
end

doubleThenSquare = compose doubleIt, squareIt
squareThenDouble = compose squareIt, doubleIt

puts doubleThenSquare.call(5)
puts squareThenDouble.call(5)

Make 2 procs to 1 proc and return proc in the method.

10.3 Passing Blocks (Not Procs) Into Methods
class Array
  def eachEven(&wasABlock_nowAProc)
    isEven = true  #  We start with "true" because arrays start with 0, which is even.
    self.each do |object|
      if isEven
        wasABlock_nowAProc.call object
      end
      isEven = (not isEven)  #  Toggle from even to odd, or odd to even.
    end
  end
end
['apple', 'bad apple', 'cherry', 'durian'].eachEven do |fruit|
  puts 'Yum!  I just love '+fruit+' pies, don\'t you?'
end
#  Remember, we are getting the even-numbered elements
#  of the array, all of which happen to be odd numbers,
#  just because I like to cause problems like that.
[1, 2, 3, 4, 5].eachEven do |oddBall|
  puts oddBall.to_s+' is NOT an even number!'
end

&name, bring block to the methods. Another example.

def profile descriptionOfBlock, &block
  startTime = Time.now
  block.call
  duration = Time.now - startTime
  puts descriptionOfBlock+':  '+duration.to_s+' seconds'
end

profile '25000 doublings' do
  number = 1
  25000.times do
    number = number + number
  end
  puts number.to_s.length.to_s+' digits'  #  That is, the number of digits in this HUGE number.
end

profile 'count to a million' do
  number = 0
  1000000.times do
    number = number + 1
  end
end

results are as follow:
7526 digits
25000 doublings:  0.1092 seconds
count to a million:  0.124801 seconds

references:
http://pine.fm/LearnToProgram/?Chapter=09