టైప్ సంకుచితం అంటే ఏమిటి మరియు కంపైలర్ దీన్ని ఎలా చేస్తుంది?

Question

Accepted Answer

**సంకుచితం** అనేది TypeScript ఒక విస్తృత టైపును (సంఘం వంటి) కోడ్ బ్రాంచ్ లోపల మరింత నిర్దిష్ట టైపుకు శుద్ధి చేసే విధానం, రన్‌టైమ్ చెక్‌ల ఆధారంగా. కంపైలర్ నియంత్రణ ప్రవాహాన్ని ట్రాక్ చేస్తుంది మరియు అందువల్ల టైపును అప్‌డేట్ చేస్తుంది.

```ts
function process(x: string | number) {
  if (typeof x === "string") {
    x.toUpperCase(); // ✅ here x is narrowed to string
  } else {
    x.toFixed(2);    // ✅ here x must be number
  }
}
```

## సంకుచితం సాధనాలు

```ts
typeof x === "string"          // typeof guard — for primitives
x instanceof Date              // instanceof — for classes
"role" in obj                  // in operator — property existence
Array.isArray(x)               // built-in guards
if (x) { ... }                  // truthiness narrows out null/undefined/0/""
if (x === null) { ... }         // equality narrowing
```

## వివక్ష సంఘాలు స్వచ్ఛంగా సంకుచితం చేస్తాయి

```ts
type Shape =
  | { kind: "circle"; r: number }
  | { kind: "square"; side: number };

function area(s: Shape) {
  switch (s.kind) {            // the discriminant
    case "circle": return Math.PI * s.r ** 2;  // s is the circle variant
    case "square": return s.side ** 2;          // s is the square variant
  }
}
```

భాగస్వామ్య literal ఫీల్డ్‌ను చెక్ చేయడం (`kind`) కంపైలర్‌కు మీకు ఖచ్చితమైన రూపాంతరం ఉందో చెబుతుంది, ఆ రూపాంతరం యొక్క లక్షణాలను అన్‌లాక్ చేస్తుంది.

## కస్టమ్ గార్డ్‌లు సంకుచితాన్ని విస్తరించాయి

```ts
function isUser(x: unknown): x is User { return !!x && typeof (x as any).name === "string"; }
```

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

సంకుచితం సంఘ టైపులను *ఉపయోగించదగినవిగా* చేస్తుంది — ఇది టైపును నిరూపించిన తర్వాత మాత్రమే టైప్-నిర్దిష్ట సభ్యులను సురక్షితంగా యాక్సెస్ చేయడానికి అనుమతిస్తుంది, రన్‌టైమ్ చెక్‌లను కంపైల్-టైమ్ గ్యారంటీలుగా మారుస్తుంది.

ఇది `string | number`, `T | null`, మరియు ట్యాగ్ చేసిన స్థితిని నిర్వహించడం వెనుక రోజువారీ విధానం.