Question

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.

谢谢！

Answer 1

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

然后当你想在数组中执行给定的函数时：

array_of_functions[0]('a string');

Answer 2

我认为这就是原始海报要完成的目标：

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函数的任何提示。

Answer 3

如果没有您想要完成的更多细节，我们有点猜测。但是你可以使用对象表示法来做这样的事情......

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

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

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

并致电其中一人......

myFuncs.firstFunc('a string')

Answer 4

或者只是：

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

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

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

Answer 5

我会通过使用shift() Javascript方法originally described here

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

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

Answer 6

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

Answer 7

上面我们看到了一些迭代。让我们使用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]();

Answer 8

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

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

Answer 9

这是正确的

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

Answer 10

也许它对某人有帮助。

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

Answer 11

运行所有人的简短方法：

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

Answer 12

这些函数数组的问题不在“数组形式”中，而是在调用这些函数的方式......然后...... 试试这个..用一个简单的eval（）......

<div class="head-btn wow fadeInLeft">
  <a href="#intro" class="btn-primary">Get started</a>
  <a href="#intro" class="btn-default">Read more</a>
</div>

.head-btn {
margin-bottom: 40px;
}

.btn-default {
    font-size: 16px;
    margin: 30px 0 10px;
    padding: 15px 30px;
    height: 35px;
    border-radius: 80px;
}

它工作在这里，没有任何上层在家里做这个工作...... 希望它会有所帮助

Answer 13

使用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')
    ]

Answer 14

尝试解决此问题时，我遇到许多问题……尝试了明显的尝试，但没有成功。它只是以某种方式附加了一个空函数。

$acc = DB::table('accounts')
    ->where('accounts.branchid', $branch_id)
    ->select('code','title','opbal','clbal')->get();
$rslt = DB::table('journal')
    ->where('journal.branchid', $branch_id)
    ->where(function($q) {$q->where('journal.cancel','!=',1)->orWhereNull('journal.cancel');})
    ->select('code',DB::raw('sum(IFNULL(dr,0) - IFNULL(cr,0)) as total'))->groupBy('code')->Get('code','total');

我通过使用字符串数组解决了该问题，后来使用eval进行了解决：

foreach ($rslt as $row) {
    $getacc = $acc->where('code',$row->code);
    $getacc->clbal = $row->total;
}

Answer 15

一个男人有这么多奇怪的答案...

global.cookieJar

{cookieJar: global.cookieJar}在默认情况下不受支持，但是有ramda，lodash甚至redux之类的库提供了此工具

Answer 16

使用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)
}

Answer 17

也许这样的事情可以解决问题：

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

Answer 18

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

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

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

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

}

Answer 19

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

Javascript函数数组

19 个答案: