స్ట్రింగ్‌లు మరియు సింబల్‌ల మధ్య తేడా ఏమిటి?

Question

Accepted Answer

**స్ట్రింగ్‌లు** అక్షరాల యొక్క మార్పులేని సంబంధాలు; **సింబల్‌లు** (`:name`) అనేవి మార్పులేని, **interned** ఐడెంటిఫైయర్‌లు — ఒకే సింబల్ ఎక్కడైనా మెమరీలో ఒకే సరిగ్గా ఒకే వస్తువు. సింబల్‌లు లేత, సమర్థవంతమైన ఐడెంటిఫైయర్‌ల కోసం ఉపయోగించబడతాయి (ముఖ్యంగా హ్యాష్ కీలు), అయితే స్ట్రింగ్‌లు వాస్తవ టెక్స్ట్ డేటాను కలిగి ఉంటాయి.

## ప్రధాన తేడా: గుర్తింపు మరియు మార్పుశీలత

```ruby
# strings — each is a NEW object (even with the same content)
"hello".object_id == "hello".object_id    # false — two different objects
"hello" << " world"                        # mutable — can be modified in place

# symbols — the SAME symbol is always the SAME object (interned)
:hello.object_id == :hello.object_id       # true — identical object every time
:hello.frozen?                              # true — symbols are immutable
```

ప్రతిটి స్ట్రింగ్ లిటరల్ కొత్త వస్తువును సృష్టిస్తుంది, కానీ సింబల్ **interned** — `:hello` ఎన్ని సార్లు కనిపించినా ఎల్లప్పుడూ మెమరీలో సరిగ్గా ఒకే వస్తువు. సింబల్‌లు కూడా మార్పులేనివి.

## సింబల్‌ల మెమరీ మరియు పనితీరు ప్రయోజనాలు

```text
Strings: each "name" allocates a new object → more memory, slower comparison (char by char)
Symbols: :name is ONE shared object → memory-efficient, fast comparison (by identity)
→ Symbols are ideal as identifiers used repeatedly (hash keys, method names, options).
```

## ఎప్పుడు ఏది ఉపయోగించాలి

```ruby
# SYMBOLS — for identifiers: hash keys, method names, options, fixed labels
user = { name: "Ann", role: :admin }       # symbol keys (the idiom)
send(:upcase)                               # method name as a symbol
status = :active                            # a fixed label/state

# STRINGS — for actual text DATA that you display, manipulate, or that varies
name = "Ann Smith"                          # real text content
message = "Hello, #{name}"                  # building/interpolating text
user_input = gets.chomp                     # data from outside
```

**ఐడెంటిఫైయర్‌ల కోసం సింబల్‌లను ఉపయోగించండి** (హ్యాష్ కీలు, ఆప్షన్ పేర్లు, స్థితులు, పద్ధతి పేర్లు — స్థిర, పునరావృత లేబెల్‌లు) మరియు **వాస్తవ టెక్స్ట్ డేటా కోసం స్ట్రింగ్‌లను ఉపయోగించండి** (మీరు ప్రదర్శించే, తారుమారు చేసే, లేదా వినియోగదారుల నుండి వచ్చే కంటెంట్).

## వాటి మధ్య మార్చడం

```ruby
"hello".to_sym    # :hello
:hello.to_s        # "hello"
```

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

స్ట్రింగ్ బनాం సింబల్ తేడాను అర్థం చేసుకోవడం ముఖ్యమైనది మరియు విభిన్నమైన Ruby జ్ఞానం, ఎందుకంటే సింబల్‌లు అనేక ఇతర భాషలకు లేని ఫీచర్, మరియు వాటిని సరిగ్గా ఉపయోగించడం idiomatic Ruby.

ప్రధాన తేడా ఏమిటంటే **సింబల్‌లు interned మరియు మార్పులేనివి** (`:name` ఎల్లప్పుడూ మెమరీలో ఒకే సరిగ్గా ఒకే వస్తువు, మార్పులేనిది), అయితే **స్ట్రింగ్‌లు మార్పులేనివి మరియు ప్రతిটి లిటరల్ కొత్త వస్తువు**.

ఇది సింబల్‌లకు **మెమరీ మరియు పనితీరు ప్రయోజనాలను** ఇడెంటిఫైయర్‌లుగా ఇస్తుంది: అవి ఒక్కసారి కేటాయించబడతాయి మరియు భాగస్వామ్యం చేయబడతాయి (పదేపదే ఉపయోగించినప్పుడు మెమరీ-సమర్థవంతమైనది), మరియు గుర్తింపు ద్వారా సరిపోల్చబడతాయి (వేగవంతమైనది) అక్షరం-చేత-అక్షరానికి కాకుండా.

వ్యావహారిక మార్గదర్శకత — **ఐడెంటిఫైయర్‌ల కోసం సింబల్‌లను ఉపయోగించండి** (హ్యాష్ కీలు, పద్ధతి పేర్లు, ఆప్షన్ లేబెల్‌లు, స్థిర స్థితులు — లేబెల్‌లుగా పదేపదే ఉపయోగించే విషయాలు) మరియు **వాస్తవ టెక్స్ట్ డేటా కోసం స్ట్రింగ్‌లను ఉపయోగించండి** (కంటెంట్ మీరు ప్రదర్శించండి, తారుమారు చేయండి, లేదా వినియోగదారుల నుండి అందుకోండి) — ముఖ్యమైనది idiomatic Ruby ఇది పనితీరు మరియు స్పష్టతా రెండింటినీ ప్రభావితం చేస్తుంది.

సింబల్ హ్యాష్ కీలు (`{ name: "Ann" }`) Ruby మరియు Rails లో సమావేశం, మరియు స్ట్రింగ్‌ల కంటే స్థిర ఐడెంటిఫైయర్‌ల కోసం సింబల్‌లను ఉపయోగించడం సమర్థవంతమైనది మరియు సాంప్రదాయిక.

ప్రతిదానిని ఎప్పుడు ఉపయోగించాలో, సింబల్‌ల interning/immutability, మరియు ఐడెంటిఫైయర్‌లుగా వాటి సామర్థ్యాన్ని అర్థం చేసుకోవడం అనేది ఆధారభూత, తరచుగా-అనువర్తిత Ruby జ్ఞానం — ఇది నూతన వారికి గందరగోళం యొక్క సాధారణ పాయింట్ (రెండూ ఎందుకు ఉన్నాయి?), మరియు తేడాను గ్రహించడం (సింబల్‌లు సమర్థవంతమైన interned ఐడెంటిఫైయర్‌లుగా, స్ట్రింగ్‌లు మార్పులేని టెక్స్ట్ డేటాగా) idiomatic, సమర్థవంతమైన Ruby ను రాయడానికి ముఖ్యమైనది మరియు ఈ విభిన్నమైన Ruby ఫీచర్ యొక్క అవగతను ప్రతిబింబించే సాధారణ ఇంటర్‌వ్యూ విషయం.