மாறிகள், அளவுருக்கள் மற்றும் திரும்பு வகைகளை எவ்வாறு குறிக்கிறீர்கள்?

Question

Accepted Answer

நீங்கள் கோலனுக்குப் பிறகு ஒரு வகையைச் சேர்க்கிறீர்கள். TypeScript பல வகைகளை **கணிக்க** முடியும், எனவே நீங்கள் இது தெளிவை சேர்க்கும் இடத்தில் அல்லது கணிப்பு சாத்தியமற்ற இடத்தில் குறிக்கிறீர்கள்.

```ts
// variables — usually let inference work
let count: number = 0;     // explicit
let name = "Ann";          // inferred as string (annotation redundant)

// function parameters — always annotate (can't be inferred)
function greet(name: string, times: number): string {
  return name.repeat(times);
}

// arrays and objects
const ids: number[] = [1, 2, 3];
const user: { name: string; age: number } = { name: "Ann", age: 30 };
```

## திரும்பு வகைகள்: கணித்தல் அல்லது குறிப்பிடுதல்?

```ts
function add(a: number, b: number) { return a + b; } // inferred return: number
function load(): Promise<User> { ... }                // explicit — documents the contract
```

திரும்பு வகைகள் கணிக்கப்படுகின்றன, ஆனால் ஏற்றுமதி/பொது செயல்பாடுகளில் அவற்றைக் குறிப்பிடுவது சிறந்த நடைமுறை: இது நோக்கத்தை ஆவணப்படுத்துகிறது மற்றும் *செயல்பாட்டிற்குள்* தவறுகளைப் பிடிக்கிறது (நீங்கள் தவறுதலாக தவறான விஷயத்தை திரும்பினால், பிழை செயல்பாட்டின் மீது சுட்டிக்காட்டுகிறது, அதன் அழைப்பாளிகள் அல்ல).

## சிறப்பு வழக்குகள்

```ts
function log(msg: string): void {}     // returns nothing
function fail(): never { throw new Error(); } // never returns normally
const fn: (x: number) => string = ...; // function type annotation
```

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

விரல் விதி: **செயல்பாட்டு கையொப்பங்களை (அளவுருக்கள் மற்றும் பொது திரும்பு வகைகள்) வெளிப்படையாக குறிப்பிடவும், உள்ளூர் மாறிகளை கணிக்க அனுமதிக்கவும்.** இது கோடை சுருக்கமாக வைத்திருக்கும் அதே நேரத்தில் செயல்பாட்டு எல்லைகளில் உள்ள ஒப்பந்தங்களை தெளிவாகவும் சரிபார்க்கப்பட்டதாகவும் செய்கிறது.