The difference between a single quote literal and a double quote literal is how much Ruby processes it when it gets created.

A double quote literal looks for substitutes for an escape sequence and # (…) constructs.

The value returned by Ruby method is the value of the last expression evaluated, so don’t need a return.

Ruby conventions:

A variable starts with a lower case ==> local variable

A variable or name starts with an upper case ==> class name, module name, or constant variable

A variable starts with $ ==> global variable

A variable starts with @ ==> instance variable

A variable starts with @@ ==> class variable

Arrays and Hashes

Both are index collections and can take any mixed type of objects. The only difference between them is arrays’ indexes must be integer whereas hashes indexes can be any kind of objects.

array = Array.new

array = []

array = [1, 'K', 'It's a string', 3.14]

array = %w[cat dog apple]

hash = Hash.new

hash = Hash.new(0)

hash = {0 => ‘cat’, ‘dog’ => ‘bark’, 9 => -9}

Control Structures

Statement modifiers

puts “Ich liebe dich” if myLove == herLove

puts “love me only” while myAge < 1000

Regular Expression

As you expect, regular expressions are objects in Ruby. The match operator =~ returns the position it first found or nil if not found.

individuated s yy:mm:dd 1P(erllython)l e Perl or Python

‘Ruby of *Peril x Ruby and zero or one move character and Perl

(Ruby 1st Perl/ 4 Ruby and one or move white space and Perl

if line =~ (perl python

puts ” You got me.”

end

pos = sub (lperll, ‘ruby’) H replace first perl with ruby

pos = grubs (Python.’ Ruby) * replace every Python with Ruby

Blocks and Iterators

Code blocks are chunks of code that you can associate with method invocations. Chunks of code are between braces or ‘do … end’. Once you’ve created a block, you can associate it with a call to a method. You might be better off thinking of the block and the method as coroutines, which transfer control back and forth between themselves.

Reading and ‘Riting

The gets routine has a side effect; as well as returning the last line read, it also stores the last line into the global variable $_.

while gets

if /Ruby/

print

end

end

ARGF represents a stream input.

ARGF.each { |line| print line unless line =~ /ruby/ }

Classes, Objects, and Variables

class – how to declare, define, create,

To create a new class object, invoke the new method of the class. Song.new calls the class’ initialize method to set up the class’ internal state.

class Song

def initialize(name, artist, duration)

@name = name

@artist = artist

@duration = duration

end

end

aSong = Song.new(‘Let it be’, ‘The Beatles’, 310)

The inspect message dumps a object’s id and instance variables. While the message’s default formatting leaves something to be desired, the to_s message can be overridden.

Inheritance and Messages

Inheritance allows you to create a class that is a refinement or specialization of another class. The less than character(<) lets you inherit from another class. Make sure that you override the initialize method and the to_s method properly. You may not want a subclass directly to access the instance variables of its super class to set up because it couples between them; that’s a bad programming style. Rather, use super in the subclass for decoupling.

Inheritance and Mixins

Multiple inheritance can be dangerous since the inheritance hierarchy can become ambiguous. In real life, however, things often inherit attributes from multiple sources. A Ruby class can only have a single direct parent, but Ruby has a technique called Mixins to provide a multiple-inheritance-like functionality.

Objects and Attributes

An object is solely responsible for maintaining its own consistency. Ruby provides a convenient way of creating getters and setters.

class Song

attr_reader :name, :artist, :duration

attr_writer :name, :artist, :duration

end

Virtual Attributes

Use attribute methods to create a virtual instance variable that seems like a real instance variable to outside of the world.

class Song

def durationInMinute

@duratoin / 60.0

end

def durationInMinute=(value)

@duration = (value * 60).to_i

end

end

The setter here is like an operator overloading in C++. Type casting is different from C-like languages. Ruby deals everything as an object, even a number, so Ruby provides the to_i method for type casting.

In his landmark book Object-Oriented Software Construction , Bertrand Meyer calls this the Uniform Access Principle. By hiding the difference between instance variables and calculated values, you are shielding the rest of the world from the implementation of your class. You’re free to change how things work in the future without impacting the millions of lines of code that use your class. This is a big win.

Class Variables and Class Methods

class Song

@@plays = 0 # a class variable

MaxPlays = 50 # a class constant variable

def Song.initPlays

@@plays = 0

end

end

For class variables, by convention, Ruby puts @@ in front of a class variable name.

Singletons and Other Constructors

A singleton is an object that is singly created from a class.

class Logger

private_class_method = new

@@logger = nil

def Logger.create

@@logger = new unless @@logger

@@logger

end

end

The Logger class can not be created by the conventional way using the new method. Also class methods can be used as pseudo-constructors.

Access Control

• Public methods can be called by anyone—there is no access control. Methods are public by default (except for initialize, which is always private).
  
• Protected methods can be invoked only by objects of the defining class and its subclasses. Access is kept within the family.
  
• Private methods cannot be called with an explicit receiver. Because you cannot specify an object when using them, private methods can be called only in the defining class and by direct descendents within that same object.
  

   
   

  What does it mean by direct descendents?
  

  If a method is protected, it may be called by any instance of the defining class or its subclasses. If a method is private, it may be called only within the context of the calling object—it is never possible to access another object’s private methods directly, even if the object is of the same class as the caller.
  

   
   

  Access control is determined dynamically, as the program runs, not statically.
  

調和, 均衡

조화와 균형

논어