class OpenStruct

An OpenStruct is a data structure, similar to a Hash, that allows the definition of arbitrary attributes with their accompanying values. This is accomplished by using Ruby's metaprogramming to define methods on the class itself.


require "ostruct"

person = = "John Smith"
person.age  = 70      # => "John Smith"
person.age       # => 70
person.address   # => nil

An OpenStruct employs a Hash internally to store the attributes and values and can even be initialized with one:

australia = => "Australia", :capital => "Canberra")
  # => #<OpenStruct country="Australia", capital="Canberra">

Hash keys with spaces or characters that could normally not be used for method calls (e.g. ()[]*) will not be immediately available on the OpenStruct object as a method for retrieval or assignment, but can still be reached through the Object#send method.

measurements ="length (in inches)" => 24)
measurements.send("length (in inches)")   # => 24

message = => true)
message.queued?                           # => true
message.send("queued?=", false)
message.queued?                           # => false

Removing the presence of an attribute requires the execution of the delete_field method as setting the property value to nil will not remove the attribute.

first_pet  = => "Rowdy", :owner => "John Smith")
second_pet = => "Rowdy")

first_pet.owner = nil
first_pet                 # => #<OpenStruct name="Rowdy", owner=nil>
first_pet == second_pet   # => false

first_pet                 # => #<OpenStruct name="Rowdy">
first_pet == second_pet   # => true


An OpenStruct utilizes Ruby's method lookup structure to find and define the necessary methods for properties. This is accomplished through the methods method_missing and define_singleton_method.

This should be a consideration if there is a concern about the performance of the objects that are created, as there is much more overhead in the setting of these properties compared to using a Hash or a Struct.

Public Class Methods

json_create(object) click to toggle source

Deserializes JSON string by constructing new Struct object with values t serialized by to_json.

# File ext/json/lib/json/add/ostruct.rb, line 11
def self.json_create(object)
  new(object['t'] || object[:t])
new(hash=nil) click to toggle source

Creates a new OpenStruct object. By default, the resulting OpenStruct object will have no attributes.

The optional hash, if given, will generate attributes and values (can be a Hash, an OpenStruct or a Struct). For example:

require "ostruct"
hash = { "country" => "Australia", :capital => "Canberra" }
data =

data   # => #<OpenStruct country="Australia", capital="Canberra">
# File lib/ostruct.rb, line 91
def initialize(hash=nil)
  @table = {}
  if hash
    hash.each_pair do |k, v|
      k = k.to_sym
      @table[k] = v

Public Instance Methods

==(other) click to toggle source

Compares this object and other for equality. An OpenStruct is equal to other when other is an OpenStruct and the two objects' Hash tables are equal.

require "ostruct"
first_pet  ="name" => "Rowdy")
second_pet =  => "Rowdy")
third_pet  ="name" => "Rowdy", :age => nil)

first_pet == second_pet   # => true
first_pet == third_pet    # => false
# File lib/ostruct.rb, line 359
def ==(other)
  return false unless other.kind_of?(OpenStruct)
  @table == other.table!
ostruct[name] → object click to toggle source

Returns the value of an attribute.

require "ostruct"
person ="name" => "John Smith", "age" => 70)
person[:age]   # => 70, same as person.age
# File lib/ostruct.rb, line 244
def [](name)
ostruct[name] = obj → obj click to toggle source

Sets the value of an attribute.

require "ostruct"
person ="name" => "John Smith", "age" => 70)
person[:age] = 42   # equivalent to person.age = 42
person.age          # => 42
# File lib/ostruct.rb, line 259
def []=(name, value)
  modifiable?[new_ostruct_member!(name)] = value
as_json(*) click to toggle source

Returns a hash, that will be turned into a JSON object and represent this object.

# File ext/json/lib/json/add/ostruct.rb, line 17
def as_json(*)
  klass =
  klass.to_s.empty? and raise JSON::JSONError, "Only named structs are supported!"
    JSON.create_id => klass,
    't'            => table,
delete_field(name) click to toggle source

Removes the named field from the object. Returns the value that the field contained if it was defined.

require "ostruct"

person = "John", age: 70, pension: 300)

person.delete_field("age")   # => 70
person                       # => #<OpenStruct name="John", pension=300>

Setting the value to nil will not remove the attribute:

person.pension = nil
person                 # => #<OpenStruct name="John", pension=nil>
# File lib/ostruct.rb, line 308
def delete_field(name)
  sym = name.to_sym
    singleton_class.remove_method(sym, "#{sym}=")
  rescue NameError
  @table.delete(sym) do
    raise"no field `#{sym}' in #{self}", sym)
dig(name, ...) → object click to toggle source

Extracts the nested value specified by the sequence of name objects by calling dig at each step, returning nil if any intermediate step is nil.

require "ostruct"
address ="city" => "Anytown NC", "zip" => 12345)
person  ="name" => "John Smith", "address" => address)

person.dig(:address, "zip")            # => 12345
person.dig(:business_address, "zip")   # => nil

data = => [1, [2, 3]])

data.dig(:array, 1, 0)   # => 2
data.dig(:array, 0, 0)   # TypeError: Integer does not have #dig method
# File lib/ostruct.rb, line 283
def dig(name, *names)
    name = name.to_sym
  rescue NoMethodError
    raise TypeError, "#{name} is not a symbol nor a string"
  @table.dig(name, *names)
each_pair {|name, value| block } → ostruct click to toggle source
each_pair → Enumerator

Yields all attributes (as symbols) along with the corresponding values or returns an enumerator if no block is given.

require "ostruct"
data ="country" => "Australia", :capital => "Canberra")
data.each_pair.to_a   # => [[:country, "Australia"], [:capital, "Canberra"]]
# File lib/ostruct.rb, line 144
def each_pair
  return to_enum(__method__) { @table.size } unless block_given?
  @table.each_pair{|p| yield p}
eql?(other) click to toggle source

Compares this object and other for equality. An OpenStruct is eql? to other when other is an OpenStruct and the two objects' Hash tables are eql?.

# File lib/ostruct.rb, line 369
def eql?(other)
  return false unless other.kind_of?(OpenStruct)
freeze() click to toggle source
Calls superclass method Object#freeze
# File lib/ostruct.rb, line 202
def freeze
  @table.each_key {|key| new_ostruct_member!(key)}
hash() click to toggle source

Computes a hash code for this OpenStruct. Two OpenStruct objects with the same content will have the same hash code (and will compare using eql?).

See also Object#hash.

# File lib/ostruct.rb, line 379
def hash
inspect() click to toggle source

Returns a string containing a detailed summary of the keys and values.

# File lib/ostruct.rb, line 324
def inspect
  ids = (Thread.current[InspectKey] ||= [])
  if ids.include?(object_id)
    detail = ' ...'
    ids << object_id
      detail = do |key, value|
        " #{key}=#{value.inspect}"
  ['#<', self.class, detail, '>'].join
Also aliased as: to_s
marshal_dump() click to toggle source

Provides marshalling support for use by the Marshal library.

# File lib/ostruct.rb, line 153
def marshal_dump
marshal_load(x) click to toggle source

Provides marshalling support for use by the Marshal library.

# File lib/ostruct.rb, line 160
def marshal_load(x)
  @table = x
to_h → hash click to toggle source
to_h {|name, value| block } → hash

Converts the OpenStruct to a hash with keys representing each attribute (as symbols) and their corresponding values.

If a block is given, the results of the block on each pair of the receiver will be used as pairs.

require "ostruct"
data ="country" => "Australia", :capital => "Canberra")
data.to_h   # => {:country => "Australia", :capital => "Canberra" }
data.to_h {|name, value| [name.to_s, value.upcase] }
            # => {"country" => "AUSTRALIA", "capital" => "CANBERRA" }
# File lib/ostruct.rb, line 124
def to_h(&block)
  if block_given?
to_json(*args) click to toggle source

Stores class name (OpenStruct) with this struct's values v as a JSON string.

# File ext/json/lib/json/add/ostruct.rb, line 28
def to_json(*args)
Alias for: inspect