Javascript Array of Functions

小开

最佳答案

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
}
}

小开

我认为这就是原始海报想要达到的目的:

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]();
}

希望这能帮助其他人(比如20分钟前的我: ——)寻找有关如何在数组中调用 JS 函数的提示。

小开

这是正确的

var array_of_functions = {
"all": function(flag) {
console.log(1+flag);
},
"cic": function(flag) {
console.log(13+flag);
}
};


array_of_functions.all(27);
array_of_functions.cic(7);

小开

我将通过使用 shift() Javascript 方法最初描述在这里发布在 Array 中执行各种函数的更简单方法来补充这个线程

  var a = function(){ console.log("this is function: a") }
var b = function(){ console.log("this is function: b") }
var c = function(){ console.log("this is function: c") }


var foo = [a,b,c];


while (foo.length){
foo.shift().call();
}

小开

/* 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();

小开

也许对某些人有帮助。

<!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>

小开

它基本上与 Darin Dimitrov's相同，但它展示了如何使用它来动态创建和存储函数和参数。我希望这对你有用:)

var argsContainer = ['hello', 'you', 'there'];
var functionsContainer = [];


for (var i = 0; i < argsContainer.length; i++) {
var currentArg = argsContainer[i];


functionsContainer.push(function(currentArg){
console.log(currentArg);
});
};


for (var i = 0; i < functionsContainer.length; i++) {
functionsContainer[i](argsContainer[i]);
}

小开

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

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

小开

一个简短的方法来经营他们所有:

[first_function, ..., nth_function].forEach (function(f) {
f('a string');
});

小开

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

array_of_function = ["fx1()","fx2()","fx3()",.."fxN()"]
var zzz=[];
for (var i=0; i<array_of_function.length; i++)
{ var zzz += eval( array_of_function[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')
]

小开

你得到了一些上面的顶级答案。这只是另一个版本。

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


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


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

}

小开

通过 ES6回调执行多个函数

const f = (funs) => {
funs().forEach((fun) => fun)
}


f(() => [
console.log(1),
console.log(2),
console.log(3)
])

小开

在上面我们看到了一些迭代。让我们使用 forEach 做同样的事情:

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') });

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

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)

默认情况下不支持 compose，但是有一些类似于 ramda、 loash 甚至 redux 的库提供了这个工具

小开

使用 ES6语法，如果您需要一个类似“管道”的进程，通过一系列函数(在我的例子中是一个 HTML 抽象语法树)传递相同的对象，那么您可以使用 for...of调用给定数组中的每个管道函数:

const setMainElement = require("./set-main-element.js")
const cacheImages = require("./cache-images.js")
const removeElements = require("./remove-elements.js")


let htmlAst = {}


const pipeline = [
setMainElement,
cacheImages,
removeElements,
(htmlAst) => {
// Using a dynamic closure.
},
]


for (const pipe of pipeline) {
pipe(htmlAst)
}

小开

也许这样的东西可以解决问题:

[f1,f2,f3].map((f) => f('a string'))

小开

这对我有所帮助，但是我在调用数组中的每个函数时遇到了麻烦。因此，对于新手来说，这里介绍了如何创建一个函数数组并调用其中一个或全部函数，这是一些不同的方法。

首先我们建立数组。

let functionsArray = [functionOne, functionTwo, functionThree];

我们可以通过使用数组中的索引来调用数组中的特定函数(记住0是数组中的第一个函数)。

functionsArray[0]();

我们必须把括号放在后面，因为否则我们只是引用函数，而不是调用它。

如果你想调用所有的函数，我们可以使用一些不同的方法。

循环播放

for (let index = 0; index < functionsArray.length; index++) {
functionsArray[index]();
}

不要忘记实际调用函数的括号。

每个人 ForEach 很好，因为我们不需要担心索引，我们只需要获得数组中我们可以使用的每个元素。我们这样使用它(非箭头函数示例如下) :

functionsArray.forEach(element => {
element();
});

在 ForEach 中，您可以将上面的 element重命名为您想要的任何名称。重命名它，而不使用箭头函数可能看起来像这样:

functionsArray.forEach(
function(funFunctionPassedIn) {
funFunctionPassedIn();
}
);

地图呢？ 在这种情况下，我们不应该使用 Map，因为 Map 构建了一个新的数组，在不使用返回的数组时使用 Map 是一种反模式(不好的做法)。

如果我们不使用它返回的数组和/或，那么就不应该使用 map 我们没有从回调中返回值。 < a href = “ https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global _ Objects/Array/map”rel = “ nofollow noReferrer”> Source

小开

我知道我来晚了，但我的意见是

let new_array = [
(data)=>{console.log(data)},
(data)=>{console.log(data+1)},
(data)=>{console.log(data+2)}
]
new_array[0]