Is it possible to implement the revealing module pattern without using an IIFE in this way while still achieving the same goal

Question

Is it possible to implement the revealing module pattern without using an IIFE in this way while still achieving the same goal

From my understanding, the concept of revealing module pattern can be demonstrated as follows:

SAMPLE #1

const iifeModulePattern = (function () {
  const secretSeed = 999; // ← hidden
  const logSecretCode = function(){console.log(secretSeed+1)};
  return {methodForPublic : logSecretCode};
})();

iifeModulePattern.methodForPublic();

As far as I know, I believe I am on the right track. Now, my question is:

Wouldn't Sample #2 accomplish the same goal?
If yes, why is Sample #1 more popular than Sample #2?
If not, what sets them apart?

SAMPLE #2

const modulePattern = () => {
  const secretSeed = 999; // ← hidden
  const logSecretCode = function(){console.log(secretSeed+1)};
  return {methodForPublic : logSecretCode};
};

modulePattern().methodForPublic();

I want to clarify that these code snippets are only examples and not meant for storing actual sensitive information like passwords.

javascript oop closures encapsulation iife

Answer 1

Answer №1

const immediateInvokeFunctionExpression = (function() {
  let value = 0; // private
  return {
    next: () => (value = 134775813 * value + 1) >>> 0
  };
})();

for (let i = 0; i < 5; ++i) {
  console.log("immediateInvokeFunctionExpression.next()", i, immediateInvokeFunctionExpression.next());
}

console.log("Understanding the concept of IIFE.");
console.log("");

const functionModulePattern = () => {
  let val = 0; // private
  return {
    next: () => (val = 134775813 * val + 1) >>> 0
  };
};

for (let i = 0; i < 5; ++i) {
  console.log("functionModulePattern().next()", i, functionModulePattern().next());
}
console.log("It might seem unnecessary this way as the sequence restarts each time.");
console.log("");

const inst1 = functionModulePattern();
const inst2 = functionModulePattern();
for (let i = 0; i < 10; ++i) {
  console.log("inst1.next()", i, inst1.next());
  if (i % 2 !== 0) {
    console.log("inst2.next()", i, inst2.next());
  }
}
console.log("Using multiple instances makes more sense.\nAnd these instances progress independently.");

.as-console-wrapper {top:0;max-height:100%!important}

Will a different Code #2 achieve the same result?

Yes, No, maybe; it relies on the usage scenario.

If not, what sets them apart?

immediateInvokeFunctionExpression

acts as a singleton, while functionModulePattern() is used as a factory method.

If so, why is Code #1 preferred over Code #2?

What's the point of naming and storing the factory in a variable when you intend to call it only once at the moment?

Answer 2

const immediateInvokeFunctionExpression = (function() {
  let value = 0; // private
  return {
    next: () => (value = 134775813 * value + 1) >>> 0
  };
})();

for (let i = 0; i < 5; ++i) {
  console.log("immediateInvokeFunctionExpression.next()", i, immediateInvokeFunctionExpression.next());
}

console.log("Understanding the concept of IIFE.");
console.log("");

const functionModulePattern = () => {
  let val = 0; // private
  return {
    next: () => (val = 134775813 * val + 1) >>> 0
  };
};

for (let i = 0; i < 5; ++i) {
  console.log("functionModulePattern().next()", i, functionModulePattern().next());
}
console.log("It might seem unnecessary this way as the sequence restarts each time.");
console.log("");

const inst1 = functionModulePattern();
const inst2 = functionModulePattern();
for (let i = 0; i < 10; ++i) {
  console.log("inst1.next()", i, inst1.next());
  if (i % 2 !== 0) {
    console.log("inst2.next()", i, inst2.next());
  }
}
console.log("Using multiple instances makes more sense.\nAnd these instances progress independently.");

.as-console-wrapper {top:0;max-height:100%!important}

Will a different Code #2 achieve the same result?

Yes, No, maybe; it relies on the usage scenario.

If not, what sets them apart?

immediateInvokeFunctionExpression

acts as a singleton, while functionModulePattern() is used as a factory method.

If so, why is Code #1 preferred over Code #2?

What's the point of naming and storing the factory in a variable when you intend to call it only once at the moment?

Is it possible to implement the revealing module pattern without using an IIFE in this way while still achieving the same goal

Answer №1

Similar questions

Can a photo frame app be created using PhoneGap?

Create a placeholder for the module function

My AJAX function is not functioning as intended

Create a captivating sliding effect on Windows 8 using a combination of CSS and JavaScript

Add a hovering effect to images by applying the absolute positioning property

My component reference seems to have gone missing in angular2

When a click event occurs, it returns either the element itself or one of its child elements,

Ajax is bypassing the success:function callback

Loading Bootstrap accordion content with AJAX only when clicked

What is the method for accessing HTML tag data within a script?

What is causing this console to output twice?

Creating an executable JAR for your Next.js application: A step-by-step guide

Discover the identities of elements that possess a specific attribute and class

The functionality of the jQuery .on() method is not compatible with appending newly created DOM elements

The formatter/render function in Angular Directive fails to refresh

Issue with reflect metadata in Next.js edge runtime causing functional problems

Amplify encounters the "Failed to load resource: the server responded with a status of 400" issue

When scrolling, use the .scrollTop() function which includes a conditional statement that

Where can I find the JavaScript code that controls the button function?

Exploring the various possibilities of establishing multiple types of many-to-many relationships between two tables using Sequelize technology