Ruby: l'Appel d'une méthode de la classe de l'instance

À l'aide de self.class.blah n'est PAS la même que l'utilisation de ClassName.blah quand il s'agit de l'héritage.

class Truck
  def self.default_make
    "mac"
  end

  def make1
    self.class.default_make
  end

  def make2
    Truck.default_make
  end
end


class BigTruck < Truck
  def self.default_make
    "bigmac"
  end
end

ruby-1.9.3-p0 :021 > b=BigTruck.new
 => #<BigTruck:0x0000000307f348> 
ruby-1.9.3-p0 :022 > b.make1
 => "bigmac" 
ruby-1.9.3-p0 :023 > b.make2
 => "mac" 

Si vous avez accès à la méthode du délégué vous pouvez faire ceci:

[20] pry(main)> class Foo
[20] pry(main)*   def self.bar
[20] pry(main)*     "foo bar"
[20] pry(main)*   end  
[20] pry(main)*   delegate :bar, to: 'self.class'
[20] pry(main)* end  
=> [:bar]
[21] pry(main)> Foo.new.bar
=> "foo bar"
[22] pry(main)> Foo.bar
=> "foo bar"

Sinon, et sans doute plus propre si vous avez plus d'une méthode ou deux, vous voulez le délégué de classe & exemple:

[1] pry(main)> class Foo
[1] pry(main)*   module AvailableToClassAndInstance
[1] pry(main)*     def bar
[1] pry(main)*       "foo bar"
[1] pry(main)*     end  
[1] pry(main)*   end  
[1] pry(main)*   include AvailableToClassAndInstance
[1] pry(main)*   extend AvailableToClassAndInstance
[1] pry(main)* end  
=> Foo
[2] pry(main)> Foo.new.bar
=> "foo bar"
[3] pry(main)> Foo.bar
=> "foo bar"

Un mot de prudence:

N'est pas seulement au hasard delegate tout ce qui n'a pas changer l'état de classe et d'instance parce que vous allez commencer à courir dans d'étranges nom choc des questions. Le faire avec parcimonie et seulement après avoir vérifié rien d'autre n'est écrasé.

Vous êtes en train de faire de la bonne façon. Les méthodes de la classe (similaire à la "statique" méthodes en C++ ou Java) ne font pas partie de l'instance, de sorte qu'ils ont à être référencé directement.

Sur cette note, dans votre exemple, vous seriez mieux servis faire "default_make' une méthode régulière:

#!/usr/bin/ruby

class Truck
    def default_make
        # Class method.
        "mac"
    end

    def initialize
        # Instance method.
        puts default_make  # gets the default via the class's method.
    end
end

myTruck = Truck.new()

Les méthodes de la classe sont plus utiles pour utilitaire-type de fonctions qui utilisent la classe. Par exemple:

#!/usr/bin/ruby

class Truck
    attr_accessor :make

    def default_make
        # Class method.
        "mac"
    end

    def self.buildTrucks(make, count)
        truckArray = []

        (1..count).each do
            truckArray << Truck.new(make)
        end

        return truckArray
    end

    def initialize(make = nil)
        if( make == nil )
            @make = default_make()
        else
            @make = make
        end
    end
end

myTrucks = Truck.buildTrucks("Yotota", 4)

myTrucks.each do |truck|
    puts truck.make
end

Voici une approche sur la façon dont vous pouvez mettre en œuvre un _class méthode qui fonctionne comme self.class de cette situation. Remarque: Ne pas utiliser dans la production de code, c'est pour l'intérêt de souci 🙂

À partir de: Pouvez-vous eval du code dans le contexte de l'appelant en Ruby? et aussi http://rubychallenger.blogspot.com.au/2011/07/caller-binding.html

# Rabid monkey-patch for Object
require 'continuation' if RUBY_VERSION >= '1.9.0'
class Object
  def __; eval 'self.class', caller_binding; end
  alias :_class :__
  def caller_binding
    cc = nil; count = 0
    set_trace_func lambda { |event, file, lineno, id, binding, klass|
      if count == 2
        set_trace_func nil
        cc.call binding
      elsif event == "return"
        count += 1
      end
    }
    return callcc { |cont| cc = cont }
  end
end

# Now we have awesome
def Tiger
  def roar
    # self.class.roar
    __.roar
    # or, even
    _class.roar
  end
  def self.roar
    # TODO: tigerness
  end
end

Peut-être que la solution, c'est de soumettre un patch pour Ruby 🙂