ఆబ్జెక్టులను freezing చేయడం ఏమి చేస్తుంది మరియు frozen string literals ఎందుకు ఉపయోగించాలి?

Question

Accepted Answer

**Freezing** ఒక ఆబ్జెక్టను (`.freeze`) **immutable** చేస్తుంది — దానిని ఇకపై సవరించలేము. సాధారణ ఉపయోగం **frozen string literals**, ఇవి పనితీరును మెరుగుపరుస్తాయి (strings పునర్వినియోగం చేయబడతాయి కంటే పునర్ నిర్ధారణ) మరియు ఆకస్మిక మార్పతో రక్షణ ఇస్తాయి. ఆధునిక Ruby freezing strings ని ప్రోత్సహిస్తుంది.

## freeze ఆబ్జెక్టులను 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` ఒక ఆబ్జెక్టకు ఏ ఇతర సవరణను నిరోధిస్తుంది — constants మరియు shared data కోసం ఉపయోగకరమైనది ఇవ్వాలి (ఆకస్మిక మార్పతో బగ్ల నుండి రక్షణ).

## The performance problem frozen strings solve

```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 సాధారణంగా mutable, కాబట్టి ప్రతిసారి ఒక కొత్త ఆబ్జెక్టను నియమించుకుంటుంది. **Frozen string literals immutable మరియు పునర్వినియోగం చేయబడతాయి** — సమానమైన strings ఒక ఆబ్జెక్టను భాగస్వామ్యం చేస్తాయి, allocations మరియు GC pressure తగ్గిస్తాయి (hot code లో అర్థవంతమైన పనితీరు ప్రయోజనం).

## The magic comment (enable per file)

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

ఒక ఫైల్ అందరికీ **`# frozen_string_literal: true`** జోడించడం దాని string literals విడిగా freezing చేస్తుంది — సిఫారసు చేయబడిన ఆధునిక ప్రాక్టీస్ పనితీరు మరియు ఆకస్మిక mutations పట్టుకోవడం కోసం. (mutable copy సృష్టించటానికి, `+"string"` లేదా `.dup` ఉపయోగించండి.)

## ఇది ఎందుకు ముఖ్యం

ఆబ్జెక్ట freezing మరియు frozen string literals అర్థం Ruby జ్ఞానం కోసం పనితీరు మరియు సరిసరి రెండింటికీ విలువైనది. **Freezing** (`.freeze`) ఆబ్జెక్టులను immutable చేస్తుంది, ఇది constants మరియు shared data ని ఆకస్మిక సవరణ నుండి రక్షించడానికి ఉపయోగకరమైనది — మార్పతో బగ్ల సందర్భం నిరోధిస్తుంది (Ruby strings డిఫాల్ట్ ద్వారా mutable ఎందుకంటే ముఖ్యమైనది మరియు ఆశ్చర్యకరంగా పరివర్తనం చేయవచ్చు).

సర్వాధిక ఈ-పాత అనువర్తనం **frozen string literals**, ఒక నిజమైన Ruby పనితీరు లక్షణం చిబుక్: string literals సాధారణంగా mutable కాబట్టి, `"hello"` లాంటి ఒక ఆక్షరిక ఎమెర్జెన్సీ ఒక * కొత్త* ఆబ్జెక్టను నియమించుకుంటుంది, మరియు hot code యిన ఇది ముఖ్యమైన నియామకం మరియు GC pressure సృష్టిస్తుంది. **Frozen string literals immutable మరియు పునర్వినియోగం చేయబడతాయి** (సమానమైన ఆక్షరిక ఒక ఆబ్జెక్టను భాగస్వామ్యం చేస్తాయి), allocations తగ్గిస్టుంది మరియు పనితీరును మెరుగుపరుస్తుంది — ఒక అర్థవంతమైన ఆప్టిమైజేషన్.

**`# frozen_string_literal: true` magic comment** (ఒక ఫైల్ లో అన్ని string literals freezing) సిఫారసు చేయబడిన ఆధునిక Ruby ప్రాక్టీస్ ఇది పనితీరు ప్రయోజనం అందిస్తుంది మరియు ఆకస్మిక string mutations పట్టుకోవడం, మరియు ఇది ఇంక్రీసింగ్ సాధారణ (మరియు భవిష్యత్ Ruby లో డిఫాల్ట్ అవుతుంది సంభవం).

Freezing (immutability కోసం constants మరియు shared data), frozen string literals (reuse కంటే re-allocation, GC pressure తగ్గిస్తుంది), మరియు magic comment ఆధునిక best practice లాగా అర్థం విలువైనది performant, సరిసరి Ruby కోసం రాయడం.

Ruby లో string allocation ఒక నిర్దేశ్యమైన పనితీరు కారకం కాబట్టి, మరియు frozen string literals ఇంక్రీసింగ్ ఒక సాధారణ ప్రాక్టీస్ పనితీరు మరియు mutation bugs నిరోధం కోసం కాబట్టి, freezing మరియు frozen strings అర్థం ముఖ్యమైన సీనియర్-లెవెల్ జ్ఞానం Ruby పనితీరు ఆప్టిమైజేషన్ మరియు ఆధునిక best practices యొక్క జ్ఞానం ప్రతిబింబిస్తుంది — performant, బలమైన Ruby కోడ్ రాయడం కోసం ఒక సంబంధితమైన విషయం మరియు performant, బలమైన Ruby developers నుండి ఆలోచన.