Javascript 如何在JS for if循环中动态选择预定义变量？
我有一个JSON对象，其中包含外汇交易，每个交易都有以下键：value 现在我想定义一个循环，循环遍历每个对象并返回主要货币欧元、英镑、澳元、瑞士法郎、日元、美元和加元的交易量。 在给出的示例中，每笔交易由一种基础货币组成：澳元，在给出的示例中由一种对应货币组成：CAD 每笔交易要么是长订单类型0、2、4，要么是短订单类型1、3、5 每笔交易都有一个以订单量表示的交易量，其中1.00等于100.000个交易单位 现在，循环的想法如下： 检查是否是包含两种主要货币的货币对，例如欧元兑美元、澳元兑加元等。 如果是，则计算基础货币和交易货币的交易量 如果不是，则根据哪种货币是主要货币，计算基础货币或对应货币的交易量 我在代码片段底部看到的问题是，我不知道如何根据需要动态选择预定义变量。否则，我将不得不设置几十个其他if语句Javascript 如何在JS for if循环中动态选择预定义变量？,javascript,Javascript,我有一个JSON对象，其中包含外汇交易，每个交易都有以下键：value 现在我想定义一个循环，循环遍历每个对象并返回主要货币欧元、英镑、澳元、瑞士法郎、日元、美元和加元的交易量。 在给出的示例中，每笔交易由一种基础货币组成：澳元，在给出的示例中由一种对应货币组成：CAD 每笔交易要么是长订单类型0、2、4，要么是短订单类型1、3、5 每笔交易都有一个以订单量表示的交易量，其中1.00等于100.000个交易单位 现在，循环的想法如下： 检查是否是包含两种主要货币的货币对，例如欧元兑美元、澳元兑
// 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
}
}
返回NaN作为第一步，您可以收集对象中每种货币的所有交易：
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
}
注意：我不确定这是否完全符合您所要求的逻辑。但这可能是一个很好的起点。作为第一步，您可以收集对象中每种货币的所有交易：
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
}
注意：我不确定这是否完全符合您所要求的逻辑。但这可能是一个很好的起点。这里有一个仅包含三个if表达式的解决方案： 风险值ma=[‘欧元’、‘英镑’、‘澳元’、‘瑞士法郎’、‘日元’、‘美元’、‘加拿大元’]； var volumeBought={}，volumeSold={}； 瓦尔乔=[ {字段：{orderType:0，orderLots:1.00，orderSymbol:AUDCAD}， {字段：{订单类型：1，订单批次：0.80，订单符号：USDEUR}， {字段：{orderType:2，orderLots:1.40，orderSymbol:EURAUD}}， {字段：{orderType:3，orderLots:2.20，orderSymbol:AUDCAD}， {字段：{orderType:4，orderLots:1.10，orderSymbol:CADDKK}， {字段：{orderType:5，orderLots:1.30，orderSymbol:GBPUSD}， {字段：{orderType:0，orderLots:3.04，orderSymbol:DKKCAD}， {字段：{orderType:1，orderLots:1.10，orderSymbol:USDCHF}， {字段：{orderType:2，orderLots:0.90，orderSymbol:JPYEUR}， {字段：{orderType:3，orderLots:0.40，orderSymbol:AUDJPY}， {字段：{orderType:4，orderLots:2.30，orderSymbol:CHFGBP}， {字段：{订单类型：5，订单批次：3.10，订单符号：EURUSD}， {字段：{orderType:0，orderLots:4.25，orderSymbol:AUDNGN}， {字段：{订单类型：1，订单批次：0.60，订单符号：USDGBP}， {字段：{orderType:2，orderLots:1.70，orderSymbol:GBPUR}} ]; jo.forEach{fields}=>{ 如果！字段。订单类型%2{ var sld=字段.orderSymbol.substr0,3， bgt=字段.orderSymbol.substr3,6， 批次=字段。订单批次*100000； 如果ma.indexOfsld>-1volumeSold[sld]=volumeSold[sld]| | 0+批次 如果ma.indexOfbgt>-1volumeBought[bgt]=volumeBought[bgt]| | 0+批次 } }; console.log'sell:'，JSON.stringifyvolumeSold
console.log'bunded:'，JSON.stringifyvolumeBought这里是一个只包含三个if表达式的解决方案： 风险值ma=[‘欧元’、‘英镑’、‘澳元’、‘瑞士法郎’、‘日元’、‘美元’、‘加拿大元’]； var volumeBought={}，volumeSold={}； 瓦尔乔=[ {字段：{orderType:0，orderLots:1.00，orderSymbol:AUDCAD}， {字段：{订单类型：1，订单批次：0.80，订单符号：USDEUR}， {字段：{orderType:2，orderLots:1.40，orderSymbol:EURAUD}}， {字段：{orderType:3，orderLots:2.20，orderSymbol:AUDCAD}， {字段：{orderType:4，orderLots:1.10，orderSymbol:CADDKK}， {字段：{orderType:5，orderLots:1.30，orderSymbol:GBPUSD}， {字段：{orderType:0，orderLots:3.04，orderSymbol:DKKCAD}， {字段：{orderType:1，orderLots:1.10，orderSymbol:USDCHF}， {字段：{orderType:2，orderLots:0.90，orderSymbol:JPYEUR}， {字段：{orderType:3，orderLots:0.40，orderSymbol:AUDJPY}， {字段：{orderType:4，orderLots:2.30，orderSymbol:CHFGBP}， {字段：{订单类型：5，订单批次：3.10，订单符号：EURUSD}， {字段：{orderType:0，orderLots:4.25，orderSymbol:AUDNGN}， {字段：{订单类型：1，订单批次：0.60，订单符号：USDGBP}， {字段：{orderType:2，orderLots:1.70，orderSymbol:GBPUR}} ]; jo.forEach{fields}=>{ 如果！字段。订单类型%2{ var sld=字段.orderSymbol.substr0,3， bgt=字段.orderSymbol.substr3,6， 批次=字段。订单批次*100000； 如果ma.indexOfsld>-1volumeSold[sld]=volumeSold[sld]| | 0+批次 如果ma.indexOfbgt>-1volumeBought[bgt]=volumeBought[bgt]| | 0+批次 } }; console.log'sell:'，JSON.stringifyvolumeSold
console.log'bunded:'，JSON.stringifyvolumeBought我终于找到了一个有效的解决方案。为了完整起见，请参见以下内容：
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
}
}
}
}
我终于找到了一个有效的解决办法。为了完整起见，请参见以下内容：
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
}
}
}
}
解决方案取决于您需要如何为循环之后的步骤构造数据。例如，您可以拥有一个结果对象，其中每个键对应一种货币。然后你可以说：result[symbolBase+'volumeBought']
=lots*100.000我知道这可能很迂腐，但orderType:0不是有效的JSON。你是说JS对象吗？@Phanti你正在序列化对象，所以我的评论无关紧要。很公平。关于你对kastenbutts的编辑，你做错了。如果你看他的代码，他第一次将变量初始化为一个数字。在你的情况下，你不是你基本上做xx=未定义+5，这是NaN@grodzi现在我明白了。谢谢。解决方案取决于您需要如何为循环之后的步骤构造数据。例如，您可以拥有一个结果对象，其中每个键对应一种货币。然后您可以说：result[symbolBase+'volumeBought']=lots*100.000我知道这可能很迂腐，但orderType:0不是有效的JSON。你是说JS对象吗？@Phanti你正在序列化对象，所以我的评论无关紧要。很公平。关于你对kastenbutts的编辑，你做错了。如果你看他的代码，他第一次将变量初始化为一个数字。在你的情况下，你不是你基本上做xx=未定义+5，这是NaN@grodzi现在我明白了。谢谢你谢谢你的这种方法。我将努力相应地实施它，并在此基础上再接再厉。hasOwnProperty代表什么？参见：对于这类问题，你应该首先使用搜索引擎。Mozilla和其他人已经很好地记录了HTML/CSS、Javascript。不要害怕阅读这些参考资料。它们通常包含示例，您可以找到许多问题的答案。感谢您的这种方法。我将努力相应地实施它，并在此基础上再接再厉。hasOwnProperty代表什么？参见：对于这类问题，你应该首先使用搜索引擎。Mozilla和其他人已经很好地记录了HTML/CSS、Javascript。不要害怕阅读这些参考资料。它们通常包含示例，你可以找到很多问题的答案。这太酷了。我会调查的。有趣的是，到处都能看到相同问题的不同解决方案。这太酷了。我会调查的。有趣的是，到处都能看到相同问题的不同解决方案。
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
}
}
}
}