Please have a look at the comments below to see that I’m understanding
things correctly;
#!/usr/bin/ruby #Tue Jan 3 14:04:28 GMT 2006
class Greeter
# a new class cllaed Greeter
def initialize(name)
# creating a new method called name @name = name
# we define a new @instance variable called name
end
def say(phrase)
# creating a new method called phrase…
puts “#{phrase}, #{@name}”
# … which uses doube quotes to substitute
end
end
Please have a look at the comments below to see that I’m
understanding things correctly;
#!/usr/bin/ruby #Tue Jan 3 14:04:28 GMT 2006
class Greeter
# a new class cllaed Greeter
def initialize(name)
# creating a new method called name
There’s no method called name.
@name = name
# we define a new @instance variable called name
Move the @ from @instance to name and you’re set
end
def say(phrase)
# creating a new method called phrase...
There’s no method called phrase.
puts "#{phrase}, #{@name}"
# ... which uses doube quotes to substitute
end
end
It seems that you’re confusing instance variable assignment with
method creation. They’re unrelated. You can, of course, write a
method that returns the current value of an instance variable:
def name @name
end
and you can even get Ruby to do it semi-automatically for you:
attr_reader :name # creates the above “name” method
Have another look at the attr_* family of methods, and keep in mind
that they’re essentially shortcuts for writing your own get-and/or-set
methods (using instance variables), and I think that part of it will
fall into place.
Please have a look at the comments below to see that I’m
understanding things correctly;
You’ve made a couple of fundamental mistakes regarding how methods
are defined. The basic schema is:
def method_name(parameter_name)
Where you can have a whole list of parameters, or none at all. See
the revised (and very verbose comments. Hope this helps.
matt smillie.
Also, I’ve changed the indented to two spaces, since that’s the Ruby
norm.
class Greeter
open class Greeter (it’s not necessarily new)
def initialize(name)
# defining the initialise method, which is called when a new
# object is created. The method takes one parameter, ‘name’.
# Example (such as: foo = Greeter.new(“Mark”). @name = name
# define an instance variable called ‘@name’ and assign it
# the value of the parameter ‘name’
end
def say(phrase)
# defining a new method called ‘say’ with a parameter
# called ‘phrase’.
puts “#{phrase}, #{@name}”
# The double quotes define a string, and the #{} sections are
# used for interpolation (substitution).
end
end
Within the context of the block, “food” is a variable. “eat”,
however, will be interpreted as a private method call (i.e. as a
call to the “eat” method on self), provided an “eat” variable does
not already exist in that scope.
Generally, given a bare identifier, the rule is:
If a previous assignment to the name exists in the current scope
(whether or not it was actually performed), the name is a variable
(or a parse error if you try to give it parameters)
otherwise, it is a call to a private method on self
Examples:
foo # method
foo = 1
foo # variable
if false
foo = 1 # never executed
end
foo # still a variable (initialized to nil)
[1, 2, 3].each { |foo| # introduced as block param
foo # variable here
}
foo # method call here
foo = 1
foo # variable
[1, 2, 3].each { |foo| # same variable
foo # yes, same variable
}
foo # still same variable
