Çfarë janë type assertions dhe kur janë të rrezikshme?

Question

Accepted Answer

Një **type assertion** i thotë kompajlerit "më besoji, kjo vlerë është e tipit X" duke përdorur `as`. Nuk bën **asnjë konvertim ose kontroll në kohën e ekzekutimit** — ndryshon vetëm se si kompajleri e trajton vlerën.

```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
```

## Pse është e rrezikshme

Një assertion anashkalon gjykimin e kompajlerit — nëse gabohesh, merr një kolaps në kohën e ekzekutimit pa asnjë paralajmërim:

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

Assertimi nuk e **bën** vlerën atë lloj; thjesht heshtë kontrolluesin. Ke marrë përgjegjësinë për korektësinë larg kompajlerit.

## Alternativat më të sigurta

```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` është ndryshe

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

## Pse ka rëndësi

Assertionet janë ndonjëherë të nevojshme (API-t DOM, përqendrimi i `unknown` që e ke kontrolluar tashmë), por secili është një vend ku kompajleri nuk mund të të mbrojë.

Prefero type guards ose schema validation për të dhënat e pabesuara, dhe trajto çdo `as` si një të vogël, të qëllimshme "Unë e di më mirë" për të cilën duhet të jesh i sigurt.

Pse është e rrezikshme

Alternativat më të sigurta

as const është ndryshe

Pse ka rëndësi

`as const` është ndryshe