objetos - variable de clase en ruby

¿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?

Ruby 1.9.3

Answer 1

¿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 contener más líneas de código que otras, pero hace que sea más fácil aprovechar las funciones de lenguaje integradas (por ejemplo, valores predeterminados para argumentos o errores de elevación si se initialize con arity incorrecto).

Answer 2

Para capitalizar 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 se ha utilizado la mezcla de inicialización y necesitamos una inicialización personalizada, simplemente llamaremos 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">

Answer 3

Puede simplemente iterar sobre las teclas e invocar a los instaladores. 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 4

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] aún es demasiado largo para usted, puede guardar un proceso como variable de instancia y llamar al valor relevante 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, aún 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, puede definir un método setter y, además, verificar 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 5

Usar todas las claves de params no es correcto, puede definir nombres poco dispuestos. Creo que debería ser una lista bastante 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 6

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

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

p Foo.class # Class
employee = Foo.new("smith", 29, "[email protected]", "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

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