Question

我对编程很新鲜，我正在研究一些代码来为我的论文生成各种值。花了几天时间寻找我的问题的答案却没有取得多大成功，我希望这个社区能够提供一些见解。

简短版：使下面的代码与输入数组arr的长度无关。

更长的版本：

我有一个数组数组arr = [a, b, c, d]，作为函数的输入，我想计算所有可能的组合（即a1,b1,c1,d1，a2,b1,c1,d1等）而不必知道arr中确定的元素数量。

问题是结果对arr中每个元素的位置依赖。换句话说，必须能够在结果中引用arr（a，b，c，d）中每个数组的名称。为了清楚起见，请说arr=[oil_price, countries, vessel_types]。然后，如果结果是随机的，而不是以相同的顺序，那就没有多大意义，例如：

[ country[1], oil_price[1], vessel_type[1] ]（第一次通过）

[ vessel_type[2], country[1], oil_price[1] ]（第二关）

下面的代码确实考虑了arr中的元素位置并创建了我想要的结果空间，但是每个元素都需要一个for循环，这就是我想要避免的元素数量arr可能会不时变化。

function resultspace(arr){
results = [];
e_id = 1;
for (count_1 = 0; count_1 < arr[0].length; count_1++){
    for (count_2 = 0; count_2 < arr[1].length; count_2++){
        for (count_3 = 0; count_3 < arr[2].length; count_3++){
            for (count_4 = 0; count_4 < arr[3].length; count_4++){
                for (count_5 = 0; count_5 < arr[4].length; count_5++){
                    for (count_6 = 0; count_6 < arr[5].length; count_6++){
                        id = e_id
                        var1 = arr[0][count_1].value;
                        var2 = arr[1][count_2].value;
                        var3 = arr[2][count_3].value;
                        var4 = arr[3][count_4].value;
                        var5 = arr[4][count_5].value;
                        var6 = arr[5][count_6].value;

                        result_instance = {id:e_id,
                                            VAR1: var1, 
                                            VAR2: var2, 
                                            VAR3: var3, 
                                            VAR4: var4, 
                                            VAR5: var5, 
                                            VAR6: var6
                                            };
                        results.push(result_instance);
                        e_id++;
                    };
                };
            };
        };
    };
return(results);
};
};

我已经研究了递归组合生成here和here，但是我无法使用这些方法考虑输入数组的元素位置。

感谢您的阅读。

Answer 1

您需要名称，因此您需要使用Map而不是Array。
您需要提供名称作为数组，因为不能保证for-in循环的顺序。

工作演示http://jsfiddle.net/tarabyte/VLj7J/。适用于现代浏览器。

function permutate(arrays, keys, memo) {
    var options, name;

    if(keys.length ) {
        name = keys.shift();
        options = arrays[name];
        memo = memo || [{}];
        return permutate(arrays, keys, options.reduce(function(all, item){
            return all.concat(memo.map(function(curr){
                var result = copy({}, curr);
                result[name] = item;
                return result;
            }));
        }, []));
    }

    return memo;
}

将其命名如下

permutate({name: [], age: [], gender: []}, ['age', 'name', 'gender']);

功能copy

function copy(to, from) {
    Object.keys(from).forEach(function(key){
        to[key] = from[key];
    });
    return to;
}

或{name: []}对数组以及其他预处理http://jsfiddle.net/tarabyte/VLj7J/2/。

function permutate(data, memo) {
    var options, name;

    if(data.length ) {
        options = data.shift();
        for(name in options){
            options = options[name];
        }
        memo = memo || [{}];
        return permutate(data, options.reduce(function(all, item){
            return all.concat(memo.map(function(curr){
                var result = copy({}, curr);
                result[name] = item;
                return result;
            }));
        }, []));
    }

    return memo;
}

按特定顺序列出所有可能的数组值组合

1 个答案: