从Javascript中的数组中获取最小值？

Question

数组 justPrices 的值如下：

[0] = 1.5
[1] = 4.5
[2] = 9.9.

如何返回数组中的最小值？

Answer 1

Jon Resig 在this article 中说明了如何通过扩展 Array 原型并调用底层 Math.min 方法来实现这一点，不幸的是，该方法不采用数组，而是采用可变数量的参数：

Array.min = function( array ){
    return Math.min.apply( Math, array );
};

然后：

var minimum = Array.min(array);

Answer 2

更新：使用 Darin 的 / John Resig 的答案，请记住，您不需要为 min 指定 thisArg，因此 Math.min.apply(null, arr) 可以正常工作。

---

或者您可以对数组进行排序并获得值#1： [2,6,7,4,1].sort()[0]

[!] 但是如果不提供自定义数字排序功能，这只适用于一种非常有限的情况：小于 10 的正数。看看它会如何破裂：

var a = ['', -0.1, -2, -Infinity, Infinity, 0, 0.01, 2, 2.0, 2.01, 11, 1, 1e-10, NaN];

// correct: 
a.sort( function (a,b) { return a === b ? 0 : a < b ? -1: 1} );
//Array [NaN, -Infinity, -2, -0.1, 0, "", 1e-10, 0.01, 1, 2, 2, 2.01, 11, Infinity]

// incorrect:
a.sort();
//Array ["", -0.1, -2, -Infinity, 0, 0.01, 1, 11, 1e-10, 2, 2, 2.01, Infinity, NaN]

此外，数组已就地更改，这可能不是您想要的。

Answer 3

找到最小值的最简洁的表达代码可能是rest parameters：

const arr = [14, 58, 20, 77, 66, 82, 42, 67, 42, 4]
const min = Math.min(...arr)
console.log(min)

---

当您不需要更改函数的上下文时，Rest 参数本质上是Function.prototype.apply 的便捷简写：

var arr = [14, 58, 20, 77, 66, 82, 42, 67, 42, 4]
var min = Math.min.apply(Math, arr)
console.log(min)

---

这也是Array.prototype.reduce 的一个很好的用例：

const arr = [14, 58, 20, 77, 66, 82, 42, 67, 42, 4]
const min = arr.reduce((a, b) => Math.min(a, b))
console.log(min)

将Math.min 直接传递给reduce 可能很诱人，但是回调接收附加参数：

callback (accumulator, currentValue, currentIndex, array)

在这种特殊情况下，它可能有点冗长。 reduce 在您想要将复杂数据集合为单个值时特别有用：

const arr = [{name: 'Location 1', distance: 14}, {name: 'Location 2', distance: 58}, {name: 'Location 3', distance: 20}, {name: 'Location 4', distance: 77}, {name: 'Location 5', distance: 66}, {name: 'Location 6', distance: 82}, {name: 'Location 7', distance: 42}, {name: 'Location 8', distance: 67}, {name: 'Location 9', distance: 42}, {name: 'Location 10', distance: 4}]
const closest = arr.reduce(
  (acc, loc) =>
    acc.distance < loc.distance
      ? acc
      : loc
)
console.log(closest)

---

当然，您始终可以使用经典迭代：

var arr,
  i,
  l,
  min

arr = [14, 58, 20, 77, 66, 82, 42, 67, 42, 4]
min = Number.POSITIVE_INFINITY
for (i = 0, l = arr.length; i < l; i++) {
  min = Math.min(min, arr[i])
}
console.log(min)

...但即使是经典的迭代也可以进行现代改造：

const arr = [14, 58, 20, 77, 66, 82, 42, 67, 42, 4]
let min = Number.POSITIVE_INFINITY
for (const value of arr) {
  min = Math.min(min, value)
}
console.log(min)

Answer 4

我发现返回数组最小值的最简单方法是在 Math.min() 函数上使用展开运算符。

return Math.min(...justPrices);
//returns 1.5 on example given 

MDN 上的页面有助于更好地理解它：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/min

一点额外的： 这也适用于 Math.max() 函数

return Math.max(...justPrices); //在给出的示例中返回 9.9。

希望这会有所帮助！

Answer 5

可能是更简单的方法？

假设 justPrices 在价值方面混淆了，所以您不知道最小值在哪里。

justPrices[0] = 4.5
justPrices[1] = 9.9
justPrices[2] = 1.5

使用排序。

justPrices.sort();

然后它会为您整理好它们。 （也可以按字母顺序排列。）然后数组将按升序排列。

justPrices[0] = 1.5
justPrices[1] = 4.5
justPrices[2] = 9.9

然后您可以轻松地抓取第一个索引。

justPrices[0]

我发现这比上面建议的更有用，因为如果您需要最小的 3 个数字作为示例怎么办？你也可以切换他们的排列顺序，更多信息http://www.w3schools.com/jsref/jsref_sort.asp

Answer 6

function smallest(){
  if(arguments[0] instanceof Array)
    arguments = arguments[0];

  return Math.min.apply( Math, arguments );
}
function largest(){
  if(arguments[0] instanceof Array)
    arguments = arguments[0];

  return Math.max.apply( Math, arguments );
}
var min = smallest(10, 11, 12, 13);
var max = largest([10, 11, 12, 13]);

console.log("Smallest: "+ min +", Largest: "+ max);

Answer 7

如果您使用 Underscore 或 Lodash，您可以使用这种简单的函数式管道获得最小值

_.chain([7, 6, -1, 3, 2]).sortBy().first().value()
// -1

你还有.min函数

_.min([7, 6, -1, 3, 2])
// -1

Answer 8

假设你有这个数组：

var arr = [1, 2, 3];

ES6方式：

var min = Math.min(...arr); //min=1

ES5方式：

var min = Math.min.apply(null, arr); //min=1

如果您使用 D3.js，有一个方便的函数可以做同样的事情，但会忽略 undefined 值并检查自然顺序：

d3.max(array[, accessor])

使用自然顺序返回给定数组中的最大值。如果 数组为空，返回未定义。一个可选的访问器函数 可以指定，相当于调用array.map(accessor) 在计算最大值之前。

与内置的 Math.max 不同，此方法忽略未定义的值； 这对于忽略丢失的数据很有用。此外，元素是 使用自然顺序而不是数字顺序进行比较。例如， 字符串 [“20”, “3”] 的最大值为“3”，而 数字 [20, 3] 是 20。

这是 D3 v4 的源代码：

export default function(values, valueof) {
  var n = values.length,
      i = -1,
      value,
      max;

  if (valueof == null) {
    while (++i < n) { // Find the first comparable value.
      if ((value = values[i]) != null && value >= value) {
        max = value;
        while (++i < n) { // Compare the remaining values.
          if ((value = values[i]) != null && value > max) {
            max = value;
          }
        }
      }
    }
  }

  else {
    while (++i < n) { // Find the first comparable value.
      if ((value = valueof(values[i], i, values)) != null && value >= value) {
        max = value;
        while (++i < n) { // Compare the remaining values.
          if ((value = valueof(values[i], i, values)) != null && value > max) {
            max = value;
          }
        }
      }
    }
  }

  return max;
}

Answer 9

ES6 是未来之道。

arr.reduce((a, b) => Math.min(a, b));

我更喜欢这种形式，因为它很容易推广到其他用例

Answer 10

我想我有一个易于理解的解决方案，只使用 javaScript 的基础知识。

function myFunction() {
            var i = 0;
            var smallestNumber = justPrices[0];
            for(i = 0; i < justPrices.length; i++) {
                if(justPrices[i] < smallestNumber) {
                    smallestNumber = justPrices[i];
                }
            }
            return smallestNumber;
        }

变量smallestNumber 设置为justPrices 的第一个元素，并且for 循环循环遍历数组（我只是假设您知道for 循环的工作原理；如果不知道，请查一下）。如果数组的元素小于当前的smallestNumber（最初是第一个元素），它将替换它的值。当整个数组经过循环后，smallestNumber 将包含数组中最小的数字。

Answer 11

var array =[2,3,1,9,8];
var minvalue = array[0]; 
for (var i = 0; i < array.length; i++) {
    if(array[i]<minvalue)
    {
        minvalue = array[i];
    }

}
  console.log(minvalue);

Answer 12

这是检测数字数组中最小值的代码。

//function for finding smallest value in an array
function arrayMin(array){
    var min = array[0];
    for(var i = 0; i < array.length; i++){
        if(min < array[i]){
            min = min;
        }else if (min > array[i]){
            min = array[i + 1];
        }else if (min == array[i]){
            min = min;
        }
    }
    return min;
};

这样称呼它：

var fooArray = [1,10,5,2];
var foo = arrayMin(fooArray);

（只需将第二个 else if 结果从：min = min 更改为 min = array[i] 如果您希望达到最小值的数字替换原始数字。）

Answer 13

这是一种递归方式，介绍如何使用三元运算符进行递归和决定是否遇到最小数字。

const findMin = (arr, min, i) => arr.length === i ? min :
  findMin(arr, min = arr[i] < min ? arr[i] : min, ++i)

代码sn-p：

const findMin = (arr, min, i) => arr.length === i ? min :
  findMin(arr, min = arr[i] < min ? arr[i] : min, ++i)
  
const arr = [5, 34, 2, 1, 6, 7, 9, 3];
const min = findMin(arr, arr[0], 0)
console.log(min);

Answer 14

这是 Darin Dimitrov 的答案的一个变体，它不修改 Array 原型：

const applyToArray = (func, array) => func.apply(Math, array)

applyToArray(Math.min, [1,2,3,4]) // 1
applyToArray(Math.max, [1,2,3,4]) // 4

Answer 15

function tinyFriends() {
    let myFriends = ["Mukit", "Ali", "Umor", "sabbir"]
    let smallestFridend = myFriends[0];
    for (i = 0; i < myFriends.length; i++) {
        if (myFriends[i] < smallestFridend) {
            smallestFridend = myFriends[i];
        }
    }
    return smallestFridend   
}

Answer 16

对于任何需要这个的人，我只是有一种感觉。 （获取数组中具有多个值的最小数） 感谢 Akexis 的回答。

如果你有一个数组 以分钟为单位的距离和 ID 和 ETA 所以你可能会推动 for 循环或其他东西

Distances.push([1.3, 1, 2]); // Array inside an array.

然后当它完成时，做一个排序

Distances.sort();

所以这将排序第一件事，即这里的距离。 现在我们有最接近或最少是你能做的第一个

Distances[0] // The closest distance or the smallest number of distance. (array).

Answer 17

找到最小值的超级简单方法是

Array.prototype.min = function(){
    return Math.min.apply(Math,this);
};

要调用函数，只需使用数组的名称并添加 .min()

Array.prototype.min = function(){
    return Math.min.apply(Math,this);
};
var arr = [12,56,126,-1,5,15];
console.log(   arr.min()   );