¿Por qué usar Proc.new para llamar a un método en una devolución de llamada de Rails?

Question

en todos los tutoriales para RoR Veo ejemplos en los que el codificador optó por usar Proc.new cuando aparentemente es innecesario y poco atractivo.

ejemplo, aquí hay una llamada de retorno para colocar en un modelo, una usando Proc.new la otra, presumiblemente, haciendo lo mismo:

class Order < ActiveRecord::Base 
    before_save :normalize_card_number, 
    :if => Proc.new { |order| order.paid_with_card? } 
end 

class Order < ActiveRecord::Base 
    before_save :normalize_card_number, :if => "paid_with_card?" 
end 

Entonces, ¿cuál es la diferencia? ¿Por qué usar el Proc? ¿No llaman ambos a la "paid_with_card?" ¿método?

Gracias de antemano

Answer 1

En el ejemplo anterior, usar un símbolo para el método condicional probablemente sea la mejor opción.

class Order < ActiveRecord::Base 
    before_save :normalize_card_number, :if => :paid_with_card? 
end 

La opción de cadena utiliza eval para evaluar el código de Ruby en la cadena. Personalmente, preferiría usar un símbolo si estoy llamando a un método o un Proc si estoy escribiendo una breve condición en línea.

por la RailsGuides documentation:

El uso de un objeto Proc le da la capacidad de escribir una condición de línea en lugar de un método separado. Esta opción es la más adecuada para los one-liners.

Creo que el uso de un Proc podría ser mejor ilustra esta manera:

class Order < ActiveRecord::Base 
    before_save :normalize_card_number, 
    :if => Proc.new { |order| order.payment_type == "card" } 
end 

Esto sería posible eliminar la necesidad de la paid_with_card? método.

Answer 2

yo diría que era el caso de que en las versiones anteriores de Rails que es como solíamos hacer las cosas, y alguien añadido la posibilidad por la cual se podía pasar una cadena a ser evaluado como una instancia método en el modelo actual.

En escenarios simples, hace que el estilo anterior sea redundante, pero permite el uso de un Proc para declaraciones 'if' más complejas que serían imposibles de lograr usando un método solo en la instancia actual.