તમે ફંક્શનને કેવી રીતે પ્રકાર કરો છો, જેમાં વૈકલ્પિક અને ડિફોલ્ટ પરિમાણો સમાવેશ થાય છે?

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);
}
```

## ફંક્શન પ્રકાર અભિવ્યક્તિઓ

તમે ફંક્શનના *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); }
```

## ઓવરલોડ્સ (બહુવિધ 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 ની મૂલ્યનો મુખ્ય અંશ છે — કૉલર્સને તપાસાયેલ આર્ગ્યુમેન્ટ્સ અને જાણીતા પરત પ્રકાર મળે છે, વૈકલ્પિક/ડિફોલ્ટ params વાસ્તવિક-વિશ્વ લવચીકતાને મોડેલ કરે છે, અને ફંક્શન પ્રકાર aliases ઉચ્ચ-ક્રમની કોડ (callbacks, ઇવેન્ટ હ্যાન્ડલર્સ, middleware) આત્મ-દલીલ અને સુરક્ષિત બનાવે છે.