પ્રકારના નિશ્ચાર શું છે અને તેઓ ક્યારે જોખમી છે?

Question

Accepted Answer

એક **પ્રકારનો નિશ્ચાર** કમ્પાઈલરને કહે છે "મને વિશ્વાસ કરો, આ મૂલ્ય X પ્રકારનું છે" `as` નો ઉપયોગ કરીને. તે **કોઈ runtime રૂપાંતર અથવા તપાસ કરતું નથી** — તે ફક્ત બદલે છે કે કમ્પાઈલર મૂલ્યને કેવી રીતે માને છે.

```ts
const el = document.getElementById("app") as HTMLInputElement;
el.value = "hi"; // compiler now allows .value (it assumed HTMLInputElement)

const data = JSON.parse(str) as User; // assert the parsed shape
```

## શા માટે તે જોખમી છે

નિશ્ચાર કમ્પાઈલરના ચુકાદાને ઓવરાઇડ કરે છે — જો તમે ખોટા હો, તો તમને runtime ક્રેશ મળશે કોઈ warning વિના:

```ts
const x = "hello" as unknown as number; // double assertion — compiler stops complaining
x.toFixed(2); // 💥 runtime error: x.toFixed is not a function
```

નિશ્ચાર મૂલ્યને તે પ્રકારમાં *બનાતું નથી*; તે ફક્ત તપાસકર્તાને શાંત કરે છે. તમે કમ્પાઈલર તરફથી સાચીતાનો જવાબદારી લીધી છે.

## વધુ સુરક્ષિત વિકલ્પો

```ts
// 1. type guard — actually verify at runtime
if (typeof input === "string") { /* input is string, proven */ }

// 2. validation library (zod) for external data
const user = UserSchema.parse(data); // throws if shape is wrong
```

## `as const` અલગ છે

```ts
const point = { x: 1 } as const; // not a risky cast — narrows to literal/readonly
```

## શા માટે તે મહત્વપૂર્ણ છે

નિશ્ચાર કેટલીક વખત જરૂરી છે (DOM APIs, `unknown` ને સંકુચિત કરવું જેને તમે પહેલાથી તપાસી ચૂક્યા છો), પરંતુ દરેક એક જગ્યા છે જ્યાં કમ્પાઈલર તમને સુરક્ષિત કરી શકતું નથી.

prose ન હોય તેવા ડેટા માટે પ્રકારની રક્ષણ અથવા schema validation પસંદ કરો, અને દરેક `as` ને નાનું, ઇરાદાપૂર્વક "હું વધુ સારું જાણું છું" તરીકે માનો જે તમે નિશ્ચિત હોવું જોઈએ.

શા માટે તે જોખમી છે

વધુ સુરક્ષિત વિકલ્પો

as const અલગ છે

શા માટે તે મહત્વપૂર્ણ છે

`as const` અલગ છે