Skip to content

Interesting Facts About Functions in TypeScript

Explain about rest parameters and arguments in TypeScript

Last Updated : 22 Aug, 2022

In this article, we will try to understand all the basic facts or details which are associated with Rest Parameters and Arguments in TypeScript.

Rest Parameters:

Rest Parameter allows us to accept zero or more arguments of the specified type.
A function (or a method) has only one rest parameter.
This parameter appears at last in the function's specified parameter list.
Since here it is TypeScript being into the picture, so the type of rest parameter is of an Array type (further the array could be string data type or number data type or anything).

Syntax: Following is the rest parameter syntax provided in TypeScript.

function function_name (...rest_parameter_name : type[]) { }

Here these "..." (triple dots) represents the rest parameter syntax followed by name of the rest parameter followed by the type of that rest parameter (must be of Array data type).

Rest Arguments:

These are arguments that we pass in while merging two data types (suppose concatenation of two arrays) using the same "..." (triple dots).
These types of arguments are generally used for merging or concatenation or for any other operational purpose itself.

Syntax: Following is the syntax of using the Rest Arguments in TypeScript (explained using an example).

let array_1 : number[] = [1 , 2 , 3]; let array_2 : number[] = [5 , 6, 7]; array_1.push(array_2);

The following examples will help us in order to understand the above-illustrated facts in a more clear manner (in case you don't know, these examples could only be runnable in your local PC if you have installed typescript in it, otherwise you may choose some online typescript compilers).

Example 1: In this example, we will get the sum of arguments of integers which are passed in a function using the rest parameter syntax.

JavaScript

function getSum(...numbers: number[]): number {     let sum = 0;     numbers.forEach((num) => sum += num);     return sum; }  // Function call console.log(getSum(10 , 50 , 30)); console.log(getSum(-50 , 50 , -10 , 5));

Output:

90 -5

Example 2: In this example, we will concatenate several strings which are passed inside the function as arguments.

JavaScript

let generateGreeting = (greeting: string, ...names: string[]) : string =>{     return greeting + " " + names.join(", ") +"!"; }  // Function call console.log(generateGreeting("Hello ", "GeeksforGeeks ", "ABCD ", "Apple"));

Output:

Hello  GeeksforGeeks , ABCD , Apple!

Example 3: In this example, we will perform multiplication of all the numbers which are passed in a function as arguments.

JavaScript

let multiply = (a: number, ...numbers: number[]): number =>{   return numbers.reduce((acc, curr) => acc * curr, a); }  // Function call let result1 = multiply(2, 2, 2, 2, 7);  let result2 = multiply(2, 3, 2, 5, 8);   // Printing data console.log(result1); console.log(result2);

Output:

112 480

Reference: https://www.typescriptlang.org/docs/handbook/functions.html#rest-parameters

Interesting Facts About Functions in TypeScript

amansingla

Improve

Article Tags :

Similar Reads

TypeScript Rest Parameters and Arguments

TypeScript Rest Parameters allow functions to accept an indefinite number of arguments of the same type, collecting them into an array. Arguments refer to the actual values passed to a function when it's invoked, while Rest Parameters provide a way to handle multiple arguments as an array within the

Explain the Rest parameter in ES6

In this article, we will try to understand the details associated with the rest parameter in ES6 which includes the syntax of rest parameters, and how to use this with the help of certain examples. The rest parameter is an improved way to handle function parameters, allowing us to handle various inp

Interesting Facts About Generics in TypeScript

TypeScript generics provide a powerful way to create reusable, type-safe components and functions that work with multiple types. They improve flexibility, reduce redundancy, and ensure strict type constraints without sacrificing reusability. 1. Generics Make Functions FlexibleGenerics allow you to c

Interesting Facts About Functions in TypeScript

TypeScript enhances JavaScript functions with strong typing, better inference, and advanced features, making code safer, more readable, and more scalable. Understanding its function-related capabilities can greatly improve development efficiency. 1. TypeScript Infers Function Argument TypesTypeScrip

Rest Parameters in TypeScript

Rest parameters in TypeScript enable functions to handle an unlimited number of arguments by grouping them into an array. They are defined using ... and must be the last parameter. Allow flexible and dynamic input handling in functions.Simplify working with multiple arguments without specifying them

TypeScript Using Type Parameters in Generic Constraints

TypeScript Generics allows you to write reusable code that works with different types. In this article, we will explore how to use type parameters in generic constraints to ensure that which types are allowed in generic types or functions. Syntax:function functionName<Type extends ConstraintType

TypeScript Parameter Type Annotations

TypeScript Parameter type annotations are used to specify the expected data types of function parameters. They provide a way to explicitly define the types of values that a function expects as arguments. Parameter type annotations are part of TypeScript's static typing system, and they help catch ty

Interesting Facts About Object Types and Interfaces in TypeScript

TypeScript enhances object types and interfaces with strong typing, extendibility, and dynamic features, making code more structured and maintainable. Mastering these concepts improves scalability, flexibility, and type safety in applications. 1. Interfaces Can Describe FunctionsInterfaces in TypeSc

TypeScript Optional Parameters in Callbacks

In TypeScript, optional parameters in callbacks are parameters that may or may not be provided when the callback function is invoked. They are denoted by a ? after the parameter name, allowing for more flexible function calls without requiring all arguments. Syntaxtype MyCallback = (param1: string,

TypeScript Generic Parameter Defaults

TypeScript Generic Parameter Defaults allow you to specify default values for generic type parameters. This feature provides a fallback type when no explicit type argument is given, making generic types more flexible and easier to use, particularly when type inference is not straightforward. Syntaxf