Apakah Struct dan bila anda menggunakannya?

Question

Accepted Answer

**`Struct`** ialah class Ruby terbina dalam untuk mencipta dengan pantas class ringkas yang membungkus bersama beberapa **atribut** — menjana constructor, accessor, kesamaan, dan banyak lagi secara automatik. Ia adalah cara ringkas untuk mentakrifkan class data ringan tanpa menulis class penuh.

## Masalah yang diselesaikan oleh Struct

```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)` menjana class dengan constructor, `attr_accessor` untuk `x` dan `y`, kesamaan berasaskan nilai, `to_s`, dan banyak lagi — menghapuskan boilerplate class data ringkas.

## 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 **kesamaan berasaskan nilai** (dua struct dengan atribut yang sama adalah sama — mudah untuk objek data), dan anda boleh menambah method tersuai dalam blok.

## Struct dimulakan dengan keyword 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
```

**`Data`** Ruby 3.2 ialah varian Struct yang immutable — sesuai untuk value object yang tidak sepatutnya berubah.

## Mengapa ia penting

`Struct` ialah ciri Ruby yang berguna untuk **mencipta class data ringkas dengan pantas** tanpa boilerplate, jadi memahaminya bernilai untuk menulis Ruby yang ringkas dan bersih.

Manfaat teras ialah menghapuskan kod berulang yang diperlukan oleh class pemegang data ringkas — bukannya menulis class penuh dengan constructor, `attr_accessor`, dan kesamaan, `Struct.new(:x, :y)` menjana semua itu dalam satu baris, termasuk **kesamaan berasaskan nilai** (dua struct dengan atribut yang sama adalah sama, iaitu apa yang anda mahukan untuk objek data dan berbeza daripada kesamaan rujukan class biasa).

Ini menjadikan Struct sesuai untuk struktur data ringan, value object, mengembalikan nilai berkumpulan daripada method, dan rekod ringkas di mana class penuh akan menjadi berlebihan — alat produktiviti praktikal yang mengekalkan kod ringkas.

Memahami Struct (class data ringkas dengan accessor dan kesamaan nilai yang dijana, serta keupayaan untuk menambah method tersuai), struct dimulakan dengan keyword (lebih jelas untuk banyak medan), dan class **`Data`** moden (alternatif immutable Ruby 3.2 untuk value object yang tidak sepatutnya berubah) ialah pengetahuan yang bernilai untuk memodelkan data ringkas dengan elegan.

Memandangkan mentakrifkan class data kecil ialah keperluan yang lazim, dan kerana Struct (dan Data) menyediakan cara yang ringkas dan idiomatik untuk melakukannya dengan tingkah laku dijana yang berguna (terutamanya kesamaan nilai), mengetahui bila untuk menggunakan Struct/Data berbanding class penuh ialah pengetahuan Ruby yang relevan secara praktikal yang mencerminkan penulisan kod yang bersih dan ringkas — alat yang berguna dalam kit alat pembangun Ruby untuk tugas kerap membungkus atribut berkaitan menjadi jenis yang ringan, merangkumi penekanan Ruby terhadap keringkasan dan mengurangkan boilerplate.