Javascript 将函数数组作为布尔数组返回

因此，我正在更新一些旧项目，并试图找到一个来源或一个我试图完成的事情的例子

我拥有的

// sample object of functions
var functions = {
    required : function(value){
        return value.length > 0;
    },
    isObject : function(value){
        return typeof value == 'object';
    }
};

//user input
var funcs = [required(''), isObject({key : 'v'})];

// what the function I'm building will process, in a sense
functions[funcs[i]](//arguments from funcs[i]);

// what would remain after each function
funcs = [false, true] // with an end result of false

上面是对象中函数的示例。我想知道的是可以做到以下几点：

伪代码

// sample object of functions
var functions = {
    required : function(value){
        return value.length > 0;
    },
    isObject : function(value){
        return typeof value == 'object';
    }
};

//user input
var funcs = [required(''), isObject({key : 'v'})];

// what the function I'm building will process, in a sense
functions[funcs[i]](//arguments from funcs[i]);

// what would remain after each function
funcs = [false, true] // with an end result of false

我不是百分之百确定这不能做到，我只是不确定这样的事情怎么会发生。让我们在这里提出一些想法，看看我们能想出什么

如果你们需要澄清我的问题，请告诉我。提前感谢您的帮助

澄清我正在努力实现的目标

// sample object of functions
var functions = {
    required : function(value){
        return value.length > 0;
    },
    isObject : function(value){
        return typeof value == 'object';
    }
};

//user input
var funcs = [required(''), isObject({key : 'v'})];

// what the function I'm building will process, in a sense
functions[funcs[i]](//arguments from funcs[i]);

// what would remain after each function
funcs = [false, true] // with an end result of false

函数的对象不是有限的，对于我正在编写的这个特定程序，可以有任意数量的函数。它们将是预定义的，因此用户输入不会成为问题。我需要能够确定在传递函数时调用什么函数，并确保与所述函数一起传递的任何参数都存在并且也被传递。因此，当我传递

required（“”）

时，我需要能够遍历我的函数对象，找到

functions['required']

，并传递空字符串值。所以像这样

函数['required']（''）

其他问题

---

函数对象是私有访问，用户不能直接访问它

当然有可能。大概是这样的：

var results = [];
var value = "value_to_pass_in";

for(var f in functions)
{
    results.push(f.call(this, value));
}

var functions = {
    required : function(value){
        return value.length > 0;
    },
    isObject : function(value){
        return typeof value == 'object';
    }
};
var args = ['', {key: 'v'}];

var results = ['required', 'isObject'].map(
    function(test, i) {
        return functions[test](args[i]);
    }
);

更新：

function superFunc(value)
{
    var results = [];

    for(var f in functions)
    {
        results.push(f.call(this, value));
    }

    return results;
}

superFunc("value_to_pass_in");

---

当然有可能。大概是这样的：

var results = [];
var value = "value_to_pass_in";

for(var f in functions)
{
    results.push(f.call(this, value));
}

var functions = {
    required : function(value){
        return value.length > 0;
    },
    isObject : function(value){
        return typeof value == 'object';
    }
};
var args = ['', {key: 'v'}];

var results = ['required', 'isObject'].map(
    function(test, i) {
        return functions[test](args[i]);
    }
);

更新：

function superFunc(value)
{
    var results = [];

    for(var f in functions)
    {
        results.push(f.call(this, value));
    }

    return results;
}

superFunc("value_to_pass_in");

---

您需要的是一个

map

函数。你可以这样模仿它（我想如果你想要一行）：

---

您需要的是一个

map

函数。你可以这样模仿它（我想如果你想要一行）：

---

简单地说，这可以通过以下方式实现：

var tests = [functions.required(''), functions.isObject({key: 'v'})];

如果这就是你所需要的，考虑我的答案。

对于更一般的方法，这里的正确工具似乎是。但是，由于您有一个包含所有函数的对象，而不是一个函数数组，因此需要某种方法来进行通信。您可以使用单独的属性名称数组（例如，

['required'、'isObject']

）轻松实现这一点。然后你可以这样做：

var results = [];
var value = "value_to_pass_in";

for(var f in functions)
{
    results.push(f.call(this, value));
}

var functions = {
    required : function(value){
        return value.length > 0;
    },
    isObject : function(value){
        return typeof value == 'object';
    }
};
var args = ['', {key: 'v'}];

var results = ['required', 'isObject'].map(
    function(test, i) {
        return functions[test](args[i]);
    }
);

当然，如果

函数

是一个数组而不是一个对象，则可以简化此过程：

var functions = [
    /* required : */ function(value){
        return value.length > 0;
    },
    /* isObject : */ function(value){
        return typeof value == 'object';
    }
];
var args = ['', {key: 'v'}];

var results = functions.map(
    function(test, i) {
        return test(args[i]);
    }
);

---

如果您想稍微封装一下，可以将

args

数组作为第二个参数传递给

map（）

，在这种情况下，您可以在函数内部使用

this[i]

而不是

args[i]

，这可以通过以下方法完成：

var tests = [functions.required(''), functions.isObject({key: 'v'})];

如果这就是你所需要的，考虑我的答案。

对于更一般的方法，这里的正确工具似乎是。但是，由于您有一个包含所有函数的对象，而不是一个函数数组，因此需要某种方法来进行通信。您可以使用单独的属性名称数组（例如，

['required'、'isObject']

）轻松实现这一点。然后你可以这样做：

var results = [];
var value = "value_to_pass_in";

for(var f in functions)
{
    results.push(f.call(this, value));
}

var functions = {
    required : function(value){
        return value.length > 0;
    },
    isObject : function(value){
        return typeof value == 'object';
    }
};
var args = ['', {key: 'v'}];

var results = ['required', 'isObject'].map(
    function(test, i) {
        return functions[test](args[i]);
    }
);

当然，如果

函数

是一个数组而不是一个对象，则可以简化此过程：

var functions = [
    /* required : */ function(value){
        return value.length > 0;
    },
    /* isObject : */ function(value){
        return typeof value == 'object';
    }
];
var args = ['', {key: 'v'}];

var results = functions.map(
    function(test, i) {
        return test(args[i]);
    }
);

如果您想稍微封装一下，可以将

args

数组作为第二个参数传递给

map（）

，在这种情况下，您可以在函数内部使用

this[i]

而不是

args[i]

var functions = {
    required : function(value){
        return value.length > 0;
    },
    isObject : function(value){
        return typeof value == 'object';
    }
};

// Because these values are user inputs, they should be strings,
// so I enclosed them in quotes.
var funcs = ["required('')", "isObject({key: 'v'})"];

funcs.map(function(e) {
    return eval('functions.' + e);
});

运行此命令将为您提供一个来自对象中函数的返回值数组。

如何

var functions = {
    required : function(value){
        return value.length > 0;
    },
    isObject : function(value){
        return typeof value == 'object';
    }
};

// Because these values are user inputs, they should be strings,
// so I enclosed them in quotes.
var funcs = ["required('')", "isObject({key: 'v'})"];

funcs.map(function(e) {
    return eval('functions.' + e);
});

var functions = {
    required : function(value){
        return value.length > 0;
    },
    isObject : function(value){
        return typeof value == 'object';
    }
};

var funcs = ["required('')", "isObject({key: 'v'})"];

function f(funcs){
  return funcs.map(function(e) {
      return eval('functions.' + e);
  });
}

console.log(f(funcs));

---

运行此命令将为您提供一个来自对象中函数的返回值数组。

您的

函数

变量不是数组；它是一个具有属性

required

和

isObject

的对象。你是在尝试（成对）匹配一个函数数组（不是你现在拥有的）和一个参数数组，并最终得到一个函数返回值数组吗？是的，这就是我的意思，哈哈，对不起，工作时间太长了。这里的问题是，对象属性没有保证的顺序。如何将函数与参数数组的顺序相匹配？这是我一直遇到的问题，因为基本上我首先需要弄清楚的是如何获取在数组中传递的函数的名称，并获取它的参数，以便执行类似于

func\u passed\u in.call的操作（这是从_func_传入的参数）；

您的

函数

变量不是数组；它是一个具有属性

必需的对象

和

isObject

。您是否尝试（成对）匹配一个函数数组（不是您当前拥有的）然后是一个参数数组，最后是一个函数返回值数组？是的，这就是我的意思，哈哈，对不起，工作时间太长了。这里的问题是对象属性没有保证的顺序。你想如何将函数与参数数组的顺序相匹配？这是我一直遇到的问题，因为基本上什么首先，我需要弄清楚如何获取在数组中传递的函数的名称，并获取它的参数，这样我就可以执行类似于

func\u passed\u in.call的操作（这是，来自\u func\u passed\u的参数）

你的解决方案需要两个部分，我现在就是这样做的。我想把它们合并成一个，基本上我想能够做

f（'value\u to\u pass\u in'）

你的解决方案需要两个部分，我现在就是这样做的。我想把它们合并成一个，基本上我想能够做

f（'value\u to\u pass\u in'））

我想你误解了这个问题。函数的对象实际上是无限的。我目前使用的对象中有大约20个函数。因此，这些函数中的任何一个都可以调用。我需要能够识别调用了哪个函数，然后将传递的参数传递给命名函数。我喜欢你的轨迹我想你是

var functions = {
    required : function(value){
        return value.length > 0;
    },
    isObject : function(value){
        return typeof value == 'object';
    }
};

var funcs = ["required('')", "isObject({key: 'v'})"];

function f(funcs){
  return funcs.map(function(e) {
      return eval('functions.' + e);
  });
}

console.log(f(funcs));