Object.prototype is Verboten?

Question

RECAP: Ok, it's been a while since I asked this question. As usual, I went and augmented the `Object.prototype` anyway, in spite of all the valid arguments against it given both here and elsewhere on the web. I guess I'm just that kind of stubborn jerk. I've tried to come up with a conclusive way of preventing the new method from mucking up any expected behaviour, which proved to be a very tough, but informative thing to do. I've learned a great many things about JavaScript. Not in the least that I won't be trying anything as brash as messing with the native prototypes, (except for `String.prototype.trim` for IE < 9). In this particular case, I don't use any libs, so conflicts were not my main concern. But having dug a little deeper into possible mishaps when playing around with native prototypes, I'm not likely to try this code in combination with any lib. By looking into this prototype approach, I've come to a better understanding of the model itself. I was treating prototypes as so…

Accepted Answer

The fact is, it's fine as long as you know what you're doing and what the costs are. But it's a big "if". Some examples of the costs:

You'll need to do extensive testing with any library you choose to use with an environment that augments `Object.prototype`, because the overwhelming convention is that a blank object will have no enumerable properties. By adding an enumerable property to `Object.prototype`, you're making that convention false. E.g., this is quite common:

```
var obj = {"a": 1, "b": 2};
var name;
for (name in obj) {
    console.log(name);
}
```

...with the overwhelming convention being that only "a" and "b" will show up, not "getProperties".

Anyone working on the code will have to be schooled in the fact that that convention (above) is not being followed.

You can mitigate the above by using `Object.defineProperty` (and similar) if supported, but beware that even in 2014, browsers like IE8 that don't support it properly remain in significant use (though we can hope that will change quickly now that XP is officially EOL'd). That's because using `Object.defineProperty`, you can add non-enumerable properties (ones that don't show up in `for-in` loops) and so you'll have a lot less trouble (at that point, you're primarily worried about name conflicts) — but it only works on systems that correctly implement `Object.defineProperty` (and a correct implementation cannot be "shimmed").

In your example, I wouldn't add `getProperties` to `Object.prototype`; I'd add it to `Object` and accept the object as an argument, like ES5 does for `getPrototypeOf` and similar.

Be aware that the Prototype library gets a lot of flak for extending `Array.prototype` because of how that affects `for..in` loops. And that's just `Array`s (which you shouldn't use `for..in` on anyway (unless you're using the `hasOwnProperty` guard and quite probably `String(Number(name)) === name` as well).

...if the V8 people do it, who am I to say they're wrong?

On V8, you can rely on `Object.defineProperty`, because V8 is an entirely ES5-compliant engine.

Note that even when the properties are non-enumerable, there are issues. Years ago, Prototype (indirectly) defined a `filter` function on `Array.prototype`. And it does what you'd expect: Calls an iterator function and creates a new array based on elements the function chooses. Then ECMAScript5 came along and defined `Array.prototype.filter` to do much the same thing. But there's the rub: Much the same thing. In particular, the signature of the iterator functions that get called is different (ECMAScript5 includes an argument that Prototype didn't). It could have been much worse than that (and I suspect — but cannot prove — that TC39 were aware of Prototype and intentionally avoided too much conflict with it).

So: If you're going to do it, be aware of the risks and costs. The ugly, edge-case bugs you can run into as a result of trying to use off-the-shelf libraries could really cost you time...

Object.prototype is Verboten?

Solution

Problem