Function overloads in Typescript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a function overload in TypeScript?

Function overloads allow you to define multiple function signatures for a single function implementation, enabling different ways to call the function with different argument types or counts.

beginner

How do you declare multiple overloads for a function in TypeScript?

You write multiple function declarations with different parameter types or counts above the actual function implementation, which has a single combined signature.

intermediate

Why must the implementation signature be compatible with all overload signatures?

Because the implementation handles all calls, it must accept all argument types and return types declared in the overloads to avoid type errors.

intermediate

Can function overloads have different return types in TypeScript?

Yes, overloads can specify different return types depending on the input parameters, allowing flexible function behavior.

beginner

What happens if you call a function with arguments that don't match any overload signature?

TypeScript will show a compile-time error because the call does not match any declared overload signature.

Which of the following is the correct way to declare function overloads in TypeScript?

A Multiple function declarations with different signatures followed by one implementation

B Multiple functions with the same name but different bodies

C One function with multiple return statements

D Using union types in a single function signature only

Function overloads require multiple declarations with different signatures, followed by a single implementation that handles all cases.

What must the implementation signature of an overloaded function include?

A Parameters and return type compatible with all overloads

B Only the first overload's parameters and return type

C No parameters, just a generic return type

D Different parameters than the overloads

The implementation must be compatible with all overload signatures to handle every possible call.

If a function has overloads with different return types, what does TypeScript do?

A It ignores the return types

B It always returns the first overload's return type

C It infers the return type based on the called overload

D It throws a runtime error

TypeScript uses the overload signature matching the call to determine the return type.

What happens if you call an overloaded function with arguments that don't match any overload?

A The function returns undefined

B The function runs with default parameters

C The function picks the closest overload

D TypeScript shows a compile-time error

Calls must match one of the declared overloads or TypeScript will report an error.

Can you overload a function by changing only the return type but keeping the same parameters?

A Yes, return type alone is enough

B No, overloads must differ in parameter types or count

C Yes, but only for async functions

D No, TypeScript does not support overloads

Overloads must differ in parameters; changing only return type is not allowed.

Explain how function overloads work in TypeScript and why they are useful.

Think about how one function can behave differently based on input.

Describe the rules for writing the implementation of an overloaded function in TypeScript.

The implementation must cover all declared ways to call the function.

Practice

1. What is the main purpose of function overloads in TypeScript?

easy

A. To allow a single function to handle different types of input with clear signatures

B. To create multiple functions with the same name but different implementations

C. To automatically generate function documentation

D. To enforce that functions only accept one specific type

Solution

1. Step 1: Understand function overloads concept

   Function overloads let one function have multiple type signatures to handle different input types clearly.

2. Step 2: Compare options with concept

   Only To allow a single function to handle different types of input with clear signatures correctly describes this purpose. Other options describe different or incorrect ideas.

3. Final Answer:

   To allow a single function to handle different types of input with clear signatures -> Option A

4. Quick Check:

   Function overloads = multiple input types handled clearly [OK]

Hint: Overloads = multiple input types, one function name [OK]

Common Mistakes:

• Thinking overloads create multiple separate functions
• Believing overloads generate docs automatically
• Assuming overloads restrict to one type only

2. Which of the following is the correct syntax for declaring function overloads in TypeScript?

easy

A. function foo(x: any): any; function foo(x: any) { return x; }

B. function foo(x: number | string): number | string { return x; }

C. function foo(x: number): number { } function foo(x: string): string { }

D. function foo(x: number): number; function foo(x: string): string; function foo(x: any) { return x; }

Solution

1. Step 1: Identify correct overload syntax

   Overloads require multiple declarations without bodies, then one implementation with a body.

2. Step 2: Check each option

   function foo(x: number): number; function foo(x: string): string; function foo(x: any) { return x; } shows multiple signatures without bodies, then one implementation with a body. Others either combine signatures or have bodies in all declarations.

3. Final Answer:

   function foo(x: number): number; function foo(x: string): string; function foo(x: any) { return x; } -> Option D

4. Quick Check:

   Overloads = multiple signatures + one implementation [OK]

Hint: Overloads: signatures no body, one implementation with body [OK]

Common Mistakes:

• Putting function bodies in all overload declarations
• Using union types instead of overloads
• Declaring only one function signature

3. What will be the output of the following TypeScript code?

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

console.log(combine(5, 10));
console.log(combine('Hi, ', 'there!'));

medium

A. '510' and 'Hi, there!'

B. 15 and 'Hithere!'

C. 15 and 'Hi, there!'

D. Error: No matching overload

Solution

1. Step 1: Analyze overload signatures and implementation

   Two overloads: one for numbers returning number, one for strings returning string. Implementation uses + operator.

2. Step 2: Evaluate console.log calls

   combine(5, 10) adds numbers: 5 + 10 = 15. combine('Hi, ', 'there!') concatenates strings: 'Hi, ' + 'there!' = 'Hi, there!'.

3. Final Answer:

   15 and 'Hi, there!' -> Option C

4. Quick Check:

   Number add = 15, String concat = 'Hi, there!' [OK]

Hint: Overloads match input types; + adds numbers or joins strings [OK]

Common Mistakes:

• Thinking + always concatenates strings only
• Expecting error due to any type in implementation
• Confusing output as string '510' for numbers

4. Identify the error in the following TypeScript function overload code:

function greet(name: string): string {
  return 'Hello, ' + name;
}
function greet(age: number): string {
  return 'You are ' + age + ' years old';
}

medium

A. Return types must be void for overloads

B. Function overloads must have multiple signatures without bodies, then one implementation

C. Function names must be different for overloads

D. Overloads cannot use string or number types

Solution

1. Step 1: Review overload syntax rules

   Overloads require multiple declarations without bodies, followed by one implementation with a body.

2. Step 2: Check given code

   Both functions have bodies and same name, which is invalid overload syntax.

3. Final Answer:

   Function overloads must have multiple signatures without bodies, then one implementation -> Option B

4. Quick Check:

   Overloads = signatures no body + one implementation [OK]

Hint: Overloads: only one function has body, others are signatures [OK]

Common Mistakes:

• Writing multiple functions with bodies for overloads
• Using different function names for overloads
• Thinking return type must be void

5. Given the following overloaded function signatures, which implementation correctly handles both overloads and returns the expected types?

function parseInput(input: string): number;
function parseInput(input: number): string;
// Implementation here

hard

A. function parseInput(input: any) {
if (typeof input === 'string') return Number(input);
else return input.toString();
}

B. function parseInput(input: string | number) {
return input;
}

C. function parseInput(input: string | number): string | number {
return input + 1;
}

D. function parseInput(input: any) {
return input;
}

Solution

1. Step 1: Understand overload signatures

   Input string returns number; input number returns string.

2. Step 2: Check each implementation

   function parseInput(input: any) { if (typeof input === 'string') return Number(input); else return input.toString(); } checks input type and converts accordingly, matching overloads. Others either return input unchanged or perform invalid operations.

3. Final Answer:

   function parseInput(input: any) { if (typeof input === 'string') return Number(input); else return input.toString(); } -> Option A

4. Quick Check:

   Type check + convert = correct overload implementation [OK]

Hint: Check input type, convert to match overload return type [OK]

Common Mistakes:

• Ignoring input type and returning input directly
• Using union types without type checks
• Returning wrong types for given inputs