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.
4. 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
5. 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
6. predefined, reserved terms associated with
specific programming tasks and contexts.
def,
class,
if, and
__FILE__
7. 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.
8.
9. 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.
12. 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.
13. 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.
14. Have to supply the correct number of
arguments.
15. 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)
17. Ruby tries to assign values to as many variables
as possible.
The sponge parameters get the lowest priority.
18.
19. 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
20.
21.
22. 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.
23. In Ruby, classes are objects.
The new method is a constructor.
Classes are named with constants.
24. Ruby executed the code within the class just
as it would execute any other code.
25. It’s possible to reopen a class and make
additions or changes.
26. These methods defined inside a class.
Used by all instances of the class.
They don’t belong only to one object.
27. 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.
30. 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
31. The attributes are implemented as reader
and/or writer methods.
32.
33. Ruby supports only single inheritance.
Classes can import modules as mixins.
The class Object is almost at the top of the
inheritance chart.
34.
35. • 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
36. It’s OK to use an explicit receiver for private
setter methods.
37.
38. The top-level method is stored as a private
instance method of the Object class.
39.
40. Every object is “born” with certain innate
abilities.
object_id
respond_to?
send
methods
instance_variables
41.
42. 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.
43.
44. 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
45.
46.
47. 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.
48. Classes are objects.
Instances of classes are objects, too.
A class object has its own methods, its own
state, its own identity.
49.
50. When you call a method, Ruby does two
things:
It finds the method (method lookup).
It executes the method. (find self).
52. 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
53. 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
54.
55. 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.
56. 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.
57.
58. 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
59. 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
60. If the object’s method-lookup path includes
more than two same methods, the first one is
the “winner”.
61. A class mixes in two or more modules.
The modules are searched in reverse order of
inclusion
62. 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.
63. Use the super keyword to jump up to the
next-highest definition, in the method-
lookup path.
64. 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)
65. The Kernel module provides an instance method called
method_missing.
66. Nested module/class chains are used to
create namespaces for classes, modules, and
methods.
module Tools
class Hammer
end
End
h = Tools::Hammer.new
67.
68. 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.
69. 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
70. Constants have a kind
of global visibility or
reachability.
Bears a close
resemblance to
searching a filesystem.
71. Like /, the :: means “start from the top level.”
72.
73. 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.
74.
75.
76. 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.
77. In a class or module definition, self is the class
or module object.
78. In a method definition, self is the object that
called it.
79. When a singleton method is executed, self is
the object that owns the method.
80. If the receiver of the message is self, you can
omit the receiver and the dot.
81. 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”
85. Scope refers to the reach or visibility of
variables and constants.
Three types of variables: global, local, and
class variables.
86. Global scope is scope that covers the entire
program.
Global scope is enjoyed by global variables.
87. 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.
88.
89.
90. Provides a storage mechanism shared
between a class and its instances.
Visible only to a class and its instances.
95. 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.
96. Where do singleton methods live?
The singleton class
Every object has two classes:
The class of which it’s an instance
Its singleton class
97. Singleton classes are anonymous.
The << object notation means the anonymous,
singleton class of object.
98.
99.
100. The Well-Grounded Rubyist, David A. Black
Metaprogramming Ruby, Paolo Perrotta
