Ruby Struct

Basic usage
Employee =, :last_name)
employee =“John”, “Doe”)
employee.first_name # => “John”
employee.last_name # => “Doe”
As you can see, it behaves like a simple Ruby class. The above code is equivalent to:

class Employee
attr_reader :first_name, :last_name

def initialize(first_name, last_name)
@first_name = first_name
@last_name = last_name

employee =“John”, “Doe”)

What if we want to define the #full_name name on our Employee class? We can do it with Struct as well:

Employee =, :last_name) do
def full_name
“#{first_name} #{last_name}”

employee =“John”, “Doe”)
employee.full_name # => “John Doe”
When to use Struct
Struct is often used to make code cleaner, format more structured data from a hash, or as a replacement for real-world classes in tests.

Temporary data structure – the most popular example is a geocoding response where you want to form Address object with attributes instead of a hash with the geocoded data.
Cleaner code
Testing – as long as Struct responds to the same methods as the object used in tests, you can replace it if it does make sense. You can consider using it when testing dependency injection.
When not to use Struct
Avoid inheritance from Struct when you can. I intentionally assigned Struct to constant in the above example instead of doing this:

class Employee <, :last_name)
def full_name
“#{first_name} #{last_name}”
When your class inherits from Struct you may not realize that:

Arguments are not required – if one of the passed arguments it’s an object then calling a method on it will cause an error
Attributes are always public – it is far from perfect encapsulation unless you desire such behavior
Instances are equal if their attributes are equal – ==
Structs don’t wanted to be subclassed – it creates an unused anonymous class and it is mentioned in the documentation
Play with it
Access the class attributes the way you want:

person =“John”)
person.first_name # => “John”
person[:first_name] # => “John”
person[“first_name”] # => “John”
Use the equality operator:

Person =“John”) ==“John”) # => true
Iterate over values or pairs:

Person =, :last_name)
person =“John”, “Doe”)


person.each do |value|
puts value

>> “John”

>> “Doe”


person.each_pair do |key, value|
puts “#{key}: #{value}”

>> “first_name: John”

>> “last_name: Doe”


Address =
Person =, :address)
address =“New York”)
person =“John Doe”, address)

person.dig(:address, :city) # => “New York”
Hash is also considered as an alternative to Struct. It is faster to use but has worse performance than its opponent (I will test it a little bit later in this article).

OpenStruct is slower but more flexible alternative. Using it you can assign attribute dynamically and it does not require predefined attributes. All you have to do is to pass a hash with attributes:

employee = “John”, last_name: “Doe”)
employee.first_name # => “John”
employee.age = 30
employee.age # => 30
Standard boilerplate
Although it may get annoying when you have to type it multiple times:

class Employee
def initialize(first_name, last_name)
@first_name = first_name
@last_name = last_name

def full_name
“#{first_name} #{last_name}”
Alternatives comparision
Name Non existing attributes Dynamically add attribute Performance (lower is better)
Struct raises error no 1
OpenStruct returns nil yes 3
Hash returns nil yes 2
I used the following code to measure the performance of the above solutions: 10 do |bench| “Hash: ” do
10_000_000.times do { name: “John Doe”, city: “New York” } end
end “Struct: ” do
klass =, :age)
10_000_000.times do“John Doe”, “New York”) end
end “Open Struct: ” do
10_000_000.times do “John Doe”, city: “New York”) end

 user    system  total   real

Hash 7.380000 0.060000 7.440000 7.456928
Struct 3.280000 0.010000 3.290000 3.283013
Open Struct 19.270000 0.120000 19.390000 19.415336

Open Struct is the slowest and most flexible solution in our comparison. Struct seems to be the best choice.