Question

我发现自己对构造函数使用了哈希参数，特别是在编写用于配置的DSL或最终用户将要暴露的其他API时。我最终做的事情如下：

class Example

    PROPERTIES = [:name, :age]

    PROPERTIES.each { |p| attr_reader p }

    def initialize(args)
        PROPERTIES.each do |p|
            self.instance_variable_set "@#{p}", args[p] if not args[p].nil?
        end
    end

end

有没有更惯用的方法来实现这一目标？抛弃常数和符号到字符串转换似乎特别令人震惊。

Answer 1

你不需要常数，但我认为你不能消除符号到字符串：

class Example
  attr_reader :name, :age

  def initialize args
    args.each do |k,v|
      instance_variable_set("@#{k}", v) unless v.nil?
    end
  end
end
#=> nil
e1 = Example.new :name => 'foo', :age => 33
#=> #<Example:0x3f9a1c @name="foo", @age=33>
e2 = Example.new :name => 'bar'
#=> #<Example:0x3eb15c @name="bar">
e1.name
#=> "foo"
e1.age
#=> 33
e2.name
#=> "bar"
e2.age
#=> nil

顺便说一句，您可以在Struct类生成器类中查看（如果您还没有），它有点类似于您正在执行的操作，但没有哈希类型初始化（但我想它不会很难做出足够的发电机级。）

`HasProperties`

试图实现hurikhan的想法，这就是我的意思：

module HasProperties
  attr_accessor :props

  def has_properties *args
    @props = args
    instance_eval { attr_reader *args }
  end

  def self.included base
    base.extend self
  end

  def initialize(args)
    args.each {|k,v|
      instance_variable_set "@#{k}", v if self.class.props.member?(k)
    } if args.is_a? Hash
  end
end

class Example
  include HasProperties

  has_properties :foo, :bar

  # you'll have to call super if you want custom constructor
  def initialize args
    super
    puts 'init example'
  end
end

e = Example.new :foo => 'asd', :bar => 23
p e.foo
#=> "asd"
p e.bar
#=> 23

由于我不熟悉元编程，我做了答案社区维基，所以任何人都可以自由地改变实现。

`Struct.hash_initialized`

扩展Marc-Andre的答案，这是一个基于Struct的通用方法来创建哈希初始化类：

class Struct
  def self.hash_initialized *params
    klass = Class.new(self.new(*params))

    klass.class_eval do
      define_method(:initialize) do |h|
        super(*h.values_at(*params))
      end
    end
    klass
  end
end

# create class and give it a list of properties
MyClass = Struct.hash_initialized :name, :age

# initialize an instance with a hash
m = MyClass.new :name => 'asd', :age => 32
p m
#=>#<struct MyClass name="asd", age=32>

Answer 2

Struct clas可以帮助你建立这样一个类。初始化器逐个接受参数而不是散列，但很容易转换它：

class Example < Struct.new(:name, :age)
    def initialize(h)
        super(*h.values_at(:name, :age))
    end
end

如果您想保持更通用，可以改为呼叫values_at(*self.class.members)。

Answer 3

Ruby中有一些有用的东西可以用来做这种事情。 OpenStruct类将使a的值传递给它的初始化方法可用作类的属性。

require 'ostruct'

class InheritanceExample < OpenStruct
end

example1 = InheritanceExample.new(:some => 'thing', :foo => 'bar')

puts example1.some  # => thing
puts example1.foo   # => bar

文档在这里： http://www.ruby-doc.org/stdlib-1.9.3/libdoc/ostruct/rdoc/OpenStruct.html

如果您不想从OpenStruct继承，那该怎么办？（或者不能，因为您是已经继承了其他东西）？您可以委派所有方法使用Forwardable调用OpenStruct实例。

require 'forwardable'
require 'ostruct'

class DelegationExample
  extend Forwardable

  def initialize(options = {})
    @options = OpenStruct.new(options)
    self.class.instance_eval do
      def_delegators :@options, *options.keys
    end
  end
end

example2 = DelegationExample.new(:some => 'thing', :foo => 'bar')

puts example2.some  # => thing
puts example2.foo   # => bar

可转发文档在这里： http://www.ruby-doc.org/stdlib-1.9.3/libdoc/forwardable/rdoc/Forwardable.html

Answer 4

鉴于你的哈希值包括ActiveSupport::CoreExtensions::Hash::Slice，有一个非常好的解决方案：

class Example

  PROPERTIES = [:name, :age]

  attr_reader *PROPERTIES  #<-- use the star expansion operator here

  def initialize(args)
    args.slice(PROPERTIES).each {|k,v|  #<-- slice comes from ActiveSupport
      instance_variable_set "@#{k}", v
    } if args.is_a? Hash
  end
end

我会将此抽象为一个通用模块，您可以将其包含在内，并定义一个“has_properties”方法来设置属性并进行正确的初始化（这是未经测试的，将其视为伪代码）：

module HasProperties
  def self.has_properties *args
    class_eval { attr_reader *args }
  end

  def self.included base
    base.extend InstanceMethods
  end

  module InstanceMethods
    def initialize(args)
      args.slice(PROPERTIES).each {|k,v|
        instance_variable_set "@#{k}", v
      } if args.is_a? Hash
    end
  end
end

Answer 5

我的解决方案类似于Marc-AndréLafortune。不同之处在于每个值都从输入哈希中删除，因为它用于分配成员变量。然后，Struct-derived类可以对Hash中可能留下的任何内容执行进一步处理。例如，下面的JobRequest在选项字段中保留Hash中的任何“额外”参数。

module Message
  def init_from_params(params)
    members.each {|m| self[m] ||= params.delete(m)}
  end
end

class JobRequest < Struct.new(:url, :file, :id, :command, :created_at, :options)
  include Message

  # Initialize from a Hash of symbols to values.
  def initialize(params)
    init_from_params(params)
    self.created_at ||= Time.now
    self.options = params
  end
end

Answer 6

请查看我的宝石Valuable：

class PhoneNumber < Valuable
  has_value :description
  has_value :number
end

class Person < Valuable
  has_value :name
  has_value :favorite_color, :default => 'red'
  has_value :age, :klass => :integer
  has_collection :phone_numbers, :klass => PhoneNumber
end

jackson = Person.new(name: 'Michael Jackson', age: '50', phone_numbers: [{description: 'home', number: '800-867-5309'}, {description: 'cell', number: '123-456-7890'})

> jackson.name
=> "Michael Jackson"
> jackson.age
=> 50
> jackson.favorite_color
=> "red"
>> jackson.phone_numbers.first
=> #<PhoneNumber:0x1d5a0 @attributes={:description=>"home", :number=>"800-867-5309"}>

我将它用于从搜索类（EmployeeSearch，TimeEntrySearch）到报告（EmployeesWhoDidNotClockOutReport，ExecutiveSummaryReport）到演示者到API端点的所有内容。如果添加一些ActiveModel位，您可以轻松地将这些类挂钩到表单以收集条件。我希望你觉得它很有用。

使用哈希参数进行Ruby初始化

6 个答案:

`HasProperties`

`Struct.hash_initialized`