1

I am struggling with the concept of modules, factory functions, and constructors...

I am the most curious about the difference between module and factory function, and when to use what?

Žiga Grošelj
  • 75
  • 8
  • A module is essentially a singleton, while a factory function can be used multiple times. (If the factory function is called only once, the lines blur… but the `function` is the factory and the returned object is the module). – Bergi Aug 14 '20 at 19:37

2 Answers2

2

The main difference between modules and factory functions are simpler than you think.

Modules are just files with blocks of code that you can import/export.

Whereas factory functions are functions that create objects and return them. Also you might find this other stack overflow post that explains constructor functions vs factory functions:

Constructor function vs Factory functions

ByteTheBits
  • 319
  • 1
  • 5
  • 13
  • "*Modules are just files*" - you seem to refer to ES6 modules here? There are other things for which the term "module" is used. – Bergi Aug 14 '20 at 19:36
1

I think the explanation above is great for constructors. I'm new to javascript, but I just asked myself this question and did some reading on it. For the difference between factory functions and the module pattern I think it comes down to a little bit of syntax (which governs use). Hopefully, what I have below explains it correctly:

> const Factoryfunction = (parameters) => {
>      const/let/var properties = values
>      const methods = (parameters) => {
>           //do stuff
>      }
>      return {public variables and methods}

}; <---- here's the big difference!

const modulePattern = ((parameters) => {
     const/let/var properties = values
     const methods = (parameters) => {
          //do stuff
     }
     return {public properties and methods}

})(); <---- here's the big difference!

Module Pattern:

From my understanding, that little set of parenthesis at the end changes how the previous block of code works. With the parenthesis, you have access to whatever public methods or properties that you created. You can also create private methods and properties with in the module to tighten control on how the module is used/ do more intricate and organized work. Those public properties/methods can be used in a variety of contexts. You can also update the properties within a module through the methods defined ore externally if that property is return (public). Now you can call these methods using the module's declared name:

modulePattern.publicMethod();
console.log(publicProperty)

Factory functions:

Without () at the end, you have a factory function that can be used to create new objects without the "new" keyword that is used with constructors:

const object = factoryFunction (parameters)

console.log(object.property)// logs property defined in factory function but based on new parameters

object.method()// calls the method defined in factory function which is now adjusted to new parameters (if that's how they work)

both factory functions and the module pattern have the following benefits:

Organizing code, improving readability and logical flow, de-cluttering the window's namespace (google scope and closure) and my favorite, being able to define whether a property or method is private or public (which benefits the security and debug-ability and more of your code). Also, reduce reuse and recycle.

This is my first contribution on Stack! I hope it's helpful!

here's where I learned all of that: https://www.theodinproject.com/lessons/node-path-javascript-factory-functions-and-the-module-pattern

Sami Syed
  • 11
  • 2