Estoy tratando de probar que puede almacenar subrutinas dentro de una variable (a menos que no pueda). ¿Hay alguna posibilidad de que tenga este código mal?
Tengo este código de Python que hace lo que quiero hacer.
def printSample(str) puts str end x = printSample str = "Hello" x(str)Rendimiento esperado:
Hola
Soy un principiante en Ruby y solo trato de aprender códigos básicos.
Su código de Python se puede traducir a Ruby como:
def print_sample(str) puts str end x = method(:print_sample) str = "Hello" x.(str) La principal diferencia es que debido a que los paréntesis en Ruby son opcionales, escribir x = print_sample ya invocaría el método. Recuperar un objeto Método al que puede llamar más tarde es un poco más complicado: tiene que llamar almethod y pasar el nombre del método como un símbolo o una cadena. (el receptor es el objeto en el que se define el método)
Y debido a que los objetos de método son objetos regulares, la sintaxis para llamar al método también es ligeramente diferente. Rubí proporciona:
x[str] x.(str) x.call(str) Siendo x.(str) azúcar sintáctico para x.call(str) , consulte Method#call
Otro enfoque es simplemente almacenar el nombre del método e invocar el método dinámicamente a través de send / public_send , por ejemplo:
x = :print_sample str = "Hello" send(x, str)Hacer referencia a los métodos a través de su nombre (simbolizado) es bastante idiomático en Ruby.
Ejemplo para manejar un método de instancia:
class Demo def initialize(s); @s = s; end def printSample(str); puts(@s+str); end end x = Demo.instance_method(:printSample) # x is now of class UnboundMethod aDemo = Demo.new("Hi") # Use x x.bind(aDemo).call("You") # Outputs: HiYou En este ejemplo, primero almacenamos el método y luego lo aplicamos a una instancia. Si tiene la instancia primero y desea obtener el método más tarde, es aún más simple. Asumiendo la definición de clase de Demo de arriba, igualmente puede hacer una
aDemo = Demo.new("Hi") y = aDemo.method(:printSample) y.call("You")