W3Schools Tryit Editor

// Function Overloads with Merging Example
// This demonstrates how TypeScript function overloads work

// In TypeScript, we would declare multiple function signatures:
// function processValue(value: string): string;
// function processValue(value: number): number;
// function processValue(value: boolean): boolean;
//
// function processValue(value: string | number | boolean): string | number | boolean {
//   if (typeof value === "string") {
//     return value.toUpperCase();
//   } else if (typeof value === "number") {
//     return value * 2;
//   } else {
//     return !value;
//   }
// }

// JavaScript implementation of the same function
function processValue(value) {
  if (typeof value === "string") {
    return value.toUpperCase();
  } else if (typeof value === "number") {
    return value * 2;
  } else if (typeof value === "boolean") {
    return !value;
  } else {
    throw new Error("Unsupported type");
  }
}

// Try with different types
console.log("Function overload examples:");
console.log(`processValue("hello"): ${processValue("hello")}`);
console.log(`processValue(10): ${processValue(10)}`);
console.log(`processValue(true): ${processValue(true)}`);

// Would cause runtime error in both JS and TS
try {
  console.log(`processValue({name: "John"}): ${processValue({name: "John"})}`);
} catch (error) {
  console.log(`Error: ${error.message}`);
}

console.log("\nIn TypeScript, function overloads provide type safety:");
console.log("// These would be valid:");
console.log('processValue("hello")  // Returns string');
console.log("processValue(10)       // Returns number");
console.log("processValue(true)     // Returns boolean");
console.log("");
console.log("// This would be a compile-time error:");
console.log("// processValue({})    // Error: Argument of type '{}' is not assignable to parameter");

console.log("\nTypeScript merges multiple function declarations into a single implementation");

Function overload examples:
processValue("hello"): HELLO
processValue(10): 20
processValue(true): false
Error: Unsupported type

In TypeScript, function overloads provide type safety:
// These would be valid:
processValue("hello")  // Returns string
processValue(10)       // Returns number
processValue(true)     // Returns boolean

// This would be a compile-time error:
// processValue({})    // Error: Argument of type '{}' is not assignable to parameter

TypeScript merges multiple function declarations into a single implementation