CODEWITHSUNDEEP
javascriptv8
Zhami
Zhami

Reputation: 19153

Is it possible to create a function where [[prototype]] refers to another function

I would like to create function objects (yes, all functions are objects) with some control over the prototypal inheritance, that is, I would like one function to inherit from another.

I can make objects that have prototypal inheritance, and know to set the prototype property of a function performing as a constructor to initialize the [[prototype]] property of the object.

However, when creating a function, I must use the function operator or the Function constructor. I could try to swizzle Function.prototype, but (1) don't know if that is writable, and (2) that just seems quite dangerous [still, I should try doing that].

btw: I only care to do this for V8 within node.JS, so if there are means that work only for that environment, that would be acceptable.

For the record, I have seen this: Is it possible to create a function with another prototype than Function.prototype?

Upvotes: 3

Views: 983

Answers (3)

Zhami
Zhami

Reputation: 19153

I came up with a solution that solves my needs. It is not cross-browser, but can be used cross-browser. My most important use case is as a module for node.JS. In that case, the mechanism of setting __proto__ works just fine, in which case I can call methods on the base function object

f.method(args...);

and it executed by code in the "super" function. Because the method is invoked by the method invocation pattern, "this" is set to the base function object, and so the proper properties are accessed even though the method resides in the "super."

Now for the in-Browser case: when I use my library client-side, I provide a proxy mechanism. Alas, code intended for the browser must be written differently. The invocation is:

f.proxy(methodName, args...);

The proxy method in the base function object is:

f.proxy = function (methodName) {
    var p = this.constructor.prototype;
    return p.proxy(this, methodName, arguments);
};

The proxy in the "super" object's prototype is:

proxy: function (instance, methodName) {
    var args = Array.prototype.splice.apply(arguments, [2]), 
        method = this[methodName];
    return (method) ? method.apply(instance, args) : undefined;
}

I probably should have named this "forward" or some such, but "proxy" is good enough.

Perhaps this mechanism might be useful to someone...

Upvotes: 1

Daniel Baulig
Daniel Baulig

Reputation: 10999

In V8 (and most other browsers/engines except IE) you can change an object's prototype by setting the __prototype__ __proto__ attribute. Setting the prototype attribute will instead change the prototype that is used to create an object if the function is invoked as a constructor function. This should not be what you want.

Afaik there currently is no standard conform way to directly "subclass" a function (or array for that matter). There's only Object.create, but there is no Function.create or Array.create.

EDIT: I just realized that function objects do not have the __prototype__ attribute and changing / setting it will not turn an object into a function. I believe though that I just recently watched a talk by Brendan Eich (the creator of JavaScript) in which he talked about Function and Array equivalents of Object.create. And infact, googling for "Function.create brendan eich" reveals the following blog post by Eich in which he talks about his wish to implement Function.create and Array.create.

EDIT 2: Ok, I screwed up. Pretty much. The non-standard attribute is of course __proto__ and not __prototype__. Setting __proto__ works fine for functions with some restrictions, which are:

  1. To be able to call aFunction you must initialize it with an actual function, eg:

    var aFunction = function () {};

    This is important. Calling a function does not access the prototype chain, so if you define aFunction as an object and simply set the __proto__ attribute, you will not able to call aFunction.

  2. You can now assign any other function to aFunction.__proto__ and reading any members (including methods) will correctly delegate to the prototype chain if the porperty is not found on aFunction itself.

  3. Calling aFunction() will always invoke the function that was originally declared when aFunction was defined and will never invoke aFunction's prototype function. So the body of the function is not subject to inheritence.

Sorry for screwing up first with the name of the attribute. Hope this helps you nevertheless.

Upvotes: 1

Matt Molnar
Matt Molnar

Reputation: 2542

I think I understand what you're trying to do. In short, there's no way to really do it natively. You'd have to access the Function constructor, which for function expressions and definitions (i.e. anything using the 'function' keyword), isn't possible as far as I can tell. You could overwrite Function and just always use new Function([args], string) but I doubt you (or any JS programmer) want to do that.

Your best bet would probably be to send your function expressions to another function that returns the function object with your custom methods dynamically added:

wrapFunc = function(f){
  f.customFunc = someCustomFunc;
  return f;
}

var myNewFunc = wrapFunc(
  function(){
    //do something
  }
);

myNewFunc.customFunc();

Upvotes: 0

Related Questions