Syntax to create function overloading in TypeScript

Function overloading is a feature in object-oriented programming where multiple functions can have the same name but different parameters. The parameters can differ in number, types, or both. This allows a single function name to perform different tasks based on the input parameters.

Syntax: 

function function_name(parameter1 : data_type, parameter2: data_type) : function_return_type;

In the above syntax:

• Different functions can have different parameters of various data types.
• The constraint is that the functions must have the same name.
• The parameters count can differ, but the types must be explicitly defined.

Example:

Let's create an example to illustrate function overloading in TypeScript. We will create three functions:

1. Two function declarations with different parameter types.
2. One function implementation that handles the logic based on the input parameter types.

function addFun(a:string, b:string):string;
  
function addFun(a:number, b:number): number;
  
function addFun(a: any, b:any): any {
    return a + b;
}
  
console.log(addFun("Geeksfor", "Geeks")); 
console.log(addFun(30, 40));

// This code is contributed by Aman Singla...

Output: 

Geeksfor Geeks
70

In the above example code, we declare function addFun() with string type of parameters and overload that function as a declaration of another second function with the same name with number type parameters and the last function should have function implementation and what type of value this function will return will decide on what values we are passing as a parameter to this function via the function call.

In the first function call, addFun() with string type arguments so the function will return string. In second function call, we pass addFun()  number type arguments so function will return number. Thus, in order to perform function overloading, we should take care of all these above mention things.

Key Points for Function Overloading

1. Function Declarations: These specify the different overloads with different parameter types.
2. Function Implementation: This contains the logic to handle the different parameter types.
3. Consistent Naming: The overloaded functions must have the same name.
4. Type Checks: The implementation function should check the types of the parameters and execute the appropriate logic.

Function overloading in TypeScript allows you to create multiple functions with the same name but different parameter types. This makes the code more flexible and easier to manage by grouping similar operations under a single function name. By understanding the syntax and implementation of function overloading, you can effectively utilize this feature to enhance the functionality of your TypeScript programs.