这是我的字典:
const dict = {
"x" : 1,
"y" : 6,
"z" : 9,
"a" : 5,
"b" : 7,
"c" : 11,
"d" : 17,
"t" : 3
};
dict字典进行从最小到最大或者从最大到最小的排序，或者如果有一个包含排好序的键的数组也可以。但是我不知道如何使用Javascript做这样的事情。我以前用Python做过这样的事情，像这样：import heapq
from operator import itemgetter
thirty_largest = heapq.nlargest(8, dict.iteritems(), key=itemgetter(1))
我在谷歌上搜索了一下，发现数组有sort()函数，但字典没有。所以我的问题是：如何对字典进行排序或获取前5个最大值？
var dict = {
"x": 1,
"y": 6,
"z": 9,
"a": 5,
"b": 7,
"c": 11,
"d": 17,
"t": 3
};
// Create items array
var items = Object.keys(dict).map(function(key) {
return [key, dict[key]];
});
// Sort the array based on the second element
items.sort(function(first, second) {
return second[1] - first[1];
});
// Create a new array with only the first 5 items
console.log(items.slice(0, 5));items = map(lambda x: [x, var[x]], var.keys())
这可以方便地表示为
items = list(dict.items())
排序步骤类似于Python的排序，使用cmp参数。
items.sort(cmp=lambda x, y: y[1] - x[1])
print items[:5]
// [['d', 17], ['c', 11], ['z', 9], ['b', 7], ['y', 6]]
@thefourtheye提供的答案在某种程度上是有效的，但它并没有返回相同的“字典”结构。
如果您想要返回具有与原始结构相同的排序对象，则可以对从接受的答案返回的项运行此操作：
sorted_obj={}
$.each(items, function(k, v) {
use_key = v[0]
use_value = v[1]
sorted_obj[use_key] = use_value
})
将它们结合起来，形成一个单一的函数，可以对JavaScript对象进行排序：
function sort_object(obj) {
items = Object.keys(obj).map(function(key) {
return [key, obj[key]];
});
items.sort(function(first, second) {
return second[1] - first[1];
});
sorted_obj={}
$.each(items, function(k, v) {
use_key = v[0]
use_value = v[1]
sorted_obj[use_key] = use_value
})
return(sorted_obj)
}
示例:
只需将您的对象传递给sort_object函数即可：
dict = {
"x" : 1,
"y" : 6,
"z" : 9,
"a" : 5,
"b" : 7,
"c" : 11,
"d" : 17,
"t" : 3
};
sort_object(dict)
结果:
{
"d":17,
"c":11,
"z":9,
"b":7,
"y":6,
"a":5,
"t":3,
"x":1
}
"证明":
res = sort_object(dict)
$.each(res, function(elem, index) {
alert(elem)
})
items.forEach( function(v) { ... })而不是$.each(items, function(k, v) { ... })可以获得更好的兼容性。 - Mostafa Nazari首先，你可能称为“字典”的东西在JavaScript中被称为“对象”。你的“dict”变量就是一个对象。
在JS中，对象是无序的，因此无法对对象进行排序。幸运的是，数组是有序的；我们将把你的字典转换为数组。请看下面的例子。
//dict -> a js object
var dict = {"x" : 1,
"y" : 6,
"z" : 9,
"a" : 5,
"b" : 7,
"c" : 11,
"d" : 17,
"t" : 3};
//Use the 'keys' function from the Object class to get the keys of your dictionary
//'keys' will be an array containing ["x", "y", "z"...]
var keys = Object.keys(dict);
//Get the number of keys - easy using the array 'length' property
var i, len = keys.length;
//Sort the keys. We can use the sort() method because 'keys' is an array
keys.sort();
//This array will hold your key/value pairs in an ordered way
//it will be an array of objects
var sortedDict = [];
//Now let's go throught your keys in the sorted order
for (i = 0; i < len; i++)
{
//get the current key
k = keys[i];
//show you the key and the value (retrieved by accessing dict with current key)
alert(k + ':' + dict[k]);
//Using the array 'push' method, we add an object at the end of the result array
//It will hold the key/value pair
sortedDict.push({'key': k, 'value':dict[k]});
}
//Result
console.log(sortedDict);
您可以在此处尝试这里
如果您想更改排序方式，请查看这里
如果您想要前五个最大值，那么，请使用for循环遍历sortedDict 5次，并取出这些值：
function getFiveFirstValues(){
var valuesArray = [];
for (i = 0; i < 5; i++)
{
valuesArray.push(sortedDict[i].value);
}
return valuesArray;
}
function sortJsObject() {
var dict = {"x" : 1, "y" : 6, "z" : 9, "a" : 5, "b" : 7, "c" : 11, "d" : 17, "t" : 3};
var keys = [];
for(var key in dict) {
keys[keys.length] = key;
}
var values = [];
for(var i = 0; i < keys.length; i++) {
values[values.length] = dict[keys [i]];
}
var sortedValues = values.sort(sortNumber);
console.log(sortedValues);
}
// this is needed to sort values as integers
function sortNumber(a,b) {
return a - b;
}
return sortedValues 这样的吗？ - Jiřífunction sortObj(obj) {
// Sort object as list based on values
return Object.keys(obj).map(k => ([k, obj[k]])).sort((a, b) => (b[1] - a[1]))
}
它与@thefourtheye的答案相同，但更加简洁。
严格来说，你不能对“字典”（JavaScript对象）进行排序，因为JavaScript对象没有顺序。它们只是一组键/值对的“袋子”。
如果您想在对象中查找前n个最大值，则需要以某种方式将对象转换为已排序的数组，其元素已经排序，例如使用@thefourtheye的解决方案。如果您想对键进行排序，那么可以使用Object.keys(object).sort()进行排序，正如另一个答案所示。
这是一段完整的代码，根据之前的回答和JavaScript中如何迭代（键、值）？：
class DictUtils {
static entries(dictionary) {
try {
//ECMAScript 2017 and higher, better performance if support
return Object.entries(dictionary);
} catch (error) {
//ECMAScript 5 and higher, full compatible but lower performance
return Object.keys(dictionary).map(function(key) {
return [key, dictionary[key]];
});
}
}
static sort(dictionary, sort_function) {
return DictUtils.entries(dictionary)
.sort(sort_function)
.reduce((sorted, kv)=>{
sorted[kv[0]] = kv[1];
return sorted;
}, {});
}
}
class SortFunctions {
static compare(o0, o1) {
//TODO compelte for not-number values
return o0 - o1;
}
static byValueDescending(kv0, kv1) {
return SortFunctions.compare(kv1[1], kv0[1]);
}
static byValueAscending(kv0, kv1) {
return SortFunctions.compare(kv0[1], kv1[1]);
}
}
let dict = {
"jack": 10,
"joe": 20,
"nick": 8,
"sare": 12
}
let sorted = DictUtils.sort(dict, SortFunctions.byValueDescending)
console.log(sorted);我来跟进一下：
const k = 5;
const dict = {
"x" : 1,
"y" : 6,
"z" : 9,
"a" : 5,
"b" : 7,
"c" : 11,
"d" : 17,
"t" : 3
};
const compare = (a, b) => {
if(a > b) return -1;
if(a < b) return 1;
return 0
};
// Object.entries() to convert the dict to: [["x",3],["y",1],["z",2]]
let arr = Object.entries(dict).sort((a, b) => compare(a[1], b[1]));
// Getting the first k = 5 biggest elements:
let biggestElemsArr = [];
for(let j = 0; j < k; j++) {
biggestElemsArr.push(arr[j][0]);
}
console.log(biggestElemsArr);
const sortObjectByValues = (dict: { [key: string]: number }, direction: 'asc'| 'desc' = 'asc') => {
return Object.fromEntries(Object.entries(dict).sort((a, b) => {
if (direction === 'asc') {
return a[1] - b[1]
}
return b[1] - a[1]
}))
}
Object.keys(dict).sort()返回一个按键排序的数组。当你需要时，你可以使用它来循环遍历字典。 - Sebastien C.