JavaScript数组筛选器执行函数

Question

我有一个包含两个值（1或2）和（a，b，c或d）的数组。根据两个值，将执行某个数学函数。该函数采用单独的输入数字并将其乘以常数，但该部分对此不是必需的。

本质上是一个用户提供3个值，我已经删除了常量'k'的一个值，所以剩下2个值来确定常数'k'的右乘数。

我正在寻找的东西比组合数组并通过switch语句中的所有可能的解决方案运行更容易和更可靠。未来有可能为阵列创建新的变量。

let k = 5; 
let input = [2, 'c']; 

if (input.join().includes('1')) { 
    if (input.join().includes('a')) { 
    return k * 10; 
    }; 
    else if (input.join().includes('b')) { 
    return k * 11; 
    }; 
    else if (input.join().includes('c')) { 
    return k * 12; 
    }; 
    else if (input.join().includes('d')) { 
    return k * 13; 
    }; 
}; 

else if (input.join().includes('2')) { 
    if (input.join().includes('a')) { 
    return k * 14; 
    }; 
    else if (input.join().includes('b')) { 
    return k * 15; 
    }; 
    else if (input.join().includes('c')) { 
    return k * 16; 
    }; 
    else if (input.join().includes('d')) { 
    return k * 17; 
    }; 
}; 

基本上我现在有这样的事情。 input和k由用户提供，但不一定以任何特定的顺序，所以我不能可靠地假设input[1]会给我（a，b，c或d）。

Answer 1

我同意帕特里克的评论，关于你在这里实际尝试做什么有点神秘。我还注意到您的评论：

我将能够补充：var mathFuncs = { 1: 'one': { a: mathFunc10, b: mathFunc20 }

你是说，你想成为能够接受的1或one交替输入值？

你可以很简单地做到这一点。下面的calculate()函数创建input数组的副本，并将每个元素都转换为数字（如果它是数字名称之一），然后对该数组进行排序以便按照一致的顺序（数字在字母之前排序）排序。接下来，我们选择使用哪个乘数列表（1或2），最后得到特定的乘数（a-d）来计算返回值。如果输入数组不匹配任何内容，我们将返回NaN。

const numbers = { 
 
    'one': 1, 
 
    'two': 2, 
 
}; 
 

 
const multipliers = { 
 
    1: { a:10, b:11, c:12, d:13 }, 
 
    2: { a:14, b:15, c:16, d:17 }, 
 
}; 
 

 
function calculate(k, input) { 
 
    const convert = n => numbers[ n.toString().toLowerCase() ] || n; 
 
    const sorted = input.map(convert).sort(); 
 
    const list = multipliers[ sorted[0] ]; 
 
    if(! list) return NaN; 
 
    const multiplier = list[ sorted[1] ]; 
 
    return multiplier == null ? NaN : k * multiplier; 
 
} 
 

 
function test(k, input) { 
 
    console.log(k, input.toString(), calculate(k, input)); 
 
} 
 

 
test(5, [ 1, 'a' ]); // 50 
 
test(5, [ 'a', 1 ]); // 50 
 
test(5, [ 'a', 'one' ]); // 50 
 
test(5, [ 2, 'c' ]); // 80 
 
test(5, [ 'two', 'c' ]); // 80 
 
test(5, [ 2, 'e' ]); // NaN 
 
test(5, [ 3, 'a' ]); // NaN 
 
test(5, [ 'three', 'a' ]); // NaN

Answer 2

var mathFunc = getMathFunc([2, 'b']); 
mathFunc(2); // 80 

function getMathFunc(arr) { 
    var inputString = arr.join(''); 

    var mathFuncs = { 
    1: { 
     a: mathFunc10, 
     b: mathFunc20 
    }, 
    2: { 
     a: mathFunc30, 
     b: mathFunc40 
    } 
    }; 

    for (var numKey in mathFuncs) { 
    if (inputString.includes(numKey)) { 
     var numObj = mathFuncs[numKey]; 

     for (var letterKey in numObj) { 
     if (inputString.includes(letterKey)) { 
      return numObj[letterKey]; 
     } 
     } 
    } 
    } 

    function mathFunc10(num) { 
    return 10 * num; 
    } 

    function mathFunc20(num) { 
    return 20 * num; 
    } 

    function mathFunc30(num) { 
    return 30 * num; 
    } 

    function mathFunc40(num) { 
    return 40 * num; 
    } 
} 

Answer 3

如果返回值的逻辑就像是在你的榜样，那么这将做到这一点：

const ref = { 1: 10, 2: 14, a: 0, b: 1, c: 2, d: 3 }, 
 
     calc = (k, input) => k * input.reduce((res, x) => res + ref[x], 0); 
 

 
// Sample calls: 
 
console.log([ 
 
    calc(5, [2, 'c']), // 80 
 
    calc(5, ['c', 2]), // 80 
 
    calc(5, ['a', 1]), // 50 
 
    calc(5, [2, 'b']), // 75 
 
    calc(5, [3, 'd']), // NaN 
 
    calc(5, ['e', 2]), // NaN 
 
]);

当然，如果在其他情况下逻辑更复杂，那么你必须在你的功能和/或专业版中实现这个逻辑提出了ref映射对象。如果“变量”更加相互依赖，那么甚至可能需要几个映射对象。