Method Overloading

Method overloading refers to the ability to define multiple methods in a class or object with the same name but with different parameter types or a different number of parameters.

In JavaScript, unlike some other programming languages like Java or C++, method overloading isn't directly supported.

However, you can achieve similar behavior by employing different techniques.

One common approach is to check the number and types of arguments passed to a function and then execute different logic based on those parameters.

class Calculator {
  add() {
    if (arguments.length === 2) {
      // If two arguments are passed, assume addition of two numbers
      return arguments[0] + arguments[1];
    } else if (arguments.length === 3 && typeof arguments[0] === 'string') {
      // If three arguments are passed and the first one is a string, assume concatenation
      return arguments[0] + arguments[1] + arguments[2];
    } else {
      // Default behavior, if the arguments don't match any specific case
      return "Invalid arguments";
    }
  }
}

const calc = new Calculator();
console.log(calc.add(2, 3)); // Outputs: 5
console.log(calc.add('Hello', ' ', 'world')); // Outputs: Hello world
console.log(calc.add(2, 3, 4)); // Outputs: Invalid arguments

In this example, the add method of the Calculator class checks the number and types of arguments passed. If two arguments (assumed to be numbers) are provided, it performs addition.

If three arguments are provided and the first one is a string, it performs concatenation.

Otherwise, it returns an "Invalid arguments" message.

This approach mimics method overloading by providing different behavior based on the parameters passed to the function, even though the function name remains the same.