Cách nhanh chóng để nhận các giá trị tối thiểu / tối đa giữa các thuộc tính của đối tượng

Tôi có một đối tượng trong javascript như thế này:

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

Có cách nào nhanh chóng để nhận giá trị nhỏ nhất và lớn nhất trong số các thuộc tính mà không cần phải lặp lại tất cả chúng không? vì đối tượng tôi có rất lớn và tôi cần nhận giá trị tối thiểu / tối đa hai giây một lần. (Các giá trị của đối tượng liên tục thay đổi).

Không có cách nào để tìm giá trị lớn nhất / tối thiểu trong trường hợp tổng quát mà không lặp lại tất cả n phần tử (nếu bạn đi từ 1 đến n-1, làm cách nào để bạn biết liệu n phần tử không lớn hơn (hoặc nhỏ hơn) tối đa hiện tại / phút)?

Bạn đã đề cập rằng các giá trị thay đổi sau vài giây. Nếu bạn biết chính xác giá trị nào thay đổi, bạn có thể bắt đầu với giá trị tối đa / tối thiểu trước đó và chỉ so sánh với giá trị mới, nhưng ngay cả trong trường hợp này, nếu một trong các giá trị đã được sửa đổi là giá trị tối đa / tối thiểu cũ của bạn, bạn có thể cần lặp lại chúng một lần nữa.

Một cách thay thế khác - một lần nữa, chỉ khi số lượng giá trị thay đổi ít - sẽ là lưu trữ các giá trị trong một cấu trúc như cây hoặc một đống và khi các giá trị mới đến, bạn sẽ chèn (hoặc cập nhật) chúng một cách thích hợp. Nhưng liệu bạn có thể làm điều đó hay không thì không rõ ràng dựa trên câu hỏi của bạn.

Nếu bạn muốn nhận phần tử tối đa / tối thiểu của một danh sách nhất định trong khi lặp qua tất cả các phần tử, thì bạn có thể sử dụng một cái gì đó như đoạn mã bên dưới, nhưng bạn sẽ không thể làm điều đó nếu không xem qua tất cả chúng

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

Cập nhật: ^{_{Phiên bản hiện đại (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}` );

Câu trả lời gốc:

Thử đi:

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

và sau đó:

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

Bản demo trực tiếp: http://jsfiddle.net/7GCu7/1/

minvà maxvẫn phải lặp qua mảng đầu vào - bằng cách nào khác họ sẽ tìm phần tử lớn nhất hoặc nhỏ nhất?

Vì vậy, chỉ cần một for..invòng lặp nhanh sẽ hoạt động tốt.

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

Bạn có thể thử:

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

Bạn cũng có thể thử với 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);

Sử dụng thư viện lodash bạn có thể viết ngắn hơn

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

Đây là một giải pháp cho phép bạn trả lại khóa và chỉ thực hiện một vòng lặp. Nó sắp xếp các mục nhập của Đối tượng (theo val) và sau đó trả về mục nhập đầu tiên và cuối cùng.

Ngoài ra, nó trả về Đối tượng đã được sắp xếp có thể thay thế Đối tượng hiện có để việc sắp xếp trong tương lai sẽ nhanh hơn vì nó đã được sắp xếp một nửa = tốt hơn O (n). Điều quan trọng cần lưu ý là các Đối tượng giữ nguyên thứ tự của chúng trong 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));

Đối với các cấu trúc lồng nhau có độ sâu khác nhau, tức là {node: {leaf: 4}, leaf: 1}, điều này sẽ hoạt động (sử dụng dấu gạch ngang hoặc dấu gạch dưới):

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

Điều này phù hợp với tôi:

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