**Course Title:** Modern JavaScript Programming: From Fundamentals to Full-Stack Development **Section Title:** Advanced JavaScript: Closures, Hoisting, and Prototypes **Topic:** Advanced patterns: Immediately Invoked Function Expressions (IIFE) and module pattern In this topic, we will explore two advanced JavaScript patterns that can help you write more modular, organized, and efficient code. We will start with Immediately Invoked Function Expressions (IIFE) and then move on to the module pattern. ### Immediately Invoked Function Expressions (IIFE) An IIFE is a function that is defined and immediately executed after its definition. It is an anonymous function that is wrapped in parentheses to create a new scope. The purpose of an IIFE is to create a new scope for variables and functions, which can help to: * Avoid polluting the global namespace * Prevent variable collisions * Create a sandbox for testing or debugging Here is an example of an IIFE: ```javascript (function () { let name = 'Modern JavaScript'; console.log(name); }()); ``` In this example, we define an anonymous function and immediately execute it by adding the parentheses at the end. The variable `name` is defined inside the IIFE and is not accessible outside of it. IIFE can also be used to create a private scope for variables and functions. For instance, you can use an IIFE to create a counter that increments each time it is called: ```javascript let counter = (function () { let count = 0; return function () { count++; console.log(count); }; }()); ``` In this example, the variable `count` is defined inside the IIFE and is not accessible outside of it. However, the function returned by the IIFE can be used to increment the counter. For more information on IIFE, please refer to: [MDN Web Docs - Immediately invoked function expression](https://developer.mozilla.org/en-US/docs/Glossary/IIFE). ### Module Pattern The module pattern is a design pattern that allows you to create self-contained modules that can be easily reused in other parts of your codebase. A module is essentially an object that contains a set of related variables and functions. The module pattern consists of several key elements: * A closure: This is the outer function that wraps the module and creates a new scope. * A namespace: This is the object that contains the variables and functions of the module. * A set of exposed functions: These are the functions that can be accessed outside of the module. Here is an example of a simple module: ```javascript const module = (function () { let privateVariable = 'private variable'; function privateFunction() { console.log('private function'); } return { publicVariable: 'public variable', publicFunction: function () { privateFunction(); console.log(publicVariable); }, }; }()); ``` In this example, the `module` object is the namespace that contains the `publicVariable` and `publicFunction`. The `privateVariable` and `privateFunction` are defined inside the closure but are not exposed outside of the module. The module pattern allows you to create modules that are easy to reuse and maintain. For instance, you can use the module pattern to create a logging module that can be used throughout your application: ```javascript const logger = (function () { let logLevel = 'debug'; return { setLogLevel: function (level) { logLevel = level; }, log: function (message) { if (logLevel === 'debug') { console.log(message); } }, }; }()); ``` In this example, the `logger` module exposes two functions: `setLogLevel` and `log`. The `logLevel` variable is defined inside the closure but can be modified using the `setLogLevel` function. For more information on the module pattern, please refer to: [Wikipedia - Module pattern](https://en.wikipedia.org/wiki/Module_pattern). ### Conclusion In this topic, we covered two advanced JavaScript patterns: Immediately Invoked Function Expressions (IIFE) and the module pattern. These patterns can help you write more modular, organized, and efficient code. By using IIFE, you can create a new scope for variables and functions, which can help to avoid polluting the global namespace and prevent variable collisions. The module pattern allows you to create self-contained modules that can be easily reused in other parts of your codebase. This pattern consists of a closure, a namespace, and a set of exposed functions. We hope that this topic has provided you with a solid understanding of these advanced patterns and how to apply them in your own code. If you have any questions or need further clarification, please leave a comment below. In the next topic, we will explore [Introduction to Object-Oriented Programming (OOP) in JavaScript](https://).