strings மற்றும் symbols இடையேயான வேறுபாடு என்ன?

Question

Accepted Answer

**Strings** ஆகியவை மாற்றக்கூடிய (mutable) எழுத்து வரிசைகள்; **symbols** (`:name`) மாற்ற முடியாத (immutable), **interned** identifiers — அதே symbol எல்லா இடங்களிலும் நினைவகத்தில் சரியாக ஒரே பொருள்தான். Symbols ஆகியவை குறைந்த எடையுடைய, திறமையான identifiers (குறிப்பாக hash keys) ஆக பயன்படுத்தப்படுகின்றன, அதே சமயம் strings உண்மையான உரை தரவை வைத்திருக்கின்றன.

## முக்கிய வேறுபாடு: identity மற்றும் 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 ஒரு புதிய பொருளை உருவாக்குகிறது, ஆனால் symbol **interned** ஆகும் — `:hello` எத்தனை முறை தோன்றினாலும் நினைவகத்தில் எப்போதும் சரியாக அதே பொருள். Symbols மாற்ற முடியாதவை (immutable).

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

## எப்போது எது பயன்படுத்த வேண்டும்

```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) மற்றும் **உண்மையான உரை தரவுக்கு strings பயன்படுத்தவும்** (நீங்கள் காட்டும் உள்ளடக்கம், கையாளும் அல்லது பயனர்களிடமிருந்து வரும் உள்ளடக்கம்).

## அவற்றுக்கு இடையே மாற்றுதல்

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

## ஏன் இது முக்கியம்

string-vs-symbol வேறுபாட்டைப் புரிந்துகொள்வது முக்கியம் மற்றும் தனிப்பட்ட Ruby அறிவு ஆகும், ஏனெனில் symbols பல வேறு மொழிகளில் இல்லாத ஒரு பண்பு, மற்றும் அவற்றை சரியாக பயன்படுத்துவது idiomatic Ruby.

சிறப்பு வேறுபாடு என்னவென்றால் **symbols interned மற்றும் immutable** (`:name` நினைவகத்தில் எப்போதும் அதே ஒரு பொருள், மாற்ற முடியாதவை), அதே சமயம் **strings mutable மற்றும் ஒவ்வொரு literal ஒரு புதிய பொருள்**.

இது **நினைவகம் மற்றும் செயல்திறன் நன்மைகளை** symbols இற்கு identifiers ஆக தருகிறது: அவை ஒரு முறை할ிக்கப்பட்டு பகிரப்படுகின்றன (நினைவகம்-திறமையான போது மீண்டும் பயன்படுத்தப்படுகின்றன), மற்றும் identity மூலம் ஒப்பிடப்படுகின்றன (வேகமான) character-by-character க்கு பதிலாக.

வ்யবহারித்தமான வழிகாட்டுதல் — **identifiers களுக்கு symbols பயன்படுத்தவும்** (hash keys, method names, option labels, நிலையான states — மீண்டும் labels ஆக பயன்படுத்தப்படும் விஷயங்கள்) மற்றும் **உண்மையான உரை தரவுக்கு strings பயன்படுத்தவும்** (நீங்கள் காட்டும் உள்ளடக்கம், கையாளும் அல்லது பயனர்களிடமிருந்து பெறும் உள்ளடக்கம்) — முக்கியமான idiomatic Ruby ஆகும் இது செயல்திறன் மற்றும் தெளிவுக்கு பாதிக்கிறது.

Symbol hash keys (`{ name: "Ann" }`) Ruby மற்றும் Rails இல் மரபு ஆகும், மற்றும் நிலையான identifiers களுக்கு strings க்கு பதிலாக symbols பயன்படுத்துவது திறமையான மற்றும் வழக்கமான.

ஒவ்வொன்றை எப்போது பயன்படுத்த வேண்டும், symbols இன் interning/immutability, மற்றும் identifiers ஆக அவற்றின் திறமை புரிந்துகொள்வது அடிப்படை, அடிக்கடி பயன்படுத்தப்படும் Ruby அறிவு — இது புதியவர்களுக்கு குழப்பத்தின் ஒரு பொதுவான புள்ளி (ஏன் இரண்டும்?), மற்றும் வேறுபாட்டை (symbols திறமையான interned identifiers ஆக, strings mutable உரை தரவு ஆக) புரிந்துகொள்வது essential idiomatic, திறமையான Ruby எழுதுவதற்கு மற்றும் இந்த தனிப்பட்ட Ruby பண்பைப் புரிந்துகொள்ளும் பொதுவான साक்षात்कार विषय.