More on the fundamentals...

Discussion in 'Ruby' started by John Maclean, Jan 3, 2006.

  1. John Maclean

    John Maclean Guest

    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
    John Maclean, Jan 3, 2006
    #1
    1. Advertising

  2. John Maclean

    Guest

    Hi --

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


    "Ruby for Rails", from Manning Publications, coming April 2006!
    http://www.manning.com/books/black
    , Jan 3, 2006
    #2
    1. Advertising

  3. 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
    >
    >
    Matthew Smillie, Jan 3, 2006
    #3
  4. John Maclean

    John Maclean Guest

    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 <> 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
    John Maclean, Jan 4, 2006
    #4
  5. John Maclean <> 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 <> 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, Jan 4, 2006
    #5
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. =?ISO-8859-1?Q?Gregory_Pi=F1ero?=

    Passing arguments to function - (The fundamentals are confusing me)

    =?ISO-8859-1?Q?Gregory_Pi=F1ero?=, Aug 9, 2005, in forum: Python
    Replies:
    20
    Views:
    666
    Dennis Lee Bieber
    Aug 10, 2005
  2. Doug

    Python / glade fundamentals

    Doug, Mar 16, 2006, in forum: Python
    Replies:
    6
    Views:
    659
    Ido Yehieli
    Mar 20, 2006
  3. bart
    Replies:
    0
    Views:
    450
  4. gdv
    Replies:
    4
    Views:
    628
    =?ISO-8859-1?Q?Arne_Vajh=F8j?=
    Oct 14, 2007
  5. John [H2O]
    Replies:
    1
    Views:
    216
Loading...

Share This Page