Llamar a un método desde una cadena con el nombre del método en Ruby

¿Cómo puedo hacer de lo que están hablando aquí , pero en Ruby?

¿Cómo harías la función en un objeto? y ¿cómo haría una función global (vea la respuesta de jetxee en la publicación mencionada)?

CÓDIGO DE EJEMPLO:

event_name = "load"

def load()
  puts "load() function was executed."
end

def row_changed()
  puts "row_changed() function was executed."
end 

#something here to see that event_name = "load" and run load()

ACTUALIZACIÓN: ¿Cómo se llega a los métodos globales? o mis funciones globales?

Probé esta línea adicional

puts methods

y cargar y remar_cambiar donde no figura.

Para llamar a funciones directamente en un objeto

a = [2, 2, 3]
a.send("length")
# or
a.public_send("length")

que devuelve 3 como se esperaba

o para una función de módulo

FileUtils.send('pwd')
# or
FileUtils.public_send(:pwd)

y un método definido localmente

def load()
    puts "load() function was executed."
end

send('load')
# or
public_send('load')

Documentación:

• Object#public_send
• Object#send

Tres formas: send/ call/ eval- y sus puntos de referencia

Invocación típica (para referencia):

s= "hi man"
s.length #=> 6

Utilizando send

s.send(:length) #=> 6

Utilizando call

method_object = s.method(:length) 
p method_object.call #=> 6

Utilizando eval

eval "s.length" #=> 6

Puntos de referencia

require "benchmark" 
test = "hi man" 
m = test.method(:length) 
n = 100000 
Benchmark.bmbm {|x| 
  x.report("call") { n.times { m.call } } 
  x.report("send") { n.times { test.send(:length) } } 
  x.report("eval") { n.times { eval "test.length" } } 
} 

... como puede ver, crear instancias de un objeto de método es la forma dinámica más rápida de llamar a un método, también observe cuán lento es el uso de eval.

#######################################
#####   The results
#######################################
#Rehearsal ----------------------------------------
#call   0.050000   0.020000   0.070000 (  0.077915)
#send   0.080000   0.000000   0.080000 (  0.086071)
#eval   0.360000   0.040000   0.400000 (  0.405647)
#------------------------------- total: 0.550000sec

#          user     system      total        real
#call   0.050000   0.020000   0.070000 (  0.072041)
#send   0.070000   0.000000   0.070000 (  0.077674)
#eval   0.370000   0.020000   0.390000 (  0.399442)

El crédito va a esta publicación de blog que elabora un poco más sobre los tres métodos y también muestra cómo verificar si los métodos existen.

Utilizar este:

> a = "my_string"
> meth = a.method("size")
> meth.call() # call the size method
=> 9

Simple, ¿verdad?

En cuanto a lo global , creo que la forma de Ruby sería buscarlo usando el methodsmétodo.

Personalmente, configuraría un hash para que funcionen las referencias y luego usaría la cadena como un índice para el hash. Luego llama a la referencia de función con sus parámetros. Esto tiene la ventaja de no permitir que la cadena incorrecta llame a algo que no desea llamar. La otra forma es básicamente evalla cadena. No hagas esto.

PD: no seas perezoso y escribe toda tu pregunta, en lugar de vincularte a algo.