ruby object model
TRANSCRIPT
Ruby Object Model
Chhorn ChamnapYoolk Mango4 Aug 2010
Agenda
Basic Ruby Methods Classes Method-Access Rules What’s in an Object? Classes in Depth What Happens When You Call a Method? Module Constants Self Scope Singleton Method
Basic Ruby
Variables
Local variables start with a lowercase letter or an underscore
Eg: x, string, __abc__, start_value, and firstName
Ruby convention is to use underscores with multiple words (first_name)
can't start with an uppercase letter Instance variables
storing information for individual objects always start with a single at-sign(@) can start with an uppercase letter
Variables (cont.)
Class variables store information per class hierarchy follow the same rules as instance
variables start with two at-signs: @@running_total
Global variables recognizable by their leading dollar sign
($) $:, $1, and $/, $stdin and $LOAD_PATH
Keywords
predefined, reserved terms associated with specific programming tasks and contexts. def, class, if, and __FILE__
Things look like local variables
Ruby interprets it as one of three things: A local variable A keyword A method call
Here’s how Ruby decides:1. If the identifier is a keyword, it’s a keyword.2. If there’s an equal sign (=) to the right of the
identifier, it’s a local variable.3. Otherwise, assumed to be a method call.
Interpreter command-line switches
“Load”-ing a file
When you load a file, Ruby looks for it in each of its load path.
The last directory is the current directory. load is a method. Load file from relative directories
load "../extras.rb" load "/home/users/dblack/book/code/loadee.rb"
A call to load always loads the file you ask for. Good to examine the effect of changes
immediately.
“Require”-ing a feature
Doesn’t reload files if already loaded. require "loadee" require "/home/users/code/loadee"
Methods
Method names
Follow the same rules and conventions as local variables except, can end with ?, !, or =
Methods are expressions that provide a value.
In some contexts, you can’t tell, just by looking at an expression.
Method calls
Ruby sees all data structures and values as objects. x = "100".to_i(9)
Methods can take arguments. Parentheses are usually optional.
Many programmers use parentheses in most or all method calls, just to be safe.
Method arguments
Have to supply the correct number of arguments.
Optional arguments
A method that allows any number of arguments.
def multi_args(*x)puts "I can take zero or more arguments!"
end
multi_args(1,2,4)multi_args(1,2)
Default values for arguments
def default_args(a,b,c=1)puts "Values of variables: ",a,b,c
end
default_args(3,2)
Order of parameters and arguments
Ruby tries to assign values to as many variables as possible.
The sponge parameters get the lowest priority.
Order of parameters and arguments (cont.)
Order of parameters and arguments (cont.)
Required ones get priority, whether they occur at the left or at the right of the list.
All the optional ones have to occur in the middle.
def broken_args(x,*y,z=1)end
syntax error
Method signatures
Classes
Objects and Classes
Classes define clusters of behavior or functionality.
Classes can respond to messages, just like objects.
Objects can change, acquiring methods and behaviors that were not defined in their class.
Classes
In Ruby, classes are objects. The new method is a constructor. Classes are named with constants.
Inside Class Definitions
Ruby executed the code within the class just as it would execute any other code.
Reopening classes
It’s possible to reopen a class and make additions or changes.
Instance methods
These methods defined inside a class.
Used by all instances of the class. They don’t belong only to one object.
Instance variables
Enables individual objects to remember state.
Always start with @. Visible only to the object to which
they belong. Initialized in one method definition is
the same as in other method definitions.
Instance variables (cont.)
Initializing an object with state
Define a special method called initialize.
Setter methods
Ruby allows you to define methods that end with an equal sign (=).
ticket.price=(63.00)ticket.price = 63.00
def price=(amount) @price = amountend
The attr_* methods
The attributes are implemented as reader and/or writer methods.
The attr_* methods (cont.)
Inheritance
Ruby supports only single inheritance.
Classes can import modules as mixins.
The class Object is almost at the top of the inheritance chart.
Method-Access Rules
Private methods
• PRIVATE METHODS CAN’T BE CALLED WITH AN EXPLICIT RECEIVER.
class Baker def bake_cake pour_flour add_egg end def pour_flour end def add_egg end private:
pour_flour, :add_eggend
class Baker def bake_cake pour_flour add_egg endprivate: def pour_flour end def add_egg endend
Private setter (=) methods
It’s OK to use an explicit receiver for private setter methods.
Protected methods
Top-level method
The top-level method is stored as a private instance method of the Object class.
What’s in an Object?
What’s in an Object?
Every object is “born” with certain innate abilities. object_id respond_to? send methods instance_variables
Object Model Diagram
The send method
Not uncommon to define a method called send. Then, use __send__ instead.
public_send, a safe version of send method.
send can call an object’s private methods public_send can’t.
Classes in Depth
Classes as objects
Every class is an instance of a class called Class.
You can also create a class the same way you create most other objects.my_class = Class.newinstance_of_my_class = my_class.new
Object Model Diagram (cont.)
Object Model Diagram (cont.)
The chicken-and-egg paradox
The class Class is an instance of itself.
Object is a class, Object is an object. And Class is a class. And Object is a
class, and Class is an object. Which came first?
Ruby has to do some of this chicken-or-egg stuff in order to get the class and object system up and running.
Class and object Roundup
Classes are objects. Instances of classes are objects, too. A class object has its own methods,
its own state, its own identity.
What Happens When You Call a Method?
What Happens When You Call a Method?
When you call a method, Ruby does two things: It finds the method (method lookup). It executes the method. (find self).
Method Lookup
“one step to the right, then up.”
How objects call their methods?
How objects call their methods? From their class From the superclass and earlier ancestors of
their class From their own store of singleton methods
Instances of Class can call methods that are defined as instance methods in their class. Class defines an instance method called new.Ticket.new
How objects call their methods? (cont.)
The class Class has two new methods as: a class method; Class.new an instance method; Ticket.new
Instances of Class have access to the instance methods defined in Module.class Ticket attr_reader :venue, :date attr_accessor :price
Module
Module
Modules are bundles of methods and constants.
Modules don’t have instances. Consists of the functionality to be
added to a class or an object. Modules encourage modular design. Modules are the more basic
structure, and classes are just a specialization.
Module (cont.)
Modules get mixed in to classes, using the include method, referred to as mix-ins.
The instances of the class have the ability to call the instance methods defined in the module.
A class can mix in more than one module.
Method Lookup
The rules of method lookup
To resolve a message into a method: Its class Modules mixed into its class The class’s superclass Modules mixed into the superclass Likewise, up to Object (and its mix-in
Kernel) and BasicObject
Defining the same method more than once
Define a method twice inside the same class, the second definition takes precedence.class D def hello puts “hello” endend
class D def hello puts “hello world” endend
Defining the same method more than once (cont.)
If the object’s method-lookup path includes more than two same methods, the first one is the “winner”.
Defining the same method more than once (cont.)
A class mixes in two or more modules. The modules are searched in reverse
order of inclusion
Including the same module more than once
Re-including a module doesn’t do anything.
N is still considered the most recently included module.
class C include M include N include Mend
The super keyword
Use the super keyword to jump up to the next-highest definition, in the method-lookup path.
The super keyword (cont.)
The way super handles arguments: Called with no argument list – super Called with an empty argument list – super() Called with specific arguments – super(a,b,c)
The method_missing method The Kernel module provides an instance method
called method_missing.
Nesting modules and classes
Nested module/class chains are used to create namespaces for classes, modules, and methods.module Tools class Hammer endEnd
h = Tools::Hammer.new
Constants
Constants
Begin with an uppercase letter.eg: A, String, FirstName, and STDIN
(FirstName) or (FIRST_NAME) is usual.
Can be referred to from inside the instance or class methods.
Modifying constants
You get a warning if you reassign to the constant.
To modify a constant, use a variable instead.
not redefining a constant, good for reloading program files
Scope of constants
Constants have a kind of global visibility or reachability.
Bears a close resemblance to searching a filesystem.
Scope of constants (cont.)
Like /, the :: means “start from the top level.”
Self
Self
At every moment, only one object is playing the role of self.
Self is the default object or current object.
To know which object is self, you need to know what context you’re in.
Self (cont.)
The top-level self object
But what is self when you haven’t yet entered any definition block? The answer is that Ruby provides you
with a start-up self at the top level.
main is a special term that the default self object.
The keyword (class, module, or def) marks a switch to a new self.
ruby -e 'puts self'
Self in class and module definitions
In a class or module definition, self is the class or module object.
Self in instance method definitions
In a method definition, self is the object that called it.
Self in singleton method definitions
When a singleton method is executed, self is the object that owns the method.
Self as the default receiver of messages
If the receiver of the message is self, you can omit the receiver and the dot.
Self as the default receiver of messages (cont.)
If both a method and a variable of a given name exist (talk), the variable takes precedence. To force Ruby to see as a method name,
you’d have to use self.talk or talk(). To call a setter method, have to
supply object-dot-notation.self.first_name = “dara”first_name = “dara”
Instance variables
Every instance variable belongs to self.
Scope
Scope
Scope refers to the reach or visibility of variables and constants.
Three types of variables: global, local, and class variables.
Global scope
Global scope is scope that covers the entire program.
Global scope is enjoyed by global variables.
Local scope
Local scope is a basic layer of every Ruby program.
Every time you cross into a class, module, or def keyword, you start a new local scope. The top level has its own local scope. Every class or module definition block has
its own local scope. Every method definition has its own local
scope.
Local scope (cont.)
Class variables
Provides a storage mechanism shared between a class and its instances.
Visible only to a class and its instances.
Class variables (cont.)
They’re class-hierarchy variables.
Singleton method
Singleton method
Let’s say we’ve created our Ticket class. Ticket isn’t only a class. Ticket is also an object in its own right.
defined directly on the class object Ticket.
referred to as a class method of the class.
More about singleton methods
Where do singleton methods live? The singleton class
Every object has two classes: The class of which it’s an instance Its singleton class
More about singleton methods (cont.)
Singleton classes are anonymous. The << object notation means the
anonymous, singleton class of object.
More about singleton methods (cont.)
Singleton classes on the method-lookup path
References
The Well-Grounded Rubyist, David A. Black
Metaprogramming Ruby, Paolo Perrotta