在JavaScript中获取最小值和最大值，但从2D数组获取

我知道这个问题被问了一次又一次，但请听我说完——这个问题略有不同

我可以从一维数组中获得最大值或最小值，如下所示：

var w_max = Math.max.apply(Math, myArray); 
var w_min = Math.min.apply(Math, myArray); 

但我的数组属于以下类型：

[[[1, 112.0],[2,5.12],[3,113.1],[4,33.6],[5,85.9],[6,219.9]]]
//max = 219.9, min = 5.12

我需要得到第二个值的最小值和最大值，第一个值是一个排序索引。我试过了

myArray[][], myArray[0][0], myArray[[1]] 

---

还有更多。控制台日志显示我得到了NaN或-Infinity

你在帖子中的数组很有趣，但这很有用

var array = [[[1, 112.0],[2,5.12],[3,113.1],[4,33.6],[5,85.9],[6,219.9]]];
function getMax(a){
    var max = a[0][0][1];
    for(var i = 0; i< a[0].length; i++){
        if(a[0][i][1] > max)
            max = a[0][i][1];
    }
    return max;
}

var数组=[[1112.0]、[2,5.12]、[3113.1]、[4,33.6]、[5,85.9]、[6219.9]；
函数getMax（a）{
var max=a[0][0][1]；
对于（var i=0；i最大值）
max=a[0][i][1]；
}
返回最大值；
}

var列表=[
[1, 112.0],
[2, 5.12],
[3, 113.1],
[4, 33.6],
[5, 85.9],
[6, 219.9]
];
函数getMinMax（列表）{
var min=+无穷大；
var max=-无穷大；
对于（变量i=0；i

您可以将数组映射到元素的第二个值：

var arr = [[[1, 112.0],[2,5.12],[3,113.1],[4,33.6],[5,85.9],[6,219.9]]];
var values = arr[0].map(function(elt) { return elt[1]; });
var max = Math.max.apply(null, values);
var min = Math.min.apply(null, values);

---

如果您说它是2D数组，那么它应该少一个[]

var myArray = [[1, 112.0],[2,5.12],[3,113.1],[4,33.6],[5,85.9],[6,219.9]];
var w_max=+Infinity;
var w_min=-Infinity;

for(var i=0;i< myArray.length;i++){
    elementArray = myArray[i];
    if(w_max < Math.max.apply(Math, elementArray)){
        w_max = Math.max.apply(Math, elementArray);
    } 
    if (w_min > Math.min.apply(Math, elementArray)){
        w_min = Math.min.apply(Math, elementArray);
        }
}

var myArray=[[1112.0]、[2,5.12]、[3113.1]、[4,33.6]、[5,85.9]、[6219.9]；
var w_max=+无穷大；
var w_min=-无穷大；
for（var i=0；iMath.min.apply（Math，elementArray））{
w_min=Math.min.apply（Math，elementArray）；
}
}

您可以使用forEach循环第一个数组（这里唯一的一个）：

var A= [
    [[1, 112.0], [2, 5.12], [3, 113.1], [4, 33.6], [5, 85.9], [6, 219.9]]
];
var mm= [Infinity, -Infinity];

A[0].forEach(function(itm){
    var n= itm[1];
    if(n<mm[0]) mm[0]= n;
    if(n>mm[1]) mm[1]= n;   
});

var A=[
[[1, 112.0], [2, 5.12], [3, 113.1], [4, 33.6], [5, 85.9], [6, 219.9]]
];
var mm=[无穷大，-无穷大]；
A[0]。forEach（函数（itm）{
var n=itm[1]；
如果（nmm[1]）mm[1]=n；
});

嗯

/*返回值：（数组）[5.12219.9]

---

*/

我真的很欣赏@TedHopp解决方案的流畅可读性，以至于我决定将其改编成一个函数。函数的实用性还有待观察，但我喜欢能够识别2D数组中指定索引的

min

/

max

的想法

function getMinMaxOf2DIndex (arr, idx) {
    return {
        min: Math.min.apply(null, arr.map(function (e) { return e[idx]})),
        max: Math.max.apply(null, arr.map(function (e) { return e[idx]}))
    }
} 

getMinMaxOf2DIndex（）接受两个参数，

arr

——一个数组，和

idx

要比较的值的索引

用法示例：

// using the OP's array as an example
var array = [[1, 112.0],[2,5.12],[3,113.1],[4,33.6],[5,85.9],[6,219.9]];

getMinMaxOf2DIndex(array, 0); // {min: 1, max: 6}
getMinMaxOf2DIndex(array, 1); // {min: 5.12, max: 219.9}

// and so on...
var array = [[1, 9, 6 , 3], [2, 4, 7, 2], [6, 5, 9, 4]];
getMinMaxOf2DIndex(array, 2); // {min: 1, max: 6}
getMinMaxOf2DIndex(array, 3); // {min: 6, max: 9}

---

在

ES6

中，您可以使用：

工作示例：

var-arr=[[1112.0]、[2,5.12]、[3113.1]、[4,33.6]、[5,85.9]、[6219.9]；
var v=arr[0].map（e=>e[1]）；
var max=数学最大值（…v）；
var min=数学最小值（…v）；
console.log（'max:'+max）；
console.log（'min:'+min）对于大型2D阵列，请使用此避免函数.prototype.apply，正如上面所述，我可以看到的几乎所有答案。因为它只能处理有限的数组长度

function MaxMin2dray(arr, idx){
    var max = Number.MIN_VALUE;
    var min = Number.MAX_VALUE;
     arr.forEach(function(e) {
     if (max < e[idx]) {
      max = e[idx];
    }
    if (min > e[idx]) {
      min = e[idx];
    }
  });
  return {max: max, min: min};
}

函数MaxMin2dray（arr，idx）{
var max=Number.MIN_值；
var min=Number.MAX_值；
arr.forEach（功能（e）{
如果（最大值e[idx]）{
min=e[idx]；
}
});
返回{max:max，min:min}；
}
第一个答案不正确

let arr = [[1, 112.0],[2,5.12],[3,113.1],[4,33.6],[5,85.9],[6,219.9]];
let values = Array.concat.apply([],arr);
let max = Math.max(...values);
let min = Math.min(...values);
console.log(arr)
console.log(min)//1
console.log(max)//219.9
console.log(values)//[ 1, 112, 2, 5.12, 3, 113.1, 4, 33.6, 5, 85.9, 6, 219.9 ]

如果数组应为[[1112.0]、[2,5.12]、[3113.1]、[4,33.6]、[5,85.9]、[6219.9]（少一个[]），则可以使用相同的数组，但删除[0]。这将是一个[0][1]和一个[i][1]刚刚注意到我不需要你的内部数组，因为它实际上是一个数组数组数组--
3D
数组，如果你愿意的话。@Aheinlein-谢谢。它的效率可能远不及显式循环和测试（因为它涉及三次迭代，再加上构造一个新数组，而不是一次迭代），但除非它是一个巨大的数组和/或执行了大量次，否则性能损失可以忽略不计。在可读性和可维护性方面有很多要说的。谢谢Ted Hopp的回复。你用最简单的方式回答了我的问题。Fwiw-我的数组最多只能有365个元素（通常更少），因为代码只能追溯到一年前。我真的很欣赏你的解决方案，如果我能勾选两个答案，我也会勾选你的。但是特德先想到的。我真的很喜欢你对他的解决方案的改编。我也喜欢这种概括+1.但是，我建议使用局部变量来存储
arr.map（…）
的结果。没有理由在构建感兴趣的值数组时重复所有工作两次。这将导致范围错误：：超出最大调用堆栈大小这太神奇了！！！！。但是，与粗体声明和代码转储相比，更好的是解释为什么您的答案是唯一的答案。这个答案是最有效的，因为它不创建额外的数组，只执行一次迭代。这里的最佳解决方案+1
function MaxMin2dray(arr, idx){
    var max = Number.MIN_VALUE;
    var min = Number.MAX_VALUE;
     arr.forEach(function(e) {
     if (max < e[idx]) {
      max = e[idx];
    }
    if (min > e[idx]) {
      min = e[idx];
    }
  });
  return {max: max, min: min};
}

let arr = [[1, 112.0],[2,5.12],[3,113.1],[4,33.6],[5,85.9],[6,219.9]];
let values = Array.concat.apply([],arr);
let max = Math.max(...values);
let min = Math.min(...values);
console.log(arr)
console.log(min)//1
console.log(max)//219.9
console.log(values)//[ 1, 112, 2, 5.12, 3, 113.1, 4, 33.6, 5, 85.9, 6, 219.9 ]