Quando utilizzare `method_missing`

Question

Nel codice seguente, il metodo roar non è definito nella classe Lion, ma può ancora essere chiamato utilizzando method_missing.

class Lion 
    def method_missing(name, *args) 
    puts "Lion will #{name}: #{args[0]}" 
    end 
end 

lion = Lion.new 
lion.roar("ROAR!!!") # => Lion will roar: ROAR!!! 

In quali situazioni e come si usa questo method_missing? Ed è sicuro da usare?

Answer 1

Sommario: Quando si usa? Quando ti semplificherà la vita, e non complicheranno la vita degli altri.

---

Ecco un esempio che mi viene in mente. È dalla gemma redis_failover.

# Dispatches redis operations to master/slaves. 
def method_missing(method, *args, &block) 
    if redis_operation?(method) 
    dispatch(method, *args, &block) 
    else 
    super 
    end 
end 

Qui controlliamo se il metodo chiamato è in realtà un comando di connessione redis. Se è così, lo deleghiamo alle connessioni sottostanti. In caso contrario, inoltrare a super.

Un altro esempio famoso di applicazione method_missing è cercatori ActiveRecord.

User.find_by_email_and_age('me@example.com', 20) 

Non c'è, ovviamente, un metodo find_by_email_and_age. Invece, method_missing interrompe il nome, analizza le parti e invoca find con i parametri corretti.

Answer 2

È interamente sicuro da utilizzare a condizione che venga utilizzato nei modi previsti e non venga portato via. Non tutto quello che puoi fare vale la pena, dopo tutto.

Il vantaggio di method_missing è la possibilità di rispondere a tutti i tipi di cose in modi unici.

Lo svantaggio è che non pubblicizzate le vostre capacità. Altri oggetti che ti aspettano a respond_to? qualcosa non riceveranno la conferma e potrebbero trattare il tuo oggetto personalizzato in modi che non hai intenzione.

Per la costruzione di linguaggi specifici del dominio e la fornitura di colla molto lenta tra i componenti, questo genere di cose è inestimabile.

Un ottimo esempio di dove questa è una buona misura è la classe Ruby OpenStruct.

Answer 3

Ecco uno dei miei preferiti

class Hash 
    def method_missing(sym,*args) 
    fetch(sym){fetch(sym.to_s){super}} 
    end 
end 

Il che mi lascia valori di accesso di un hash come se fossero attributi. Questo è particolarmente utile quando si lavora con dati JSON.

Quindi, ad esempio, piuttosto che dover scrivere tweets.collect{|each|each['text']}, posso semplicemente scrivere tweets.collect(&:text) che è molto più breve. O anche, invece di tweets.first['author'], posso semplicemente scrivere tweets.first.author che sembra molto più naturale. In realtà, ti dà accesso in stile Javascript ai valori di un hash.

 

NB, mi aspetto la scimmia patching polizia alla mia porta da un momento all'altro ...

Answer 4

Ho anche trovato un post sul blog da (Paolo Perrotta), dove ha dimostrato quando usare method_missing:

class InformationDesk 
    def emergency 
    # Call emergency... 
    "emergency() called" 
    end 

    def flights 
    # Provide flight information... 
    "flights() called" 
    end 

    # ...even more methods 
end 

Verificare se è stato richiesto un servizio durante l'ora di pranzo.

class DoNotDisturb 
    def initialize 
    @desk = InformationDesk.new 
    end 

    def method_missing(name, *args) 
    unless name.to_s == "emergency" 
     hour = Time.now.hour 
     raise "Out for lunch" if hour >= 12 && hour < 14 
    end 

    @desk.send(name, *args) 
    end 
end 

# At 12:30... 
DoNotDisturb.new.emergency # => "emergency() called" 
DoNotDisturb.new.flights # ~> -:37:in `method_missing': Out for lunch (RuntimeError) 

Answer 5

Innanzitutto, attenersi al riassunto di Sergio Tulentsev.

Oltre a ciò, penso che guardare agli esempi sia il modo migliore per avere un'idea delle situazioni giuste e sbagliate per method_missing; ecco è un altro semplice esempio: l'uso

Recentemente ho fatto di method_missing in un Null Object.

• L'Oggetto Nullo sostituiva un modello Ordine.

• L'ordine memorizza prezzi diversi per diverse valute.

---

Senza method_missing Sembra che questo:

class NullOrder 
    def price_euro 
    0.0 
    end 

    def price_usd 
    0.0 
    end 

    # ... 
    # repeat for all other currencies 
end 

---

Con method_missing, posso accorciare a:

class NullOrder 
    def method_missing(m, *args, &block) 
    m.to_s =~ /price_/ ? 0.0 : super 
    end 
end 

con l'ulteriore vantaggio di non avere a (ricordarsi di) aggiornare lo NullOrder quando aggiungo nuovi attributi price_xxx a Order.