객체의 속성 중에서 min/max 값을 얻는 빠른 방법

객체의 속성 중에서 min/max 값을 얻는 빠른 방법

자바스크립트에 다음과 같은 객체가 있습니다.

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

내가 가지고 있는 객체가 커서 2초마다 최소/최대값을 구해야 하는데, 속성들 중 최소값과 최대값을 모두 루프하지 않고 얻을 수 있는 빠른 방법이 있을까요?(객체의 값은 계속 바뀝니다.)

업데이트:

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

---

원래 답변:

시도해 보기:

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/

일반적인 경우에서 n개의 원소를 모두 루프하지 않고 최대/최소값을 찾을 수 있는 방법은 없습니다(1에서 n-1로 이동할 경우 n이 현재 최대/최소값보다 크지 않은지(또는 작음).).

몇 초 간격으로 값이 바뀐다고 하셨잖아요.어떤 값이 변경되는지 정확히 알고 있다면 이전의 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;
}

다음을 시도해 볼 수 있습니다.

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

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

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

사용해 볼 수도 있습니다.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);

// 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 ]

당신은 a를 사용할 수 있습니다.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]

최대 키와 최소 키를 가져오려면 다음과 같이 하십시오.

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)

여기에 키를 반납할 수 있고 루프를 하나만 할 수 있는 솔루션이 있습니다.개체의 항목을 val에 따라 정렬한 다음 처음 항목과 마지막 항목을 반환합니다.

또한 기존 Object를 대체할 수 있는 정렬된 Object를 반환하여 O(n)보다 반 sorted = 향상되므로 향후 정렬 속도가 빨라집니다.개체는 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));

깊이가 다른 중첩 구조의 경우.{node: {leaf: 4}, leaf: 1}, 작동합니다(lodash 또는 밑줄 사용).

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

lodash 라이브러리를 사용하면 더 짧게 쓸 수 있습니다.

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

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))

   obj.prototype.getMaxinObjArr = function (arr,propName) {
        var _arr = arr.map(obj => obj[propName]);
        return Math.max(..._arr);
    }

이것은 저에게 효과가 있습니다.

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

날짜 시간 값을 정렬하는 경우 아래 설명된 절차를 따릅니다.

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)

언급URL : https://stackoverflow.com/questions/11142884/fast-way-to-get-the-min-max-values-among-properties-of-object