获取对象属性间最小/最大值的快速方法

我在 javascript 中有一个这样的对象:

{ "a":4, "b":0.5 , "c":0.35, "d":5 }

有没有一种快速的方法可以获得属性之间的最小值和最大值，而不必循环遍历所有属性？因为我的对象很大，我需要每两秒钟得到最小/最大值。(对象的值不断变化)。

175370 次浏览
小开

无论如何，min和 max必须遍历输入数组-否则他们如何找到最大或最小的元素？

所以只需要一个快速的 for..in循环就可以了。

var min = Infinity, max = -Infinity, x;
for( x in input) {
if( input[x] < min) min = input[x];
if( input[x] > max) max = input[x];
}
小开
最佳答案

There's no way to find the maximum / minimum in the general case without looping through all the N elements (if you go from, 1 to n-1, how do you know whether the element N isn't larger (or smaller) than the current max/min)?

您提到值每隔几秒钟就会变化一次。如果您确切地知道哪些值发生了变化，您可以从以前的 max/min 值开始，并且只与新的值进行比较，但是即使在这种情况下，如果修改的值之一是旧的 max/min 值，您可能需要再次遍历它们。

另一种替代方法——同样，只有在变化的值数量很小的情况下——是将值存储在一个结构中，比如树或堆，当新值到达时，您将适当地插入(或更新)它们。但是基于你的问题，你是否能做到这一点还不清楚。

如果希望在循环遍历所有元素时获取给定列表的最大/最小元素，那么可以使用下面的代码片段，但是如果不遍历所有元素，就无法做到这一点

var list = { "a":4, "b":0.5 , "c":0.35, "d":5 };
var keys = Object.keys(list);
var min = list[keys[0]]; // ignoring case of empty list for conciseness
var max = list[keys[0]];
var i;


for (i = 1; i < keys.length; i++) {
var value = list[keys[i]];
if (value < min) min = value;
if (value > max) max = value;
}
小开

更新: 现代版(ES6 +) 

let obj = { a: 4, b: 0.5 , c: 0.35, d: 5 };


let arr = Object.values(obj);
let min = Math.min(...arr);
let max = Math.max(...arr);


console.log( `Min value: ${min}, max value: ${max}` );

Original Answer:

试试这个:

let obj = { a: 4, b: 0.5 , c: 0.35, d: 5 };
var arr = Object.keys( obj ).map(function ( key ) { return obj[key]; });

然后:

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

现场演示: http://jsfiddle.net/7gCu7/1/”rel = “ noReferrer”> http://jsfiddle.net/7gcu7/1/

小开

对于不同深度的嵌套结构，例如 {node: {leaf: 4}, leaf: 1}，这将工作(使用 loash 或下划线) :

function getMaxValue(d){
if(typeof d === "number") {
return d;
} else if(typeof d === "object") {
return _.max(_.map(_.keys(d), function(key) {
return getMaxValue(d[key]);
}));
} else {
return false;
}
}
小开

这对我有用:

var object = { a: 4, b: 0.5 , c: 0.35, d: 5 };
// Take all value from the object into list
var valueList = $.map(object,function(v){
return v;
});
var max = valueList.reduce(function(a, b) { return Math.max(a, b); });
var min = valueList.reduce(function(a, b) { return Math.min(a, b); });
小开 
// 1. iterate through object values and get them
// 2. sort that array of values ascending or descending and take first,
//    which is min or max accordingly
let obj = { 'a': 4, 'b': 0.5, 'c': 0.35, 'd': 5 }
let min = Object.values(obj).sort((prev, next) => prev - next)[0] // 0.35
let max = Object.values(obj).sort((prev, next) => next - prev)[0] // 5
小开

使用 洛达什图书馆你可以写得更短

_({ "a":4, "b":0.5 , "c":0.35, "d":5 }).values().max();
小开

这里有一个解决方案，它允许您返回密钥，并且只执行一个循环。它对 Object 的条目进行排序(通过 val) ，然后返回第一个和最后一个。

此外，它还返回已排序的 Object，它可以替换现有的 Object，这样将来的排序会更快，因为它已经是半排序 = 比 O (n)更好。重要的是要注意，对象在 ES6中保持它们的顺序。

const maxMinVal = (obj) => {
const sortedEntriesByVal = Object.entries(obj).sort(([, v1], [, v2]) => v1 - v2);


return {
min: sortedEntriesByVal[0],
max: sortedEntriesByVal[sortedEntriesByVal.length - 1],
sortedObjByVal: sortedEntriesByVal.reduce((r, [k, v]) => ({ ...r, [k]: v }), {}),
};
};


const obj = {
a: 4, b: 0.5, c: 0.35, d: 5
};


console.log(maxMinVal(obj));

小开

你可以试试:

const obj = { a: 4, b: 0.5 , c: 0.35, d: 5 };
const max = Math.max.apply(null, Object.values(obj));
console.log(max) // 5
小开

You can also try with Object.values

const points = { Neel: 100, Veer: 89, Shubham: 78, Vikash: 67 };


const vals = Object.values(points);
const max = Math.max(...vals);
const min = Math.min(...vals);
console.log(max);
console.log(min);

小开 
var newObj = { a: 4, b: 0.5 , c: 0.35, d: 5 };
var maxValue = Math.max(...Object.values(newObj))
var minValue = Math.min(...Object.values(newObj))
小开 
// Sorted
let Sorted = Object.entries({ "a":4, "b":0.5 , "c":0.35, "d":5 }).sort((prev, next) => prev[1] - next[1])
>> [ [ 'c', 0.35 ], [ 'b', 0.5 ], [ 'a', 4 ], [ 'd', 5 ] ]




//Min:
Sorted.shift()
>> [ 'c', 0.35 ]


// Max:
Sorted.pop()
>> [ 'd', 5 ]
小开

可以使用 reduce()函数。

例如:

let obj = { "a": 4, "b": 0.5, "c": 0.35, "d": 5 }


let max = Object.entries(obj).reduce((max, entry) => entry[1] >= max[1] ? entry : max, [0, -Infinity])
let min = Object.entries(obj).reduce((min, entry) => entry[1] <= min[1] ? entry : min, [0, +Infinity])


console.log(max) // ["d", 5]
console.log(min) // ["c", 0.35]
小开 
   obj.prototype.getMaxinObjArr = function (arr,propName) {
var _arr = arr.map(obj => obj[propName]);
return Math.max(..._arr);
}
小开

去拿 Max 和 min 的钥匙

var list = { "a":4, "b":0.5 , "c":0.35, "d":5 };
var keys = Object.keys(list);
var min = keys[0]; // ignoring case of empty list for conciseness
var max = keys[0];
var i;


for (i = 1; i < keys.length; i++) {
var value = keys[i];
if (list[value] < list[min]) min = value;
if (list[value] > list[max]) max = value;
}


console.log(min, '-----', max)

小开

如果我们排序日期时间值，然后按照下面描述的过程

const Obj = {
"TRADE::Trade1": {
"dateTime": "2022-11-27T20:17:05.980Z",
},
"TRADE::Trade2": {
"dateTime": "2022-11-27T20:36:10.659Z",
},
"TRADE::Trade3": {
"dateTime": "2022-11-27T20:28:10.659Z",
}
}




const result = Object.entries(Obj).sort((prev, next) => new Date(prev[1].dateTime) - new Date(next[1].dateTime))


console.log(result)


提交答案