როგორ მუშაობს ტიპის დასკვნა?

Question

Accepted Answer

**Type inference** არის TypeScript-ის ტიპების ავტომატური გამოცნობა კონტექსტიდან, ასე რომ თქვენ არ უნდა აღვნიშნოთ ყველაფერი. ის დასკვნას აკეთებს საწყისი მნიშვნელობებიდან, return განცხადებებიდან და გამოყენებიდან.

```ts
let x = 10;          // inferred: number
let s = "hi";        // inferred: string
const arr = [1, 2];  // inferred: number[]
const obj = { a: 1, b: "x" }; // inferred: { a: number; b: string }
```

## დასკვნა ფუნქციებსა და callback-ებში

```ts
function double(n: number) { return n * 2; } // return inferred as number

[1, 2, 3].map(n => n * 2); // `n` inferred as number from the array — no annotation needed
```

ეს **კონტექსტუალური აკრეფა** არის მიზეზი იმისა, რომ callback-ებს იშვიათად სჭირდებათ პარამეტრის აღნიშვნები — TypeScript იცის, რომ `map` on `number[]`-ზე გადის `number`.

## let vs const გაფართოება

```ts
let a = "hello";     // widened to string (let can be reassigned)
const b = "hello";   // narrowed to the literal type "hello"
```

`const` დასკვნებს *ლიტერალური* ტიპი, რადგან ის არასდროს შეიძლება შეიცვალოს; `let` გაფართოებს ზოგად ტიპს. ეს მნიშვნელოვანია კავშირებისთვის:

```ts
const dir = "up";              // type "up"
let dir2 = "up";               // type string
```

## როდის აღვნიშნოთ მაინც

- ფუნქციის პარამეტრები (დასკვნას ვერ ხდება).
- როდესაც დასკვნა ძალიან ფართო/ვიწრო (მაგ. თქვენ გსურთ `string` არა ლიტერალი).
- ცარიელი კონტეინერები: `const xs = []` დასკვნებს `any[]` — აღნიშნეთ როგორც `number[]`.

## Mengapa это wichtig

ინფერენცია TypeScript კოდს JavaScript-ის მსგავსად ლაკონური ინახავს, სრულად აკრეფილი რჩება.

ესმის *როდის* იწყება ის (და როდის გაფართოვდება) საშუალებას გაძლევთ აღნიშნოთ მხოლოდ იქ, სადაც ის ნამდვილად ეხმარება.