Asp Forum - More on the fundamentals...

John Maclean

1/3/2006 2:51:00 PM

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

# say hello
g1 = Greeter.new("jayeola")
g2 = Greeter.new("buddy")
g3 = Greeter.new("vimmer")
g4 = Greeter.new("slammer")
# we have just created four new (object) instances belonging to the class
# Greeter. They can now use the instance variables that have been created
# above
g1.say("Hello")
g2.say("Wotcha")
g3.say("Ire!")
g4.say("Elake")

--
John Maclean
MSc (DIC)
07739 171 531

5 Answers

dblack

1/3/2006 3:02:00 PM

Matthew Smillie

1/3/2006 3:06:00 PM

On Jan 3, 2006, at 14:51, John Maclean wrote:

> 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

>
> #!/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
>
> # say hello
> g1 = Greeter.new("jayeola")
> g2 = Greeter.new("buddy")
> g3 = Greeter.new("vimmer")
> g4 = Greeter.new("slammer")
> # we have just created four new (object) instances belonging to
> the class
> # Greeter. They can now use the instance variables that have been
> created
> # above
> g1.say("Hello")
> g2.say("Wotcha")
> g3.say("Ire!")
> g4.say("Elake")
>
> --
> John Maclean
> MSc (DIC)
> 07739 171 531
>
>

John Maclean

1/4/2006 12:43:00 AM

In this line of code can anyone tell me why "food" is a method? I thought that they are preceded by a dot.

__ an array __ the method __ parameters for code block
/ / /
[cornflakes, yam, rice].each { |food| eat food}
/ code block __/ \__block args

On Tue, 3 Jan 2006 23:51:15 +0900
John Maclean <info@jayeola.org> wrote:

> 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
>
> # say hello
> g1 = Greeter.new("jayeola")
> g2 = Greeter.new("buddy")
> g3 = Greeter.new("vimmer")
> g4 = Greeter.new("slammer")
> # we have just created four new (object) instances belonging to the class
> # Greeter. They can now use the instance variables that have been created
> # above
> g1.say("Hello")
> g2.say("Wotcha")
> g3.say("Ire!")
> g4.say("Elake")
>

--
John Maclean
MSc (DIC)
07739 171 531

Yohanes Santoso

1/4/2006 2:15:00 AM

John Maclean <info@jayeola.org> writes:

> In this line of code can anyone tell me why "food" is a method? I
> thought that they are preceded by a dot.

It is not a method, it's a variable, very possibly a block-local one.

>
> __ an array __ the method __ parameters for code block
> / / /
> [cornflakes, yam, rice].each { |food| eat food}
> / > code block __/ \__block args
>

^^^ is parsed as: [corflakes, yam, rice].each {|food| eat(food)}

YS.

>
> On Tue, 3 Jan 2006 23:51:15 +0900
> John Maclean <info@jayeola.org> wrote:
>
>> 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
>>
>> # say hello
>> g1 = Greeter.new("jayeola")
>> g2 = Greeter.new("buddy")
>> g3 = Greeter.new("vimmer")
>> g4 = Greeter.new("slammer")
>> # we have just created four new (object) instances belonging to the class
>> # Greeter. They can now use the instance variables that have been created
>> # above
>> g1.say("Hello")
>> g2.say("Wotcha")
>> g3.say("Ire!")
>> g4.say("Elake")
>>
>
>
> --
> John Maclean
> MSc (DIC)
> 07739 171 531

MenTaLguY

1/4/2006 5:25:00 PM

Quoting John Maclean <info@jayeola.org>:

> In this line of code can anyone tell me why "food" is a method? I
> thought that they are preceded by a dot.
>
> __ an array __ the method __ parameters for code
> block
> / / /
> [cornflakes, yam, rice].each { |food| eat food}
> / > code block __/ \__block args
>

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:

1. 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)

2. otherwise, it is a call to a private method on self

Examples:

1. foo # method

2. foo = 1
foo # variable

3. if false
foo = 1 # never executed
end
foo # still a variable (initialized to nil)

4. [1, 2, 3].each { |foo| # introduced as block param
foo # variable here
}
foo # method call here

5. foo = 1
foo # variable
[1, 2, 3].each { |foo| # same variable
foo # yes, same variable
}
foo # still same variable

-mental

comp.lang.ruby

More on the fundamentals...

John Maclean

dblack

Matthew Smillie

John Maclean

Yohanes Santoso

MenTaLguY

x Login to ForumsZone