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

Question

如何获取一组数字并使用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]) 

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

Answer 1

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 
    } 
} 

或

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 
    }); 
} 

Answer 2

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

function highAndLow(array) { 
 
    return array.reduce(function (r, a) { 
 
     return { 
 
      low: Math.min(r.low, a), 
 
      high: Math.max(r.high, a) 
 
     }; 
 
    }, { low: array[0], high: array[0] }); 
 
} 
 

 
document.write('<pre>' + JSON.stringify(highAndLow([5, 2, 1, 6, 8]), 0, 4) + '</pre>'); 
 
document.write('<pre>' + JSON.stringify(highAndLow([]), 0, 4) + '</pre>'); 
 
document.write('<pre>' + JSON.stringify(highAndLow([-2, .1, 0, 1, 2]), 0, 4) + '</pre>');

Answer 3

这里是一个解决方案：

[-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 
// } 

我们提供的初始值{min: Infinity, max: -Infinity}，具有min这是>=任何我们会遇到价值和max这是<=任何我们将遇到的价值。

然后我们编写我们的reduce函数，它必须像我们的初始值那样获取一个值，以及数组提供的值。在我们的案例中，{min, max}和Number。我们的功能简单地将输入数字与阵列中的max和min值进行比较，确保我们始终返回具有相同属性的对象max和min。

这些是任何使用reduce的基本要求。

顺便说一句，我们可以采用一个非常实用和简洁的方法与es6。

[-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}) 

Answer 4

对于任何数量的参数规定，则下面可以工作

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}