तपाई भेरिएबल, प्यारामिटर र रिटर्न टाइप कसरी एनोटेट गर्नुहुन्छ?

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

## किन यो महत्त्वपूर्ण छ

अंगूठाको नियम: **कार्य हस्ताक्षर (प्यारामिटर र सार्वजनिक रिटर्न टाइप) स्पष्ट रूपमा एनोटेट गर्नुहुन्छ, स्थानीय भेरिएबलहरूलाई अनुमान गरिओस्।** यसले कोडलाई संक्षिप्त राख्छ जबकि कार्य सीमामा सम्झौता स्पष्ट र जाँचिएको हुन्छ।