Menene abin da freezing abubuwa ke yi da kuma me yasa za mu yi amfani da frozen string literals?

Question

Accepted Answer

**Freezing** wani abu (`.freeze`) yana sa shi **immutable** — ba za a iya canja shi ba. Gada gida shine **frozen string literals**, wanda ke inganta karfin (strings ana sake amfani da su maimakon sake ƙirƙira) da kare karewa daidai. Ruby na zamani yana buƙatar frozen strings.

## freeze yana sa abubuwa su zama immutable

```ruby
config = { api_key: "secret" }.freeze
config[:api_key] = "new"    # ❌ FrozenError — can't modify a frozen object

NAME = "Application".freeze   # freeze constants to prevent accidental modification

str = "hello".freeze
str.frozen?                  # true
str << " world"              # ❌ FrozenError
```

`.freeze` yana hana kowane canja gida na abu — mai amfani ga constants da bayanan da ake barazana wanda ba ya kamata ya canja (karewa daga kuƙi na canja

## Matsalar karfin da frozen strings ke warware

```ruby
# WITHOUT frozen string literals: each "hello" creates a NEW string object
1000.times { x = "hello" }    # 1000 separate string objects allocated! (GC pressure)

# WITH frozen string literals: identical literals are REUSED (one shared object)
1000.times { x = "hello" }    # reuses the SAME frozen "hello" object → efficient
```

String literals suna da alama mutable, don haka kowane sashe yana ƙirƙira sabuwar abu. **Frozen string literals ba su da wuri don canja kuma ana sake amfani da su** — string daidai suna raba wani abu, na rage ƙirƙira da GC matsi (ban da amfani na karfi a sehun da ke aiki).

## Maganar sihin (kunna bFile daya)

```ruby
# frozen_string_literal: true     # ← magic comment at the TOP of the file

# now ALL string literals in this file are automatically frozen (immutable + reused)
def greet
  "hello"    # this literal is frozen → reused, not re-allocated
end
```

ƙara **`# frozen_string_literal: true`** a saman fili yana sa duk string literals a cikin shi su zama daji — iya nuna alal yau da kullun don karfin da kare karewa daidai. (Don ƙirƙira kopai masu canja, yi amfani da `+"string"` ko `.dup`.)

## Me yasa yana da mahimmanci

Sanin freezing na abu da frozen string literals shine ilmi mai daraja na Ruby don karfin da gaskiya. **Freezing** (`.freeze`) yana sa abubuwa su zama immutable, wanda ke da amfani don karewa constants da bayanan da ake barazana daga karewa daidai — karewa nau'i na kuƙi na canja (muhimmi ne musamman tun da Ruby strings suna da alama mutable ta tiyaga kuma za su iya canja ba tabbas).

Mafi tasiri buƙatu shine **frozen string literals**, wanda ke magance gaskiyar karfin Ruby: domin string literals suna da alama mutable ta tiyaga, kowane faɗin karkacin kamar `"hello"` yana ƙirƙira sabuwar abu, kuma a sehun da ke aiki wannan yana ƙirƙira matsi da GC matsi. **Frozen string literals ba su da wuri don canja kuma ana sake amfani da su** (karkacin daidai suna raba wani abu), na rage ƙirƙira da inganta karfin — taƙaitaccen ingantacce.

**`# frozen_string_literal: true` maganar sihin** (freezing duk string literals a cikin fili) shine niya ta rubuce-rubucen Ruby ta yau da kullun wanda ke ba buƙatu da kare karewa daidai, kuma yana da kowa (kuma zai yiwu ya zama aiki na gida a Ruby masu gida). Sanin freezing (immutability don constants da bayanan da ake barazana), buƙatu na karfin frozen string literals (sake amfani maimakon ƙirƙira, na rage GC matsi), da maganar sihin azaman niya ta yau da kullun shine mahimmi don rubuce-rubucen Ruby da karfin, gaskiya.