使用eval在JavaScript中运行一组闭包

我想将一组闭包存储到一个数组中，这些闭包在被调用时运行

评估是最好的做法吗？

“评估是邪恶的”——）

但这里有一个可能的解决方案

Array.prototype.execute = function() {
    for ( var i in this ) {
        if ( i && 'execute' != i && Function == this[ i ].constructor ) {
            this[ i ].apply( this );
        }
    }
};

var arr = [];
arr.push( ( function() {alert('A'); } ) );
arr.push( ( function() {alert('B'); } ) );
arr.push( ( function() {alert('C'); } ) );
arr.execute();

---

请记住：不建议像我那样扩展基本Javascript类型。

我不确定“调用时运行”是什么意思，但由于数组是对象，因此可以将静态信息作为对象键存储在数组中：

var arr = ['foo','bar'];
arr.methods = {
   foo: function() { alert(this[0]); },
   bar: function() { alert(this[1]); },
};
arr.run = function() {
    for (var fn in this.methods) {
        this.methods[fn].call(this);
    }
};

​arr.run();​

---

您也可以使用原型继承将其嵌入到可重用函数中，但您需要将数组嵌入其中，因为数组在javascript中不是“子类化的”。

您可以动态创建函数并将引用存储在变量中：

var something = function() { alert("hello world"); };

通过在数组中扩展：

var something = [function() { alert("hello world"); }, 
                 function() { alert("hello world"); }, 
                 function() { alert("hello world"); }];

稍后您可以使用

something（）调用它或
某物[1]（）。这里绝对不需要Eval，除非函数的实际主体来自用户输入（上帝禁止：-）

调用什么以及如何调用它由实现来决定，但一旦您意识到这一点，它应该是相当简单的。
好的，因为每个人都在猜测您实际上在寻找什么，下面是我的.02：

var closures = (function(Global,undefined)
{
    var that = [];//return value
    that[0] = (function(some,vars, forClosure1)
    {
         return function()
         {
             console.log(some, vars,forClosure1);
         };
    })(values,of,closureArguments);//create all closures you need
    that.execAll = function (context,args)//the method to call them all (with arguments)
    {
        context = (context === undefined || context === Global ? that : context);
        args = args.length ? args : [];//make sure arguments has length property
        for (var i=0;i<that.length;i++)
        {
            if (typeof that[i] === 'function')
            {
                that[i].apply(context,args);
            }
        }
    };
    return that;//return closure array (with execAll method)
})(window);

var闭包=（函数（全局，未定义）
{
var that=[]；//返回值
[0]=（函数（一些、变量、forClosure1）
{
返回函数（）
{
console.log（一些、变量、forClosure1）；
};
})（值，of，closureArguments）；//创建所需的所有闭包
that.execAll=function（context，args）//调用它们的方法（带参数）
{
上下文=（上下文===未定义的| |上下文===全局？即：上下文）；
args=args.length？args:[]；//确保参数具有length属性
对于（var i=0；i将调用什么？数组？！使用
eval
从来都不是一件好事。您将如何为此使用eval？JS中的闭包保留了闭包时的作用域，因此您不需要eval。为什么需要eval？为什么不
array[0]=（函数（some，closure，vars）{return function（）{return some+'whatever'；}；}（1,2,3））；
@ThiefMaster如果没有
eval
我们就不会在浏览器中使用JSON…不要（永远）在
语法中使用
for..迭代数组。检查这个奇怪的结果：
Array.prototype.F=function（）{alert（'我从哪里来的？'）；[].execute（）；
如果不建议这样做，为什么要在回答中这样做？另外，我们通常不建议扩展基本
对象或任何DOM对象，但其余的都可以。这只是一个懒惰的解决方案。您可以从数组派生一个类，并以这种方式扩展它，但您必须编写
var arr=new MyArray（）
扩展
数组。prototype
非常好，除非您必须处理使用
for..in
在数组上迭代的蹩脚代码。它与我的解决方案类似，但在这里您总是为每个实例设置arr.run。很好的解决方案，这里您没有给任何东西分配闭包，您只是在创建refe对函数的引用。@EliasVanOotegem实际上没有区别，因为该函数无论如何只能与该特定引用一起使用。完全不真实。
someFunc=function（）{return null；}；var-anotherVar=someFunc；anotherVar（）
将很好地工作。但是，您缺少的关键是：代码中没有包含或公开引用。没有包含或公开，没有保留范围，因此根本没有闭包。是的，您可以将引用分配给另一个变量并调用它，但再次谈到实用术语，我无法做到看看这与将函数复制到另一个变量并调用它（内存中除外）相比有什么不同。此外，闭包不一定要保留作用域才能成为闭包。Mahn，我认为您需要了解一些事情：函数是JS中的对象，因此它们总是通过引用传递，从不复制。以“常规”方式声明函数与
var foo=function（）{}
基本相同
，除了提升。你只是实例化一个函数对象。好吧，闭包的定义是：闭包是一个表达式（通常是一个函数），它可以有自由变量，还有一个绑定这些变量的环境（“关闭”表达式）。所以你确实需要一个环境（也称为作用域）