Array.of vs “[ ]”. When to use Array.of over “[ ]”?

Question

I was doing a bit of reading when I found Array.of.

As per MDN,

The Array.of() method creates a new Array instance with a variable number of argum

Answer 1

Iterating off of Redu's answer, you could use ArraySubclass.of to create instances of an array subclass. For example, you could create an Array-subclass wrapper around lodash's Array methods.

For example:

_.Array = class extends Array {
  uniq() {
    return _.Array.from(_.uniq(this));
  }
  last() {
    return _.last(this);
  }
  flatten() {
    return _.Array.from(_.flatten(this));
  }
  // ... more methods
}

_.Array.of([1,2,3], [3,4,5]) // <_.Array> [[1,2,3],[3,4,5]]
  .flatten()                 // <_.Array> [1,2,3,3,4,5]
  .uniq()                    // <_.Array> [1,2,3,4,5]
  .last()                    //  5

JSFiddle

---

Edit

I ended up extending this example to use ES Proxies.

_.Array = class extends Array { }
_.Array.prototype = new Proxy(Array.prototype, {
  get(proto, name) {
    if (name in _) return function (...args) {
        const ret = _[name](this, ...args);
        return Array.isArray(ret) ? _.Array.from(ret) : ret;
    }
    return proto[name];
  }
});

Now every lodash function is available, and those returning arrays are wrapped in the _.Array class, similar to _(array) implicit chaining.