Ruby 结构中的命名参数

Question

我对 Ruby 还很陌生，所以如果这是一个明显的问题，我深表歉意。

我想在实例化 Struct 时使用命名参数，即能够指定 Struct 中的哪些项获取哪些值，并将其余项默认为 nil。

例如我想做：

Movie = Struct.new :title, :length, :rating
m = Movie.new :title => 'Some Movie', :rating => 'R'

这不起作用。

所以我想出了以下方法：

class MyStruct < Struct
  # Override the initialize to handle hashes of named parameters
  def initialize *args
    if (args.length == 1 and args.first.instance_of? Hash) then
      args.first.each_pair do |k, v|
        if members.include? k then
          self[k] = v
        end
      end
    else
      super *args
    end
  end
end

Movie = MyStruct.new :title, :length, :rating
m = Movie.new :title => 'Some Movie', :rating => 'R'

这似乎工作得很好，但我不确定是否有更好的方法来做到这一点，或者我是否正在做一些相当疯狂的事情。如果有人可以验证/分解这种方法，我将不胜感激。

更新

我最初在 1.9.2 中运行了这个，它运行良好；但是在其他版本的 Ruby 中尝试过（谢谢 rvm），它工作/不工作如下：

• 1.8.7：不工作
• 1.9.1：工作
• 1.9.2：工作
• JRuby（设置为运行为 1.9.2 ）：不工作

JRuby 对我来说是一个问题，因为我希望保持它与部署目的兼容。

另一个更新

在这个不断增加的漫无目的的问题中，我尝试了 Ruby 的各个版本，发现 1.9.x 中的结构将其成员存储为符号，但在 1.8.7 和 JRuby 中，它们是存储为字符串，因此我将代码更新为以下内容（采纳已经友好给出的建议）：

class MyStruct < Struct
  # Override the initialize to handle hashes of named parameters
  def initialize *args
    return super unless (args.length == 1 and args.first.instance_of? Hash)
    args.first.each_pair do |k, v|
      self[k] = v if members.map {|x| x.intern}.include? k
    end
  end
end

Movie = MyStruct.new :title, :length, :rating
m = Movie.new :title => 'Some Movie', :rating => 'R'

现在，这似乎适用于我尝试过的所有 Ruby 风格。

Answer 1

在 Ruby 2.5+ 中，您可以使用 keyword_init: true

Movie = Struct.new(:title, :length, :rating, keyword_init: true)

Movie.new(title: 'Title', length: '120m', rating: 'R')
  # => #<struct Movie title="Title", length="120m", rating="R">

Answer 2

综合现有的答案揭示了 Ruby 2.0+ 的一个更简单的选项：

class KeywordStruct < Struct
  def initialize(**kwargs)
    super(*members.map{|k| kwargs[k] })
  end
end

用法与现有的 Struct 相同，其中任何未给出的参数将默认为 nil：

Pet = KeywordStruct.new(:animal, :name)
Pet.new(animal: "Horse", name: "Bucephalus") # => #<struct Pet animal="Horse", name="Bucephalus">  
Pet.new(name: "Bob") # => #<struct Pet animal=nil, name="Bob"> 

如果您想需要像 Ruby 2.1+ 所需的 kwargs 那样的参数，这是一个非常小的变化：

class RequiredKeywordStruct < Struct
  def initialize(**kwargs)
    super(*members.map{|k| kwargs.fetch(k) })
  end
end

此时，重写 initialize 来给出某些 kwargs 默认值也是可行的：

Pet = RequiredKeywordStruct.new(:animal, :name) do
  def initialize(animal: "Cat", **args)
    super(**args.merge(animal: animal))
  end
end

Pet.new(name: "Bob") # => #<struct Pet animal="Cat", name="Bob">

Answer 3

你知道的越少越好。无需知道底层数据结构是否使用符号或字符串，甚至不需要知道它是否可以作为哈希进行寻址。只需使用属性设置器：

class KwStruct < Struct.new(:qwer, :asdf, :zxcv)
  def initialize *args
    opts = args.last.is_a?(Hash) ? args.pop : Hash.new
    super *args
    opts.each_pair do |k, v|
      self.send "#{k}=", v
    end
  end
end

它同时接受位置参数和关键字参数：

> KwStruct.new "q", :zxcv => "z"
 => #<struct KwStruct qwer="q", asdf=nil, zxcv="z">

Answer 4

仅允许 Ruby 关键字参数 (Ruby >=2.0) 的解决方案。

class KeywordStruct < Struct
  def initialize(**kwargs)
    super(kwargs.keys)
    kwargs.each { |k, v| self[k] = v }
  end
end

用法：

class Foo < KeywordStruct.new(:bar, :baz, :qux)
end


foo = Foo.new(bar: 123, baz: true)
foo.bar  # --> 123
foo.baz  # --> true
foo.qux  # --> nil
foo.fake # --> NoMethodError

这种结构作为值对象非常有用，特别是如果您喜欢更严格的方法访问器，它实际上会出错而不是返回 nil （类似于 OpenStruct）。

Answer 5

您考虑过 OpenStruct 吗？

require 'ostruct'

person = OpenStruct.new(:name => "John", :age => 20)
p person               # #<OpenStruct name="John", age=20>
p person.name          # "John"
p person.adress        # nil

Answer 6

您可以重新排列 if。

class MyStruct < Struct
  # Override the initialize to handle hashes of named parameters
  def initialize *args
    # I think this is called a guard clause
    # I suspect the *args is redundant but I'm not certain
    return super *args unless (args.length == 1 and args.first.instance_of? Hash)
    args.first.each_pair do |k, v|
      # I can't remember what having the conditional on the same line is called
      self[k] = v if members.include? k
    end
  end
end

Answer 7

基于 @Andrew Grimm 的答案，但使用 Ruby 2.0 的关键字参数：

class Struct

  # allow keyword arguments for Structs
  def initialize(*args, **kwargs)
    param_hash = kwargs.any? ? kwargs : Hash[ members.zip(args) ]
    param_hash.each { |k,v| self[k] = v }
  end

end

请注意，这不允许混合常规参数和关键字参数——您只能使用其中之一。

Answer 8

如果你的哈希键是有序的，你可以调用 splat 运算符来救援：

NavLink = Struct.new(:name, :url, :title)
link = { 
  name: 'Stack Overflow', 
  url: 'https://stackoverflow.com', 
  title: 'Sure whatever' 
}
actual_link = NavLink.new(*link.values) 
#<struct NavLink name="Stack Overflow", url="https://stackoverflow.com", title="Sure whatever"> 

Answer 9

如果您确实需要混合常规参数和关键字参数，您始终可以手动构造初始值设定项...

Movie = Struct.new(:title, :length, :rating) do
  def initialize(title, length: 0, rating: 'PG13')
    self.title = title
    self.length = length
    self.rating = rating
  end
end

m = Movie.new('Star Wars', length: 'too long')
=> #<struct Movie title="Star Wars", length="too long", rating="PG13">

这将标题作为强制的第一个参数只是为了说明。它还具有的优点是您可以为每个关键字参数设置默认值（尽管这在处理电影时不太可能有帮助！）。

Answer 10

对于与 Struct 行为的 1 对 1 等效（在未给出所需参数时引发），我有时会使用它（Ruby 2+）：

def Struct.keyed(*attribute_names)
  Struct.new(*attribute_names) do
    def initialize(**kwargs)
      attr_values = attribute_names.map{|a| kwargs.fetch(a) }
      super(*attr_values)
    end
  end
end

并且从那里开始，

class SimpleExecutor < Struct.keyed :foo, :bar
  ...
end

如果您错过了一个参数，对于更严格的构造函数和具有大量参数、数据传输对象等的构造函数来说非常好。

Answer 11

这并不能完全回答问题，但我发现如果你说你想要构造的值的散列，它会很好地工作。它的优点是不需要记住属性的顺序，同时也不需要子类化 Struct。

MyStruct = Struct.new(:height, :width, :length)

hash = {高度：10，宽度：111，长度：20}

MyStruct.new (*MyStruct.members.map {|key| hash[key] })

Answer 12

仅限 Ruby 2.x（如果您需要必需的关键字参数，则为 2.1）。仅在 MRI 中进行了测试。

def Struct.new_with_kwargs(lamb)
  members = lamb.parameters.map(&:last)
  Struct.new(*members) do
    define_method(:initialize) do |*args|
      super(* lamb.(*args))
    end
  end
end

Foo = Struct.new_with_kwargs(
  ->(a, b=1, *splat, c:, d: 2, **kwargs) do
    # must return an array with values in the same order as lambda args
    [a, b, splat, c, d, kwargs]
  end
)

用法：

> Foo.new(-1, 3, 4, c: 5, other: 'foo')
=> #<struct Foo a=-1, b=3, splat=[4], c=5, d=2, kwargs={:other=>"foo"}>

次要的缺点是您必须确保 lambda 以正确的顺序返回值；最大的好处是您可以使用 ruby​​ 2 的关键字参数的全部功能。