Wywołanie metody z łańcucha o nazwie metody w języku Ruby

Jak mogę zrobić to, o czym oni tutaj mówią , ale w Rubim?

Jak wykonałbyś funkcję na obiekcie? i jak wykonałbyś funkcję globalną (zobacz odpowiedź jetxee we wspomnianym poście)?

PRZYKŁADOWY KOD:

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()

AKTUALIZACJA: Jak dostać się do metod globalnych? czy moje funkcje globalne?

Wypróbowałem tę dodatkową linię

puts methods

oraz load i row_change, jeśli nie są wymienione.

Do wywoływania funkcji bezpośrednio na obiekcie

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

która zwraca 3 zgodnie z oczekiwaniami

lub dla funkcji modułu

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

i lokalnie zdefiniowana metoda

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

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

Dokumentacja:

• Object#public_send
• Object#send

Trzy sposoby: send/ call/ eval- i ich punkty odniesienia

Typowe wywołanie (w celach informacyjnych):

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

Za pomocą send

s.send(:length) #=> 6

Za pomocą call

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

Za pomocą eval

eval "s.length" #=> 6

Benchmarki

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" } } 
} 

... jak widać, tworzenie instancji obiektu metody jest najszybszym dynamicznym sposobem wywoływania metody. Zwróć też uwagę, jak wolno jest używać 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)

Podziękowania dla tego wpisu na blogu, który zawiera nieco więcej informacji na temat trzech metod, a także pokazuje, jak sprawdzić, czy metody istnieją.

Użyj tego:

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

Proste, prawda?

Jeśli chodzi o globalne , myślę, że sposób w Ruby polegałby na przeszukaniu go za pomocą methodsmetody.

Osobiście ustawiłbym hash do funkcji referencji, a następnie użyłbym ciągu jako indeksu do skrótu. Następnie wywołujesz odwołanie do funkcji z jej parametrami. Ma to tę zaletę, że nie pozwala złemu łańcuchowi wywołać czegoś, czego nie chcesz wywołać. Innym sposobem jest w zasadzie evalsznurek. Nie rób tego.

PS nie bądź leniwy i faktycznie wpisz całe swoje pytanie, zamiast tworzyć link do czegoś.