ruby - tecnicas - programacion funcional ventajas y desventajas

Evaluación perezosa en rubí

Question

Tengo una situación para Ruby, donde es posible que sea necesario crear un objeto, pero no es seguro. Y como la creación del objeto puede ser costosa, no estoy demasiado ansioso por crearlo. Creo que este es un caso claro para la carga perezosa. ¿Cómo puedo definir un objeto que no se crea solo cuando alguien le envía un mensaje? El objeto sería creado en un bloque. ¿Hay alguna forma de carga / inicialización perezosa simple en Ruby? ¿Están estas cosas respaldadas por algunas gemas, que proporcionan diferentes soluciones para varios casos de inicialización perezosa de objetos? Gracias por tus sugerencias!

Answer 1

Hay dos maneras.

La primera es dejar que el llamador maneje la creación de objetos perezosos. Esta es la solución más simple, y es un patrón muy común en el código 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 segunda opción es dejar que el objeto se inicialice perezosamente. Creamos un objeto delegado alrededor de nuestro objeto real para lograr esto. Este enfoque es un poco más complicado y no se recomienda a menos que tenga un código de llamada existente que no pueda modificar, por ejemplo.

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

También puede utilizar el delegate stdlib para construir esto sobre.

Answer 2

Si desea evaluar partes de código con pereza, use 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

Entonces lo usas así:

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

Puedes usar este código para hacer una inicialización arbitrariamente compleja de cosas caras:

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

¿Como funciona? Usted crea una instancia de un objeto LazyProxy que contiene instrucciones sobre cómo construir un objeto costoso en un Proc. Si luego llama a algún método en el objeto proxy, primero crea una instancia del objeto costoso y luego le delega la llamada al método.