Can you describe what the Module Pattern is?

The Module Pattern is a design pattern in JavaScript that allows developers to create encapsulated and reusable code. It is a way of organizing code into self-contained modules that can be easily reused across different parts of an application. The main idea behind the Module Pattern is to create a private scope for variables and functions, which helps to prevent naming collisions and other issues that can arise when working with global variables. One of the key features of the Module Pattern is the use of an immediately invoked function expression (IIFE) to create a private scope. This allows developers to define private variables and functions that are not accessible from outside the module. By using the return statement, developers can expose only the public API of the module, which can be used by other parts of the application. Here is an example of how the Module Pattern can be used to create a simple module that provides a public API for adding and subtracting numbers:

<script>
var calculator = (function() {
  var total = 0;

  function add(number) {
    total += number;
  }

  function subtract(number) {
    total -= number;
  }

  return {
    add: add,
    subtract: subtract,
    getTotal: function() {
      return total;
    }
  };
})();

calculator.add(5);
calculator.subtract(2);
console.log(calculator.getTotal()); // Output: 3
</script>

In this example, the calculator module is defined using an IIFE, which creates a private scope for the total, add, and subtract variables. The module returns an object that exposes the add, subtract, and getTotal methods, which can be used to manipulate the total variable. By using the Module Pattern, developers can create reusable and encapsulated code that is easy to maintain and debug.