FunctionParametersAnnotations

## Function Parameters Annotations :-

- Function Parameters annotations in Typescript are used to specify the expected types of the paramters that function takes.

- here is the example of the function paramters annotations

```ts
// Regular Function Annotations
function addOne(num: number) {
  return num + 1;
}

// calling the function and storing to the variable
const result = addOne(3);

console.log(result);

// Arrow Function Annotations

const double = (x: number, y: number) => {
  return x * y;
};

// calling the function and storing to the variable with the number data type arguments passing :-
const res = double(2, 10);

console.log(res);
```

- NOTE :-
  Also notice, Typescript will gives you warning if you provide more or less arguments,
  then you specify in your parameters area

  for an example , from the above `double` code function

```ts
double(2, 10, 20); // 👈 warning or error

// error like :- expected 2 arguments , but got 3.
```

## Default Params Value :-

- here is the example code for it , how we assign the type to default value for the function.

```ts
function greet(person: string = "Anonymous") {
  return `Hello ${person}`;
}

const res = greet();
console.log(res);
```

- so this will give the output as `Hello Anonymous`
- as the function have default value and we are not passing any arguments, so it will use the default value.
- but that default value we have `annoted the type` as `string`.
- so that any other data type passed will not work.

- and if we want to override the default value passed in the function, we would do like this 👇

```ts
function greetByName(person: string = "Anonymous") {
  return `Hello ${person}`;
}

// calling the function and storing to the variable,
// string data type being passed to function call.
const resByName = greetByName("Aman Yadav");
console.log(resByName);
```

- so this will give the output as `Hello Aman Yadav`
- as the function have default value and we are now passing the arguments, so it will override the default value.
- but that overriden value we have `annoted the type` as `string`.
- so that any other data type passed will not work.
- and it will gives us an error that type string is not assinable to type number, when we try to pass the number data type arguments.

## Return Annotations (Regular Function)

- now we will learn about `return value` for a `function annotations` in typescript.
- here is the example of it 👇

```ts
// Regular function
function double1(x: number): number {
  return x * x;
}

const result = double1(5);
// it will return only number and answer will be 25
console.log(result);
```

- in that above function outside of the parameter area that is this -> `(x:number)` we will write `: number` to return a specific type of value.

## Return Annotations (Arrow Function)

- now here we will learn how to annotate the `return value` for `arrow functions` in typescript.

- here is the example of it 👇

```ts
// Using Arrow Function
const double2 = (y: number): number => y * y;

// it will return only number and answer will be 9
const result2 = double2(3);
console.log(result2);
```

- in that above function outside of the parameter area that is this -> `(y:number)` we will write `: number` to return a specific type of value.

## Void In Typescript

- `Void` is a type that represents the `absence of any value`.
- it is often used as `return type` for a `functions that do not return any value`.

- here is the example code to understand better 👇

```ts
function printMessage(message: string): void {
  console.log(`This is my message :- ${message}`);

  // ERROR 👇
  return message;
}

printMessage("Hello How Are You ?");
```

- so for better clearity , what we are doing is that suppose for an example we are not defining any return type like `string`, `number` and not returning any value from the function
- here is the above code without return statment and return annotations 👇

```ts
function printMessage1(message: string) {
  console.log(`This is my message :- ${message}`);
}

printMessage1("Hii, How are you ?");
```

- so typescript will implicitly annoted the function return value as `void`.
- as we are not returning any value from the function.

- and if we provide a return statement to the function then it will automatically get the return type of the function that is for above example `printMessage` function is string.

- and if still we have written `:void` for a function return annotations and we are returning then it will gives us an compile error that is `Type 'string' is not assignable to type 'void'.`
- on the return statment line itself
- u should `avoid to use void` as functions must return some value but for void case it can be used in some cases.
- it may be run the code correctly but it is a bad practise to do.

## Never

- This is the keyword we can simply say as father, mother , grandfather or whatever you want to call of `any keyword`😅

- The `never keyword` is used to indicate that a `function will not return anything`, or that `variable can never have a value`.
- The never type is useful for `indicating that certain code paths should never be reached`, or that certain `values are impossible`.
- It can help `catch errors at compile-time` instead of runtime.

<strong>We are using Never keyword for following reasons 👇</strong>

1. A function that always throws an error.
2. A function that has an infinite loop.
3. A variable that can never have a value.

Examples of the never keyword 👇

1. A function that always throws an error.

```ts
function throwErrorMsg(message: string): never {
  throw new Error(message);
}
```

2. A function that has an infinite loop.

```ts
function infiniteLoop(): never {
  while (true) {}
}
```

3. A variable that can never have a value.

```ts

// we are declearing variable x and annoted with never keyword
let x: never;

function neverReturns(): never {
  while (true) {}
}

x = neverReturns();
```
- this `x = neverReturns()` line will cause a `compile time error` because the function never returns.