按值对对象属性进行排序


695

如果我有一个JavaScript对象,例如:

var list = {
  "you": 100, 
  "me": 75, 
  "foo": 116, 
  "bar": 15
};

有没有一种方法可以基于值对属性进行排序?这样我最终

list = {
  "bar": 15, 
  "me": 75, 
  "you": 100, 
  "foo": 116
};

4
不仅是“排序”,而且更重要的是对数字进行排序。数字不受Javascripts Array.sort()方法的影响,这意味着您不仅需要找到一种对属性进行排序的方法,而且还必须编写自己的函数来比较数值。
桑普森

104
阅读答案之前:答案为。对象属性的顺序在ECMAScript中是非标准的。您永远不应假设JavaScript对象中元素的顺序。对象是属性的无序集合。下面的答案显示了如何在数组的帮助下“使用”排序的属性,但从未真正改变对象本身的属性顺序。所以,不,这是不可能的。即使您构建具有预排序属性的对象,也不能保证它们将来会以相同顺序显示。继续阅读:)。
Govind Rai

3
@GovindRai但是,在现实世界中的前端应用程序中,我们遍历了以ID为键的对象集合,如果转换为HTML模板,则顺序很重要。您说它们没有顺序,我说它们与在当前浏览器中进行console.logging时所看到的顺序完全相同。该订单可以重新排序。一旦您遍历它们,它们就会下达命令。
ProblemsSuSumit

7
@GovindRai:现在有一种在规范中以指定顺序访问属性的方法。这是个好主意吗?几乎可以肯定。:-)但从ES2015开始,它就在那里。
TJ Crowder

7
2019年访问者:检查这个勉强赞成Object.entries的答案,这是自ES2017以来最干净,最易读的技术水平:stackoverflow.com/a/37607084/245966
jakub.g

Answers:


704

将它们移动到一个数组,对该数组进行排序,然后根据需要使用该数组。这是一个解决方案:

var maxSpeed = {
    car: 300, 
    bike: 60, 
    motorbike: 200, 
    airplane: 1000,
    helicopter: 400, 
    rocket: 8 * 60 * 60
};
var sortable = [];
for (var vehicle in maxSpeed) {
    sortable.push([vehicle, maxSpeed[vehicle]]);
}

sortable.sort(function(a, b) {
    return a[1] - b[1];
});

//[["bike", 60], ["motorbike", 200], ["car", 300],
//["helicopter", 400], ["airplane", 1000], ["rocket", 28800]]

有了数组后,您可以按自己喜欢的顺序从数组中重建对象,从而完全实现了您打算要做的事情。在我所知道的所有浏览器中都可以使用,但这取决于实现的怪癖,并且可能随时中断。您永远不应假设JavaScript对象中元素的顺序。

var objSorted = {}
sortable.forEach(function(item){
    objSorted[item[0]]=item[1]
})

24
您能否将“您可以重建”重新表述为“您可以使用数组来维护键的顺序并从对象中提取值”?正如您自己提到的那样,它不仅是非标准的,而且这种错误的假设已被今天不只是Chrome的更多浏览器所打破,因此最好不要鼓励用户尝试它。
Oleg V. Volkov

32
这是代码的更紧凑版本。Object.keys(maxSpeed).sort(function(a,b){return-(maxSpeed [a]-maxSpeed [b])});;
TheBrain 2012年

6
@TheBrain:值得补充的keys()是,只有IE9 +(和其他现代浏览器)才支持。还keys()从元素原型链中排除了可枚举的属性(与in.in不同)-但这通常更可取。
MrWhite 2012年

31
_.pairs将对象变成[[key1,value1],[key2,value2]]。然后调用排序。然后调用_.object它以将其返回。
Funkodebat

2
我的项目需要用于干净合并的对象键,但是随着元数据驱动UI时,还需要显式排序。我遵循了类似的方法,只是添加了hasOwnProperty检查以避免爬上原型链。这是一篇关于在JS hackernoon.com/
Nathan Agersea

416

我们不想复制整个数据结构,也不想在需要关联数组的地方使用数组。

这是与bonna相同的另一种方式:

var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
keysSorted = Object.keys(list).sort(function(a,b){return list[a]-list[b]})
console.log(keysSorted);     // bar,me,you,foo


22
这似乎是按键而不是值排序,这不是问题所要的吗?
迈克尔

27
它按值排序,并显示键-但是,由于它只打印键,因此在打印输出时会丢失值计数。
Hanna

6
用JavaScript不能保证对象属性的顺序,因此排序应按数组而不是对象进行(这就是您所说的“关联数组”)。
Christopher Meyers

6
别忘了 keysSorted是一个数组!不是对象!
格林

17
如果添加.map(key => list[key]);到排序的末尾,它将返回整个对象,而不仅仅是键
James Moran

182

您的对象可以具有任意数量的属性,如果将对象放入数组中,则可以选择按所需的对象属性,数字或字符串进行排序。考虑以下数组:

var arrayOfObjects = [   
    {
        name: 'Diana',
        born: 1373925600000, // Mon, Jul 15 2013
        num: 4,
        sex: 'female'
    },
    {

        name: 'Beyonce',
        born: 1366832953000, // Wed, Apr 24 2013
        num: 2,
        sex: 'female'
    },
    {            
        name: 'Albert',
        born: 1370288700000, // Mon, Jun 3 2013
        num: 3,
        sex: 'male'
    },    
    {
        name: 'Doris',
        born: 1354412087000, // Sat, Dec 1 2012
        num: 1,
        sex: 'female'
    }
];

按出生日期排序,从大到大

// use slice() to copy the array and not just make a reference
var byDate = arrayOfObjects.slice(0);
byDate.sort(function(a,b) {
    return a.born - b.born;
});
console.log('by date:');
console.log(byDate);

按名称分类

var byName = arrayOfObjects.slice(0);
byName.sort(function(a,b) {
    var x = a.name.toLowerCase();
    var y = b.name.toLowerCase();
    return x < y ? -1 : x > y ? 1 : 0;
});

console.log('by name:');
console.log(byName);

http://jsfiddle.net/xsM5s/16/


1
按名称排序不应substr超过第一个字符;否则,DianaDebra具有未定义的顺序。另外,您的byDate排序实际上使用num,而不是born
劳伦斯·多尔2014年

这看起来不错,但是请注意,您可以使用字符串进行比较x.localeCompare(y)
Jemar Jones

2
@JemarJones localCompare看起来是一个非常有用的功能!请注意,并非所有浏览器都支持该功能-IE 10及以下版本,Safari Mobile 9及以下版本。
inorganik

@inorganik是对那些需要支持这些浏览器的人的一个很好的注意
Jemar Jones

1
这是对象的阵列,这是不要求(与几个属性的对象)的OP
若昂皮门特尔费雷拉

62

为了完整起见,此函数返回对象属性的排序数组

function sortObject(obj) {
    var arr = [];
    for (var prop in obj) {
        if (obj.hasOwnProperty(prop)) {
            arr.push({
                'key': prop,
                'value': obj[prop]
            });
        }
    }
    arr.sort(function(a, b) { return a.value - b.value; });
    //arr.sort(function(a, b) { a.value.toLowerCase().localeCompare(b.value.toLowerCase()); }); //use this to sort as strings
    return arr; // returns array
}

var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
var arr = sortObject(list);
console.log(arr); // [{key:"bar", value:15}, {key:"me", value:75}, {key:"you", value:100}, {key:"foo", value:116}]

上面代码的Jsfiddle在这里。此解决方案基于本文

更新的小提琴用于排序字符串在这里。您可以从中删除两个附加的.toLowerCase()转换,以进行区分大小写的字符串比较。


1
那对象数组呢?[{name:Will},{name:Bill},{name:Ben}]
汉考克

1
嗨,威尔,您可以使用localeCompare函数进行比较。将其添加到上面的答案。
Stano 2012年

很好的解决方案。字符串排序需要返回
pfwd

@Stano正确而简单的解决方案。非常感谢。
阿布拉·侯赛因

48

ECMAScript 2017引入了Object.values / Object.entries。顾名思义,前者将对象的所有值聚合到一个数组中,后者将整个对象聚合到一个数组中[key, value]。Python的等价于dict.values()dict.items()

这些功能使将任何哈希排序到有序对象中变得非常容易。到目前为止,只有一小部分JavaScript平台支持它们,但是您可以在Firefox 47+上尝试使用。

let obj = {"you": 100, "me": 75, "foo": 116, "bar": 15};

let entries = Object.entries(obj);
// [["you",100],["me",75],["foo",116],["bar",15]]

let sorted = entries.sort((a, b) => a[1] - b[1]);
// [["bar",15],["me",75],["you",100],["foo",116]]

这如何回答问题的标题Sorting JavaScript Object by property value?您误解了我认为的问题,因为您要更改原始Object而不是从中创建一个新的Array。
vsync

2
@vsync此答案给出的结果与接受的答案相同,但是代码更少且没有临时变量。
达伦·库克

3
FWIW,这个答案很干净,是唯一对我有帮助的答案。
NetOperator Wibby

仅在ff中,而不是在chrome中,它们会自动对对象进行排序。wtf
fb

请注意,这不会保留密钥。
Vael Victus '19

40

@marcusR的答案的“箭头”版本以供参考

var myObj = {"you": 100, "me": 75, "foo": 116, "bar": 15};
keysSorted = Object.keys(myObj).sort((a,b) => myObj[a]-myObj[b])
alert(keysSorted);     // bar,me,you,foo

更新:20174月 -这将返回myObj上面定义的排序对象。

Object
 .keys(myObj)
 .sort((a, b) => myObj[a]-myObj[b])
 .reduce((_sortedObj, key) => ({
   ..._sortedObj, 
   [key]: myObj[key]
 }), {})

在这里尝试!

更新:201810月 -Object.entries版本

Object
 .entries(myObj)
 .sort()
 .reduce((_sortedObj, [k,v]) => ({
   ..._sortedObj, 
   [k]: v
 }), {})

在这里尝试!


1
不适用于var myObj = {"1": {"Value": 40}, "2": {"Value": 10}, "3": {"Value": 30}, "4": {"Value": 20}};
Rohanil '18

5
OP的问题以及此答案不包含嵌套对象@Rohanil也许您想问另一个问题而不是拒绝投票。你拥有各类嵌套的对象显然需要超过这个解决方案提供
贾森J.弥敦道

请注意:您的更新实际上无法正常工作。至少不是到处都是因为不是entries。根据标准,对象是属性的无序集合。好吧,这意味着如果您在按属性值或其他值对新对象进行排序后尝试构造新对象,则属性键的排序将再次变得不确定。例如,Chrome默认情况下会对属性键进行排序,因此每次尝试以不同的顺序对属性键进行排序都是没有用的。您唯一的机会就是根据您的订购偏好获得“索引”,并相应地遍历原始对象。
ZorgoZ

是的@ZorgoZ,您是对的,很多人在这篇文章中提到了它。在大多数情况下,在转换为另一种类型(例如JSON)之前或在另一个reduce函数之前,我们都会将此函数用作转换。如果目标是此后对其进行变异,则可能会产生意外结果。我在跨引擎的此功能上取得了成功。
杰森·内森

注意:你不希望使用sort()Object.entries()
Solvitieg

36

根据定义,JavaScript对象是无序的(请参阅ECMAScript语言规范 8.6节)。语言规范甚至不能保证,如果您连续两次遍历对象的属性,那么第二次它们将以相同的顺序出现。

如果需要订购商品,请使用数组和Array.prototype.sort方法。


4
请注意,对此已有很多争论。大多数实现将列表按添加元素的顺序排列。IIRC,Chrome没有。关于Chrome是否应与其他实现保持一致的说法存在争议。我认为JavaScript对象是哈希,因此不应假定任何顺序。我相信Python会经历相同的争论,并且最近引入了新的有序散列状列表。对于大多数浏览器,您可以通过重新创建对象,按排序值添加元素来完成您想要的事情。但是你不应该。
Nosredna

编辑。Chrome通常会保持秩序,但并非总是如此。这是相关的Chromium错误:code.google.com/p/chromium/issues/detail?id=883
Nosredna,2009年

6
该错误报告是不合理的,那些依赖于未记录的行为的人就是那些存在错误的人。阅读ECMASCript第8.6节;它明确指出“对象是属性的无序集合”。任何人发现在某些实现中似乎都不是这种方式,然后开始依赖于特定于实现的行为,这是一个很大的错误,他们不应该试图将责任推卸给自己。如果我是Chrome小组的成员,则将该错误报告标记为“无效,WontFix”。
NickFitz

8
EcmaScript 5实际上将枚举顺序定义为插入顺序-缺少定义被视为ES3中的规范错误。值得注意的是,EcmaScript规范定义了没有人会认为是理智的行为-例如,规范行为是在许多情况下在运行时抛出语法错误,对continue,break,++,-,const等使用不正确。按照规范,任何在到达该代码之前引发异常的引擎都是错误的
olliej

4
@olliej-我认为这是不正确的。规范说:“未指定枚举属性的机制和顺序(第一个算法中的步骤6.a,第二个算法中的步骤7.a)”。这是最终草案PDF的第92页。
whitneyland '02

25

好的,您可能知道,javascript具有sort()函数,可以对数组进行排序,但对象没有任何功能...

因此,在那种情况下,我们需要以某种方式获取键的数组并对其进行排序,这就是api大部分时间为您提供数组对象的原因,因为Array与对象文字相比,与它们相比,它具有更多的本机功能,无论如何,快速的解决方法是使用Object.key返回对象键的数组,我在下面创建了ES6函数来为您完成工作,它使用了JavaScript中的本机sort()reduce()函数:

function sortObject(obj) {
  return Object.keys(obj)
    .sort().reduce((a, v) => {
    a[v] = obj[v];
    return a; }, {});
}

现在您可以像这样使用它:

let myObject = {a: 1, c: 3, e: 5, b: 2, d: 4};
let sortedMyObject = sortObject(myObject);

检查sortedMyObject,您可以看到按如下键排序的结果:

{a: 1, b: 2, c: 3, d: 4, e: 5}

同样,主对象也不会被触摸,实际上我们得到了一个新对象。

我还创建了下面的图像,以使功能步骤更加清晰,以防万一您需要对其进行一些更改以按自己的方式工作:

按属性值对JavaScript对象进行排序


4
按键排序,而不按值排序。
ROROROOROROR

@ROROROOROROR,这只是说明它的工作方式,因为它们没有什么不同,但是都很好,我也将按值添加排序
Alireza

1
按值排序是错误的,它是您的数据集。更改c: 3c: 13,您会发现它崩溃了。
VtoCorleone

1
@VtoCorleone这只是自然的排序错误,首先出现1,而不是所介绍算法中的缺陷。
Michael Ryan Soileau '18 -4-23

10
var list = {
    "you": 100, 
    "me": 75, 
    "foo": 116, 
    "bar": 15
};

function sortAssocObject(list) {
    var sortable = [];
    for (var key in list) {
        sortable.push([key, list[key]]);
    }
    // [["you",100],["me",75],["foo",116],["bar",15]]

    sortable.sort(function(a, b) {
        return (a[1] < b[1] ? -1 : (a[1] > b[1] ? 1 : 0));
    });
    // [["bar",15],["me",75],["you",100],["foo",116]]

    var orderedList = {};
    for (var idx in sortable) {
        orderedList[sortable[idx][0]] = sortable[idx][1];
    }

    return orderedList;
}

sortAssocObject(list);

// {bar: 15, me: 75, you: 100, foo: 116}

简单而完美!这回答了问题。谢谢。
阿杰·辛格

不能保证javascript中的键顺序,因此如果键是整数或类似值,这对我来说将失败
ParoX

确切的是,ParoX。当键是整数类型时,这不能正常工作。
jungwon jin

8

用ES6更新:如果您担心要遍历排序对象(这就是为什么我想您希望对对象属性进行排序的原因),则可以使用Map对象。

您可以按已排序的顺序插入(键,值)对,然后执行for..of循环将确保按插入顺序对它们进行循环

var myMap = new Map();
myMap.set(0, "zero");
myMap.set(1, "one");
for (var [key, value] of myMap) {
  console.log(key + " = " + value);
}
// 0 = zero 
// 1 = one

同样在ES6(ES2015)中:对象属性确实具有顺序(或者有一种以定义的顺序访问它们的方法,具体取决于您的观点)。如果属性名称是字符串,并且看起来不像数组索引,则顺序是它们添加到对象的顺序。此顺序指定为for-in或遵守Object.keys,但定义Object.getOwnPropertyNames为该顺序和其他用于访问属性名称数组的新方法。这是另一种选择。
TJ Crowder

但是“ sort”操作在哪里?它们根本没有排序
绿色

@Green我想我想强调的是,Map实际上您拥有一个可以按排序顺序存储(排序数据,循环遍历并将其存储在地图中)的数据结构,但您不能保证对象。
julianljk

6

Underscore.js或Lodash.js用于高级数组或对象排序

 var data={
        "models": {

            "LTI": [
                "TX"
            ],
            "Carado": [
                "A",
                "T",
                "A(пасс)",
                "A(груз)",
                "T(пасс)",
                "T(груз)",
                "A",
                "T"
            ],
            "SPARK": [
                "SP110C 2",
                "sp150r 18"
            ],
            "Autobianchi": [
                "A112"
            ]
        }
    };

    var arr=[],
        obj={};
    for(var i in data.models){
      arr.push([i, _.sortBy(data.models[i],function (el){return el;})]);
    }
    arr=_.sortBy(arr,function (el){
      return el[0];
    });
    _.map(arr,function (el){return obj[el[0]]=el[1];});
     console.log(obj);

演示


5

我正在遵循slebetman提供的解决方案(请仔细阅读以获取所有详细信息),但是由于您的对象不是嵌套对象,因此已经进行了调整。

// First create the array of keys/values so that we can sort it:
var sort_array = [];
for (var key in list) {
    sort_array.push({key:key,value:list[key]});
}

// Now sort it:
sort_array.sort(function(x,y){return x.value - y.value});

// Now process that object with it:
for (var i=0;i<sort_array.length;i++) {
    var item = list[sort_array[i].key];

    // now do stuff with each item
}


4

在没有多个for循环的情况下对值进行排序(按键排序将排序回调中的索引更改为“ 0”)

const list = {
    "you": 100, 
    "me": 75, 
    "foo": 116, 
    "bar": 15
  };

let sorted = Object.fromEntries(
                Object.entries(list).sort( (a,b) => a[1] - b[1] )    
             ) 
console.log('Sorted object: ', sorted) 


2

这可能是将其作为真实有序对象处理的简单方法。不知道它有多慢。使用while循环也可能会更好。

Object.sortByKeys = function(myObj){
  var keys = Object.keys(myObj)
  keys.sort()
  var sortedObject = Object()
  for(i in keys){
    key = keys[i]
    sortedObject[key]=myObj[key]
   }

  return sortedObject

}

然后,我从以下位置找到了此求反函数:http : //nelsonwells.net/2011/10/swap-object-key-and-values-in-javascript/

Object.invert = function (obj) {

  var new_obj = {};

  for (var prop in obj) {
    if(obj.hasOwnProperty(prop)) {
      new_obj[obj[prop]] = prop;
    }
  }

  return new_obj;
};

所以

var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
var invertedList = Object.invert(list)
var invertedOrderedList = Object.sortByKeys(invertedList)
var orderedList = Object.invert(invertedOrderedList)

2
a = { b: 1, p: 8, c: 2, g: 1 }
Object.keys(a)
  .sort((c,b) => {
    return a[b]-a[c]
  })
  .reduce((acc, cur) => {
    let o = {}
    o[cur] = a[cur]
    acc.push(o)
    return acc
   } , [])

输出= [{p:8},{c:2},{b:1},{g:1}]


2

以防万一,有人使用@Markus R和@James Moran注释的代码引用来寻找保留对象(带有键和值)的方法,只需使用:

var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
var newO = {};
Object.keys(list).sort(function(a,b){return list[a]-list[b]})
                 .map(key => newO[key] = list[key]);
console.log(newO);  // {bar: 15, me: 75, you: 100, foo: 116}

2
您正在返回一个作业mapforEach这样会更好
DiegoRBaquero


1

许多类似且有用的功能:https : //github.com/shimondoodkin/groupbyfunctions/

function sortobj(obj)
{
    var keys=Object.keys(obj);
    var kva= keys.map(function(k,i)
    {
        return [k,obj[k]];
    });
    kva.sort(function(a,b){
        if(a[1]>b[1]) return -1;if(a[1]<b[1]) return 1;
        return 0
    });
    var o={}
    kva.forEach(function(a){ o[a[0]]=a[1]})
    return o;
}

function sortobjkey(obj,key)
{
    var keys=Object.keys(obj);
    var kva= keys.map(function(k,i)
    {
        return [k,obj[k]];
    });
    kva.sort(function(a,b){
        k=key;      if(a[1][k]>b[1][k]) return -1;if(a[1][k]<b[1][k]) return 1;
        return 0
    });
    var o={}
    kva.forEach(function(a){ o[a[0]]=a[1]})
    return o;
}

1

对象按值排序(DESC)

function sortObject(list) {
  var sortable = [];
  for (var key in list) {
    sortable.push([key, list[key]]);
  }

  sortable.sort(function(a, b) {
    return (a[1] > b[1] ? -1 : (a[1] < b[1] ? 1 : 0));
  });

  var orderedList = {};
  for (var i = 0; i < sortable.length; i++) {
    orderedList[sortable[i][0]] = sortable[i][1];
  }

  return orderedList;
}

1

这是另一个示例:

function sortObject(obj) {
  var arr = [];
  var prop;
  for (prop in obj) {
    if (obj.hasOwnProperty(prop)) {
      arr.push({
        'key': prop,
        'value': obj[prop]
      });
    }
  }
  arr.sort(function(a, b) {
    return a.value - b.value;
  });
  return arr; // returns array
}
var list = {
  car: 300,
  bike: 60,
  motorbike: 200,
  airplane: 1000,
  helicopter: 400,
  rocket: 8 * 60 * 60
};
var arr = sortObject(list);
console.log(arr);


1
    var list = {
    "you": 100,
    "me": 75,
    "foo": 116,
    "bar": 15
};
var tmpList = {};
while (Object.keys(list).length) {
    var key = Object.keys(list).reduce((a, b) => list[a] > list[b] ? a : b);
    tmpList[key] = list[key];
    delete list[key];
}
list = tmpList;
console.log(list); // { foo: 116, you: 100, me: 75, bar: 15 }

1

打字稿

以下函数按值或值的属性对对象进行排序。如果您不使用TypeScript,则可以删除类型信息以将其转换为JavaScript。

/**
 * Represents an associative array of a same type.
 */
interface Dictionary<T> {
  [key: string]: T;
}

/**
 * Sorts an object (dictionary) by value or property of value and returns
 * the sorted result as a Map object to preserve the sort order.
 */
function sort<TValue>(
  obj: Dictionary<TValue>,
  valSelector: (val: TValue) => number | string,
) {
  const sortedEntries = Object.entries(obj)
    .sort((a, b) =>
      valSelector(a[1]) > valSelector(b[1]) ? 1 :
      valSelector(a[1]) < valSelector(b[1]) ? -1 : 0);
  return new Map(sortedEntries);
}

用法

var list = {
  "one": { height: 100, weight: 15 },
  "two": { height: 75, weight: 12 },
  "three": { height: 116, weight: 9 },
  "four": { height: 15, weight: 10 },
};

var sortedMap = sort(list, val => val.height);

不能保证JavaScript对象中键的顺序,因此我将结果排序并返回为Map保留排序顺序的对象。

如果要将其转换回Object,可以执行以下操作:

var sortedObj = {} as any;
sortedMap.forEach((v,k) => { sortedObj[k] = v });

1

输入是对象,输出是对象,使用lodash&js内置库,带有降序或升序选项,并且不会改变输入对象

例如输入和输出

{
  "a": 1,
  "b": 4,
  "c": 0,
  "d": 2
}
{
  "b": 4,
  "d": 2,
  "a": 1,
  "c": 0
}

实施

const _ = require('lodash');

const o = { a: 1, b: 4, c: 0, d: 2 };


function sortByValue(object, descending = true) {
  const { max, min } = Math;
  const selector = descending ? max : min;

  const objects = [];
  const cloned = _.clone(object);

  while (!_.isEmpty(cloned)) {
    const selectedValue = selector(...Object.values(cloned));
    const [key, value] = Object.entries(cloned).find(([, value]) => value === selectedValue);

    objects.push({ [key]: value });
    delete cloned[key];
  }

  return _.merge(...objects);
}

const o2 = sortByValue(o);
console.log(JSON.stringify(o2, null, 2));

1
const arrayOfObjects = [
{name: 'test'},
{name: 'test2'}
]

const order = ['test2', 'test']

const setOrder = (arrayOfObjects, order) =>
    arrayOfObjects.sort((a, b) => {
        if (order.findIndex((i) => i === a.name) < order.findIndex((i) => i === b.name)) {
            return -1;
        }

        if (order.findIndex((i) => i === a.name) > order.findIndex((i) => i === b.name)) {
            return 1;
        }

        return 0;
    });

1

我的解决方案:

let list = {
    "you": 100, 
    "me": 75, 
    "foo": 116, 
    "bar": 15
};

let sorted = Object.entries(list).sort((a,b) => a[1] - b[1]);

for(let element of sorted) {
    console.log(element[0]+ ": " + element[1]);
}

请将您的代码格式化为代码
Itamar Mushkin

1
<pre>
function sortObjectByVal(obj){  
var keysSorted = Object.keys(obj).sort(function(a,b){return obj[b]-obj[a]});
var newObj = {};
for(var x of keysSorted){
    newObj[x] = obj[x];
}
return newObj;

}
var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
console.log(sortObjectByVal(list));
</pre>

1
欢迎使用stackoverflow。除了您提供的答案外,请考虑简要说明为什么以及如何解决此问题。
jtate

0

解决此问题的另一种方法:

var res = [{"s1":5},{"s2":3},{"s3":8}].sort(function(obj1,obj2){ 
 var prop1;
 var prop2;
 for(prop in obj1) {
  prop1=prop;
 }
 for(prop in obj2) {
  prop2=prop;
 }
 //the above two for loops will iterate only once because we use it to find the key
 return obj1[prop1]-obj2[prop2];
});

// res将有结果数组


0

谢谢并继续回答@Nosredna

现在我们了解了需要将对象转换为数组然后对数组进行排序的知识。这对于按字符串对数组(或转换为数组的对象)进行排序很有用:

Object {6: Object, 7: Object, 8: Object, 9: Object, 10: Object, 11: Object, 12: Object}
   6: Object
   id: "6"
   name: "PhD"
   obe_service_type_id: "2"
   __proto__: Object
   7: Object
   id: "7"
   name: "BVC (BPTC)"
   obe_service_type_id: "2"
   __proto__: Object


    //Sort options
    var sortable = [];
    for (var vehicle in options)
    sortable.push([vehicle, options[vehicle]]);
    sortable.sort(function(a, b) {
        return a[1].name < b[1].name ? -1 : 1;
    });


    //sortable => prints  
[Array[2], Array[2], Array[2], Array[2], Array[2], Array[2], Array[2]]
    0: Array[2]
    0: "11"
    1: Object
        id: "11"
        name: "AS/A2"
        obe_service_type_id: "2"
        __proto__: Object
        length: 2
        __proto__: Array[0]
    1: Array[2]
    0: "7"
    1: Object
        id: "7"
        name: "BVC (BPTC)"
        obe_service_type_id: "2"
        __proto__: Object
        length: 2

0

尝试这个。即使您的对象不具有要基于其进行排序的属性,也将得到处理。

只需通过发送带有对象的属性来调用它。

var sortObjectByProperty = function(property,object){

    console.time("Sorting");
    var  sortedList      = [];
         emptyProperty   = [];
         tempObject      = [];
         nullProperty    = [];
    $.each(object,function(index,entry){
        if(entry.hasOwnProperty(property)){
            var propertyValue = entry[property];
            if(propertyValue!="" && propertyValue!=null){
              sortedList.push({key:propertyValue.toLowerCase().trim(),value:entry});  
            }else{
                emptyProperty.push(entry);
           }
        }else{
            nullProperty.push(entry);
        }
    });

      sortedList.sort(function(a,b){
           return a.key < b.key ? -1 : 1;
         //return a.key < b.key?-1:1;   // Asc 
         //return a.key < b.key?1:-1;  // Desc
      });


    $.each(sortedList,function(key,entry){
        tempObject[tempObject.length] = entry.value;
     });

    if(emptyProperty.length>0){
        tempObject.concat(emptyProperty);
    }
    if(nullProperty.length>0){
        tempObject.concat(nullProperty);
    }
    console.timeEnd("Sorting");
    return tempObject;
}
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.