Question

我见过使用Structs的代码库来包装类中的属性和行为。 Ruby类和Struct有什么区别？何时应该使用另一个。？

Answer 1

Struct是一种使用访问器方法将多个属性捆绑在一起的便捷方式，而无需编写显式类。

Struct类生成包含一组成员及其值的新子类。对于每个成员，创建类似于Module＃attr_accessor的读写器方法。

所以，如果我想要一个可以访问名称属性（读写）的Person类，我可以通过声明一个类来实现：

class Person
  attr_accessor :name

  def initalize(name)
    @name = name
  end
end

或使用Struct：

Person = Struct.new(:name)

在这两种情况下，我都可以运行以下代码：

 person = Person.new
 person.name = "Name"
 #or Person.new("Name")
 puts person.name

何时使用？

正如描述所述，当我们需要一组可访问的属性而不必编写显式类时，我们使用Structs。

例如，我想要一个点变量来保存X和Y值：

point = Struct.new(:x, :y).new(20,30)
point.x #=> 20

更多例子：

http://blog.steveklabnik.com/posts/2012-09-01-random-ruby-tricks--struct-new
＆＃34; When to use Struct instead of Hash in Ruby?＆＃34;也有一些非常好的观点（与使用哈希相比）。

Answer 2

Struct是一种用于创建类的Ruby简写。在适用的地方使用Struct可以简化代码。在https://www.rubytapas.com/2012/11/07/episode-020-struct/

对此进行了很好的讨论

Answer 3

要添加到其他答案中，有些内容是Struct无法完成的，而有些则是您无法做到的。

例如，您不能创建没有参数的结构：

Bar = Struct.new
=> ArgumentError: wrong number of arguments (given 0, expected 1+)

Bar = Struct.new(:bar)
bar = Bar.new(nil)
bar.class
=> Bar

但是，一堂课会让你做到这一点：

class Foo; end
foo = Foo.new
foo.class
=> Foo

您不能为Struct参数设置默认值：

Bar = Struct.new(bar: 'default')
=> ArgumentError: unknown keyword: bar

Bar = Struct.new(bar = 'default')
=> NameError: identifier default needs to be constant

但是您可以使用一个类来实现，既可以传递散列，又可以使参数以任意顺序甚至丢失：

class Bar
  attr_reader :bar, :rab
  def initialize(bar: 'default', rab:)
    @bar = bar
    @rab = rab
  end
end

bar = Bar.new(rab: 'mandatory')
bar.rab
=> 'mandatory'
bar.bar
=> 'default'

bar = Bar.new(rab: 'mandatory', bar: 'custom_value')
bar.rab
=> 'mandatory'
bar.bar
=> 'custom_value'

或直接传递值，如果参数应该以相同的顺序给出，则默认值始终在末尾：

class Bar
  attr_reader :rab, :bar
  def initialize(rab, bar = 'default')
    @rab = rab
    @bar = bar
  end
end

bar = Bar.new('mandatory')
bar.rab
=> 'mandatory'
bar.bar
=> 'default'

bar = Bar.new('mandatory', 'custom_value')
bar.rab
=> 'mandatory'
bar.bar
=> 'custom_value'

除非使用以下超级详细的方式为参数设置默认值，否则您无法对Structs进行任何操作：

A = Struct.new(:a, :b, :c) do
  def initialize(a:, b: 2, c: 3)
    super(a, b, c)
  end
end

（示例取自this answer）

您可以在Struct中定义方法：

Foo = Struct.new(:foo) do
  def method(argument)
    # do something with argument
    end
  end
end

结构对于创建数据对象很有用，例如答案之一中提到的要点示例。

我有时会用它们以简单的方式在测试中创建假货和模拟。有时RSpec allow(foo).to receive(:blah)等可能会变得太冗长，而使用Struct非常简单。

Answer 4

我想@sam_forgot建议基准。比较不是很公平。如今，类和结构都支持关键字参数。在每个参数上使用关键字参数会产生相反的效果，正如从我的示例结构中使用关键字参数的性能所看到的那样，与类并没有太大的不同。

require 'benchmark'

REP=1000000

SUser = Struct.new(:name, :age)
SUserK = Struct.new(:name, :age, keyword_init: true)

DATA = { name: "Harry", age: 75 }
DATA2 = DATA.values

class CUser
  attr_accessor :name, :age
  def initialize(name, age)
    @name = name
    @age = age
  end
end

class CUserK
  attr_accessor :name, :age
  def initialize(name:, age:)
    @name = name
    @age = age
  end
end

Benchmark.bmbm do |x|
  x.report 'Struct create and access, without keyword arguments' do
    REP.times do
      user = SUser.new(DATA)
      "#{user.name} - #{user.age}"
    end
  end

  x.report 'Struct create and access, with keyword arguments' do
    REP.times do
      user = SUserK.new(**DATA)
      "#{user.name} - #{user.age}"
    end
  end

  x.report 'Class create and access, without keyword arguments' do
    REP.times do
      user = CUser.new(*DATA2)
      "#{user.name} - #{user.age}"
    end
  end 

  x.report 'Class create and access, with keyword arguments' do
    REP.times do
      user = CUserK.new(DATA)
      "#{user.name} - #{user.age}"
    end
  end
end

Rehearsal ---------------------------------------------------------------------------------------
Struct create and access, without keyword arguments   3.484609   0.011974   3.496583 (  3.564523)
Struct create and access, with keyword arguments      0.965959   0.005543   0.971502 (  1.007738)
Class create and access, without keyword arguments    0.624603   0.003999   0.628602 (  0.660931)
Class create and access, with keyword arguments       0.901494   0.004926   0.906420 (  0.952149)
------------------------------------------------------------------------------ total: 6.003107sec

                                                          user     system      total        real
Struct create and access, without keyword arguments   3.300488   0.010372   3.310860 (  3.339511)
Struct create and access, with keyword arguments      0.876742   0.004354   0.881096 (  0.903551)
Class create and access, without keyword arguments    0.553393   0.003962   0.557355 (  0.568985)
Class create and access, with keyword arguments       0.831672   0.004811   0.836483 (  0.850224)

Answer 5

实际性能差异很大，在ruby 2.6.3p62中的示例行为：

                          user       system     total     real
Struct create and access  3.052825   0.005204   3.058029  (3.066316)
Class create and access   0.738605   0.001467   0.740072  (0.743738)

示例代码：

require 'benchmark'

REP=1000000
SUser = Struct.new(:name, :age)
DATA = { name: "Harry", age: 75 }

class User
  attr_accessor :name, :age
  def initialize(name:, age:)
    @name = name
    @age = age
  end
end

Benchmark.bm 20 do |x|
  x.report 'Struct create and access' do
    REP.times do
      user = SUser.new(DATA)
      "#{user.name} - #{user.age}"
    end
  end
  x.report 'Class create and access' do
    REP.times do
      user = User.new(DATA)
      "#{user.name} - #{user.age}"
    end
  end
end

Ruby类与结构

5 个答案: