आप व्हेरिएबल, पैरामीटर आणि रिटर्न टाइप कसे अ‍ॅनोटेट करता?

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

## हे महत्वाचे का आहे

थंब नियम: **कार्य स्वाक्षरी (पैरामीटर आणि सार्वजनिक रिटर्न प्रकार) स्पष्टपणे अ‍ॅनोटेट करा, स्थानिक व्हेरिएबलला अनुमानित होऊ द्या.** हे कोडला संक्षिप्त ठेवते तर कार्य सीमांवरील करार स्पष्ट आणि तपासले जातात.