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

数组的值如下所示：

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

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

Jon Resig演示了如何通过扩展数组原型并调用底层方法来实现这一点，不幸的是，该方法不接受数组，而是接受数量可变的参数：

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

然后：

var minimum = Array.min(array);

---

更新：使用Darin的/John Resig答案，请记住您不需要为

min

指定此参数，因此

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]

var a=[“”，-0.1，-2，-无穷大，无穷大，0,0.01,2,2.0,2.01,11,1,1e-10,NaN]；
//正确：
a、 排序（函数（a，b）{返回a==b？0:a

---

而且，数组也会发生相应的更改，这可能不是您想要的

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

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

我发现返回数组最小值的最简单方法是在Math.min（）函数上使用Spread运算符

返回Math.min（…justPrices）；
//在给定的示例中返回1.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个数字作为例子呢？您还可以切换它们的排列顺序，更多信息请访问

函数最小值（）{
if（参数[0]数组实例）
参数=参数[0]；
返回Math.min.apply（数学，参数）；
}
函数最大（）{
if（参数[0]数组实例）
参数=参数[0]；
返回Math.max.apply（数学、参数）；
}
最小值=最小值（10,11,12,13）；
var max=最大值（[10,11,12,13]）；
日志（“最小值：+min+”，最大值：+max）如果使用下划线或Lodash，则可以使用这种简单的函数管道获得最小值

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

您还具有
.min
功能

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

假设您拥有以下阵列：

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，则有一个方便的函数可以执行相同的操作，但会忽略未定义的值，并检查自然顺序：

d3.max（数组[，访问器]）

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

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

这是D3V4的源代码：

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

导出默认函数（值，valueof）{
var n=值。长度，
i=-1，
价值
最大值；
if（valueof==null）{
而（++i=value）{
最大值=最大值；
而（++imax）{
最大值=最大值；
}
}
}
}
}
否则{
而（++i=value）{
最大值=最大值；
而（++imax）{
最大值=最大值；
}
}
}
}
}
返回最大值；
}
ES6是未来的道路。

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

我更喜欢这种形式，因为它很容易推广到其他用例中
我想我有一个简单易懂的解决方案，只使用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;
        }

函数myFunction（）{
var i=0；
var smallestNumber=justPrices[0]；
对于（i=0；i

变量
smallestNumber
被设置为
justPrices
的第一个元素，并且for循环在数组中循环（我只是假设您知道for循环是如何工作的；如果不知道，请查找它）。如果数组中的一个元素小于当前的
smallestNumber
（它首先是第一个元素），它将替换它的值。当整个数组经过循环时，
smallestNumber
将包含数组中的最小数。
var数组=[2,3,1,9,8]；
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);

var minvalue=数组[0]；
对于（var i=0；iif（array[i]这里的代码将检测数字数组中的最小值

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

（如果
结果从：
min=min
更改为
min=array[i]
如果你想麻木
var fooArray = [1,10,5,2];
var foo = arrayMin(fooArray);

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

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

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

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

Distances.sort();

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