Apa itu Struct dan kapan Anda menggunakannya?

Question

Accepted Answer

**`Struct`** adalah built-in class Ruby untuk dengan cepat membuat class sederhana yang menggabungkan beberapa **atribut** — menghasilkan constructor, accessor, equality, dan lebih banyak lagi secara otomatis. Ini adalah cara yang ringkas untuk mendefinisikan lightweight data class tanpa menulis class lengkap.

## Masalah yang Struct selesaikan

```ruby
# ❌ a full class for simple data is verbose boilerplate
class Point
  attr_accessor :x, :y
  def initialize(x, y)
    @x = x
    @y = y
  end
  def ==(other)
    x == other.x && y == other.y
  end
end

# ✅ Struct does all of that in ONE line
Point = Struct.new(:x, :y)
```

`Struct.new(:x, :y)` menghasilkan sebuah class dengan constructor, `attr_accessor`s untuk `x` dan `y`, value-based equality, `to_s`, dan lainnya — menghilangkan boilerplate dari simple data class.

## Menggunakan Struct

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

p = Point.new(1, 2)
p.x              # 1 — accessor generated
p.y = 5           # setter generated
p == Point.new(1, 5)   # true — VALUE-based equality (generated)
p.to_a            # [1, 5] — convertible

# Structs can have methods too
Point = Struct.new(:x, :y) do
  def distance_from_origin
    Math.sqrt(x**2 + y**2)
  end
end
Point.new(3, 4).distance_from_origin   # 5.0
```

Struct menyediakan accessor dan **value-based equality** (dua struct dengan atribut yang sama adalah sama — nyaman untuk data object), dan Anda dapat menambahkan custom method dalam sebuah block.

## Keyword-initialized struct dan Data (Ruby 3.2)

```ruby
# keyword arguments (clearer for many fields)
Point = Struct.new(:x, :y, keyword_init: true)
Point.new(x: 1, y: 2)

# Data (Ruby 3.2+) — an IMMUTABLE alternative to Struct (for value objects)
Point = Data.define(:x, :y)
p = Point.new(1, 2)
p.x              # 1 (read-only — immutable)
p2 = p.with(x: 5)  # non-destructive copy with a change
```

Ruby 3.2's **`Data`** adalah variant immutable dari Struct — ideal untuk value object yang tidak seharusnya berubah.

## Mengapa ini penting

`Struct` adalah fitur Ruby yang berguna untuk **dengan cepat membuat simple data class** tanpa boilerplate, jadi memahaminya berharga untuk menulis Ruby yang ringkas dan bersih.

Manfaat utamanya adalah menghilangkan kode repetitif yang diperlukan simple data-holding class — alih-alih menulis class lengkap dengan constructor, `attr_accessor`s, dan equality, `Struct.new(:x, :y)` menghasilkan semua itu dalam satu baris, termasuk **value-based equality** (dua struct dengan atribut yang sama adalah sama, yang adalah yang Anda inginkan untuk data object dan berbeda dari reference equality class biasa).

Ini membuat Struct ideal untuk lightweight data structure, value object, mengembalikan grouped value dari method, dan simple record di mana full class akan berlebihan — alat produktivitas praktis yang menjaga kode tetap ringkas.

Memahami Struct (concise data class dengan accessor yang dihasilkan dan value equality, plus kemampuan menambahkan custom method), keyword-initialized struct (lebih jelas untuk banyak field), dan modern **`Data`** class (alternatif immutable Ruby 3.2 untuk value object yang tidak seharusnya berubah) adalah pengetahuan berharga untuk memodelkan simple data dengan elegan.

Karena mendefinisikan small data class adalah kebutuhan umum, dan karena Struct (dan Data) menyediakan cara ringkas dan idiomatic untuk melakukannya dengan useful generated behavior (terutama value equality), mengetahui kapan harus menggunakan Struct/Data versus full class adalah pengetahuan Ruby yang praktis-relevan yang mencerminkan penulisan kode yang bersih dan ringkas — alat berguna dalam toolkit Ruby developer untuk tugas yang sering terjadi yaitu menggabungkan atribut terkait ke dalam lightweight type, yang memanifestasikan penekanan Ruby pada conciseness dan mengurangi boilerplate.