ఫంక్షన్‌లను ఎలా టైప్ చేస్తారు, ఐచ్ఛిక మరియు డిఫాల్ట్ పారామితులతో సహా?

Question

Accepted Answer

మీరు పారామితులు మరియు రిటర్న్ విలువను టైప్ చేస్తారు, మరియు TypeScript ఐచ్ఛిక, డిఫాల్ట్, మరియు rest పారామితులను సపోర్ట్ చేస్తుంది.

```ts
// basic
function add(a: number, b: number): number { return a + b; }

// optional parameter (?) — must come after required ones
function greet(name: string, title?: string): string {
  return title ? `${title} ${name}` : name; // title is string | undefined
}

// default parameter — implies optional
function inc(n: number, by: number = 1): number { return n + by; }

// rest parameter — typed as an array
function sum(...nums: number[]): number {
  return nums.reduce((a, n) => a + n, 0);
}
```

## Function type expressions

మీరు ఫంక్షన్ యొక్క *signature* ను ఒక టైప్ గా వర్ణించవచ్చు — callbacks మరియు ఫంక్షన్‌లను కలిగి ఉన్న వేరియబుల్‌ల కోసం ఉపయోగకరం:

```ts
type BinaryOp = (a: number, b: number) => number;
const multiply: BinaryOp = (a, b) => a * b; // params inferred from BinaryOp

// callback parameter
function apply(op: (x: number) => number, val: number) { return op(val); }
```

## Overloads (multiple signatures)

```ts
function parse(x: string): number;
function parse(x: number): string;
function parse(x: any): any { return typeof x === "string" ? +x : String(x); }
```

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

ఫంక్షన్‌లను ఖచ్చితంగా టైప్ చేయడం TypeScript యొక్క విలువ యొక్క కోర్ — కాలర్‌లు తనిఖీ చేయబడిన ఆర్గ్యుమెంట్‌లు మరియు తెలిసిన రిటర్న్ టైప్‌లను పొందుతారు, ఐచ్ఛిక/డిఫాల్ట్ పారామితులు వాస్తవ-ప్రపంచ సరళత్వాన్ని మోడల్ చేస్తాయి, మరియు ఫంక్షన్ టైప్ aliases అధిక-క్రమం కోడ్ (callbacks, event handlers, middleware) స్వీయ-డాక్యుమెంటింగ్ మరియు సురక్షితమైనది చేస్తాయి.