விருப்பமான (?) மற்றும் 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
```

## ஏன் இது முக்கியம்

`?` உண்மையான விருப்பமான தரவுக்கு மாதிரி சொல்கிறது மற்றும் null-பாதுகாப்பை நிர்ப்பந்திக்கிறது; `readonly` மாறாமைக்கு வெளிப்படுத்திக்கிறது மற்றும் வலதுசெய்கிறது (கட்டமைப்பு, props மற்றும் தற்செயலான நிலை மாற்றம் தடுக்க பெரியது).

இரண்டும் சரியான தன்மை சரிபார்ப்பை கம்பைலரில் உந்துகின்றன.