Question

我有一个FunctionArray对象，我想用它来一次调用几个函数。基本上你在这里看到的就是我到目前为止所做的，但有一件事情就是调用像myFunctionArrayInstance()这样的函数数组。有办法做到这一点还是不可能？

var FunctionArray =  function(){
    this.apply = function(){
        var args = arguments;
        this.forEach(function(e,i){
            e.apply(args);
        });
    }
    this.call = function(){
        var args = arguments;
        this.forEach(function(e,i){
            e.call(args);
        });
    }
    this.bind = function(){
        var args = arguments;
        var binds = [];
        this.forEach(function(e,i){
            binds.push(e.bind(args));
        });
        return function(){
            var args2 = arguments;
            binds.forEach(function(e,i){
                e.apply(args2);
            });
        };
    };

};
FunctionArray.prototype = [];

我这样使用它。

var initers = new FunctionArray();
initers.push(function(){/*something here*/});
initers.push(function(){/*something here*/});
initers();

Answer 1

你的结构看起来很有趣，但遗憾的是如果你想要一个 Function （而不是构造的 Object ）来拥有一个自定义原型链，你需要使用非常昂贵的Object.setPrototypeOf如果它产生了许多意想不到的结果，我不会感到惊讶。您需要添加一个执行调用的方法。

我认为如果你没有将 Array 放在原型中，而是在实例上有一个属性来保存你的函数并从您需要的 Array 复制包装的方法版本。我还添加了调用并重新实现了长度。

然后基本上所有东西都在原型中，除了你的函数的 Array 。在初始定义之后，创建实例应该只需要很少的时间/内存。

function FunctionArray() { this.fns = []; } FunctionArray.prototype = Object.create(null); (function () { var i, arr = ['push', 'pop', 'shift', 'unshift', 'splice']; function addToProto(key, fn) { FunctionArray.prototype[key] = function () { return fn.apply(this.fns, arguments); }; } for (i = 0; i < arr.length; ++i) { addToProto(arr[i], Array.prototype[arr[i]]); } Object.defineProperty( FunctionArray.prototype, 'length', { get: function () {return this.fns.length;}, set: function (x) {return this.fns.length = x;} } ); FunctionArray.prototype.item = function (i) { return this.fns[i]; }; FunctionArray.prototype.invoke = function () { var i; for (i = 0; i < this.fns.length; ++i) { this.fns[i].apply(this, arguments); } }; FunctionArray.prototype.call = function (ctx) { var i, args = arguments.slice(1); for (i = 0; i < this.fns.length; ++i) { this.fns[i].apply(ctx, args); } }; FunctionArray.prototype.apply = function (ctx, args) { var i; for (i = 0; i < this.fns.length; ++i) { this.fns[i].apply(ctx, args); } }; FunctionArray.prototype.bind = function () { var i; for (i = 0; i < this.fns.length; ++i) { this.fns[i] = Function.prototype.bind.apply(this.fns[i], arguments); } }; }());

现在你可以做类似
的事情了
var fa = new FunctionArray(); fa.push(function (fizz) {console.log(this, fizz)}); fa.push(function (buzz) {console.log(this, buzz)}); fa.bind({'foo': 'bar'}); fa.length; // 2 fa.invoke('baz'); // logs {foo: "bar"} "baz" twice

然而，

使用Object.setPrototypeOf
可能但强烈不推荐
function FunctionArray() { var foo = function () { return foo.invoke.apply(foo, arguments); }; Object.setPrototypeOf(foo, FunctionArray.prototype); foo.fns = []; return foo; } FunctionArray.prototype = Object.create(Function.prototype); // continue from here as above

现在

var fa = new FunctionArray(); fa.push(function (fizz) {console.log(this, fizz)}); fa.push(function (buzz) {console.log(this, buzz)}); fa.bind({'foo': 'bar'}); fa.length; // 2 fa('baz'); // logs {foo: "bar"} "baz" twice

Answer 2

这是一个很酷的构造:)唉，如果构造的对象是数组的后代，它就不会被调用。另一方面，为什么不使它成为一个函数构造函数（它会使实例可调用），并用类似数组的机制来扩充这个实例来存储和检索其中的函数？

我在想：

(function(){ 'use strict';
function makeFunctionArray(){
    var functionArray = function(){
        functionArray.functions.forEach(function(f){
            f();
        });
    }

    functionArray.functions = [];
    functionArray.push=function(fnToAdd){
        functionArray.functions.push(fnToAdd);
    }
    functionArray.pop=function(){
        return functionArray.functions.pop();
    }
    //and so on... you can add any array functionality you need
    //(maybe even bracket notation with some fiddling?)

    return functionArray;
}

//using it:
var fa = makeFunctionArray();
typeof fa; //'function'
fa.push(function(){console.log(123);});
fa.push(function(){console.log(456);});
fa(); //-> outputs '123' then '456'
})();

编辑：根据Grundy的建议清理代码。

如何实现一个也有其他原型的函数

2 个答案:

然而，