Question

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

基本上用户提供了3个值，我已经删除了一个值，即常数＆＃39;，所以我留下2个值来确定正确的乘数常数＆＃39;

。

我正在寻找比组合数组并在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 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 2

我同意帕特里克的评论，即你在这里尝试做的事情有点神秘。我也注意到你的评论：

我可以添加：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 3

If the logic of the returned value is like in your example, then this will do it:

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
]);

Of course, if the logic is more complex in other cases, then you'll have to implement that logic in your function and/or the proposed ref mapping object. If the "variables" are more interdependent, you may even need several mapping objects.

Javascript数组过滤器执行函数

3 个答案: