JavaScript的如何调用函数的功能等。基于关闭的阵列？

Question

我真的不知道如何字这个问题，这就是为什么我遇到了一些麻烦Google上搜寻它，但我试图让，基本上，一个辅助函数用于修改MongoDB的数据，我有命令的列表，格式如下：

              var commands = {
                    "find": {
                        "names": {
                            "find":["query"],
                            "toArray":["callback"]
                        }
                    },
                    "sort": {
                        "names": {
                            "find":[],
                            "sort":["query"],
                            "toArray":["callback"]
                          }                          
                    },
                    "limit": {
                        "names": {
                            "find":[],
                            "limit":["number"],
                            "toArray":["callback"]
                          }                          
                    },
                    "deleteOne": {
                        "args":["query","callback"]
                    },
                    "findOne": {
                        "args":["query", "callback"]
                    },
                    "insertOne": {
                        "args":["query", "callback"]
                    },
                    "insertMany": {
                        "args":["array"]
                    },
                    "remove": {
                        "args":["query", "callback"]
                    },
                    "drop": {
                        "args":["callback"]
                    },
                    "updateOne": {
                        "args":["query", "newvalues", "callback"]
                    },
                    "aggregate": {
                        "args": ["query"],
                        "hasCB":"toArray"
                    },
                    "createCollection": {
                        "args":["string", "callback"]
                    }
                };

然后将这些值的字典：和想法是基于所述输入，以调用特定的MongoDB功能等

Based off of this, I am able to make an array that looks like this:

[["find",[]],["sort",[{"name":-1}]],["toArray",[/*some function reference*/]]],

基于这一点，我想打电话：

something.find().sort({"name":-1}).toArray(callback);

如果我有这样的事情：

[[ “查找”，[{ “名称”： “喜”}]]，[ “指定者”，[/一些功能参考/]]]，

我应该能够产生的结果是：something.find（{“名”：“喜”}）指定者（CB）。

所有相同的功能。

这不完全是一个Node.js的问题，一般更多的JavaScript的，在格式给出的函数

[[functionName1,arrayOfArguments1],[functionName2,arrayOfArguments2],[functionName3,arrayOfArguments3]]

你怎么骂functionName1(...arrayOfArguments1)[functionName2](...arrayOfArguments2)[functionName3](...arrayOfArguments3)，

使用循环，或一个功能，让说什么？不用手动写出来，我怎么产生这种结果？目前，我正在做这样一个开关/箱，但是这不太理想：

switch(funcList.length) {
                        case 2:
                            console.log(col[funcList[0][0]](...funcList[0][1])[funcList[1][0]](...funcList[1][1]));
                            break;
                        case 3:
                            console.log(col[funcList[0][0]](...funcList[0][1])[funcList[1][0]](...funcList[1][1])[funcList[2][0]](...funcList[2][1]));
                            break;
                    }

Answer 1

你与表名称只是解析

var Jstr = JSON.parse(commands).find;

现在，Jstr包含

"names": {
     "find":["query"],
      "toArray":["callback"]
  }

像这样一样，你可以分析，并得到价值。

Answer 2

比方说，

const functionArr = [["find",[]],["sort",[{"name":-1}]],["toArray",[/*some function reference*/]]];

那么你可以写，

const functionChainResult = initialObj;
functionArr.forEach(fn => {
  functionChainResult = functionChainResult.apply(window[fn[0]], fn[1]);
});
console.log(functionChainResult);

对于使用不同于其他window一些情况下，你可以看到this。

Answer 3

要调用基于其已在弦设置的功能名称的阵列功能的一些序列我从你的问题理解为。如果我是正确的，我觉得这个解决方案将帮助你。 让我们尝试使用的功能“应用”功能。

var arrx = [["find",[]],["sort",[{"name":-1}]],["toArray",[x]]];

function callSequence(model, operationArray) {
  var res = model; // this will help to call function chain

  // recursive function
  function call(arr, index) {
    // arr[index][0] is current function name
    // arr[index][1] is current function arguments 
    res = res[arr[index][0]].apply({}, arr[index][1]);
    if(index < arr.length) {
      call(arr, index + 1); // call recursively throught the array.
    }
  }

  call(arrx, 0);
}

callSequence(Something, arrx);