¿Cómo inicializar limpiamente los atributos en Ruby con nuevo?

Question

class Foo 
    attr_accessor :name, :age, :email, :gender, :height 

    def initalize params 
    @name = params[:name] 
    @age = params[:age] 
    @email = params[:email] 
    . 
    . 
    . 
    end 

Esto parece una manera tonta de hacerlo. ¿Cuál es una forma mejor/más idiomática de initalizar objetos en Ruby?

de Ruby 1.9.3

Answer 1

def initialize(params) 
    params.each do |key, value| 
    instance_variable_set("@#{key}", value) 
    end 
end 

Answer 2

Usted sólo puede iterar sobre las claves e invocar los definidores. Prefiero esto porque atrapará si pasas una clave inválida.

class Foo 
    attr_accessor :name, :age, :email, :gender, :height 

    def initialize params = {} 
    params.each { |key, value| send "#{key}=", value } 
    end 
end 

foo = Foo.new name: 'Josh', age: 456 
foo.name # => "Josh" 
foo.age # => 456 
foo.email # => nil 

Answer 3

Si recibe un hash como único argumento, ¿por qué no mantenerlo como una variable de instancia? Siempre que necesite un valor, llámelo desde el hash. Puede mantener corto el nombre de la variable de instancia para que pueda ser llamado fácilmente.

class Foo 
    attr_reader :p 
    def initalize p 
    @p = p 
    end 
    def foo 
    do_something_with(@p[:name]) 
    ... 
    end 
end 

Si @p[:name] sigue siendo demasiado largo para usted, entonces usted puede ahorrar un proc como una variable de instancia, y llame a la magnitud de salida como @p.(:name).

class Foo 
    attr_reader :p 
    def initialize p 
    @p = ->x{p[x]} 
    end 
    def foo 
    do_something_with(@p.(:name)) 
    ... 
    end 
end 

O, una forma alternativa es definir un método que llame al hash y aplique la clave.

class Foo 
    def initalize p 
    @p = p 
    end 
    def get key 
    @p[key] 
    end 
    def foo 
    do_something_with(get(:name)) 
    ... 
    end 
end 

Si desea establecer los valores, se puede definir un método de selección y comprobación adicional para las claves no válidas si lo desea.

class Foo 
    Keys = [:name, :age, :email, :gender, :height] 
    def initalize p 
    raise "Invalid key in argument" unless (p.keys - Keys).empty? 
    @p = p 
    end 
    def set key, value 
    raise "Invalid key" unless Keys.key?(key) 
    @p[key] = value 
    end 
    def get key 
    @p[key] 
    end 
    def foo 
    do_something_with(get(:name)) 
    ... 
    end 
end 

Answer 4

El uso de todas las teclas de params no es correcto, puede definir nombres poco convenientes. Creo que debería ser una especie de lista blanca de nombres

class Foo 
    @@attributes = [:name, :age, :email, :gender, :height] 

    @@attributes.each do |attr| 
    class_eval { attr_accessor "#{attr}" } 
    end 

    def initialize params 
    @@attributes.each do |attr| 
     instance_variable_set("@#{attr}", params[attr]) if params[attr] 
    end 
    end 
end 

Foo.new({:name => 'test'}).name #=> 'test' 

Answer 5

¿Por qué no simplemente especificar explícitamente una lista real de argumentos?

class Foo 
    attr_accessor :name, :age, :email, :gender, :height 

    def initialize(name, age, email, gender, height) 
    @name = name 
    @age = age 
    @email = email 
    @gender = gender 
    @height = height 
    end 
end 

Esta versión puede haber más líneas de código que otros, pero lo hace más fácil para apalancar (por ejemplo, valores por defecto para los argumentos o errores que crían si initialize se llama con aridad incorrecta) incorporados en las características del lenguaje.

Answer 6

Foo = Struct.new(:name, :age, :email, :gender, :height) 

Esto es suficiente para una clase completamente funcional. Demostración:

p Foo.class # Class 

employee = Foo.new("smith", 29, "smith@foo.com", "m", 1.75) #create an instance 
p employee.class # Foo 
p employee.methods.sort # huge list which includes name, name=, age, age= etc 

Answer 7

para sacar provecho de la respuesta de Joshua Cheek con un poco de generalización

module Initializable 
    def initialize(params = {}) 
    params.each do |key, value| 
     setter = "#{key}=" 
     send(setter, value) if respond_to?(setter.to_sym, false) 
    end 
    end 
end 

class Foo 
    include Initializable 

    attr_accessor :name, :age, :email, :gender, :height 
end 

Foo.new name: 'Josh', age: 456 
=> #<Foo:0x007fdeac02ecb0 @name="Josh", @age=456> 

NB Si la inicialización mix-in se ha utilizado y necesitamos inicialización de encargo, nos simplemente llame a super:

class Foo 
    include Initializable 

    attr_accessor :name, :age, :email, :gender, :height, :handler 

    def initialize(*) 
    super 

    self.handler = "#{self.name} #{self.age}" 
    end 
end 

Foo.new name: 'Josh', age: 45 
=> #<Foo:0x007fe94c0446f0 @name="Josh", @age=45, @handler="Josh 45">