对象在javascript中没有返回值

Question

如何根据javascript中的组合获取对象值？

我不知道如何根据提供给函数调用的输入迭代对象并获取对象值。需要一些帮助。

预期的输出应该如下所示。

getValueCreditToBank(obj, "credit", "bank", "SGD");
getValueDebitToBank(obj, "debit", "bank", "THB");

下面的代码取值但要做两个函数，单函数调用有什么方法可以做，

// getValueCreditToBank(obj, "credit", "bank", "SGD");
function getValueCreditToBank(provider, typein, typeout, source){
  return provider.map(item => {
    if (item.country_from[0].paymentIn[0].type == typein 
        && item.country_from[0].currency.includes(source) 
        && item.country_from[0].paymentOut[0].type == typeout) {
      return {
        paymentIn: typein,
        paymentOut: typeout,
        paymentInFee: item.country_from[0].paymentIn[0].fee.number + "%",
        payInSpeed: item.country_from[0].paymentIn[0].speed.number + "days",
        ...item
      }      
    }
   })
  .map(y=>({  
    ...y,
    targetAmountwithPay: y.targetAmount + y.country_from[0].paymentIn[0].fee.number*y.targetAmount/100
  }))
}

// getValueDebitToBank(obj, "debit", "bank", "SGD");
function getValueDebitToBank(provider, typein, typeout, source){
  return provider.map(item => {
    if (item.country_from[0].paymentIn[1].type == typein 
        && item.country_from[0].currency.includes(source) 
        && item.country_from[0].paymentOut[0].type == typeout) {
      return {
        paymentIn: typein,
        paymentOut: typeout,
        paymentInFee: item.country_from[0].paymentIn[1].fee.number + "%",
        payInSpeed: item.country_from[0].paymentIn[1].speed.number + "days",
        ...item
      }      
    }
   })
  .map(y=>({  
    ...y,
    targetAmountwithPay: y.targetAmount + y.country_from[0].paymentIn[0].fee.number*y.targetAmount/100
  }))
}

对象示例：

var obj = [{
    "id": "identity1",
    "fee": '2',
    "rate": '0.5',
    "targetAmount": '1000',
     "country_from": [{
        "currency": [
            "SGD",
            "USD"
        ],
        "paymentIn": [{
            "type": "credit",
            "speed": {
                "unit": "days",
                "number": "1"
            },
            "fee": {
                "type": "%",
                "number": "1.5"
            }
        },{
            "type": "debit",
            "speed": {
                "unit": "days",
                "number": "1"
            },
            "fee": {
                "type": "%",
                "number": "1"
            }
        }],
       "paymentout":[{
          "type":"bank"
       }]
    }]
},
{
    "id": "identity2",
    "fee": '1',
    "rate": '0.5',
    "targetAmount": '1000',
     "country_from": [{
        "currency": [
            "THB",
            "USD"
        ],
        "paymentIn": [{
            "type": "debit",
            "speed": {
                "unit": "days",
                "number": "1"
            },
            "fee": {
                "type": "%",
                "number": "1"
            }
        }
        ],
       "paymentout":[{
          "type":"bank"
       }]
    }]
}]

预期输出：

//getValue(obj, "credit", "bank", "SGD"); should return object as
 {id: "identity1",
 fee: '2',
 rate: '0.5',
 currency: SGD,
 paymentIn: "credit",
 paymentOut: "bank",
 paymentIn Fee: 1.5%,
 targetAmount: 1000,
 targetAmountwithPay: 506.485 //(((targetamount-fee)*rate)+credit fee))}
//getValue(obj, "debit", "bank", "THB"); should return object as
 {id: "identity2",
 fee: '1',
 rate: '0.5',
 currency: THB,
 paymentIn: "debit",
 paymentOut: "bank",
 paymentIn Fee: 1%,
 targetAmount: 1000,
 targetAmountwithPay: 504.49 //(((targetamount-fee)*rate)+credit fee))}

Answer 1

我在您的代码中看到的第一个问题是您映射了所有数组，但您只更改了一些元素。

也许您没有注意到这一点，因为您设置的过滤器正在传递所有数组元素，但如果没有，您将在最终数组中看到许多未定义的元素。

所以我建议你更新你的代码引入一个过滤器：

function getValueCreditToBank(provider, typein, typeout, source){
  return provider
    .filter(item => (item.country_from[0].paymentIn[0].type == typein 
        && item.country_from[0].currency.includes(source) 
        && item.country_from[0].paymentOut[0].type == typeout))
    .map(item => ({
        paymentIn: typein,
        paymentOut: typeout,
        paymentInFee: item.country_from[0].paymentIn[0].fee.number + "%",
        payInSpeed: item.country_from[0].paymentIn[0].speed.number + "days",
        ...item
      }))
  .map(y=>({  
    ...y,
    targetAmountwithPay: y.targetAmount + y.country_from[0].paymentIn[0].fee.number*y.targetAmount/100
  }))
}

你在这两个函数中做了几乎相同的任务，并且你没有正确使用参数，所以例如你可以通过typein参数确定paymentIn的索引：

function getValueToBank(provider, typein, typeout, source){
  const paymentInIndex = typein === 'credit' ? 0 : 1;
  return provider
    .filter(item => (item.country_from[0].paymentIn[paymentInIndex].type == typein 
        && item.country_from[0].currency.includes(source) 
        && item.country_from[0].paymentOut[0].type == typeout))
    .map(item => ({
        paymentIn: typein,
        paymentOut: typeout,
        paymentInFee: item.country_from[0].paymentIn[paymentInIndex].fee.number + "%",
        payInSpeed: item.country_from[0].paymentIn[paymentInIndex].speed.number + "days",
        ...item
      }))
}

然后你就可以实现你的功能了：

function getValueCreditToBank(provider, typeout, source){
    return getValueToBank(provider, 'credit', typeout, source)
    .map(y=>({  
        ...y,
        targetAmountwithPay: y.targetAmount + y.country_from[0].paymentIn[0].fee.number*y.targetAmount/100
  }))
}

function getValueDebitToBank(provider, typeout, source){
    return getValueToBank(provider, 'debit', typeout, source)
}

因此，您从原始函数中删除 typein 参数，因为它由函数名称决定。

这只是一个例子，你可以用不同的方式重写，一个更易读的方法是为你传递给过滤和映射数组的箭头函数命名。

Answer 2

这里有三个函数：

• getValue(obj, pin, pout, currency) 是做aaaall逻辑的那个。
• getValueCreditToBank(obj, currency) 是 getValue(obj, 'credit', 'bank', currency) 的简写。
• getValueDeditToBank(obj, currency) 是 getValue(obj, 'debit', 'bank', currency) 的简写。

该函数目前仅在country_from 数组有一个对象时才有效。

逻辑很简单：

• 在对象数组中找到对应的paymentIn和paymentOut对象，以及对应的currency。
• 如果找到相应的对象：
  • 计算targetAmountWithPay。
  • 返回一个新对象。

/**
 * Shorthand for getValue() with {pin = "credit"} and {pout = "bank"}.
 * @param {Object[]} obj
 * @param {string} currency
 * @returns {Object}
 */
function getValueCreditToBank(obj, currency) {
  return getValue(obj, 'credit', 'bank', currency);
}

/**
 * Shorthand for getValue() with {pin = "debit"} and {pout = "bank"}.
 * @param {Object[]} obj
 * @param {string} currency
 * @returns {Object}
 */
function getValueDebitToBank(obj, currency) {
  return getValue(obj, 'debit', 'bank', currency);
}

/**
 * @param {Object[]} obj
 * @param {string} pin
 * @param {string} pout
 * @param {string} currency
 * @returns {Object}
 */
function getValue(obj, pin, pout, currency) {
  // paymentIn and paymentOut corresponding objects found from function parameters, initialized to undefined.
  let opint, opout;
  
  // The corresponding item found from function parameters.
  const found = obj.find((item) => {
    // Gets paymentIn object from pin parameter.
    opin = item.country_from[0].paymentIn.find((pinItem) => (pinItem.type.indexOf(pin) > -1));
    
    // Gets paymentOut object from pout parameter.
    opout = item.country_from[0].paymentout.find((poutItem) => (poutItem.type.indexOf(pout) > -1));
    
    // If no paymentIn object, or no paymentOut object, or no currency found,
    // we cannot find anything.
    if (item.country_from[0].currency.indexOf(currency) === -1 || !opin || !opout) {
      return false;
    }
    
    return true;
  });
  
  // If a corresponding object is found, creates the returned object.
  if (found) {
    let targetAmountWithPay = (found.targetAmount - found.fee) * found.rate;
    targetAmountWithPay += opin.fee.number * targetAmountWithPay / 100;
  
    return {
      id: found.id,
      fee: parseFloat(found.fee),
      rate: parseFloat(found.rate),
      currency: currency,
      paymentIn: pin,
      paymentOut: pout,
      paymentInFee: `${opin.fee.number}${opin.fee.type}`,
      targetAmount: parseFloat(found.targetAmount),
      targetAmountWithPay: targetAmountWithPay
    };
  }
  
  // If not, returns null.
  return null;
}

// Tests you gave us.
console.log(getValueCreditToBank(obj, 'SGD'));
console.log(getValueDebitToBank(obj, 'THB'));

// Test if nothing is found. Should return null.
console.log(getValueCreditToBank(obj, 'EUR'));
console.log(getValueDebitToBank(obj, 'EUR'));
console.log(getValue(obj, 'credit', 'not-a-bank', 'SGD'));
console.log(getValue(obj, 'not-a-credit-nor-a-debit', 'bank', 'SGD'));

<script>
// I put your object in HTML in order to have two different frames in the snippet.
const obj = [{
    "id": "identity1",
    "fee": '2',
    "rate": '0.5',
    "targetAmount": '1000',
     "country_from": [{
        "currency": [
            "SGD",
            "USD"
        ],
        "paymentIn": [{
            "type": "credit",
            "speed": {
                "unit": "days",
                "number": "1"
            },
            "fee": {
                "type": "%",
                "number": "1.5"
            }
        },{
            "type": "debit",
            "speed": {
                "unit": "days",
                "number": "1"
            },
            "fee": {
                "type": "%",
                "number": "1"
            }
        }],
       "paymentout":[{
          "type":"bank transfer"
       }]
    }]
},
{
    "id": "identity2",
    "fee": '1',
    "rate": '0.5',
    "targetAmount": '1000',
     "country_from": [{
        "currency": [
            "THB",
            "USD"
        ],
        "paymentIn": [{
            "type": "debit",
            "speed": {
                "unit": "days",
                "number": "1"
            },
            "fee": {
                "type": "%",
                "number": "1"
            }
        }
        ],
       "paymentout":[{
          "type":"bank transfer"
       }]
    }]
}];
</script>

如果您想获得有关您尝试自己执行的功能的更新的答案，请查看@Mario Santini's answer。