Sometimes in Ruby programming, you get to a fork in the road: should you pick Struct or go for a custom Class? They might seem like two sides of the same coin, but they each bring their own flair and strengths to your coding repertoire. Knowing when to use each can seriously level up your Ruby game.

Structs: The Easygoing Data Containers

Let’s kick things off with Struct, the laid-back, no-fuss solution for bundling attributes together. Think of a Struct as Ruby’s answer to “I need some quick data storage, stat!” Without the hassle of writing a whole class, Struct grants you accessor methods for each attribute, much like attr_accessor in custom classes.

Here’s a straightforward example:

Customer = Struct.new(:name, :address) do
  def greeting
    "Hello #{name}!"
  end
end

# Meet Dave
dave = Customer.new("Dave", "123 Main")
puts dave.name       # => "Dave"
puts dave.greeting   # => "Hello Dave!"

See? Simple, right? Struct is just the ticket when you need to whip up a data container, pronto.

Custom Classes: The Versatile Player

Now, if you’re looking for more control and customization, custom classes are where the magic happens. You can define a plethora of methods, initialize objects with various parameters, and even throw in default values for attributes—it’s all about flexibility here.

Check this out for a similar Customer class:

class Customer
  attr_accessor :name, :address

  def initialize(name, address)
    @name = name
    @address = address
  end

  def greeting
    "Hello #{name}!"
  end
end

# Reintroducting Dave
dave = Customer.new("Dave", "123 Main")
puts dave.name       # => "Dave"
puts dave.greeting   # => "Hello Dave!"

Both snippets give you the same Dave, but with a custom class, you have a bigger canvas to paint on.

When to Pick a Struct

So, when should you go with Struct?

• When you need a simple, no-frills data container.
• When you’re prototyping and need to avoid boilerplate code.
• When conserving memory is high on your list.

And When to Rock a Custom Class

On the flip side, custom classes are your go-to for:

• Embedding complex logic and custom methods.
• Initializing objects with default values and handling arguments like a pro.
• Keeping your namespace tidy and avoiding constant name clashes.

Let’s Compare By Example: Struct vs Class

Take a Point class, for instance. Here’s how you can roll both ways:

Using Struct:

Point = Struct.new(:x, :y)

point = Point.new(1, 2)
puts point.x   # => 1
puts point.y   # => 2

Using a custom class:

class Point
  attr_accessor :x, :y

  def initialize(x, y)
    @x = x
    @y = y
  end

  def distance_from_origin
    Math.sqrt(x**2 + y**2)
  end
end

point = Point.new(1, 2)
puts point.x           # => 1
puts point.y           # => 2
puts point.distance_from_origin # => 2.23606797749979

The custom class lets you add methods like distance_from_origin, showing off its ability to handle complex logic.

OpenStruct: The Wild Card

Ruby also throws OpenStruct into the mix, found in the standard library. Want to get even more dynamic with attributes? This bad boy lets you define attributes on the fly, like a hash but cooler, with method-esque access.

require 'ostruct'

person = OpenStruct.new
person.name = "John Smith"
person.age = 70

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

No need for pre-defined attributes, which can be a game-changer for dynamic data.

Performance: The Showdown

Alright, let’s touch on performance. Once upon a Ruby version, Struct was the Usain Bolt of memory usage. But recent updates have pumped some serious speed into regular classes, making them often faster. Still, Struct provides a lighter memory footprint in many cases.

Best Practices Summarized

• Opt for Struct when simplifying your data handling—think simple, low-overhead situations.
• Custom classes are perfect when you need the big guns—think flexibility and complex behavior.
• Don’t get caught up in the ease of Struct. It’s not a one-size-fits-all replacement for well-designed classes.

At the end of the day, your choice should harmonize with your specific needs, making your Ruby code not just efficient, but also a pleasure to work with. Understanding the quirks and advantages of both Struct and custom classes will make your journey through Ruby’s landscape much smoother and more enjoyable.