Typing Functions

In TypeScript, you can also annotate the types of function parameters and the return value.

Here’s an example where we define the types of both parameters and the return type:

function add(a: number, b: number): number {
  return a + b;
}

In this function, both a and b are numbers, and the function will return a number.

You can also use type annotations with arrow functions:

const add = (a: number, b: number): number => a + b;

Optional parameters

In JavaScript, you can call functions with fewer arguments than expected. But in TypeScript, you must define all required parameters. If a parameter is optional, we can mark it with a question mark (?):

function add(a: number, b?: number): number {
  return a + (b || 0);
}

In this case, b is optional. If we don’t provide b, the function will add 0 by default.

Important: The optional parameter must always come after the required parameters

Default Values

To make an optional parameter easier to use, you can also set a default value for it. This way, if the parameter is not provided, the default value will be used:

function add(a: number, b: number = 0): number {
  return a + b;
}

Now, if b is not given, it will automatically be set to 0.

Rest Parameters

Rest parameters allow a function to accept an unknown number of arguments. Instead of defining each parameter individually, we can use ... followed by a name to collect all the extra arguments into an array.

Here’s an example:

function sum(...numbers: number[]): number {
  return numbers.reduce((total, num) => total + num, 0);
}

console.log(sum(1, 2, 3)); // Output: 6
console.log(sum(5, 10, 15, 20)); // Output: 50

In this case, numbers is an array that contains all the arguments passed to the function. You can now pass as many arguments as you want, and TypeScript will correctly infer that numbers is an array of numbers.

Rest parameters must be the last parameter in the function, so you can’t have other parameters after it.

This makes it easy to create functions that can handle a variable number of arguments.

In summary, TypeScript allows us to clearly define the types of variables and functions. This makes our code more predictable and less error-prone. By using type annotations, we ensure that our variables and functions behave exactly as expected, making our development process smoother and more reliable.