ਤੁਸੀਂ ਵੇਰੀਏਬਲਾਂ, ਪੈਰਾਮੀਟਰਾਂ ਅਤੇ ਰਿਟਰਨ ਕਿਸਮਾਂ ਨੂੰ ਕਿਵੇਂ ਐਨੋਟੇਟ ਕਰਦੇ ਹੋ?

Question

Accepted Answer

ਤੁਸੀਂ ਇੱਕ ਕੋਲਨ ਤੋਂ ਬਾਅਦ ਇੱਕ ਕਿਸਮ ਜੋੜਦੇ ਹੋ। TypeScript ਬਹੁਤ ਸਾਰੀਆਂ ਕਿਸਮਾਂ **infer** ਕਰ ਸਕਦਾ ਹੈ, ਇਸ ਲਈ ਤੁਸੀਂ ਉਥੇ ਐਨੋਟੇਟ ਕਰਦੇ ਹੋ ਜਿੱਥੇ ਇਹ ਸਪੱਸ਼ਟਤਾ ਜੋੜਦਾ ਹੈ ਜਾਂ ਜਿੱਥੇ inference ਸੰਭਵ ਨਹੀਂ ਹੈ।

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

## Return ਕਿਸਮਾਂ: infer ਜਾਂ annotate?

```ts
function add(a: number, b: number) { return a + b; } // inferred return: number
function load(): Promise<User> { ... }                // explicit — documents the contract
```

Return ਕਿਸਮਾਂ infer ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਪਰ ਉਹਨਾਂ ਨੂੰ exported/public functions ਉੱਤੇ annotate ਕਰਨਾ ਚੰਗਾ ਅਭਿਆਸ ਹੈ: ਇਹ intent ਨੂੰ ਦਸਤਾਵੇਜ਼ ਕਰਦਾ ਹੈ ਅਤੇ function ਦੇ *ਅੰਦਰ* ਗਲਤੀਆਂ ਨੂੰ ਫੜਦਾ ਹੈ (ਜੇ ਤੁਸੀਂ ਗਲਤੀ ਨਾਲ ਗਲਤ ਚੀਜ਼ ਵਾਪਸ ਕਰੋ, ਤਾਂ ਗਲਤੀ function ਉੱਤੇ ਇਸ਼ਾਰਾ ਕਰਦੀ ਹੈ, ਇਸ ਦੇ callers ਉੱਤੇ ਨਹੀਂ)।

## Special ਸਥਿਤੀਆਂ

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

## ਇਹ ਕਿਉਂ ਮਾਇਨੇ ਰਖਦਾ ਹੈ

ਥੰਬ ਦਾ ਨਿਯਮ: **function signatures (parameters ਅਤੇ public return types) ਨੂੰ explicitly annotate ਕਰੋ, local variables ਨੂੰ infer ਹੋਣ ਦਿਓ।** ਇਹ code ਨੂੰ ਸੰਖੇਪ ਰੱਖਦਾ ਹੈ ਜਦੋਂ function boundaries ਉੱਤੇ contracts ਨੂੰ ਸਪੱਸ਼ਟ ਅਤੇ ਚੈਕ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।