Schneller Weg, um die Min / Max-Werte unter den Eigenschaften des Objekts zu erhalten

Ich habe ein Objekt in Javascript wie folgt:

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

Gibt es eine schnelle Möglichkeit, den minimalen und maximalen Wert zwischen den Eigenschaften zu ermitteln, ohne sie alle durchlaufen zu müssen? weil das Objekt, das ich habe, riesig ist und ich alle zwei Sekunden den Min / Max-Wert erhalten muss. (Die Werte des Objekts ändern sich ständig).

Es gibt im allgemeinen Fall keine Möglichkeit, das Maximum / Minimum zu finden, ohne alle n Elemente zu durchlaufen (wenn Sie von 1 nach n-1 gehen, woher wissen Sie, ob das Element n nicht größer (oder kleiner) als das ist Strom max / min)?

Sie haben erwähnt, dass sich die Werte alle paar Sekunden ändern. Wenn Sie genau wissen, welche Werte sich ändern, können Sie mit Ihren vorherigen Max / Min-Werten beginnen und nur mit den neuen vergleichen. Selbst in diesem Fall können Sie dies tun, wenn einer der geänderten Werte Ihr alter Max / Min-Wert war müssen sie erneut durchlaufen.

Eine andere Alternative - wiederum nur, wenn die Anzahl der sich ändernden Werte gering ist - besteht darin, die Werte in einer Struktur wie einem Baum oder einem Heap zu speichern. Wenn die neuen Werte eintreffen, würden Sie sie entsprechend einfügen (oder aktualisieren). Aber ob Sie das können, ist anhand Ihrer Frage nicht klar.

Wenn Sie das maximale / minimale Element einer bestimmten Liste erhalten möchten, während Sie alle Elemente durchlaufen, können Sie so etwas wie das folgende Snippet verwenden, aber Sie können dies nicht tun, ohne alle Elemente durchzugehen

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

Update: ^{_{Moderne Version (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}` );

Ursprüngliche Antwort:

Versuche dies:

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

und dann:

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

Live-Demo: http://jsfiddle.net/7GCu7/1/

minund maxmüssen trotzdem das Eingabearray durchlaufen - wie sonst würden sie das größte oder kleinste Element finden?

Eine kurze for..inSchleife funktioniert also einwandfrei.

var min = Infinity, max = -Infinity, x;
for( x in input) {
    if( input[x] < min) min = input[x];
    if( input[x] > max) max = input[x];
}

Du könntest es versuchen:

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

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

Sie können es auch mit versuchen 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);

Mit der lodash-Bibliothek können Sie kürzer schreiben

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

Hier ist eine Lösung, mit der Sie auch den Schlüssel zurückgeben können und nur eine Schleife ausführen. Es sortiert die Einträge des Objekts (nach Wert) und gibt dann den ersten und den letzten zurück.

Außerdem wird das sortierte Objekt zurückgegeben, das das vorhandene Objekt ersetzen kann, sodass zukünftige Sortierungen schneller sind, da es bereits halbsortiert ist = besser als O (n). Es ist wichtig zu beachten, dass Objekte ihre Reihenfolge in ES6 beibehalten.

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

Für verschachtelte Strukturen unterschiedlicher Tiefe {node: {leaf: 4}, leaf: 1}funktioniert dies (dh mit lodash oder Unterstrich):

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

Das funktioniert bei mir:

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