在JavaScript中按值对字典排序

这是我的字典：

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

---

我在Google中搜索过它，发现数组有

sort（）

函数，但没有字典。因此，我的问题是：如何对字典进行排序或按排序顺序获取前5个最大值？您可以尝试以下代码。它按值对整数数组进行排序

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

函数sortJsObject（）{
变量dict={“x”：1，“y”：6，“z”：9，“a”：5，“b”：7，“c”：11，“d”：17，“t”：3}；
var键=[]；
对于（dict中的var键）{
键[键.长度]=键；
}
var值=[]；
对于（变量i=0；i

---

希望它能有所帮助。

在JavaScript中可能并不直接

var dict={
“x”：1，
“y”：6，
“z”：9，
“a”：5，
“b”：7，
“c”：11，
“d”：17，
“t”：3
};
//创建项目数组
var items=Object.keys（dict）.map（function（key）{
返回[key，dict[key]]；
});
//根据第二个元素对数组进行排序
items.sort（函数（第一、第二）{
返回第二个[1]-第一个[1]；
});
//创建仅包含前5项的新数组
console.log（items.slice（0,5））首先，在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);

//dict->js对象
变量dict={“x”：1，
“y”：6，
“z”：9，
“a”：5，
“b”：7，
“c”：11，
“d”：17，
“t”：3}；
//使用对象类中的“keys”函数获取字典的键
//“键”将是一个数组，包含[“x”、“y”、“z”…]
var keys=Object.keys（dict）；
//获取键的数量-使用数组“length”属性很容易
变量i，len=键长度；
//把钥匙分类。我们可以使用sort（）方法，因为“keys”是一个数组
keys.sort（）；
//此数组将按顺序保存键/值对
//它将是一个对象数组
var sortedDict=[]；
//现在，让我们按顺序检查一下你的钥匙
对于（i=0；i

你可以试试看

如果要更改排序，请查看

如果您想要前五个最大值，那么，用for循环将sortedct循环5次，然后将这些值取出来：

function getFiveFirstValues(){
    var valuesArray = [];
    for (i = 0; i < 5; i++)
    {
        valuesArray.push(sortedDict[i].value);
    }
    return valuesArray;
}

函数getFiveFirstValues（）{
var值ray=[]；
对于（i=0；i<5；i++）
{
值ray.push（sortedDict[i].value）；
}
返回值数组；
}

请记住，在JavaScript中，对象是无序的它们可能看起来是有序的，但它们不是，并且根据浏览器的JS实现它们的顺序可能会有所不同

在本例中，sortedDict是一个数组（已排序），因此可以进行排序。

---

在该数组的每个元素中，您将为“字典”的每一对找到一个键和值对。

严格来说，您不能对“字典”（JavaScript对象）排序，因为JavaScript对象没有顺序。它们只是键/值对的“包”

---

如果您想在对象中找到n个最大的值，那么您需要以某种方式将对象转换为数组，数组的元素是有序的，例如使用@thefourtheye的解决方案。如果您想对键进行排序，那么可以使用

Object.keys（Object.sort（）

对它们进行排序，因为另一个答案会告诉您如何进行排序。

由@thefourtheye提供的答案在一定程度上有效，但它不会返回相同的“dictionary”结构

如果要返回具有与开始时相同结构的排序对象，可以对从接受答案返回的项目运行此操作：

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

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

示例：

只需将对象传递到sort_object函数中即可：

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

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

结果：

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

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

“证明”：

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

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

---

在JS中，您有对象（而不是字典）。关于这个问题有一些问题。。。例如，您可以查看：。它似乎是按值排序的，请参见最后一行：获取前5个最大值……因为javascript中的对象（字典）没有顺序，所以对此类内容进行排序毫无意义。因此，我强烈建议您将标题改为“如何获得前五大价值”，以避免人们关闭此问题。他说，他想按字典键对字典进行排序。JS中不存在字典，因此我们可以构建一个键/值顺序结构来满足他的需要，它看起来像一个“字典”。没有必要改变他的问题。我认为这对于来自其他语言的人来说是一个常见的问题，因此在我看来，这个标题应该保持原样

Object.keys（dict）.sort（）

返回一个包含已排序键的数组。然后，您可以使用它在字典w上循环