Évaluation paresseuse en Ruby

J'ai une situation pour le Rubis, où un objet est peut-être nécessaire d'être créé, mais il n'est pas sûr. Et comme la création de l'objet peut être coûteux je ne suis pas trop pressé de le créer. Je pense que c'est un cas clair pour le chargement paresseux. Comment puis-je définir un objet qui n'est créé que lorsque quelqu'un envoie un message? L'objet est créé dans un bloc. Est-il un moyen pour de simples chargement paresseux/initialisation du Rubis? Ces choses sont-elles prises en charge par certaines pierres, qui fournissent des solutions différentes pour les différents cas de paresseux initialisation des objets? Merci pour vos suggestions!

source d'informationauteur fifigyuri

  1. 34

    Il existe deux façons.

    La première est de laisser le appelant poignée paresseux création de l'objet. C'est la solution la plus simple, et c'est un schéma très commun dans le code Ruby.

    class ExpensiveObject
  def initialize
    # Expensive stuff here.
  end
end

class Caller
  def some_method
    my_object.do_something
  end

  def my_object
    # Expensive object is created when my_object is called. Subsequent calls
    # will return the same object.
    @my_object ||= ExpensiveObject.new
  end
end

    La deuxième option est de laisser le objet initialiser lui-même paresseusement. Nous créons un délégué de l'objet autour de notre objet à atteindre cet objectif. Cette approche est un peu plus délicat et n'est pas recommandé, à moins que vous avez déjà le code appelant, que vous ne pouvez pas modifier, par exemple.

    class ExpensiveObject        # Delegate
  class RealExpensiveObject  # Actual object
    def initialize
      # Expensive stuff here.
    end

    # More methods...
  end

  def initialize(*args)
    @init_args = args
  end

  def method_missing(method, *args)
    # Delegate to expensive object. __object method will create the expensive
    # object if necessary.
    __object__.send(method, *args)
  end

  def __object__
    @object ||= RealExpensiveObject.new(*@init_args)
  end
end

# This will only create the wrapper object (cheap).
obj = ExpensiveObject.new

# Only when the first message is sent will the internal object be initialised.
obj.do_something

    Vous pouvez également utiliser la stdlib déléguer pour construire ce sur le dessus de.

  2. 5

    Si vous voulez paresseusement évaluer les morceaux de code, l'utilisation d'un proxy:

    class LazyProxy

  # blank slate... (use BasicObject in Ruby 1.9)
  instance_methods.each do |method| 
    undef_method(method) unless method =~ /^__/
  end

  def initialize(&lazy_proxy_block)
    @lazy_proxy_block = lazy_proxy_block
  end

  def method_missing(method, *args, &block)
    @lazy_proxy_obj ||= @lazy_proxy_block.call # evaluate the real receiver
    @lazy_proxy_obj.send(method, *args, &block) # delegate unknown methods to the real receiver
  end
end

    Vous pouvez ensuite l'utiliser comme ceci:

    expensive_object = LazyProxy.new { ExpensiveObject.new }
expensive_object.do_something

    Vous pouvez utiliser ce code pour faire arbitrairement complexe d'initialisation de trucs chers:

    expensive_object = LazyProxy.new do
  expensive_helper = ExpensiveHelper.new
  do_really_expensive_stuff_with(expensive_helper)
  ExpensiveObject.new(:using => expensive_helper)
end
expensive_object.do_something

    Comment ça fonctionne? Vous instanciez un LazyProxy objet qui contient des instructions sur la façon de construire un peu cher objet dans un Proc. Si vous appelez une méthode sur l'objet proxy, il instancie le cher objet, puis les délégués de la méthode de l'appel à elle.