Ruby object model

  • 4,952 views
Uploaded on

 

More in: Technology
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
No Downloads

Views

Total Views
4,952
On Slideshare
0
From Embeds
0
Number of Embeds
25

Actions

Shares
Downloads
126
Comments
0
Likes
11

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. Chhorn Chamnap Yoolk Mango 4 Aug 2010
  • 2.  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
  • 3.  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
  • 4.  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
  • 5.  predefined, reserved terms associated with specific programming tasks and contexts.  def,  class,  if, and  __FILE__
  • 6.  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.
  • 7.  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.
  • 8.  Doesn’t reload files if already loaded.  require "loadee"  require "/home/users/code/loadee"
  • 9.  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.
  • 10.  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.
  • 11.  Have to supply the correct number of arguments.
  • 12.  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)
  • 13. def default_args(a,b,c=1) puts "Values of variables: ",a,b,c end default_args(3,2)
  • 14.  Ruby tries to assign values to as many variables as possible.  The sponge parameters get the lowest priority.
  • 15.  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) syntax error end
  • 16.  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.
  • 17.  In Ruby, classes are objects.  The new method is a constructor.  Classes are named with constants.
  • 18.  Ruby executed the code within the class just as it would execute any other code.
  • 19.  It’s possible to reopen a class and make additions or changes.
  • 20.  These methods defined inside a class.  Used by all instances of the class.  They don’t belong only to one object.
  • 21.  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.
  • 22.  Define a special method called initialize.
  • 23.  Ruby allows you to define methods that end with an equal sign (=). def price=(amount) ticket.price=(63.00) @price = amount ticket.price = 63.00 end
  • 24.  The attributes are implemented as reader and/or writer methods.
  • 25.  Ruby supports only single inheritance.  Classes can import modules as mixins.  The class Object is almost at the top of the inheritance chart.
  • 26. • Private methods can’t be called with an explicit receiver. class Baker class Baker def bake_cake def bake_cake pour_flour pour_flour add_egg add_egg end end def pour_flour private end def pour_flour def add_egg end end def add_egg private: pour_flour, end :add_egg end end
  • 27.  It’s OK to use an explicit receiver for private setter methods.
  • 28.  The top-level method is stored as a private instance method of the Object class.
  • 29.  Every object is “born” with certain innate abilities.  object_id  respond_to?  send  methods  instance_variables
  • 30.  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.
  • 31.  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.new instance_of_my_class = my_class.new
  • 32.  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.
  • 33.  Classes are objects.  Instances of classes are objects, too.  A class object has its own methods, its own state, its own identity.
  • 34.  When you call a method, Ruby does two things:  It finds the method (method lookup).  It executes the method. (find self).
  • 35.  “one step to the right, then up.”
  • 36.  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
  • 37.  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
  • 38.  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.
  • 39.  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.
  • 40.  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
  • 41.  Define a method twice inside the same class, the second definition takes precedence. class D def hello puts “hello” end end class D def hello puts “hello world” end end
  • 42.  If the object’s method-lookup path includes more than two same methods, the first one is the “winner”.
  • 43.  A class mixes in two or more modules.  The modules are searched in reverse order of inclusion
  • 44. class C include M include N include M end  Re-including a module doesn’t do anything.  N is still considered the most recently included module.
  • 45.  Use the super keyword to jump up to the next-highest definition, in the method- lookup path.
  • 46.  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)
  • 47.  The Kernel module provides an instance method called method_missing.
  • 48.  Nested module/class chains are used to create namespaces for classes, modules, and methods. module Tools class Hammer end End h = Tools::Hammer.new
  • 49.  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.
  • 50.  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
  • 51.  Constants have a kind of global visibility or reachability.  Bears a close resemblance to searching a filesystem.
  • 52.  Like /, the :: means “start from the top level.”
  • 53.  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.
  • 54.  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. ruby -e 'puts self'  main is a special term that the default self object.  The keyword (class, module, or def) marks a switch to a new self.
  • 55.  In a class or module definition, self is the class or module object.
  • 56.  In a method definition, self is the object that called it.
  • 57.  When a singleton method is executed, self is the object that owns the method.
  • 58.  If the receiver of the message is self, you can omit the receiver and the dot.
  • 59.  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”
  • 60.  Every instance variable belongs to self.
  • 61.  Scope refers to the reach or visibility of variables and constants.  Three types of variables: global, local, and class variables.
  • 62.  Global scope is scope that covers the entire program.  Global scope is enjoyed by global variables.
  • 63.  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.
  • 64.  Provides a storage mechanism shared between a class and its instances.  Visible only to a class and its instances.
  • 65.  They’re class-hierarchy variables.
  • 66.  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.
  • 67.  Where do singleton methods live?  The singleton class  Every object has two classes:  The class of which it’s an instance  Its singleton class
  • 68.  Singleton classes are anonymous.  The << object notation means the anonymous, singleton class of object.
  • 69.  The Well-Grounded Rubyist, David A. Black  Metaprogramming Ruby, Paolo Perrotta