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** நேரடியாக கடக்கப்படுவதற்கு செயலுக்கு வரும்போது கடுமையான "அதிகப்படியான சொத்து சரிபார்ப்பு" பெற்றுக்கொள்ளுங்கள் — ஆனால் முதலில் அதை ஒரு மாறியாக ஒதுக்கி விட்டு அது கடக்கும். இது நমনीয়தா மற்றும் தவறுகளைப் பிடிக்க இடையே ஒரு வேண்டுமென்றே ভারிசைக் கொணர்த்துதல் ஆகும்.

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

Kட்டமைப்பு typing TypeScript-ஐ நমனீய மற்றும் ergonomic ஆக்குகிறது — நீங்கள் ஒரு இடைமுகத்தை வெளிப்படையாக செயல்படுத்தாமல் திருப்தி செய்யலாம், இது JavaScript இன் object-literal பாணியை பொருத்துகிறது.

ஒப்பந்தம்: ஒரே வடிவத்தை பகிர்ந்துகொள்ளும் வகைகள் கருத்தளவில் தொடர்பற்றவையாக இருந்தாலும் பரிமாறத்தக்கவை (மக்கள் nominal-போன்ற தனித்தன்மை தேவைப்படுவதற்கு *branded types* ஐப் பயன்படுத்துவதற்கான காரணம்).