Struct ਕੀ ਹੈ ਅਤੇ ਤੁਸੀਂ ਇਸਦੀ ਵਰਤੋਂ ਕਦੋਂ ਕਰਦੇ ਹੋ?

Question

Accepted Answer

**`Struct`** ਇੱਕ ਬਿਲਟ-ਇਨ Ruby ਕਲਾਸ ਹੈ ਜੋ ਕੁਝ ਸਧਾਰਨ ਕਲਾਸਾਂ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਬਣਾਉਣ ਲਈ ਹੈ ਜੋ ਕੁਝ **attributes** ਨੂੰ ਇਕੱਠਾ ਕਰਦੀਆਂ ਹਨ — constructor, accessors, equality, ਅਤੇ ਹੋਰ ਬਹੁਤ ਕੁਝ ਆਪਣੇ ਆਪ ਬਣਾ ਦਿੰਦੀਆਂ ਹਨ। ਇਹ ਇੱਕ ਪੂਰੀ ਕਲਾਸ ਲਿਖਣ ਤੋਂ ਬਿਨਾ ਹਲਕੇ ਡੇਟਾ ਕਲਾਸਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦਾ ਸੰਖੇਪ ਤਰੀਕਾ ਹੈ।

## ਸਮੱਸਿਆ ਜੋ 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)` ਇੱਕ constructor, `x` ਅਤੇ `y` ਲਈ `attr_accessor`s, value-based equality, `to_s`, ਅਤੇ ਹੋਰ ਵੀ ਪ੍ਰਦਾਨ ਕਰਦਿਆਂ ਇੱਕ ਕਲਾਸ ਬਣਾਉਂਦਾ ਹੈ — ਇੱਕ ਸਧਾਰਨ ਡੇਟਾ ਕਲਾਸ ਦੇ boilerplate ਨੂੰ ਖਤਮ ਕਰਦਿਆਂ।

## 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
```

Structs accessors ਅਤੇ **value-based equality** ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ (ਦੋ structs ਬਰਾਬਰ attributes ਦੇ ਨਾਲ ਬਰਾਬਰ ਹਨ — ਡੇਟਾ ਆਬਜੈਕਟਸ ਲਈ ਸੁਵਿਧਾਜਨਕ), ਅਤੇ ਤੁਸੀਂ ਇੱਕ ਬਲਾਕ ਵਿੱਚ ਕਸਟਮ ਤਰੀਕੇ ਸ਼ਾਮਿਲ ਕਰ ਸਕਦੇ ਹੋ।

## Keyword-initialized structs ਅਤੇ 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 ਦਾ **`Data`** Struct ਦਾ ਇਮਿਊਟੇਬਲ ਵੇਰੀਐਂਟ ਹੈ — value objects ਲਈ ਆਦਰਸ਼ ਜੋ ਬਦਲਦੇ ਨਹੀਂ ਹਨ।

## ਇਹ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

`Struct` boilerplate ਤੋਂ ਬਿਨਾ **ਸਧਾਰਨ ਡੇਟਾ ਕਲਾਸਾਂ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਬਣਾਉਣ** ਲਈ ਇੱਕ ਮਉਜ਼ੂਂ Ruby ਵਿਸ਼ੇਸ਼ਤਾ ਹੈ — ਇਸਨੂੰ ਸਮਝਣਾ ਸੰਖੇਪ, ਸਾਫ਼ Ruby ਲਿਖਣ ਲਈ ਮੁੱਲਵਾਨ ਹੈ।

ਮੂਲ ਲਾਭ ਉਹ ਦੁਹਰਾਈ ਜਾਣ ਵਾਲਾ ਕੋਡ ਖਤਮ ਕਰਨਾ ਹੈ ਜੋ ਇੱਕ ਸਧਾਰਨ data-holding ਕਲਾਸ ਨੂੰ ਲੋੜ ਹੈ — ਇੱਕ constructor, `attr_accessor`s, ਅਤੇ equality ਦੇ ਨਾਲ ਪੂਰੀ ਕਲਾਸ ਲਿਖਣ ਦੀ ਬਜਾਏ, `Struct.new(:x, :y)` ਇੱਕ ਲਾਈਨ ਵਿੱਚ ਉਸ ਸਭ ਨੂੰ ਬਣਾਉਂਦਾ ਹੈ, **value-based equality** ਸਮੇਤ (ਦੋ structs ਬਰਾਬਰ attributes ਦੇ ਨਾਲ ਬਰਾਬਰ ਹਨ, ਜੋ ਤੁਹਾਡੇ ਪਾਸ ਡੇਟਾ ਆਬਜੈਕਟਸ ਲਈ ਹੈ ਅਤੇ ਰੈਗੂਲਰ ਕਲਾਸਾਂ ਦੀ reference equality ਤੋਂ ਅਲਗ ਹੈ)।

ਇਹ Struct ਨੂੰ ਹਲਕੀਆਂ ਡੇਟਾ ਸਟ੍ਰਕਚਰਾਂ, value objects, ਮੈਥਡਸ ਤੋਂ ਗਰੁੱਪ ਕੀਤੀਆਂ ਵੈਲਯੂਜ਼ ਵਾਪਸ ਕਰਨ, ਅਤੇ ਸਧਾਰਨ ਰਿਕਾਰਡਸ ਲਈ ਆਦਰਸ਼ ਬਣਾਉਂਦਾ ਹੈ ਜਿੱਥੇ ਇੱਕ ਪੂਰੀ ਕਲਾਸ ਓਵਰਕਿਲ ਹੋਵੇ — ਇੱਕ ਵਿਹਾਰਕ ਉਤਪਾਦਕਤਾ ਟੂਲ ਜੋ ਕੋਡ ਨੂੰ ਸੰਖੇਪ ਰੱਖਦਾ ਹੈ।

Struct (generated accessors ਅਤੇ value equality ਦੇ ਨਾਲ ਸੰਖੇਪ ਡੇਟਾ ਕਲਾਸਾਂ, ਨਾਲ ਹੀ custom methods ਸ਼ਾਮਿਲ ਕਰਨ ਦੀ ਸਮਰੱਥਾ), keyword-initialized structs (ਬਹੁਤ ਸਾਰੀਆਂ ਫੀਲਡਸ ਲਈ ਵਧੇਰੇ ਸਪਸ਼ਟ), ਅਤੇ ਆਧੁਨਿਕ **`Data`** ਕਲਾਸ (Ruby 3.2 ਦਾ immutable ਵਿਕਲਪ value objects ਲਈ ਜੋ ਬਦਲਦੇ ਨਹੀਂ ਹਨ) ਨੂੰ ਸਮਝਣਾ ਸਧਾਰਨ ਡੇਟਾ ਨੂੰ ਸ਼ਾਨਦਾਰ ਢੰਗ ਨਾਲ ਮਾਡਲ ਕਰਨ ਲਈ ਮੁੱਲਵਾਨ ਗਿਆਨ ਹੈ।

ਕਿਉਂਕਿ ਛੋਟੀਆਂ ਡੇਟਾ ਕਲਾਸਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਇੱਕ ਆਮ ਜ਼ਰੂਰਤ ਹੈ, ਅਤੇ Struct (ਅਤੇ Data) ਉਸ ਲਈ ਇੱਕ ਸੰਖੇਪ, idiomatic ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ ਲਾਭਦਾਇਕ generated behavior (ਖਾਸ ਕਰਕੇ value equality) ਦੇ ਨਾਲ, Struct/Data ਬਨਾਮ ਪੂਰੀ ਕਲਾਸ ਪੌਂਦੇ ਸਮੇਂ ਇਸ ਨੂੰ ਜਾਣਨਾ ਵਿਹਾਰਕ ਤੌਰ ਉੱਤੇ ਪ੍ਰਾਸੰਗਿਕ Ruby ਗਿਆਨ ਹੈ ਜੋ ਸਾਫ਼, ਸੰਖੇਪ ਕੋਡ ਲਿਖਣ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ — Ruby ਡਿਵੈਲਪਰ ਦੇ ਟੂਲਕਿਟ ਵਿੱਚ ਇੱਕ ਮੁਫੀਦ ਟੂਲ ਸੰਬੰਧਿਤ attributes ਨੂੰ ਇੱਕ ਹਲਕੀ ਕਿਸਮ ਵਿੱਚ ਬੰਡਲ ਕਰਨ ਦੇ ਅਕਸਰ ਕੰਮ ਲਈ, Ruby ਦੇ conciseness ਅਤੇ boilerplate ਨੂੰ ਘਟਾਉਣ ਉੱਤੇ ਜ਼ੋਰ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।