Javascript自定义数组原型

例如，我有一个多维数组：

MyArray[('A', 40, true), ('B', 20, false), ('C', 55, true), ('D', 17, true)]

我想实现一个定制的min（）和max（）原型，以获得min和max，其中只有一个是“true”。。。有什么把戏吗？我一直在考虑使用.map（）来提取某个属性，但如何检查是否启用了提取true/false属性

---

确切地说，我做到了：

var MyArray = [];

MyArray.push( {
   name: 'A',
   valueA: 40,
   valueB: 36,
   enabled: true
});

MyArray.push( {
   name: 'B',
   valueA: 20,
   valueB: 18,
   enabled: false
});

MyArray.push( {
   name: 'C',
   valueA: 55,
   valueB: 75,
   enabled: true
});

.
.
.

这就是为什么我要寻找状态为真的最大值和最小值，排除状态为假的最大值和最小值

我试图实施：

Array.minElement = function(array, prop) {
    return Math.min.apply(Math,
                array.filter(function(arr) { return arr['enabled']; })
                     .map(function(arr) { return arr[prop]; })
           );
}

Array.maxElement = function(array, prop) {
    return Math.max.apply(Math,
                array.filter(function(arr) { return arr['enabled']; })
                     .map(function(arr) { return arr[prop]; })
           );
}

所以我应该调用like Array.minElement（MyArray，'valueA'）来获得最小值，但看起来它不起作用……它应该返回最小值

我做错了什么

谢谢 干杯

---

Luigi

如果MyArray看起来像：

var MyArray = [['A', 40, true], ['B', 20, false], ['C', 55, true], ['D', 17, true]]

我将结合使用

过滤器

和

映射

来获得数组，然后应用

数学

方法：

Math.max.apply(Math, 
    MyArray.filter(function(arr) { return arr[2]; })
           .map(function(arr) { return arr[1]; })
); // => 55

但这里有一个例子

var createSpecialArray = (function () {

    function max() {
        return this.reduce(function (maxVal, item) {
            var val = item[1];

            return item[2]? 
                ((maxVal === null || maxVal < val)? val : maxVal) : 
                maxVal;
        }, null);
    }

    return function createSpecialArray() {
        var arr = Array.apply([], arguments);

        arr.max = max;

        return arr;
    };

})();

---

最后，我重新实现了minElement和maxElement，如下所示：

Array.minElement = function(array, prop) {
    var lowest = Number.POSITIVE_INFINITY;
    for (var i=array.length-1; i>=0; i--) {
        if (parseFloat(array[i][prop]) < lowest) lowest = parseFloat(array[i][prop]);
    }
    return lowest;
}

Array.maxElement = function(array, prop) {
    var highest = Number.NEGATIVE_INFINITY;
    for (var i=array.length-1; i>=0; i--) {
        if (parseFloat(array[i][prop]) > highest) highest = parseFloat(array[i][prop]);
    }       
    return highest;
}

Array.minElement=函数（数组，属性）{
var lowest=正无穷大数；
对于（var i=array.length-1；i>=0；i--）{
if（parseFloat（array[i][prop]）=0；i--）{
if（parseFloat（数组[i][prop]）>highest）highest=parseFloat（数组[i][prop]）；
}       
回报最高；
}

---

现在它工作得很好

告诉我们你尝试过的东西你可能是什么意思

[[A'，40，true]，'B'，20，false]…

。在当前的形式中，它是一个由四个布尔值组成的数组。你能告诉我们你尝试过什么，以及你的预期输出吗？

Array.minElement = function(array, prop) {
    var lowest = Number.POSITIVE_INFINITY;
    for (var i=array.length-1; i>=0; i--) {
        if (parseFloat(array[i][prop]) < lowest) lowest = parseFloat(array[i][prop]);
    }
    return lowest;
}

Array.maxElement = function(array, prop) {
    var highest = Number.NEGATIVE_INFINITY;
    for (var i=array.length-1; i>=0; i--) {
        if (parseFloat(array[i][prop]) > highest) highest = parseFloat(array[i][prop]);
    }       
    return highest;
}