आप वेरिएबल, पैरामीटर और रिटर्न प्रकार को कैसे एनोटेट करते हैं?

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
```

## यह क्यों महत्वपूर्ण है

अंगूठे का नियम: **फ़ंक्शन सिग्नेचर (पैरामीटर और सार्वजनिक रिटर्न प्रकार) को स्पष्ट रूप से एनोटेट करें, स्थानीय वेरिएबल को अनुमानित होने दें।** यह कोड को संक्षिप्त रखता है जबकि फ़ंक्शन सीमाओं पर अनुबंध स्पष्ट और जांचे जाते हैं।