Czym są asercje typów i kiedy są ryzykowne?

Question

Accepted Answer

**Asercja typów** mówi kompilatorowi "ufaj mi, ta wartość ma typ X" używając `as`. Nie wykonuje **żadnej konwersji ani sprawdzania w czasie wykonywania** — zmienia tylko sposób, w jaki kompilator traktuje wartość.

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

## Dlaczego to ważne

Asercja przesłania osąd kompilatora — jeśli się mylisz, otrzymujesz crash w czasie wykonywania bez ostrzeżenia:

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

Asercja nie *czyni* wartości tego typu; po prostu wycisza kontrolę. Przejąłeś odpowiedzialność za poprawność od kompilatora.

## Bezpieczniejsze alternatywy

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

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

## Dlaczego to ważne

Asercje są czasami konieczne (API DOM, zawężanie `unknown`, które już sprawdziłeś), ale każda z nich to miejsce, w którym kompilator nie może Cię chronić.

Preferuj type guards lub walidację schematów dla niezaufanych danych i traktuj każde `as` jako małe, świadome "wiem lepiej", którym musisz być pewien.

Dlaczego to ważne

Bezpieczniejsze alternatywy

as const jest inne

Dlaczego to ważne

`as const` jest inne