რა არის ტიპის assertions და როდის არის ისინი რისკიანი?

Question

Accepted Answer

**ტიპის assertion** ეუბნება კომპილატორს "დამიჯერი, ეს მნიშვნელობა X ტიპისაა" `as`-ის გამოყენებით. ეს **არ აკეთებს რানტაიმ კონვერტაციას ან შემოწმებას** — ის მხოლოდ იცვლის თუ როგორ განიხილავს კომპილატორი მნიშვნელობას.

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

## რატომ არის ეს რისკიანი

Assertion გადაფარავს კომპილატორის განჭვრეტას — თუ შენ ცდები, მიიღებ რანტაიმ crash-ს რაიმე გაფრთხოების გარეშე:

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

Assertion-ის გაკეთება არ ხდის მნიშვნელობას იმ ტიპის; ის უბრალოდ დათიშავს შემოწმებას. თქვენ ჩამოაგიბეთ სიზუსტეზე პასუხისმგებლობა კომპილატორისგან.

## უფრო უსაფრთხო ალტერნატივები

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

## რატომ აქვს მნიშვნელობა

Assertions ზოგჯერ აუცილებელია (DOM APIs, `unknown`-ის შევიწროება რომელიც უკვე შეამოწმეთ), მაგრამ თითოეული ერთი წერტილია სადაც კომპილატორი ვერ დაგიცავთ.

მიმაჩნია ტიპის guards ან schema validation სანდო მონაცემებისთვის, და განიხილეთ ყველა `as` როგორც მცირე, განზრახული "მე მეტი ვიცი" რომელიც თქვენ უნდა დარწმუნდეთ.

რატომ არის ეს რისკიანი

უფრო უსაფრთხო ალტერნატივები

as const განსხვავებულია

რატომ აქვს მნიშვნელობა

`as const` განსხვავებულია