any மற்றும் unknown இடையே உள்ள வேறுபாடு என்ன?

Question

Accepted Answer

இரண்டும் *எந்த* மதிப்பையும் வைத்திருக்க முடியும், ஆனால் அவை **பாதுகாப்பு**ல் வேறுபடுகின்றன. `any` வகை சரிபார்ப்பை முடக்கிவிடும்; `unknown` அதை பெற்றுக்கொள்ளும் மற்றும் பயன்படுத்துவதற்கு முன் வரையறுக்க நিர்ப்பந்திக்கும்.

```ts
let a: any = "hello";
a.foo.bar;        // ✅ compiles — no checking at all (may crash at runtime)
a();              // ✅ compiles — TypeScript trusts you blindly

let u: unknown = "hello";
u.toUpperCase();  // ❌ Error: object is of type 'unknown'
u();              // ❌ Error — must narrow first
```

## unknown பயன்படுத்துவதற்கு முன் சரிபார்ப்பை கட்டாயப்படுத்தும்

```ts
function handle(input: unknown) {
  if (typeof input === "string") {
    input.toUpperCase(); // ✅ inside the guard, TS knows it's a string
  }
}
```

`unknown` என்பது `any`யின் **வகை-பாதுகாப்பான சமকக்ష**: நீங்கள் எந்த எதையும் *அதற்கு* நியமிக்க முடியும், ஆனால் ஒரு வகை பாதுகாப்பு மூலம் அது என்ன என்பதை நிரூபிக்கும் வரை நீங்கள் அதுடன் *எதுவும் செய்ய முடியாது*.

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

- **`unknown`** — உண்மையில் அறியப்படாத வகையின் மதிப்புகளுக்கு எல்லையில்: `JSON.parse` முடிவுகள், API பதிலளிப்புகள், `catch (e: unknown)`. இது சரிபார்ப்பை நிர்ப்பந்திக்கும்.
- **`any`** — JS ஐ இடம்பெயர்க்கும்போது அல்லது உண்மையில் ஏதாவது வகையை தெரிந்து கொள்ள முடியாதபோது தப்பிக்கும் வழி. குறைவாக பயன்படுத்தவும்; இது silent ஆக பரவுகிறது மற்றும் பாதுகாப்பை முடக்குகிறது.

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

`any` க்கு வந்துவிடுவது TypeScript ன் நோக்கத்தைத் தோல்வியடையச் செய்கிறது.

வகையறிந்த எல்லைகளில் `unknown` ஐ முன்னுரிமை கொடுங்கள் — இது compiler இன் உத்திரவாதங்களை வைத்துக்கொள்ளும் அதே வேளையில் தன்னிச்சையான உள்ளீட்டைக் ஏற்றுக்கொள்ளும், தரவை நம்புவதற்கு முன் சரிபார்க்க உங்களை தள்ளும்.