TypeScript లో structural typing అంటే ఏమిటి?

Question

Accepted Answer

TypeScript **structural typing** ("duck typing")-ను ఉపయోగిస్తుంది: రెండు రకాలు **ఒకే ఆకారం** కలిగి ఉంటే సంగతిపడతాయి, వాటి పేరు లేదా ఎక్కడ ప్రకటించినా పర్వాలేదు. ఇది *nominal* typing (Java, C#) నుండి భిన్నంగా ఉంది, ఇక్కడ సంగతి ప్రకటించిన రకం పేరుపై ఆధారపడుతుంది.

```ts
interface Point { x: number; y: number; }

function print(p: Point) { console.log(p.x, p.y); }

// No `: Point` annotation anywhere, but the shape matches:
const obj = { x: 1, y: 2, z: 3 };
print(obj); // ✅ works — obj has x and y (extra z is fine)
```

`obj` ఎప్పుడూ `Point` గా ప్రకటించబడలేదు, అయితే ఇది *నిర్మాణాత్మకంగా* ఆకారాన్ని సంతృప్తిపరుస్తుంది కాబట్టి ఆమోదించబడుతుంది. ఇప్పటికే ఉన్న వేరియబల్ను చేరుకొచ్చేటప్పుడు అదనపు లక్షణాలు అనుమతించబడతాయి.

## అతిరిక్త-ఆస్తి చెక్ మినహాయింపు

```ts
print({ x: 1, y: 2, z: 3 }); // ❌ Error: 'z' does not exist in type 'Point'
```

ఆబ్జెక్ట్ **literals** నేరుగా చేరుకొచ్చినపుడు విరుద్ధ "అతిరిక్త ఆస్తి చెక్" పొందుతుంది — కానీ ముందుగా దానిని వేరియబల్కు కేటాయించండి మరియు ఇది చేరుకుంటుంది. ఇది నమ్యత మరియు లోపాలను పట్టుకోవటం మధ్య ఉద్దేశ్యపూర్వక సమతుల్య.

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

NirmaanAtmaka typing TypeScript-ను నమ్యమైనదిగా మరియు ergonomic-గా చేస్తుంది — మీరు ఇంటర్ఫేస్ను స్పష్టంగా అమలు చేయకుండా సంతృప్తిపర్చవచ్చు, ఇది JavaScript యొక్క object-literal శైలికి సరిపోతుంది.

ట్రేడ్-ఆఫ్: ఆకారాన్ని భాగస్వామ్యం చేసే రకాలు సంభావితంగా సంబంధం లేనివి అయితే కూడా పరస్పరం మార్చుకోవచ్చు (*branded types* వాడకం చేసుకోవటానికి ఒక కారణం ఏమిటంటే, వారికి nominal-లాంటి సంభిన్నత అవసరమైనప్పుడు).