如何在JS for-if循环中动态选择预定义变量？

Question

我有一个包含外汇交易的JSON对象，每个对象都使用以下key:values

[...]
orderType: 0
orderLots: "1.00"
orderSymbol: "AUDCAD"
[...]

现在，我想要定义一个循环，循环遍历每个对象，并返回主要货币(EUR|GBP|AUD|CHF|JPY|USD|CAD)的交易卖空和多头成交量。

每笔交易由一个基本货币in the example given: CAD和一个反货币in the example given: AUD组成。

每笔交易要么是多头( 1, 3, 5)

• Each 0, 2, 4)，要么是空头(orderTypes

• )，交易量以orderLots表示，其中1.00等于100.000交易单位(

)

现在，循环的思想如下：

检查是否是包含两种主要货币的货币对(例如，EURUSD, AUDCAD, etc.)

• If so，计算基本和计数器货币

• 的交易量，如果不是，则计算基础货币或计数器货币的交易量，取决于哪种货币是主要的

)。

我的问题(请参阅代码片段的底部)是，我不知道如何根据需要动态地选择预定义的变量。否则，我将不得不设置几十个else if语句。

// define variables
var eurVolumeBought = 0
var eurVolumeSold = 0
var usdVolumeBought = 0
var usdVolumeSold = 0
[...]
var chfVolumeBought = 0
var chfVolumeSold = 0

// iterate each trade in returned JSON object 
for (var i = 0; i < tradesTotal; i++) {

    symbol = trades[i].fields.orderSymbol
    // returns e.g. AUD/CAD

    symbolBase = symbol.slice(0, 3)
    // returns e.g. AUD

    symbolCounter = symbol.slice(3, 6)
    // returns e.g. CAD

    lots = trades[i].fields.orderLots
    // returns e.g. 1.00

    orderType = trades[i].fields.orderType
    // orderTypes 0, 2, 4 are long trades and 1, 3, 5 are short trades accordingly

    // check for main pairs where that contain two major currencies
    if (symbolBase.match(/^(EUR|GBP|AUD|CHF|JPY|USD|CAD)$/) && symbolCounter.match(/^(EUR|GBP|AUD|CHF|JPY|USD|CAD)$/){

        // Create logic for long trades
        if (orderType == '0' || orderType == '2' || orderType == '4') {


        // >>>> here i run into issues <<<<
        // In the example given, we have a AUDCAD long trade of 100.000 units.
        // Thus, I want to dynamically pick the audVolumeBought and cadVolumeSold variables 
        // to increase them accordingly. My foolish approach right now is as follows:

        symbolBase = symbolBase.toLowerCase()
        (symbolBase + 'volumeBought') = lots * 100.000 // I try to grab audVolumeBought variable here
        }

}

编辑到@kastenbutts评论：

结果变量的值将在chart.JS图表中推送。因此，对于每个交易对象，会有一个或两个计算，仅此而已。

使用

result[symbolBase + 'volumeBought'] = result[symbolBase + 'volumeBought'] + (lots * 100.000)

返回NaN

Answer 1

作为第一步，您可以在一个对象中收集每种货币的所有交易：

let result = {}; // Each key in this object will correspond to a currency

for (var i = 0; i < tradesTotal; i++) {

    symbol = trades[i].fields.orderSymbol
    symbolBase = symbol.slice(0, 3)
    symbolCounter = symbol.slice(3, 6)
    lots = trades[i].fields.orderLots

    orderType = trades[i].fields.orderType

    if (symbolBase.match(/^(EUR|GBP|AUD|CHF|JPY|USD|CAD)$/) && symbolCounter.match(/^(EUR|GBP|AUD|CHF|JPY|USD|CAD)$/){

        if (orderType == '0' || orderType == '2' || orderType == '4') {

            symbolBase = symbolBase.toLowerCase()

            if(result.hasOwnProperty(symbolBase + 'volumeBought')) {
                result[symbolBase + 'volumeBought'] += lots * 100.000
            }
            else {
                result[symbolBase + 'volumeBought'] = lots * 100.000
            }

        }
    // ... handle short case 

}

下一步，您需要按照ChartJ的要求将数据转换为图表对象。如果你想要一个简单的条形图，你可以这样做：

let data = [];
let label = [];
for(let cur in result) {
    label.push(cur);
    data.push(result[cur]);
}
let barChart = {
    type: 'bar',
    data: {
        labels: labels,
        datasets: [{
            data: data
        }]
    }
}

注意:我不确定这是否符合您所需的逻辑。但这可能是一个很好的起点。

Answer 2

下面是一个只有三个if表达式的解决方案：

​

var ma=['EUR','GBP','AUD','CHF','JPY','USD','CAD'];
var volumeBought={}, volumeSold={};
var jo=[
  {fields:{orderType: 0,orderLots: "1.00",orderSymbol: "AUDCAD"}},
  {fields:{orderType: 1,orderLots: "0.80",orderSymbol: "USDEUR"}},
  {fields:{orderType: 2,orderLots: "1.40",orderSymbol: "EURAUD"}},
  {fields:{orderType: 3,orderLots: "2.20",orderSymbol: "AUDCAD"}},
  {fields:{orderType: 4,orderLots: "1.10",orderSymbol: "CADDKK"}},
  {fields:{orderType: 5,orderLots: "1.30",orderSymbol: "GBPUSD"}},
  {fields:{orderType: 0,orderLots: "3.04",orderSymbol: "DKKCAD"}},
  {fields:{orderType: 1,orderLots: "1.10",orderSymbol: "USDCHF"}},
  {fields:{orderType: 2,orderLots: "0.90",orderSymbol: "JPYEUR"}},
  {fields:{orderType: 3,orderLots: "0.40",orderSymbol: "AUDJPY"}},
  {fields:{orderType: 4,orderLots: "2.30",orderSymbol: "CHFGBP"}},
  {fields:{orderType: 5,orderLots: "3.10",orderSymbol: "EURUSD"}},
  {fields:{orderType: 0,orderLots: "4.25",orderSymbol: "AUDNGN"}},
  {fields:{orderType: 1,orderLots: "0.60",orderSymbol: "USDGBP"}},
  {fields:{orderType: 2,orderLots: "1.70",orderSymbol: "GBPEUR"}}
];

jo.forEach(({fields})=>{
  if (!(fields.orderType%2)) {
  var sld=fields.orderSymbol.substr(0,3),
      bgt=fields.orderSymbol.substr(3,6),
      lots=fields.orderLots*100000;
      if (ma.indexOf(sld)>-1)volumeSold[sld]=(volumeSold[sld]||0) + lots
      if (ma.indexOf(bgt)>-1)volumeBought[bgt]=(volumeBought[bgt]||0) + lots    
  }   
});
console.log('sold:',JSON.stringify(volumeSold))
console.log('bought:',JSON.stringify(volumeBought))

​

上面的大部分代码都涉及生成一些示例数据。实际的工作发生在底部的几行线上。当满足一定条件(“多头交易”和“主要货币”)时，我收集“卖出”和“购买”数量。结果显示为JSON字符串，但它确实可以作为JS对象使用，当然可以以多种不同的方式使用。

表达式volumeSold[sld]=(volumeSold[sld]||0) + lots将把lots的值添加到对象的属性中，而不管它以前是否存在(在这种情况下，它首先是用"0“初始化的)。

Answer 3

我终于找到了解决办法。为了完整起见，请在下面找到它：

let resultBought = {}
let resultSold = {}

for (var i = 0; i < tradesTotal; i++) {

symbol = trades[i].fields.orderSymbol
// returns e.g. EUR/USD

symbolBase = symbol.slice(0, 3)
// returns e.g. EUR

symbolCounter = symbol.slice(3, 6)
// returns e.g. USD

lots = trades[i].fields.orderLots
// returns e.g. 1.00

orderType = trades[i].fields.orderType
// orderTypes 0, 2, 4 are long trades, 1, 3, 5 shorts accordingly

// check for major pairs where XXX/YYY = defined currencies
if (symbolBase.match(/^(EUR|GBP|AUD|CHF|JPY|USD|CAD)$/) && symbolCounter.match(/^(EUR|GBP|AUD|CHF|JPY|USD|CAD)$/)) {
    // Long Trades Major Pairs
    if (orderType == '0' || orderType == '2' || orderType == '4') {

        // Base currency
        if(resultBought.hasOwnProperty(symbolBase + 'VolumeBought')) {
            resultBought[symbolBase + 'VolumeBought'] += lots * 100.000
        }
        else {
            resultBought[symbolBase + 'VolumeBought'] = lots * 100.000
        }
        // Counter currency
        if(resultSold.hasOwnProperty(symbolCounter + 'VolumeSold')) {
            resultSold[symbolCounter + 'VolumeSold'] += lots * 100.000
        }
        else {
            resultSold[symbolCounter + 'VolumeSold'] = lots * 100.000
        }

    // Short Trades Major Pairs
    } else if (orderType == '1' || orderType == '3' || orderType == '5') {

        // Base currency
        if(resultSold.hasOwnProperty(symbolBase + 'VolumeSold')) {
            resultSold[symbolBase + 'VolumeSold'] += lots * 100.000
        }
        else {
            resultSold[symbolBase + 'VolumeSold'] = lots * 100.000
        }

        // Counter currency
        if(resultBought.hasOwnProperty(symbolCounter + 'VolumeBought')) {
            resultBought[symbolCounter + 'VolumeBought'] += lots * 100.000
        }
        else {
            resultBought[symbolCounter + 'VolumeBought'] = lots * 100.000
        }
      }
// consider the non major pairs
} else if (symbolBase.match(/^(EUR|GBP|AUD|CHF|JPY|USD|CAD)$/) || symbolCounter.match(/^(EUR|GBP|AUD|CHF|JPY|USD|CAD)$/)) {
    if (orderType == '0' || orderType == '2' || orderType == '4') {

        if(resultBought.hasOwnProperty(symbolBase + 'VolumeBought')) {
            resultBought[symbolBase + 'VolumeBought'] += lots * 100.000
        }
        else {
            resultBought[symbolBase + 'VolumeBought'] = lots * 100.000
        }

    } else if (orderType == '1' || orderType == '3' || orderType == '5') {

        if(resultSold.hasOwnProperty(symbolBase + 'VolumeSold')) {
            resultSold[symbolBase + 'VolumeSold'] += lots * 100.000
        }
        else {
            resultSold[symbolBase + 'VolumeSold'] = lots * 100.000
        }
      }
  }
}