仅在模块内使用修改后的Array.prototype

Question

I'm working on creating a module within a larger codebase. In several instances, I need the ability to concatenate sub arrays within larger arrays, so the array is flattened to only one dimension. There are a few libraries that offer similar functionality under the method name concatAll() .

This is the function:

Array.prototype.concatAll = function concatAll() {
    return Array.prototype.concat.apply([], this);
};

The problem with this solution is that it modifies the Array.prototype in every instance of the entire codebase. I want to be able to chain this array method to other Array methods, so I can't just create a function that performs this operation.

myArray
  .filter(...)
  .map(...)
  .concatAll();

I know that I can delete Array.prototype.concatAll , but our module loader is such that I only know when the module needs to be bootstrapped to the page, and not when the module is "un" bootstrapped. So calling delete Array.prototype.concatAll would render the method unusable within the module.

Is there a way that I can temporarily add this method the Array prototype within a module, without having every array instance inherit the method?

Answer 1

The first idea is to arrange to have the code with your augmented array prototype run in a separate environment, such as an iframe or a web worker. The Array object in each such environment is independent, and changes to one will not affect the others.

Alternatively, assuming your concern is that someone else not overwrite your method, you could define it as follows:

Object.defineProperty(Array.prototype, "concatAll", {
  get: function () {
    return function concatAll() {
      return Array.prototype.concat.apply([], this);
    };
  },
  set: function() {
    throw new Error("Attempt to overwrite Array#concatAll!");
  }
});

That would at least throw an error if someone else tries to redefine it via assignment. Attempt to redefine it via another Object.defineProperty would also throw since the property is by default not configurable.

Possibly minor point:

The problem with this solution is that it modifies the Array.prototype in every instance of the entire codebase.

Technically, no instances are modified, of course. If you mean that every instance will pick up the new method from the prototype, that's true, of course, but what specifically are you worried about?