Extending the Number Type for Chained Operations

1. To add methods to all numbers, use Number.prototype.
2. Inside each method, this will refer to the number the method is being called on.
3. Each method must return the result of the operation (a new number) so that the next method in the chain can work with it.
4. Don’t forget to handle division by zero in the divide method.

/**
 * We extend the Number prototype to add new methods.
 * `this` inside these methods will refer to the number
 * the method is being called on.
 */
 
// Method for addition
Number.prototype.plus = function(num) {
  // `this` is the current number (e.g., (2) in (2).plus(3))
  // We return the result of the addition to allow for chaining
  return this + num;
};
 
// Method for subtraction
Number.prototype.minus = function(num) {
  return this - num;
};
 
// Method for multiplication
Number.prototype.multiply = function(num) {
  return this * num;
};
 
// Method for division
Number.prototype.divide = function(num) {
  // Handle division by zero
  if (num === 0) {
    return Infinity;
  }
  return this / num;
};

Step-by-step code explanation:

1. Number.prototype.plus = function(num) { ... };

   • We access Number.prototype to add a new plus method to all instances of Number (i.e., to all numbers).
   • The function takes one argument, num — the number to be added.

2. return this + num;

   • this in the context of this method is the value of the number the method is called on. For example, in the expression (5).plus(3), this will be equal to 5.
   • We return the result of adding this and num. This is the key to building a chain: the result of (5).plus(3) (i.e., 8) becomes the new this for the next call in the chain.

3. Similar methods minus, multiply, divide

   • They work on the same principle, performing the corresponding arithmetic operations.

4. Handling division by zero

   • In the divide method, we added a check: if (num === 0). If we try to divide by zero, the function will return Infinity, which is consistent with standard JavaScript behavior.

Why it works this way:

• Extensibility: Modifying the prototype allows you to add new functionality to all objects of a certain type without changing each object individually.
• Readability: Method chaining (a fluent API) makes the code more declarative and easy to read, resembling natural language.
• Caution: Although this is an excellent learning example, modifying the prototypes of built-in objects (Number, Array, String, etc.) is considered bad practice in large-scale projects. It can lead to conflicts with other libraries or future versions of JavaScript.