optional மற்றும் default parameter-கள் உட்பட function-களுக்கு எவ்வாறு type கொடுப்பீர்கள்?

Question

Accepted Answer

நீங்கள் parameter-களுக்கும் return value-க்கும் type கொடுக்கிறீர்கள், மேலும் TypeScript optional, default, மற்றும் rest parameter-களை ஆதரிக்கிறது.

```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 expression-கள்

ஒரு function-இன் *signature*-ஐ ஒரு type-ஆக நீங்கள் விவரிக்கலாம் — callback-களுக்கும் function-களை வைத்திருக்கும் variable-களுக்கும் இது பயனுள்ளதாக இருக்கும்:

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

## Overload-கள் (பல signature-கள்)

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

## இது ஏன் முக்கியம்

function-களுக்கு துல்லியமாக type கொடுப்பது TypeScript-இன் மதிப்பின் மையமாகும் — caller-கள் சரிபார்க்கப்பட்ட argument-களையும் அறியப்பட்ட return type-களையும் பெறுகிறார்கள், optional/default parameter-கள் நிஜ-உலக நெகிழ்வுத்தன்மையை மாதிரியாக்குகின்றன, மேலும் function type alias-கள் higher-order code-ஐ (callback-கள், event handler-கள், middleware) தன்னை விளக்கிக் கொள்ளும் (self-documenting) மற்றும் பாதுகாப்பானதாக ஆக்குகின்றன.