strings और symbols में क्या अंतर है?

Question

Accepted Answer

**Strings** characters के mutable sequences हैं; **symbols** (`:name`) immutable, **interned** identifiers हैं — वही symbol हर जगह memory में बिल्कुल वही object होता है। Symbols का उपयोग हल्के, कुशल identifiers के रूप में किया जाता है (विशेष रूप से hash keys), जबकि strings वास्तविक text data रखते हैं।

## The core difference: identity and mutability

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

हर string literal एक नया object बनाता है, लेकिन एक symbol **interned** होता है — `:hello` हमेशा memory में बिल्कुल वही object होता है, चाहे यह कितनी भी बार आए। Symbols immutable भी होते हैं।

## Memory and performance benefits of symbols

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

## When to use which

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

**identifiers के लिए symbols का उपयोग करें** (hash keys, option names, states, method names — निश्चित, दोहराए जाने वाले labels) और **वास्तविक text data के लिए strings** (content जिसे आप display करते हैं, हेरफेर करते हैं, या जो users से आता है)।

## Converting between them

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

## यह क्यों महत्वपूर्ण है

string-बनाम-symbol अंतर को समझना महत्वपूर्ण और स्पष्ट रूप से Ruby-विशिष्ट ज्ञान है, क्योंकि symbols एक ऐसी विशेषता है जिसकी कई अन्य languages में कमी है, और उनका उचित उपयोग idiomatic Ruby है।

मुख्य अंतर यह है कि **symbols interned और immutable हैं** (`:name` हमेशा memory में वही एकल object है, immutable), जबकि **strings mutable हैं और हर literal एक नया object है**।

यह symbols को identifiers के रूप में **memory और performance लाभ** देता है: वे एक बार allocate होते हैं और साझा होते हैं (बार-बार उपयोग होने पर memory-efficient), और character-by-character के बजाय identity द्वारा तुलना की जाती है (तेज़)।

व्यावहारिक मार्गदर्शन — **identifiers के लिए symbols का उपयोग करें** (hash keys, method names, option labels, fixed states — चीज़ें जो labels के रूप में बार-बार उपयोग होती हैं) और **वास्तविक text data के लिए strings** (content जिसे आप display करते हैं, हेरफेर करते हैं, या users से प्राप्त करते हैं) — महत्वपूर्ण idiomatic Ruby है जो performance और स्पष्टता दोनों को प्रभावित करता है।

Symbol hash keys (`{ name: "Ann" }`) Ruby और Rails में परंपरा हैं, और निश्चित identifiers के लिए strings के बजाय symbols का उपयोग करना कुशल और पारंपरिक है।

यह समझना कि प्रत्येक का कब उपयोग करना है, symbols की interning/immutability, और identifiers के रूप में उनकी दक्षता मूलभूत, बार-बार लागू होने वाला Ruby ज्ञान है — यह नवागंतुकों के लिए भ्रम का एक आम बिंदु है (दोनों क्यों रखें?), और इस अंतर को समझना (symbols कुशल interned identifiers के रूप में, strings mutable text data के रूप में) idiomatic, कुशल Ruby लिखने के लिए आवश्यक है और एक बार-बार आने वाला interview विषय है जो इस विशिष्ट Ruby विशेषता की समझ को दर्शाता है।