**Course Title:** Mastering TypeScript: From Basics to Advanced Applications **Section Title:** Control Structures and Functions **Topic:** Understanding function overloading ### Introduction to Function Overloading In TypeScript, function overloading is a feature that allows multiple functions with the same name to be defined, as long as they have different parameter lists. This means that you can create multiple functions with the same name, but with different numbers or types of parameters. This is useful when you want to perform different actions based on the input parameters, but still want to reuse the same function name. ### Key Concepts * **Function Signature**: In TypeScript, a function signature is the combination of the function name, parameter list, and return type. When defining multiple functions with the same name, each function signature must be unique. * **Type Inference**: When using function overloading, TypeScript uses type inference to determine which function to call based on the input parameters. * **Compile-time checking**: TypeScript checks the function calls at compile-time to ensure that the correct function is being called. ### Example 1: Basic Function Overloading ```typescript function add(a: number, b: number): number { return a + b; } function add(a: number, b: number, c: number): number { return a + b + c; } console.log(add(1, 2)); // Output: 3 console.log(add(1, 2, 3)); // Output: 6 ``` In the above example, we have two functions with the same name `add`, but with different parameter lists. The first function takes two numbers and returns their sum, while the second function takes three numbers and returns their sum. ### Example 2: Function Overloading with Different Parameter Types ```typescript function greet(name: string): void { console.log(`Hello, ${name}!`); } function greet(age: number): void { console.log(`You are ${age} years old.`); } greet('John'); // Output: Hello, John! greet(30); // Output: You are 30 years old. ``` In this example, we have two functions with the same name `greet`, but with different parameter types. The first function takes a string and prints a greeting message, while the second function takes a number and prints a message about the person's age. ### Advanced Example: Function Overloading with Multiple Parameters ```typescript function calculate(x: number, y: number): number; function calculate(x: number, y: string): string; function calculate(x: number, y: number | string): number | string { if (typeof y === 'string') { return `${x} ${y}`; } return x + y; } console.log(calculate(1, 2)); // Output: 3 console.log(calculate(1, 'hello')); // Output: 1 hello ``` In this example, we have two function signatures for the `calculate` function. The first signature takes two numbers and returns their sum, while the second signature takes a number and a string and returns a concatenation of the two. The implementation uses type inference to determine which function signature to use. ### Key Takeaways * Function overloading allows multiple functions with the same name to be defined, as long as they have different parameter lists. * Each function signature must be unique, including the function name, parameter list, and return type. * TypeScript uses type inference to determine which function to call based on the input parameters. * Function overloading is useful when you want to perform different actions based on the input parameters, but still want to reuse the same function name. ### Further Reading * [TypeScript Documentation on Function Overloading](https://www.typescriptlang.org/docs/handbook/2/functions.html#function-overloads) * [TypeScript Tutorial on Function Overloading](https://www.tutorialspoint.com/typescript/typescript_function_overloading.htm) ### What's Next? In the next topic, we will cover **Primitive and Complex Types: Arrays, Tuples, and Enums**. You will learn about the different types of primitive and complex types in TypeScript, including arrays, tuples, and enums. You will also learn how to use these types to create more complex data structures. If you have any questions or need further clarification on function overloading, please leave a comment below. We encourage you to ask questions and engage with the material to get the most out of this course.