Self in method name

ruby-talk
1

Is there any difference between using self in a method name, and not
using it?
For example, I've seen a lot something like

class Foo
    def self.bar
        ...
    end
end

Is this the same thing as

class Foo
    def bar
        ...
    end
end
?

···

--
Posted via http://www.ruby-forum.com/.

2

iskaldur wrote:

Is there any difference between using self in a method name, and not
using it?
For example, I've seen a lot something like

class Foo
    def self.bar
        ...
    end
end

Is this the same thing as

class Foo
    def bar
        ...
    end
end
?

I believe the first is equivalent to:

   class Foo
      def Foo.bar
          ...
      end
   end

and so quite different to the second.

3

The first one creates a class method as opposed to the second one that
creates an instance method (e.g., Foo.bar rather than x = Foo.new;
x.bar;). :slight_smile:

--Jeremy

···

On 6/12/07, iskaldur <iskaldur@gmail.com> wrote:

Is there any difference between using self in a method name, and not
using it?
For example, I've seen a lot something like

class Foo
    def self.bar
        ...
    end
end

Is this the same thing as

class Foo
    def bar
        ...
    end
end
?

--
Posted via http://www.ruby-forum.com/\.

--
http://www.jeremymcanally.com/

My free Ruby e-book:
http://www.humblelittlerubybook.com/book/

My blogs:

http://www.rubyinpractice.com/

4

Hi --

Is there any difference between using self in a method name, and not
using it?
For example, I've seen a lot something like

class Foo
   def self.bar
       ...
   end
end

Is this the same thing as

class Foo
   def bar
       ...
   end
end

def self.bar is just a special case of:

   def some_object.some_method

i.e., defining a singleton method on an object (a method that exists
only in the method look-up for that particular object, not for other
objects of its class). Actually it's not even a special case; it's
just using the current value of self as the object on which to define
the method.

At the top level of a class definition block, self is the class object
-- in this case, Foo. A singleton method defined on a class object
(such as Foo.bar) is usually referred to as a class method. In
addition, class methods are special-cased a bit, in comparison with
other singleton methods... but that's Lesson Two :slight_smile:

David

···

On Tue, 12 Jun 2007, iskaldur wrote:

--
* Books:
   RAILS ROUTING (new! http://safari.awprofessional.com/9780321509246\)
   RUBY FOR RAILS (http://www.manning.com/black\)
* Ruby/Rails training
     & consulting: Ruby Power and Light, LLC (http://www.rubypal.com)

5

Hi,

class Foo
    def self.bar
        ...
    end
end

Is this the same thing as

  class Foo
    class <<self
      def bar
          ...
      end
    end
  end

Bertram

···

Am Dienstag, 12. Jun 2007, 13:19:02 +0900 schrieb iskaldur:

--
Bertram Scharpf
Stuttgart, Deutschland/Germany
http://www.bertram-scharpf.de

6

class Foo
   def self.bar
   end

   def bar
   end
end

Arguably, the equivalent in Java is this:

public class Foo {
   public static void bar1() {
   }

   public void bar2() {
   }
}

Notice that you can't use the same method name statically and
as instance method in Java, whereas you can use the same name
for the class method and the instance method in Ruby.

gegroet,
Erik V. - http://www.erikveen.dds.nl/

7

Yes, except in the second you're actually opening up the virtual class
to work on it directly whereas in the first example you're defining
the method using an absolute name.

It's easy to see this as a pattern though without understanding the
background, which, hopefully, a brief example will rectify:

class << Fixnum
   def x; "y"; end
end

puts Fixnum.x # => "y"
puts 10.x # ERROR

Note that you can dig into virtual classes at any time, not just
within the capacity of a class you're currently defining :slight_smile:

So.. when you see class << self within the definition of another
class, then it's the equivalent of class << ClassName, and merely
using the "self" to provide the current class rather than naming it
explicitly.

Cheers,
Peter Cooper

···

On 6/12/07, Bertram Scharpf <lists@bertram-scharpf.de> wrote:

> class Foo
> def self.bar
> ...
> end
> end

Is this the same thing as

  class Foo
    class <<self
      def bar
          ...
      end
    end
  end