Question

我有一个这样的嵌套对象-

finalObj = {

"1" : {
    "1" : 0.6,
    "2" : 0.3,
    "3" : 0.1,
    "score" : "a,b"
},
"3" : {
    "2" : 0.4,
    "3" : 0.4,
    "4" : 0.2,
    "score" : "c,d"
},
"4" : {
    "1" : 0.6,
    "4" : 0.4,
    "score" : "e,f"
}

}

var newObj = {
    "1": [0.6 * (a / b) + 0.6 * (e / f)] / (0.6 + 0.6),
    "2": [0.3 * (a / b) + 0.4 * (c / d)] / (0.6 + 0.4),
    "3": [0.1 * (a / b) + 0.4 * (c / d)] / (0.1 + 0.4),
    "4": [0.2 * (c / d) + 0.4 * (e / f)] / (0.2 + 0.4)
}

var obj = {};
for (let key in finalObj) {
    console.log(key) // "1" , "3" , "4" 
    for (let bey in finalObj[key]) {
        if (bey !== "score") {
            var x = finalObj[key]["score"].split(",")
            if (obj.hasOwnProperty(bey)) {
                console.log(x[0] + " if  " + x[1])
                obj[bey] += finalObj[key][bey] * x[0] / x[1]
            }
            else {
                console.log(x[0] + " else " + x[1])

                obj[bey] = finalObj[key][bey] * x[0] / x[1]
            }
        }

    }
}

其中，外部对象的键是指"question_id"，内部嵌套对象的键是指"skills_id"及其权重，而"scores"在用逗号分隔的字符串中有两个值。 -- "1", "3", "4"是question_id。内部问题ID "1" : "1", "2", "3"是引用该问题的技能ID。“得分”具有“ a（获得的分数），b（总分数）”

我想返回另一个具有技能ID及其标准化分数的对象-newObj

//其中，“ 1”，“ 2”，“ 3”，“ 4”是使用以上//所用公式标准化的所有技能ID。

//我需要使用多少个循环才能实现此目的？ //将数据放入嵌套对象中是否正确？

//到目前为止，我正在尝试类似的操作- // 请帮忙 - //我正在获取输出，但是代码看起来很奇怪！

Answer 1

我将收集左右值以预先求和，并在最后一步建立除法结果。

对于获取值，我建议使用带有相应键的适当对象。

var data = { 1: { 1: 0.6, 2: 0.3, 3: 0.1, score: "a,b" }, 3: { 2: 0.4, 3: 0.4, 4: 0.2, score: "c,d" }, 4: { 1: 0.6, 4: 0.4, score: "e,f" } },
    values = { a: 45, b: 50, c: 35, d: 40, e: 5, f: 10 },
    collection = {},
    div = (a, b) => a / b,
    result;

Object
    .entries(data)
    .forEach(([k, o]) => Object
        .entries(o)
        .filter(([l]) => l !== 'score')
        .forEach(([l, v]) => {
            collection[l] = collection[l] || { left: 0, right: 0 };
            collection[l].left += v * o.score.split(',').map(k => values[k]).reduce(div);
            collection[l].right += v;
        })
    );

result = Object.assign(...Object
    .entries(collection)
    .map(([k, o]) => ({ [k]: o.left / o.right }))
);

console.log(result);
console.log(collection);

.as-console-wrapper { max-height: 100% !important; top: 0; }

如何以最低的复杂度获得结果？

1 个答案: