Forum: Ruby More on the fundamentals...

Announcement (2017-05-07): www.ruby-forum.com is now read-only since I unfortunately do not have the time to support and maintain the forum any more. Please see rubyonrails.org/community and ruby-lang.org/en/community for other Rails- und Ruby-related community platforms.
John M. (Guest)
on 2006-01-03 16:53
(Received via mailing list)
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")
unknown (Guest)
on 2006-01-03 17:06
(Received via mailing list)
Hi --

On Tue, 3 Jan 2006, John M. 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

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

But @name = name is just a variable assignment.

> # 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

I would say "instances of the class Greeter".

> # above
> g1.say("Hello")
> g2.say("Wotcha")
> g3.say("Ire!")
> g4.say("Elake")

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.


David

--
David A. Black
removed_email_address@domain.invalid

"Ruby for Rails", from Manning Publications, coming April 2006!
http://www.manning.com/books/black
Matthew S. (Guest)
on 2006-01-03 17:10
(Received via mailing list)
On Jan 3, 2006, at 14:51, John M. 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
John M. (Guest)
on 2006-01-04 02:44
(Received via mailing list)
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
Yohanes S. (Guest)
on 2006-01-04 04:16
(Received via mailing list)
John M. <removed_email_address@domain.invalid> 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.
unknown (Guest)
on 2006-01-04 19:26
(Received via mailing list)
Quoting John M. <removed_email_address@domain.invalid>:

> 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
This topic is locked and can not be replied to.