Javascript函数数组_Javascript_Arrays_Function

Javascript函数数组

javascript arrays function

Javascript函数数组,javascript,arrays,function,Javascript,Arrays,Function,这不符合预期，因为数组中的每个函数都是在创建数组时执行的执行数组中任何函数的正确方法是： var array_of_functions = [ first_function('a string'), second_function('a string'), third_function('a string'), forth_function('a string') ] array_of_functions[0]; 谢谢 array_of_functions[

这不符合预期，因为数组中的每个函数都是在创建数组时执行的

执行数组中任何函数的正确方法是：

var array_of_functions = [
    first_function('a string'),
    second_function('a string'),
    third_function('a string'),
    forth_function('a string')
]

array_of_functions[0];

谢谢

array_of_functions[0];  // or, array_of_functions[1] etc.

然后，当您要在数组中执行给定函数时：

var array_of_functions = [
    first_function,
    second_function,
    third_function,
    forth_function
]

如果没有更多关于你想要完成什么的细节，我们只是在猜测。但是你可以用对象符号来做这样的事情

array_of_functions[0]('a string');

给他们中的一个打电话

var myFuncs = {
  firstFunc: function(string) {
    // do something
  },

  secondFunc: function(string) {
    // do something
  },

  thirdFunc: function(string) {
    // do something
  }
}

或者只是：

myFuncs.firstFunc('a string')

我认为这就是原始海报的目的：

var myFuncs = {
  firstFun: function(string) {
    // do something
  },

  secondFunc: function(string) {
    // do something
  },

  thirdFunc: function(string) {
    // do something
  }
}

函数的变量数组=[ function（）{first_function（'a string'）}， function（）{second_function（'a string'）}， function（）{third_function（'a string'）}，函数（）{fourth_函数（'a string'）} ] 对于（i=0；i 希望这能帮助其他人（比如20分钟前的我：-）寻找关于如何在数组中调用JS函数的任何提示。

这是正确的

var array_of_functions = [
    function() { first_function('a string') },
    function() { second_function('a string') },
    function() { third_function('a string') },
    function() { fourth_function('a string') }
]

for (i = 0; i < array_of_functions.length; i++) {
    array_of_functions[i]();
}

我将通过使用

shift（）

Javascript方法发布一种在数组中执行各种函数的更简单方法来补充此线程

也许这对某人有帮助

/* PlanetGreeter */

class PlanetGreeter {
    hello   : { () : void; } [] = [];
    planet_1 : string = "World";
    planet_2 : string = "Mars";
    planet_3 : string = "Venus";
    planet_4 : string = "Uranus";
    planet_5 : string = "Pluto";
    constructor() {
        this.hello.push( () => { this.greet(this.planet_1); } );
        this.hello.push( () => { this.greet(this.planet_2); } );
        this.hello.push( () => { this.greet(this.planet_3); } );
        this.hello.push( () => { this.greet(this.planet_4); } );
        this.hello.push( () => { this.greet(this.planet_5); } );
    } 
    greet(a: string) : void { alert("Hello " + a); }
    greetRandomPlanet() : void { 
        this.hello [ Math.floor( 5 * Math.random() ) ] (); 
    } 
} 
new PlanetGreeter().greetRandomPlanet();


window.manager={
curHandler:0，
处理程序：[]
};
manager.run=函数（n）{
this.handlers[this.curHandler]（n）；
};
manager.changeHandler=函数（n）{
如果（n>=this.handlers.length | | n<0）{
抛出新错误（'n必须从0到'+（this.handlers.length-1），n）；
}
this.curHandler=n；
};
变量a=函数（n）{
log（“处理程序a.参数值为“+n”）；
};
var b=函数（n）{
log（“处理程序b.参数值为“+n”）；
};
var c=函数foo（n）{
对于（var i=0；i而言，它与Darin Dimitrov的

基本相同，但它展示了如何使用它动态创建和存储函数和参数。我希望它对你有用：）

var argscocontainer=['hello'，'you'，'there']；
var函数container=[]；
对于（变量i=0；i}

如果您正在尝试动态传递回调，则可以将单个对象作为参数传递。这使您能够更好地控制要使用任何参数执行哪些函数

<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8">
    <title></title>
    <script type="text/javascript">
        window.manager = {
            curHandler: 0,
            handlers  : []
        };

        manager.run = function (n) {
            this.handlers[this.curHandler](n);
        };

        manager.changeHandler = function (n) {
            if (n >= this.handlers.length || n < 0) {
                throw new Error('n must be from 0 to ' + (this.handlers.length - 1), n);
            }
            this.curHandler = n;
        };

        var a = function (n) {
            console.log("Handler a. Argument value is " + n);
        };

        var b = function (n) {
            console.log("Handler b. Argument value is " + n);
        };

        var c = function foo(n) {
            for (var i=0; i<n; i++) {
                console.log(i);
            }
        };

        manager.handlers.push(a);
        manager.handlers.push(b);
        manager.handlers.push(c);
    </script>
</head>
<body>
<input type="button" onclick="window.manager.run(2)" value="Run handler with parameter 2">
<input type="button" onclick="window.manager.run(4)" value="Run handler with parameter 4">
<p>
<div>
    <select name="featured" size="1" id="item1">
        <option value="0">First handler</option>
        <option value="1">Second handler</option>
        <option value="2">Third handler</option>
    </select>
    <input type="button" onclick="manager.changeHandler(document.getElementById('item1').value);" value="Change handler">
</div>
</p>
</body>
</html>

函数函数一（arg）{
console.log（arg）
};
函数func_二（arg）{
log（arg+'make this distance'）
};
var obj={
回调：[函数一，函数二]，
params:[“某物”、“其他某物”]；
};
功能剂量测定法（obj）{
变量n=对象计数器
对于（n；n<（obj.callbacks.length-obj.len）；n++）{
对象回调[n]（对象参数[n]）；
}
};
obj.counter=0；
obj.len=0；
剂量测定法（obj）；
//某物
//还有别的东西让这不一样
obj.counter=1；
obj.len=0；
剂量测定法（obj）；
//还有别的东西让这不一样

运行所有这些功能的短方法：

function func_one(arg) {
    console.log(arg)
};

function func_two(arg) {
    console.log(arg+' make this different')
};

var obj = {
    callbacks: [func_one, func_two],
    params: ["something", "something else"];
};

function doSomething(obj) {
    var n = obj.counter
    for (n; n < (obj.callbacks.length - obj.len); n++) {
        obj.callbacks[n](obj.params[n]);
    }
};

obj.counter = 0;
obj.len = 0;
doSomething(obj); 

//something
//something else make this different

obj.counter = 1;
obj.len = 0;
doSomething(obj);

//something else make this different

这些函数数组的问题不在于“数组形式”，而在于调用这些函数的方式……那么。。。用一个简单的eval（）试试这个

函数的数组=[“fx1（）”、“fx2（）”、“fx3（）”、..“fxN（）”] var zzz=[]；

对于（var i=0；i使用Function.prototype.bind（）

你在上面找到了一些最重要的答案。这只是另一个版本

var array_of_functions = [
        first_function.bind(null,'a string'),
        second_function.bind(null,'a string'),
        third_function.bind(null,'a string'),
        forth_function.bind(null,'a string')
    ]

}

通过ES6回调执行许多函数上面我们看到了一些迭代。让我们使用forEach做同样的事情：

var dictFun = {
     FunOne: function(string) {
     console.log("first function");
  },

   FuncTwo: function(string) {
   console.log("second function");
 },

  FuncThree: function(string) {
   console.log("third function");
}

var funcs=[函数（）{
控制台日志（1）
},
函数（）{
控制台日志（2）
}
];
funcs.forEach（函数（func）{
func（）；//输出1，然后输出2
});
//对于（i=0；i

我在尝试解决这个问题时遇到了很多问题…尝试了显而易见的方法，但没有成功。它只是不知何故附加了一个空函数

var funcs = [function () {
        console.log(1)
  },
  function () {
        console.log(2)
  }
];

funcs.forEach(function (func) {
  func(); // outputs  1, then 2
});
//for (i = 0; i < funcs.length; i++) funcs[i]();

我使用字符串数组解决了这个问题，后来使用eval：

array_of_functions.push(function() { first_function('a string') });

啊，老兄，有这么多奇怪的答案

array_of_functions.push("first_function('a string')");

for (var Func of array_of_functions) {
   eval(Func);
   }

compose

在默认情况下不受支持，但有些库（如ramda、lodash，甚至redux）使用ES6语法提供了此工具

，如果您需要一个类似“管道”的过程，在该过程中通过一系列函数传递同一对象（在我的例子中，是HTML抽象语法树），您可以使用for…of调用给定数组中的每个管道函数：

const setMainElement=require（“./set main element.js”）
const cacheImages=require（“./cache images.js”）
常量removeElements=require（“./remove elements.js”）
设htmlAst={}
常量管道=[
SetMain元素，
缓存图像，
去除元素，
（htmlAst）=>{
//使用动态闭包。
},
]
用于（管道的施工管道）{
管道（最后一个）
}

也许像这样的东西可以达到目的：

[f1，f2，f3].map（（f）=>f（'a string'））

填充数组时是否需要知道

'a string'

，或者函数的调用方是否可以传递它？我很想了解您试图完成的任务的更多细节，因为可能有更好的方法来处理这个问题。“函数数组”-或者我们喜欢称之为带有方法的对象。你不认为你应该提供更多细节吗？可能有更好的方法来处理这个问题。你确定你想回答的是什么吗？这没有关系。@Bergi实际上是。用

函数数组

替换答案的

opera

，你得到了同样的结果。怎么样现在？@Jesse谢谢，现在我对post代码有了一个想法，这是我的第一个回应。但是OP有一个数组，而这是一个对象（带有od）

var dictFun = {
     FunOne: function(string) {
     console.log("first function");
  },

   FuncTwo: function(string) {
   console.log("second function");
 },

  FuncThree: function(string) {
   console.log("third function");
}

var funcs = [function () {
        console.log(1)
  },
  function () {
        console.log(2)
  }
];

funcs.forEach(function (func) {
  func(); // outputs  1, then 2
});
//for (i = 0; i < funcs.length; i++) funcs[i]();

array_of_functions.push(function() { first_function('a string') });

array_of_functions.push("first_function('a string')");

for (var Func of array_of_functions) {
   eval(Func);
   }

const execute = (fn) => fn()
const arrayOfFunctions = [fn1, fn2, fn3]

const results = arrayOfFunctions.map(execute)

or if you want to sequentially feed each functions result to the next:
compose(fn3, fn2, fn1)