Leveraging object literals or the Object constructor becomes cumbersome when managing numerous similar entities due to code repetition. To adress this, specific design patterns abstract the construction logic.

Throughout ECMAScript history, object modeling capabilities have evolved significantly. ECMAScript 5.1 lacked native class structures, yet developers utilized prototypal inheritance to mimic such behavior. ECMA Script 6 introduced official class syntax, which acts as syntactic sugar wrapping the underlying constructor and prototype mechanisms.

Factory Pattern

A factory function encapsulates the creation process for defined object interfaces. This approach returns a fully formed object based on input parameters.

function buildAccount(username, tier) {
  const account = {};
  account.handle = username;
  account.level = tier;
  account.verify = function() {
    console.log(this.handle);
  };
  return account;
}

let userA = buildAccount('alpha', 'gold');
let userB = buildAccount('beta', 'silver');

While efficient for structure, this method does not distinguish the object type at runtime.

Constructor Pattern

Constructors define object types that can be instantiated using the new operator. Custom constructors follow the same logic as native types like Array, utilizing the this keyword to bind properties.

function Product(label, cost) {
  this.name = label;
  this.price = cost;
  this.showDetails = function() {
    console.log(this.name);
  };
}

const item1 = new Product('Keyboard', 50);
const item2 = new Product('Mouse', 25);
item1.showDetails();

In contrast to factory functions, constructors omit the return statement and rely on implicit context assignment. Naming conventions require constructor identifiers to start with an uppercase letter to differentiate them from regular functions.

Invoking a function via new performs specific operations:

1. Allocates a new empty object in memory.
2. Links the new object’s internal [[Prototype]] reference to the constructor’s prototype property.