Inherit Method to All Objects Except Primitives

Question

I want to add a method that is capable of working on all objects. Preferably it should not exist on primitives (number, boolean, string, symbol), on which it cannot work.

Is this possible, and if so, how?

Using Object.prototype does not work because the primitive types inherit from Object.

Define "working". Do you mean a function that appears in the prototype of every object in JS? — Asad Saeeduddin, Sep 04 '16 at 02:49
@AsadSaeeduddin adding a property, which does not work on primitives. — Daniel Herr, Sep 04 '16 at 02:50
@DanielHerr It seems you are misunderstanding what happens in that code. It's the object wrapper who inherits the `test` property, not `true`. — Oriol, Sep 04 '16 at 03:05

score 3 · Accepted Answer · answered Sep 04 '16 at 02:56

You can set the function on the prototype of Object, then set the corresponding member on the prototypes of the constructors where you don't want it to undefined:

Object.prototype.foo = function() { alert("foo"); };
Number.prototype.foo = undefined;
var x = {};
var y = 10;
x.foo(); // works
y.foo(); // TypeError: y.foo is not a function

I don't know why you're doing this, and it seems like a code smell, but there you go.

score 1 · Answer 2 · edited May 23 '17 at 12:08

Primitives are not objects and don't inherit from anywhere. They can be wrapped in objects which do inherit from Object.prototype, but these are objects.

It might look like primitives inherit properties, but under the hood these are accessed on the object wrappers, not the primitives. When GetValue resolves a property reference,

If HasPrimitiveBase(V) is true, then

Assert: In this case, base will never be null or undefined.

Let base be ToObject(base).

Return base.[[Get]](GetReferencedName(V), GetThisValue(V)).

So if the base of the reference was a primitive, it will be converted to an object before attempting to get the property.

But as @nnnnnn notes, when you call the method, the this value will be the primitive, because the base of the reference didn't change. Note in sloppy mode it will be coerced to an object.

In fact, you could take advantage of this and test whether the this value is an object, if what you want is prevent primitives from being used as bases of references when calling the method:

Object.prototype.method = function() {
  "use strict";
  if(Object(this) !== this) {
    throw Error('This method can only be called on objects');
  }
  // ...
  return "works";
};
true.method(); // Error: This method can only be called on objects
new Boolean(true).method(); // "works"

I understand the distinction you're making, but...even your own example `true.self()` shows that you can take a primitive and directly call the method from `Object.prototype`. (I say "directly" in the sense that in the code you don't explicitly convert or wrap anything, it just "works".) Also, think about what happens if you add `"use strict";` to your function... — nnnnnn, Sep 04 '16 at 03:26

score 0 · Answer 3 · answered Sep 04 '16 at 03:15

0

Streamlined way of removing the method from primitives.

Object.prototype.test = function() { }

for(let { prototype } of [ String, Number, Boolean, Symbol ]) {
 prototype.test = undefined
}

answered Sep 04 '16 at 03:15

Daniel Herr

19,083
6
44
61

Inherit Method to All Objects Except Primitives

3 Answers3