TypeScript Functions

Functions in TypeScript allow you to define reusable blocks of code with the added benefits of static typing. You can specify types for parameters, return values, and leverage advanced features like optional parameters, default values, and rest parameters.

 

Syntax for Functions

Basic Syntax:

function functionName(param1: type, param2: type): returnType {  
  // function body  
}  

 

Function Types

Functions with Parameter Types and Return Types

• You can explicitly define parameter types and return types to ensure type safety.

Optional Parameters

• Parameters can be made optional using the ? symbol. Optional parameters must come after required parameters.

Default Parameters

• You can assign default values to parameters in case no argument is passed.

Rest Parameters

• Use the ... syntax to accept a variable number of arguments.

Anonymous Functions

You can define functions without a name and assign them to a variable.

const multiply = function (a: number, b: number): number {  
  return a * b;  
};  

console.log(multiply(5, 3)); // Output: 15  

Arrow Functions

Arrow functions provide a concise way to write functions and automatically bind this.

const subtract = (a: number, b: number): number => a - b;  

console.log(subtract(10, 3)); // Output: 7  

Function Overloading

Function overloading allows you to define multiple function signatures for the same function.

function combine(a: string, b: string): string;  
function combine(a: number, b: number): number;  
function combine(a: any, b: any): any {  
  return a + b;  
}  

console.log(combine(5, 10));         // Output: 15  
console.log(combine("Hello, ", "World!")); // Output: Hello, World!  

Void Return Type

If a function does not return a value, use the void type.

function logMessage(message: string): void {  
  console.log(message);  
}  

logMessage("Hello, TypeScript!"); // Output: Hello, TypeScript!  

Never Return Type

The never type is used for functions that never return a value, such as functions that throw errors or run indefinitely.

function throwError(message: string): never {  
  throw new Error(message);  
}  

// throwError("Something went wrong!");  

Example: Function with Multiple Features

function displayInfo(name: string, age?: number, ...hobbies: string[]): string {  
  const ageInfo = age ? `, Age: ${age}` : "";  
  const hobbiesInfo = hobbies.length ? `, Hobbies: ${hobbies.join(", ")}` : "";  

  return `Name: ${name}${ageInfo}${hobbiesInfo}`;  
}  

console.log(displayInfo("John"));  
console.log(displayInfo("Alice", 25, "Reading", "Traveling"));  

Output:

Name: John  
Name: Alice, Age: 25, Hobbies: Reading, Traveling  

 

Summary

Functions in TypeScript provide a structured way to define logic with type safety. By using parameter types, return types, optional parameters, default values, and rest parameters, you can create more robust and predictable code. Features like arrow functions, function overloading, and void or never types enhance the flexibility and readability of TypeScript functions.