સિમ્બલ્સ Ruby માં હેશ કીઓ માટે પરંપરાગત અને પ્રાધાન્યક્ષમ પસંદ છે કારણ કે તેઓ મેમરી-કાર્યક્ષમ છે (interned — એક શેર કરેલ ઑબ્જેક્ટ) અને તુલના માટે ઝડપી છે (ઓળખ દ્વારા). સિમ્બલ કીઓનો ઉપયોગ Ruby માટે idiomatic છે અને Rails જેવા ફ્રેમવર્કમાં માનક છે.
user = { , , }
user[]
user = { => , => }
user[]
আધુનિક { name: "Ann" } સીંટેક્સ સિમ્બલ કીઓનો ઉપયોગ કરે છે — નિશ્ચિત, જાણીતી કીઓ માટે માનક.
# 1. MEMORY: each string key is a NEW object; a symbol is ONE shared (interned) object
{ "name" => 1 } # "name" — a new string object each time it appears
{ name: 1 } # :name — always the SAME single object (interned)
# → in a program with thousands of hashes using the same keys, symbols save lots of memory
# 2. SPEED: comparing symbols is by IDENTITY (fast); strings compare character-by-character
:name == :name # fast — same object
"name" == "name" # slower — compares each character
✓ Memory-efficient — :name is interned (one shared object), reused everywhere
✓ Fast comparison — by object identity, not character-by-character
✓ Immutable — keys won't accidentally change
✓ Idiomatic — symbol keys are the Ruby/Rails convention; signal "this is an identifier"
હેશ કીઓ સામાન્ય રીતે નિશ્ચિત ઓળખકર્તા છે જેનો વારંવાર ઉપયોગ થાય છે (ચલશીલ ટેક્સ્ટ ડેટા નહીં), તેથી સિમ્બલ્સના interning (એક શેર કરેલ ઑબ્જેક્ટ જે સર્વત્ર પુનઃઉપયોગ થાય છે) અને ઝડપી ઓળખ તુલના સ્ટ્રિંગ્સ કરતાં વધુ કાર્યક્ષમ અને યોગ્ય બનાવે છે.
# use STRING keys when keys are dynamic/data (e.g. from user input, JSON, varying values)
params = JSON.parse(input) # → string keys (data, not fixed identifiers)
counts = Hash.new(0)
counts[user_input] += 1 # dynamic keys from data → strings
સ્ટ્રિંગ કીઓ યોગ્ય છે જ્યારે કીઓ ગતિશીલ ડેટા (વપરાશકર્તા ઇનપુટ, parsed JSON, ચલશીલ મૂલ્યો) માંથી આવે છે અને નિશ્ચિત ઓળખકર્તા નથી.
શા માટે સિમ્બલ્સ હેશ કીઓ તરીકે પ્રાધાન્યક્ષમ છે તે સમજવું મહત્વપૂર્ણ idiomatic Ruby જ્ઞાન છે, કારણ કે સિમ્બલ-keyed હેશ્સ ({ name: "Ann" }) Ruby અને Rails માં વ્યાપક છે, અને જાણવું શા માટે (અને ક્યારે નહીં) યોગ્ય સમજણ પ્રતિબિંબિત કરે છે.
શા માટે સિમ્બલ્સ નિશ્ચિત કીઓ માટે વધુ સારા છે તેના કારણો મૂર્ત છે: મેમરી કાર્યક્ષમતા (સિમ્બલ્સ interned છે — :name હંમેશા એક શેર કરેલ ઑબ્જેક્ટ છે જે સર્વત્ર પુનઃઉપયોગ થાય છે, જ્યારે દરેક સ્ટ્રિંગ કી "name" એક અલગ ઑબ્જેક્ટ છે, તેથી એમ્ સમાન કીઓ વાપરતા ઘણા હેશ્સ સાથે પ્રોગ્રામમાં, સિમ્બલ્સ નોંધપાત્ર મેમરી બચાવે છે) અને ગતિ (સિમ્બલ્સ ઑબ્જેક્ટ ઓળખ દ્વારા તુલના કરે છે, જે ઝડપી છે, જ્યારે સ્ટ્રિંગ્સ તે તત્પર-દર-તત્પર તુલના કરે છે).
હેશ કીઓ સામાન્ય રીતે નિશ્ચિત ઓળખકર્તા તે વારંવાર ઉપયોગ થાય છે (વિકલ્પ નામ, ક્ષેત્ર નામ, નિશ્ચિત લેબલ) ચલશીલ ટેક્સ્ટ ડેટા નથી, સિમ્બલ્સના interning અને ઝડપી તુલના તેમને કાર્યક્ષમ, યોગ્ય, અને idiomatic પસંદ બનાવે છે — તે કારણે આધુનિક key: value સીંટેક્સ અને Rails પરંપરા સિમ્બલ કીઓ વાપરે છે.
સમાન મહત્વનું છે જ્યારે સ્ટ્રિંગ કીઓ હજુ પણ યોગ્ય છે તે જાણવું: જ્યારે કીઓ ગતિશીલ ડેટા છે (વપરાશકર્તા ઇનપુટ, parsed JSON, અથવા મૂલ્યો તે ચલશીલ છે) નિશ્ચિત ઓળખકર્તા નથી.
કાર્યક્ષમતા કારણો (interning, ઝડપી તુલના) સમજવું, નિશ્ચિત ઓળખકર્તા માટે સિમ્બલ્સની યોગ્યતા, અને કીઓ જ્યાં સ્ટ્રિંગ કીઓ ફિટ છે (ગતિશીલ ડેટા) તે કેસ્સ idiomatic, કાર્યક્ષમ Ruby લખવા માટે અને Ruby/Rails કોડમાં સર્વવ્યાપક સિમ્બલ-keyed હેશ્સ સમજવા માટે મહત્વપૂર્ણ છે.
તે વ્યાપક સિમ્બલ-વિરુદ્ધ-સ્ટ્રિંગ તફાવત સાથે જોડાય છે અને આ એક આવર્તક વિષય છે જે key idiomatic Ruby પ્રણાલી તે કામગીરી અને પરંપરા બંને અસર કરે છે તેની સમજણ પ્રતિબિંબિત કરે છે.