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`** — JavaScript માંથી સ્થાનાંતર કરતી વખતે અથવા જ્યારે તમે સાચે જ કોઈ વસ્તુને પ્રકાર આપી શકતા નથી ત્યારે એક્સેસ હેચ. સાવચેતીથી વાપરો; તે શાંતિથી ફેલાય છે અને સલામતી અક્ષમ કરે છે.

## શું તે મહત્વનું છે

`any` માટે પહોંચવું TypeScript ના હેતુને તોડી નાખે છે.

અનટાઇપ્ડ સીમાંતો પર `unknown` ને પ્રાધાન્ય આપો — તે કમ્પાઇલરના ગ્યારંટીઓ જાળવી રાખે છે જ્યારે તે મૂશ્કેલી ઇનપુટ સ્વીકાર કરે છે, તમને વિશ્વાસ કરતા પહેલા ડેટા ચકાસવા માટે દબાણ કરે છે.