మీరు వేరియబుల్‌లు, పారామితులు మరియు రిటర్న్ రకాలను ఎలా ఐచ్ఛికంగా నిర్దేశిస్తారు?

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

## ఇది ఎందుకు ముఖ్యమైనది

చేతి యొక్క నియమం: **ఫంక్షన్ సంతకాలు (పారామితులు మరియు పబ్లిక్ రిటర్న్ రకాలు) స్పష్టంగా నిర్దేశించండి, స్థానిక వేరియబుల్‌లను ఊహించనివ్వండి.** ఇది కోడ్‌ను సంక్షిప్తంగా ఉంచుతుంది, అదే సమయంలో ఫంక్షన్ సరిహద్దుల వద్ద ఒప్పందాలను స్పష్టంగా మరియు తనిఖీ చేయబడినవిగా చేస్తుంది.