Static Factory Methods

Tomas Eglinskas — Wed, 06 Mar 2019 20:42:53 +0000

As a JavaScript developer without design pattern fundamentals, static factory methods would have made my code cleaner on multiple occasions. If you’re like me - and most people, when you create a class you want to initialise it at some point.

    const Coordinate: Coordinate = new Coordinate(x, y)

    class Coordinate {
      public x: number;
      public y: number;

      constructor(x: number, y: number) {
        this.x = x;
        this.y = y;  
      }
    }

And this behavior is perfectly common - we want to create instances of our classes. But let’s say you want to create a Coordinate which has parameters x & y doubled upon initialization.

The easy and dirty is double it in the constructor

    constructor(x: number, y: number) {
      this.x = 2 * x;
      this.y = 2 * y;
    }

but most of us wouldn’t do this, we would create a method

    class Coordinate {
      ...
      public double() { 
        this.x = this.x * 2;
        this.y = this.y * 2;
      }
    }

    const coordinate = new Coordinate(1, 5).double()

Regular flow and everything is fine. But what if the desired outcome was to create a double Coordinate without the ability to use any methods like double? We don’t want to expose this method for other people to use. What if someone used double 20 times?

We could hide the creation logic and create a static factory method - it would just return a double Coordinate and it would be clear as day. As you can see the constructor is private - the Coordinate creation is encapsulated in the class.

    class Coordinate {
      // ...
      private constructor(x: number, y: number) {
        this.x = x;
        this.y = y;
      }

      static doubledCoordinate(x: number, y: number) { 
        return new Coordinate(x * 2, y * 2)
      }
    }

    const coordinate = Coordinate.doubleCoordinate(1, 5) // and the naming - fancy

Also have in mind, that if you wanted to introduce a side-effect (like a console.log()) in a typical constructor - you would return a new object, by using a static method you are not required to create a new object each time it’s invoked.

This was maybe a trivial example, but the main idea is to hide the implementation from the outside-world - to delegate the construction of an object to the static method, let’s say you have a database connection and you don't want to expose Monitor and how a database is connected and what processing operations it needs to do.

    // some methods are fake

    import Monitor from "//.."

    class Database {  
      private static Monitor = new Monitor()
      private static connection: MongoClient;
      private static regionCount: number = 0;

      static getConnection() {
        if (connection.timedOut() ||
            !connection.established) {
          Monitor.sendStatus();
          connection = new MongoClient()
        }

        return this.connection
      }

      static currentRegionCount() {
          regionCount = //..
      }

      static getAvailableRegions() {
        return regionCount;
      }
    }

With a static variable, you are able to cache the value without assigning new memory addresses to inner variables. If you would create a new Coordinate() or new Database() every-time the inner variables would precisely belong to the instance class.

Therefore when we call Database.getConnection we are referencing the same if a connection is established connection (it’s an example, we would have a listener). Which makes our code more performant and cleaner.

I, personally, have initialized too many classes in my life - creating multiple instances, exporting as an instance, exposing too many methods I never intended - making a big mess. JavaScript is a free spirit, but it needs some taming in order to write clean code.

What's your favorite algorithm?

Tomas Eglinskas — Sat, 09 Feb 2019 22:21:43 +0000

This is my favorite question to ask for technical recruiters - everyone has a unique story, you can have a better understanding of the company and the person, and of course, a conversation can easily follow afterward. I heard various shuffle algorithms, bloom filters, HyperLogLog and etc.

Mine is more of a technique, but I really liked it because of its simplicity.
Including a mini explanation below (for the curious).

What's your favorite algorithm? :)

/* 
 * Question:
 * Given an array of integers from 1 <= A[i] <= n, 
 * some elements repeat twice and others only once.
 *
 * Your task is to find the elements which repeat twice.
 * Without using any extra space and in O(n) time.
 */

/*
 * The key here is not to use a hashmap, O(N) space, 
 * but to flip the numbers from positive to negative.
 *
 * When you traverse the array you can map the number 5 to index 4 
 * (we will check by sign and not value for duplicates) and if it is not negative 
 * - meaning it has not repeated - negate it. If it is negative, you know it has been 
 * already encountered. 
 * 
*/

const A = [5,2,1,4,2,1,7];

function findDuplicates(A) {

 const oldLength = A.length;
 for (let i = 0; i < oldLength; ++i) {
   const value = Math.abs(A[i]) - 1; // ignoring the sign and get the value

   if (A[value] > 0) A[value] *= -1;
   else A.push(value + 1);
 }

 return A.slice(oldLength);
}

DEV Community: Tomas Eglinskas

Static Factory Methods

What's your favorite algorithm?