Javascript 可选参数

目前我正在做一项研究。我宁愿复制/粘贴挑战本身，也不愿自己编写

创建一个将两个参数相加的函数。如果只有一个 参数，然后返回需要一个参数的函数 并返回总和

例如，addTogether（2，3）应该返回5，addTogether（2） 应该返回一个函数

使用单个参数调用此返回函数将返回 总额：

var sumTwoAnd=相加（2）

sumTwoAnd（3）返回5

如果任一参数不是有效数字，则返回undefined

这就是我创建的解决方案：

function addTogether(a) {
  for (let j = 0; j < arguments.length; j++){
    // console.log(typeof(arguments[j]));
    if(typeof(arguments[j]) != "number"){
      return undefined;
    } else if (typeof(arguments[j]) == 'string') {
      return undefined;
    } else {
      console.log('go up');
      if (arguments.length >= 2){
        let sum = 0;
        for(let i = 0; i < arguments.length; i++){
          sum += arguments[i];
        }
        return sum;
      }
    }
  }

  return function(b){
    if (typeof(b) == 'object'){
      return undefined;
    } else {
      return a + b;
    }
  }
}

函数相加（a）{
for（设j=0；j=2）{
设和=0；
for（设i=0；i

---

这个解决方案是80%正确的，但是它不能处理

addTogether（2，“3”）应该返回未定义的。

尽管我添加了这个检查

typeof（arguments[j]）==“string”

。我如何让它工作？谢谢。

您能提供有关测试用例的更多详细信息吗

function addTogether(a, b = null) {
   if (b === undefined || typeof(b) !== 'number') return a + b;
   return function (c) {
     return a + c
   }
 }

function addTogether(a) {
  const argLength = arguments.length;
  if(argLength >= 2) {
    let sum = 0;
    for(let i = 0; i < argLength; i++) {
      if(typeof arguments[i] === 'number') {
        sum += arguments[i];
      } else {
        return undefined;
      }
    }
    return sum;
  } else {
    return function(b) {
      if(typeof a !== 'number') {
        return undefined;
      }
      if(typeof b === 'number') {
        return a + b;
      }
    }
  }
}

函数相加（a）{
const argLength=arguments.length；
如果（argLength>=2）{
设和=0；
for（设i=0；i

能否提供有关测试用例的更多详细信息

function addTogether(a) {
  const argLength = arguments.length;
  if(argLength >= 2) {
    let sum = 0;
    for(let i = 0; i < argLength; i++) {
      if(typeof arguments[i] === 'number') {
        sum += arguments[i];
      } else {
        return undefined;
      }
    }
    return sum;
  } else {
    return function(b) {
      if(typeof a !== 'number') {
        return undefined;
      }
      if(typeof b === 'number') {
        return a + b;
      }
    }
  }
}

函数相加（a）{
const argLength=arguments.length；
如果（argLength>=2）{
设和=0；
for（设i=0；i

尝试调用

addTogether（）

函数相加（a，b）{
if（typeof（a）！='number'| |（b！=未定义的&&typeof（b）！='number'））{
返回未定义；
}
如果（b==未定义）{
返回c=>addTogether（a，c）；
}
返回a+b；
}
相加（2,3）尝试调用
addTogether（）


函数相加（a，b）{
if（typeof（a）！='number'| |（b！=未定义的&&typeof（b）！='number'））{
返回未定义；
}
如果（b==未定义）{
返回c=>addTogether（a，c）；
}
返回a+b；
}
相加（2,3）函数绑定可用于减少重复代码，如下所示：

function addTogether(a, b) {
  if (Number.isNaN(b)) return addTogether.bind(null, a)
  return a + b
 }

函数绑定可用于减少重复代码，如下所示：

function addTogether(a, b) {
  if (Number.isNaN(b)) return addTogether.bind(null, a)
  return a + b
 }

addTogether（2，“3”）
应该给出
undefined
，而不是
23
。另外，考虑“代码> B<代码>作为输入的代码< 0 > /代码>的情况。虽然这个代码可以解决这个问题，但是一个好的答案也应该解释它所做的和它是如何帮助的。<代码> AdOutCube（2，“3”）< /C>应该给出<代码>未定义的< /代码>，而不是<代码> 23 < /C>。同时，考虑代码< B>代码>作为代码> 0 作为输入的情况。虽然这段代码可能会解决这个问题，但一个好的答案也应该解释它所做的以及它是如何帮助的。