ఐచ్ఛిక (?) మరియు readonly సవరణలు ఏమి చేస్తాయి?

Question

Accepted Answer

ఈ ఆస్తి సవరణలు ఆస్తి **అవసరమైనది** కానీ **పునర్నిర్ణయం** చేయబడుతుందో లేదో నియంత్రిస్తాయి.

## ఐచ్ఛిక (`?`)

```ts
interface User {
  name: string;
  email?: string; // optional — may be absent
}

const a: User = { name: "Ann" };               // ✅ email omitted
const b: User = { name: "Bo", email: "b@x" };  // ✅ included

function f(u: User) {
  u.email.length;   // ❌ Error: email is possibly 'undefined'
  u.email?.length;  // ✅ optional chaining handles the maybe-undefined
}
```

ఐచ్ఛిక ఆస్తి `T | undefined` రకాన్ని కలిగి ఉంది, కాబట్టి కంపైలర్ మీరు లేని సందర్భాన్ని నిర్వహించవలసి ఉంటుంది — "cannot read property of undefined" బగ్‌లను నిరోధిస్తుంది.

## readonly

```ts
interface Point { readonly x: number; readonly y: number; }
const p: Point = { x: 1, y: 2 };
p.x = 5; // ❌ Error: cannot assign to readonly property

// arrays too
const nums: readonly number[] = [1, 2, 3];
nums.push(4); // ❌ push doesn't exist on readonly array
```

`readonly` సంకలన-సమయం మాత్రమే (రన్‌టైమ్ ఎన్‌ఫోర్సమెంట్ లేదు), కానీ ఇది టైప్ సిస్టమ్‌లో మరియు ఇమ్యూటబిలిటీని డాక్యుమెంట్ చేస్తుంది మరియు ఎన్‌ఫోర్స్ చేస్తుంది, ఆకస్మిక మ్యూటేషన్‌లను ఆక్ష్కారపరుస్తుంది.

## సంయుక్తమైనవి మరియు స్కేల్‌లో

```ts
interface Config { readonly id: string; tags?: readonly string[]; }
type Frozen = Readonly<User>; // utility type makes ALL props readonly
```

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

`?` నిజమైన ఐచ్ఛిక డేటా మరియు శూన్య-భద్రతను ఖచ్చితంగా మోడల్ చేస్తుంది; `readonly` మరియు నిరక్షర (గ్రేట్ కాన్ఫిగ్, props, మరియు ఆకస్మిక స్టేట్ మ్యూటేషన్ నిరోధించడానికి).

రెండూ సరిదిద్దటి సరిపోయింపును కంపైలర్‌లోకి ఠెట్లగా కదిలిస్తాయి.