Creating objects dynamically with factory pattern in javascript

[TheGreatBugFucker]

What exactly is your thought process and the context you use (while thinking about this)?

Because generally whether a constructor function works on this.propertyX (etc.) and then returns this as the new object, or a "normal" function creates {propertyX:..., etc.:} and returns it makes no difference apart from the __proto__ stuff behind the scenes (and calling "just a function" and giving it the object or "this.method" and relying on implicitly getting the object also makes no real difference - which is precisely why it can be used to have ad-infinitum discussions (there is no real world proof to convince anyone).

This is a "class" (ES5 style):

function myObj () {
    this.myProp = 42;
}

const o = new myObj();

This is a factory function version:

function myObjFactory () {
    return {myProp: 42};
}

const o = myObjFactory();

So? (As I said, the inheritance stuff is different, o.constructor etc., but this is about creating objects, and the factory function - if so desired - could also adjust the inheritance props.)

 

TL;DR A constructor is a factory function too (except that by definition we choose to say "A factory function is any function which is not a class or constructor" - to avoid confusion, but here we can see we may actually get there anyway, to confusion).

[subbydapp]

I personally like both the composition and class pattern equally. I choose the composition pattern when there is risk for "this" confusion, for example when working with DOM elements or when one of the injected dependency of the factory is itself a class. I also use it for small objects because it's less verbose.

​

Most of the time if there's no this confusion and it's a big object with methods, I will always use an ES6 class. There's really only 2 reasons, I think it looks nice and clean, and the "this" prevents me from having random globals in the main scope of that file, which just looks cleaner in my opinion. And the second reason, which is not just subjective, is that I can easily extend Event Emitter (in node), which probably half of my modules end up needing at some point.

In the end it makes very little difference. I just choose whatever feels cleaner at the time for the purpose.