如何使用Javascript中的reduce函数获取一个数字数组并返回最高和最低的数字

如何使用Javascript中的reduce函数获取一个数字数组并返回最高和最低的数字

我迄今为止的努力：

 function each(collection, callback) {
    if(Array.isArray(collection)) {
       for(var i = 0; i < collection.length; i++) {     
           callback(collection[i]);
    }
  } else {
    for(var prop in collection) {
        callback(collection[prop]);
    }
}
}

function reduce(collection, callback, initial) {
each(collection, function(element) {
    if(initial === undefined) {
        initial = element;
    } else {
        initial = callback(initial, element);
    }
});
return initial;
}

function highAndLow(collection) {
//use reduce
return reduce(collection, function(initial, element){
    if(initial[element] > initial[element]){
        initial = "high: " + element;
    } else {
        initial = "low: " + element
    }
    return initial;
}, {})
}

highAndLow([5,2,1,6,8])

每个函数（集合、回调）{
if（数组.isArray（集合））{
对于（var i=0；i初始[元素]）{
initial=“high:”+元素；
}否则{
初始值=“低：”+元素
}
返回首字母；
}, {})
}
高低（[5,2,1,6,8]）

结果应该是这样的： highAndLow（5,2,1,6,8）=={low:1，high:8}

函数highAndLow（）{
function highAndLow() = {
   var args = Array.prototype.call(arguments);
   var low = Infinity;
   var high = -Infinity;
   args.forEach(function (arg) {
      if (arg < low) {
          low = arg;
      }
      if (arg > high) {
          high = arg;
      }
   });
   return {
       low: low,
       high: high
   }
}

var args=Array.prototype.call（参数）；
var low=无穷大；
var high=-无穷大；
args.forEach（函数（arg）{
如果（arg<低）{
低=精氨酸；
}
如果（arg>高）{
高=arg；
}
});
返回{
低:低,，
高：高
}
}

或

函数高低（）{
返回Array.prototype.call（参数）.reduce（函数（散列，参数）{
hash.low=arghash.high？arg:hash.high；
返回散列；
}, {
低：无限，
高：-无穷大
});
}

是的，这是可能的，例如使用此代码

函数高低（数组）{
返回数组.reduce（函数（r，a）{
返回{
低：数学最小值（r.low，a），
高中：数学最高（r.high，a）
};
}，{low:array[0]，high:array[0]}）；
}
document.write（''+JSON.stringify（highAndLow（[5,2,1,6,8]），0,4）+''；
document.write（''+JSON.stringify（highAndLow（[]），0,4）+''；
write（“”+JSON.stringify（highAndLow（[-2,1,0,1,2]），0,4）+“”）以下是一个解决方案：

对于指定的任意数量的参数，下面的方法都可以工作

函数高低（）{
var-inputArr=Array.prototype.slice.call（参数）；
返回inputArr.reduce（函数（res，num）{
如果（res==null）{
res={high:num，low:num}；
}
如果（数值>分辨率高）{
res.high=num；
}
如果（数值

function highAndLow() {
    return Array.prototype.call(arguments).reduce(function (hash, arg) {
        hash.low = arg < hash.low ? arg : hash.low;
        hash.high = arg > hash.high ? arg : hash.high;
        return hash;
    }, {
       low: Infinity,
       high: -Infinity
    });
}

[-30, 30, 1, 10000, -20, 50, 0].reduce(function(acc, n) {
  if (n < acc.min) {
      return {
        min: n,
        max: acc.max
      }
  }
  if (n > acc.max) {
      return {
        min: acc.min,
        max: n
      }
  }
  return acc
}, {min: Infinity, max: -Infinity})

// {
//   max: 10000,
//   min: -30
// }

[-30, 30, 1, 10000, -20, 50, 0].reduce(({min, max}, n) => ({
  min: n < min ? n : min,
  max: n > max ? n : max
}), {min: Infinity, max: -Infinity})

function highAndLow() {
  var inputArr = Array.prototype.slice.call(arguments);
  return inputArr.reduce(function(res, num) {
    if (res === null){
    res = {high:num,low:num};
    }
    if (num > res.high) {
      res.high = num;
    }
    if (num < res.low) {
      res.low = num;
    }
    return res;
  }, null);
}

highAndLow(5, 2, 1, 6, 8) //{high: 8, low: 1}