સ્ટ્રિંગ્સ અને સિમ્બલ્સ વચ્ચે શું તફાવત છે?

Question

Accepted Answer

**સ્ટ્રિંગ્સ** મ્યુટેબલ કેરેક્ટર્સનો ક્રમ છે; **સિમ્બલ્સ** (`:name`) ઇમ્યુટેબલ, **ઇન્ટર્નड** આઇડેન્ટિફાયર છે — એક જ સિમ્બલ હમેશા મેમરીમાં એક જ ઑબ્જેક્ટ હોય છે. સિમ્બલ્સ હળવા, કાર્યક્ષમ આઇડેન્ટિફાયર્સ તરીકે વપરાય છે (ખાસ કરીને હેશ કીઓ), જ્યારે સ્ટ્રિંગ્સ વાસ્તવિક ટેક્સ્ટ ડેટા રાખે છે.

## મૂળ તફાવત: આઇડેન્ટિટી અને મ્યુટેબિલિટી

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

પ્રતિ સ્ટ્રિંગ લિટરલ નવો ઑબ્જેક્ટ બનાય છે, પરંતુ સિમ્બલ **ઇન્ટર્નડ** છે — `: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 જ્ઞાન છે, કારણ કે સિમ્બલ્સ એક વિશેષતા છે જે ઘણી બીજી ભાષાઓ પાસે નથી, અને તેમને યોગ્ય રીતે વાપરવું idiomaticRuby છે.

મૂળ તફાવત એ છે કે **સિમ્બલ્સ ઇન્ટર્નડ અને ઇમ્યુટેબલ** છે (`:name` હમેશા મેમરીમાં બરાબર એક જ ઑબ્જેક્ટ છે, ઇમ્યુટેબલ), જ્યારે **સ્ટ્રિંગ્સ મ્યુટેબલ અને પ્રતિ લિટરલ નવો ઑબ્જેક્ટ** છે.

આ સિમ્બલ્સને **મેમરી અને પરફોર્મન્સ ફાયદાઓ** આપે છે આઇડેન્ટિફાયર્સ તરીકે: તેઓ એક વાર આવંટિત કરવામાં આવે છે અને શેર કરવામાં આવે છે (મેમરી-કાર્યક્ષમ જ્યારે વારંવાર વાપર્યો જાય), અને આઇડેન્ટિટી દ્વારા સરખાવવામાં આવે છે (ઝડપી) અક્ષર-દર-અક્ષર તુલના કરવાને બદલે.

વ્યવહારુ માર્ગદર્શન — **આઇડેન્ટિફાયર્સ માટે સિમ્બલ્સ વાપરો** (હેશ કીઓ, મેથડ નામો, વિકલ્પ લેબલ્સ, નિશ્ચિત સ્ટેટ્સ — વસ્તુઓ જે વારંવાર લેબલ્સ તરીકે વાપરાય છે) અને **વાસ્તવિક ટેક્સ્ટ ડેટા માટે સ્ટ્રિંગ્સ** (કન્ટેન્ટ જે તમે પ્રદર્શિત કરો, હેરફેર કરો, અથવા વપરાશકર્તાઓ પાસેથી પ્રાપ્ત કરો) — મહત્વપૂર્ણ idiomaticRuby છે જે પરફોર્મન્સ અને સ્પષ્ટતા બંનેને અસર કરે છે.

સિમ્બલ હેશ કીઓ (`{ name: "Ann" }`) Ruby અને Rails માં સંમેલન છે, અને નિશ્ચિત આઇડેન્ટિફાયર્સ માટે સ્ટ્રિંગ્સને બદલે સિમ્બલ્સ વાપરવું કાર્યક્ષમ અને પરંપરાગત છે.

પ્રતિ કયો વાપરવો તે, સિમ્બલ્સનું ઇન્ટર્નિંગ/ઇમ્યુટેબિલિટી, અને આઇડેન્ટિફાયર્સ તરીકે તેમની કાર્યક્ષમતા સમજવું પાયાનું, વારંવાર-લાગુ Ruby જ્ઞાન છે — તે નવાગમોમાં સામાન્ય મૂંઝવણનો બિંદુ છે (શા માટે બંને?), અને તફાવતને સમજવું (સિમ્બલ્સ કાર્યક્ષમ ઇન્ટર્નડ આઇડેન્ટિફાયર્સ તરીકે, સ્ટ્રિંગ્સ મ્યુટેબલ ટેક્સ્ટ ડેટા તરીકે) idiomatic, કાર્યક્ષમ Ruby લખવા માટે અપરિહાર્ય અને આ વિશિષ્ટ Ruby વિશેષતા સમજવો પ્રતિબિંબિત કરતો વારંવાર ઇન્ટરવ્યુ વિષય છે.