Symbols என்றால் என்ன மற்றும் அவை எங்கு பயன்படுகின்றன?

Question

Accepted Answer

**Symbol** என்பது ஒரு தனிப்பட்ட, மாறாத primitive ஆகும். நீங்கள் உருவாக்கும் ஒவ்வொரு `Symbol()` **உறுதியாக வேறுபட்டது** — ஒரே விவரணையுடன் இரண்டு கூட சமம் இல்லை. அவற்றின் முக்கிய வேலை **collision-proof object keys** ஆக இருப்பது.

```js
const id = Symbol("id");
const id2 = Symbol("id");
id === id2;        // false — always unique

const user = { [id]: 123, name: "Ann" };
user[id];          // 123
```

## ஏன் தனிப்பட்ட விசைகள் பயனுள்ளவை

Symbol-keyed properties string keys உடன் மோதுவதில்லை மற்றும் சாதாரண enumeration இலிருந்து **hidden** — metadata இணைக்க object ஐ மாசுபடுத்தாமல் சிறந்தது:

```js
Object.keys(user);          // ["name"]  — symbol key is skipped
for (const k in user) {}    // skips the symbol
JSON.stringify(user);       // {"name":"Ann"} — symbol not serialized
Object.getOwnPropertySymbols(user); // [Symbol(id)] — only way to list them
```

குறிப்பாக, ஒரு library உங்கள் object இல் Symbol மூலம் அக ডেटা சேமிக்க முடியும் உங்கள் properties உடன் மோதாமல் அல்லது உங்கள் loops இல் காணப்படாமல்.

## நன்கறிந்த symbols மொழி நடத்தையை தனிப்பயன்படுத்தும்

மிக முக்கியமான பயன்பாடு — `Symbol.iterator` ஒரு object iterable ஆக்குகிறது:

```js
const range = {
  [Symbol.iterator]() {
    let i = 1;
    return { next: () => (i <= 3 ? { value: i++, done: false } : { done: true }) };
  },
};
[...range]; // [1, 2, 3]
```

மற்றவை: `Symbol.asyncIterator`, `Symbol.toPrimitive` (custom coercion), `Symbol.hasInstance`.

## Global registry

```js
Symbol.for("key"); // shared symbol across the whole app (and across realms)
```

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

Symbols non-colliding metadata keys ஐ செயல்படுத்தி மற்றும் நீங்கள் core language protocols (iteration, coercion) ஆக hook செய்ய அனுமதி — அவை எப்படி built-ins மற்றும் frameworks safely objects விரிவாக்குவது.