When should I use Struct vs. OpenStruct?

Other benchmark:

require 'benchmark' require 'ostruct' REP = 100000 User = Struct.new(:name, :age) USER = "User".freeze AGE = 21 HASH = {:name => USER, :age => AGE}.freeze Benchmark.bm 20 do |x| x.report 'OpenStruct slow' do REP.times do |index| OpenStruct.new(:name => "User", :age => 21) end end x.report 'OpenStruct fast' do REP.times do |index| OpenStruct.new(HASH) end end x.report 'Struct slow' do REP.times do |index| User.new("User", 21) end end x.report 'Struct fast' do REP.times do |index| User.new(USER, AGE) end end end 

For the impatient who wants to get an idea of the benchmark results, without running them themselves, here is the output of the code above (on an MB Pro 2.4GHz i7)

 user system total real OpenStruct slow 4.430000 0.250000 4.680000 ( 4.683851) OpenStruct fast 4.380000 0.270000 4.650000 ( 4.649809) Struct slow 0.090000 0.000000 0.090000 ( 0.094136) Struct fast 0.080000 0.000000 0.080000 ( 0.078940) 

UPDATE:

Timings for creating 1 million instances:

0.357788 seconds elapsed for Class.new (Ruby 2.5.5) 0.764953 seconds elapsed for Struct (Ruby 2.5.5) 0.842782 seconds elapsed for Hash (Ruby 2.5.5) 2.211959 seconds elapsed for OpenStruct (Ruby 2.5.5) 0.213175 seconds elapsed for Class.new (Ruby 2.6.3) 0.335341 seconds elapsed for Struct (Ruby 2.6.3) 0.836996 seconds elapsed for Hash (Ruby 2.6.3) 2.070901 seconds elapsed for OpenStruct (Ruby 2.6.3) 0.936016 seconds elapsed for Class.new (Ruby 2.7.2) 0.453067 seconds elapsed for Struct (Ruby 2.7.2) 1.016676 seconds elapsed for Hash (Ruby 2.7.2) 1.482318 seconds elapsed for OpenStruct (Ruby 2.7.2) 0.421272 seconds elapsed for Class.new (Ruby 3.0.0) 0.322617 seconds elapsed for Struct (Ruby 3.0.0) 0.719928 seconds elapsed for Hash (Ruby 3.0.0) 35.130777 seconds elapsed for OpenStruct (Ruby 3.0.0) (oops!) 0.443975 seconds elapsed for Class.new (Ruby 3.0.1) 0.348031 seconds elapsed for Struct (Ruby 3.0.1) 0.737662 seconds elapsed for Hash (Ruby 3.0.1) 16.264204 seconds elapsed for SmartHash (Ruby 3.0.1) (meh) 53.396924 seconds elapsed for OpenStruct (Ruby 3.0.1) (oops!) 0.407767 seconds elapsed for Class.new (Ruby 3.0.3) 0.326846 seconds elapsed for Struct (Ruby 3.0.3) 0.652807 seconds elapsed for Hash (Ruby 3.0.3) 10.679195 seconds elapsed for SmartHash (Ruby 3.0.3) 35.212618 seconds elapsed for OpenStruct (Ruby 3.0.3) 

See: Ruby 3.0.0 Bug #18032 was closed, because it is a feature, not a bug

Quotes:

OpenStruct is now considered as "an antipattern", so I recommend you no longer to use OpenStruct.

[the Ruby team] prioritized correctness over performance and came back to a solution similar to that of Ruby 2.2

Old Answers:

As of Ruby 2.4.1 OpenStruct and Struct are much closer in speed. See https://stackoverflow.com/a/43987844/128421

For completeness: Struct vs. Class vs. Hash vs. OpenStruct

Running similar code as burtlo's, on Ruby 1.9.2, (1 of 4 cores x86_64, 8GB RAM) [table edited to align columns]:

 creating 1 Mio Structs : 1.43 sec , 219 MB / 90MB (virt/res) creating 1 Mio Class instances : 1.43 sec , 219 MB / 90MB (virt/res) creating 1 Mio Hashes : 4.46 sec , 493 MB / 364MB (virt/res) creating 1 Mio OpenStructs : 415.13 sec , 2464 MB / 2.3GB (virt/res) # ~100x slower than Hashes creating 100K OpenStructs : 10.96 sec , 369 MB / 242MB (virt/res) 

OpenStructs are sloooooow and memory intensive , and don't scale well for large data sets

Here's the script to reproduce the results:

require 'ostruct' require 'smart_hash' MAX = 1_000_000 class C; attr_accessor :name, :age; def initialize(name, age) self.name = name self.age = age end end start = Time.now collection = (1..MAX).collect do |i| C.new('User', 21) end; 1 stop = Time.now puts " #{stop - start} seconds elapsed for Class.new (Ruby #{RUBY_VERSION})" s = Struct.new(:name, :age) start = Time.now collection = (1..MAX).collect do |i| s.new('User', 21) end; 1 stop = Time.now puts " #{stop - start} seconds elapsed for Struct (Ruby #{RUBY_VERSION})" start = Time.now collection = (1..MAX).collect do |i| {:name => "User" , :age => 21} end; 1 stop = Time.now puts " #{stop - start} seconds elapsed for Hash (Ruby #{RUBY_VERSION})" start = Time.now collection = (1..MAX).collect do |i| s = SmartHash[].merge( {:name => "User" , :age => 21} ) end; 1 stop = Time.now puts " #{stop - start} seconds elapsed for SmartHash (Ruby #{RUBY_VERSION})" start = Time.now collection = (1..MAX).collect do |i| OpenStruct.new(:name => "User" , :age => 21) end; 1 stop = Time.now puts " #{stop - start} seconds elapsed for OpenStruct (Ruby #{RUBY_VERSION})" 

The use cases for the two are quite different.

You can think of the Struct class in Ruby 1.9 as an equivalent to the struct declaration in C. In Ruby Struct.new takes a set of field names as arguments and returns a new Class. Similarly, in C, a struct declaration takes a set of fields and allows the programmer to use the new complex type just like he would any built-in type.

Ruby:

Newtype = Struct.new(:data1, :data2) n = Newtype.new 

C:

typedef struct { int data1; char data2; } newtype; newtype n; 

The OpenStruct class can be compared to an anonymous struct declaration in C. It allows the programmer to create an instance of a complex type.

Ruby:

o = OpenStruct.new(data1: 0, data2: 0) o.data1 = 1 o.data2 = 2 

C:

struct { int data1; char data2; } o; o.data1 = 1; o.data2 = 2; 

Here are some common use cases.

OpenStructs can be used to easily convert hashes to one-off objects which respond to all the hash keys.

h = { a: 1, b: 2 } o = OpenStruct.new(h) o.a = 1 o.b = 2 

Structs can be useful for shorthand class definitions.

class MyClass < Struct.new(:a,:b,:c) end m = MyClass.new m.a = 1 

OpenStructs use significantly more memory and are slower performers versus Structs.

require 'ostruct' collection = (1..100000).collect do |index| OpenStruct.new(:name => "User", :age => 21) end 

On my system the following code executed in 14 seconds and consumed 1.5 GB of memory. Your mileage might vary:

User = Struct.new(:name, :age) collection = (1..100000).collect do |index| User.new("User",21) end 

That finished nearly instantaneously and consumed 26.6 MB of memory.

Struct:

>> s = Struct.new(:a, :b).new(1, 2) #=> #<struct a=1, b=2> >> s.a #=> 1 >> s.b #=> 2 >> s.c #=> NoMethodError: undefined method `c` for #<struct a=1, b=2> 

OpenStruct:

>> require 'ostruct' #=> true >> os = OpenStruct.new(a: 1, b: 2) #=> #<OpenStruct a=1, b=2> >> os.a #=> 1 >> os.b #=> 2 >> os.c #=> nil 

Have a look at the API with regard to the new method. A lot of the differences can be found there.

Personally, I quite like OpenStruct, as I don't have to define the structure of the object beforehand, and just add stuff as I want. I guess that would be its main (dis)advantage?

• http://www.ruby-doc.org/core/classes/Struct.html
• http://www.ruby-doc.org/stdlib/libdoc/ostruct/rdoc/classes/OpenStruct.html

Using @Robert code, I add Hashie::Mash to the benchmark item and got this result:

 user system total real Hashie::Mash slow 3.600000 0.000000 3.600000 ( 3.755142) Hashie::Mash fast 3.000000 0.000000 3.000000 ( 3.318067) OpenStruct slow 11.200000 0.010000 11.210000 ( 12.095004) OpenStruct fast 10.900000 0.000000 10.900000 ( 12.669553) Struct slow 0.370000 0.000000 0.370000 ( 0.470550) Struct fast 0.140000 0.000000 0.140000 ( 0.145161) 

Not actually an answer to the question, but a very important consideration if you care about performance. Please notice that every time you create an OpenStruct the operation clears the method cache, which means your application will perform slower. The slowness or not of OpenStruct is not just about how it works by itself, but the implications that using them bring to the whole application: https://github.com/charliesome/charlie.bz/blob/master/posts/things-that-clear-rubys-method-cache.md#openstructs