我如何继承JavaScript功能?

内容来源于 Stack Overflow,并遵循CC BY-SA 3.0许可协议进行翻译与使用

  • 回答 (1)
  • 关注 (0)
  • 查看 (5)
// Don't break the function prototype.
// pd - https://github.com/Raynos/pd
var proto = Object.create(Function.prototype, pd({
  "prop": 42
}));

var f = function() { return "is a function"; };
f.__proto__ = proto;

console.log(f.hasOwnProperty("prop")); // false
console.log(f.prop); // 42
console.log(f()); // "is a function"

.__proto__ 是非标准的和不赞成的。

我该如何继承原型创建一个对象,但让这个对象成为一个函数。

Object.create 返回一个对象不是函数。

new Constructor 返回一个对象不是函数。

一个跨浏览器finherit

var finherit = function (parent, child) {
    var f = function() { 
        parent.apply(this, arguments);
        child.apply(this, arguments);
    };
    f.__proto__ = parent;
    Object.keys(child).forEach(function _copy(key) {
        f[key] = child[key];
    });
    return f;
};

我不认为这是可能的,所以我们应该提出一个Function.createes-discuss邮件列表

/*
  Creates a new function whose prototype is proto.
  The function body is the same as the function fbody.
  The hash of propertydescriptors props is passed to defineproperties just like
  Object.create does.
*/
Function.create = (function() {
  var functionBody = function _getFunctionBody(f) {
    return f.toString().replace(/.+\{/, "").replace(/\}$/, "");
  };
  var letters = "abcdefghijklmnopqrstuvwxyz".split("");

  return function _create(proto, fbody, props) {
    var parameters = letters.slice(0, fbody.length);
    parameters.push(functionBody(fbody));
    var f = Function.apply(this, parameters);
    f.__proto__ = proto;
    Object.defineProperties(f, props);
    return f;
  };
})();

正如es-discuss线程中提到的那样,存在一个ES:strawman <|原型操作符,可以实现这一点。

让我们看看它会是什么样子 <|

var f1 = function () {
  console.log("do things");
};

f1.method = function() { return 42; };

var f2 = f1 <| function () {
  super();
  console.log("do more things");
}
console.log(f1.isPrototypeOf(f2)); // true
console.log(f2()); // do things do more things
console.log(f2.hasOwnProperty("method")); // false
console.log(f2.method()); // 42
提问于
用户回答回答于

我希望我能理解这个权利。

我相信你想要一个既是预定义原型的实例(是的,一个类,而不是经典类)的函数,也可以直接调用?对?如果是这样,那么这是非常有意义的,并且非常强大和灵活(特别是在JavaScript等高度异步的环境中)。可悲的是,没有办法在JavaScript中优雅地进行操作而不进行操作__proto__。您可以通过分解一个匿名函数并将所有引用复制到所有方法(这似乎是您要引导的方向)来充当代理类来执行此操作。缺点是...

  1. 从运行时方面讲它非常昂贵。
  2. (functorObj instanceof MyClass)永远不会true
  3. 属性不能直接访问(如果它们都是通过引用分配的,这将是一个不同的故事,但是基元是按值赋值的)。这可以通过accessor来解决,defineProperty或者在必要时通过简单的accessor方法来解决(看起来这就是你正在寻找的东西,只需要defineProperty通过getter / setter 将所有属性添加到函数中,而不是只需要函数,如果你不需要跨越引擎支持/向后兼容性)。
  4. 你很可能遇到最终本地原型(如Object.prototype或Array.prototype [如果你继承])可能无法按预期运行的边缘情况。
  5. 调用functorObj(someArg)始终使this上下文成为对象,无论它是否被调用functorObj.call(someOtherObj, someArg)(虽然方法调用不是这样)
  6. 因为functor对象是在请求时创建的,所以它会被及时锁定,并且操作初始原型不会影响分配的functor对象,就像普通对象会受到影响一样(修改MyClass.prototype不会影响任何函数对象,反之亦然也是如此)。

如果你轻轻地使用它,这些都不是什么大问题。

在你的类的原型中定义类似...

// This is you're emulated "overloaded" call() operator.
MyClass.prototype.execute = function() {
   alert('I have been called like a function but have (semi-)proper access to this!');
};

MyClass.prototype.asFunctor = function(/* templateFunction */) {
   if ((typeof arguments[0] !== 'function') && (typeof this.execute !== 'function'))
      throw new TypeError('You really should define the calling operator for a functor shouldn\'t you?');
   // This is both the resulting functor proxy object as well as the proxy call function
   var res = function() {
      var ret;
      if (res.templateFunction !== null)
         // the this context here could be res.asObject, or res, or whatever your goal is here
         ret = res.templateFunction.call(this, arguments);
      if (typeof res.asObject.execute === 'function')
         ret = res.asObject.execute.apply(res.asObject, arguments);
      return ret;
   };
   res.asObject = this;
   res.templateFunction = (typeof arguments[0] === 'function') ? arguments[0] : null;
   for (var k in this) {
      if (typeof this[k] === 'function') {
         res[k] = (function(reference) {
            var m = function() {
               return m.proxyReference.apply((this === res) ? res.asObject : this, arguments);
            };
            m.proxyReference = reference;
            return m;
         })(this.asObject[k]);
      }
   }
   return res;
};

导致的用法看起来像...

var aobj = new MyClass();
var afunctor = aobj.asFunctor();
aobj.someMethodOfMine(); // << works
afunctor.someMethodOfMine(); // << works exactly like the previous call (including the this context).
afunctor('hello'); // << works by calling aobj.execute('hello');

(aobj instanceof MyClass) // << true
(afunctor instanceof MyClass) // << false
(afunctor.asObject === aobj) // << true

// to bind with a previous function...
var afunctor = (new MyClass()).asFunctor(function() { alert('I am the original call'); });
afunctor() // << first calls the original, then execute();
// To simply wrap a previous function, don't define execute() in the prototype.

你甚至可以链接无数的其他对象/功能/等,直到奶牛回家。只需重构代理呼叫。

希望有所帮助。哦,当然你可以改变工厂流程,这样一个没有new操作符的构造函数就会实例化一个新对象并返回该函数对象。然而你更喜欢(你也可以用其他方式来做)。

最后,要让函数变得更加优雅一些,可以使代理函数成为一个方法,Function.prototype然后将对象传递给它,如果你想做一些类似的事情(你必须交换templateFunctionthisthis与课程的参数)...

var functor = (function() { /* something */ }).asFunctor(aobj);

扫码关注云+社区