`as const` assertion ఏమి చేస్తుంది?

Question

Accepted Answer

`as const` అనేది **const assertion** ఇది TypeScript కు విలువను కోసం **చాలా నిర్దిష్టమైన (literal), deeply readonly** టైప్ ను అనుమానించమని చెబుతుంది, దానిని విస్తరించడానికి బదులుగా.

```ts
// without as const — widened, mutable
let a = "up";            // type: string
const obj = { x: 1 };     // type: { x: number }
const arr = [1, 2];       // type: number[]

// with as const — narrow literals, readonly
const b = "up" as const;          // type: "up"
const obj2 = { x: 1 } as const;    // type: { readonly x: 1 }
const arr2 = [1, 2] as const;      // type: readonly [1, 2] (a tuple!)
```

ఇది మూడు విషయాలను చేస్తుంది: ఏమీ విస్తరించదు (literal విలువలను ఉంచుతుంది), ప్రతిదీ `readonly` చేస్తుంది, మరియు arrays ను **tuples** గా మారుస్తుంది.

## ఇది ఎందుకు చాలా ఉపయోగకరమైనది

**ఒక విలువల జాబితా నుండి union type ను ఉత్పన్నం చేయడం (single source of truth):**

```ts
const ROLES = ["admin", "editor", "viewer"] as const;
type Role = typeof ROLES[number]; // "admin" | "editor" | "viewer"
// add a role to the array → the union updates automatically
```

**Config/state కోసం literal types ను సంరక్షించడం:**

```ts
const action = { type: "INCREMENT", by: 1 } as const;
// action.type is "INCREMENT" (a literal), so it works in discriminated unions
// without as const it'd be `string`, breaking narrowing
```

## ఇది ఎందుకు ముఖ్యమైనది

`as const` runtime విలువలు మరియు precise types ల మధ్య సేతువ.

ఇది మీకు డేటా ను ఒకసారి (ఒక array/object) నిర్వచించడానికి మరియు దాని నుండి exact literal types ను ఉత్పన్నం చేయడానికి అనుమతిస్తుంది — action types, route maps, config, మరియు literal గా ఉండాలి కాని `string` గా విస్తరించకూడదు అయిన discriminated-union tag కోసం అమూల్యమైనది.