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映射對象。如果「變量」更加相互依賴，那麼甚至可能需要幾個映射對象。