按字符串属性值对对象数组进行排序

Tyrone Slothrop 2535 javascript arrays sorting

我有一个JavaScript对象数组:

var objs = [ 
    { first_nom: 'Lazslo', last_nom: 'Jamf'     },
    { first_nom: 'Pig',    last_nom: 'Bodine'   },
    { first_nom: 'Pirate', last_nom: 'Prentice' }
];

如何根据last_nomJavaScript中的值对它们进行排序?

我知道sort(a,b),但这似乎只适用于字符串和数字.我是否需要为toString()对象添加方法?

Wogan.. 3651

编写自己的比较函数很容易:

function compare( a, b ) {
  if ( a.last_nom < b.last_nom ){
    return -1;
  }
  if ( a.last_nom > b.last_nom ){
    return 1;
  }
  return 0;
}

objs.sort( compare );

或内联(c/o Marco Demaio):

objs.sort((a,b) => (a.last_nom > b.last_nom) ? 1 : ((b.last_nom > a.last_nom) ? -1 : 0)); 

  • 或者内联:objs.sort(function(a,b){return(a.last_nom> b.last_nom)?1:((b.last_nom> a.last_nom)? - 1:0);}); (404认同)
  • `return a.last_nom.localeCompare(b.last_nom)`也可以. (156认同)
  • 对于那些寻找字段为数字的排序的人来说,比较函数体:`return a.value - b.value;`(ASC) (138认同)
  • 官方文档:https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/sort (35认同)
  • @Cerbrus`localeCompare`在外语中使用重音字符时很重要,也更优雅. (15认同)
  • 我知道创建一个完整的比较函数是冗长的,但是人类会让逻辑更容易.谢谢. (2认同)

Ege Özcan.. 805

您还可以创建一个动态排序函数,按照您传递的值对对象进行排序:

function dynamicSort(property) {
    var sortOrder = 1;
    if(property[0] === "-") {
        sortOrder = -1;
        property = property.substr(1);
    }
    return function (a,b) {
        /* next line works with strings and numbers, 
         * and you may want to customize it to your needs
         */
        var result = (a[property] < b[property]) ? -1 : (a[property] > b[property]) ? 1 : 0;
        return result * sortOrder;
    }
}

所以你可以有一个这样的对象数组:

var People = [
    {Name: "Name", Surname: "Surname"},
    {Name:"AAA", Surname:"ZZZ"},
    {Name: "Name", Surname: "AAA"}
];

......当你这样做时它会起作用:

People.sort(dynamicSort("Name"));
People.sort(dynamicSort("Surname"));
People.sort(dynamicSort("-Surname"));

实际上这已经回答了这个问题.下面的部分是因为许多人联系我,抱怨它不适用于多个参数.

多个参数

您可以使用以下函数生成具有多个排序参数的排序函数.

function dynamicSortMultiple() {
    /*
     * save the arguments object as it will be overwritten
     * note that arguments object is an array-like object
     * consisting of the names of the properties to sort by
     */
    var props = arguments;
    return function (obj1, obj2) {
        var i = 0, result = 0, numberOfProperties = props.length;
        /* try getting a different result from 0 (equal)
         * as long as we have extra properties to compare
         */
        while(result === 0 && i < numberOfProperties) {
            result = dynamicSort(props[i])(obj1, obj2);
            i++;
        }
        return result;
    }
}

这将使您能够做到这样的事情:

People.sort(dynamicSortMultiple("Name", "-Surname"));

将它添加到原型

(下面的实现灵感来自Mike R回答)

我不建议更改本机对象原型,只是为了给出一个示例,以便您可以在自己的对象上实现它(对于支持它的环境,您也可以使用Object.defineProperty,如下一节所示,至少没有可枚举的负面副作用,如最后一部分所述)

原型实现将类似于以下(这是一个工作示例):

class MyArray extends Array {
    sortBy(...args) {
        return this.sort(dynamicSortMultiple.apply(null, args));
    }
}

将其添加到原型的"OK"方式

如果你的目标是IE v9.0,那么就像我之前提到的那样,使用像这样的Object.defineProperty(工作示例):

MyArray.from(People).sortBy("Name", "-Surname");

绑定运算符到达之前,这可以是可接受的折衷方案.

所有这些原型乐趣都可以实现:

function dynamicSort(property) {
    var sortOrder = 1;
    if(property[0] === "-") {
        sortOrder = -1;
        property = property.substr(1);
    }
    return function (a,b) {
        /* next line works with strings and numbers, 
         * and you may want to customize it to your needs
         */
        var result = (a[property] < b[property]) ? -1 : (a[property] > b[property]) ? 1 : 0;
        return result * sortOrder;
    }
}

你应该读这个

如果你使用直接原型访问方法(Object.defineProperty很好)而其他代码没有检查hasOwnProperty,小猫会死!好吧,老实说,任何小猫都没有受到伤害,但可能事情会破裂,团队中的其他开发人员都会讨厌你:

邪恶

看到最后一个"SortBy"?是啊.不酷.尽可能使用Object.defineProperty,否则单独保留Array.prototype.

  • @LloydBanks如果你严格使用这个字符串,那么你可以使用`var result = a [property] .localeCompare(b [property]);`而不是`var result =(a [property] <b [property]) ?-1:([属性]> b [属性])?1:0;`. (5认同)

Vlad Bezden.. 336

在ES6/ES2015或更高版本中,您可以这样做:

objs.sort((a, b) => a.last_nom.localeCompare(b.last_nom));

  • 这是自JS 1.1以来一直可用的,这个胖箭头是ES6/2015的一块.但在我看来仍然非常有用,也是最好的答案 (26认同)
  • @PratikKelwalkar:如果你需要反向它只需切换a和b比较:objs.sort((a,b)=> b.last_nom.localeCompare(a.last_nom)); (12认同)
  • @VladBezden感谢您的回答!这个解决方案是第一个具有非常小的编程工作和正确的排序结果和一个字符串数组,如:["Name1","Name10","Name2","其他东西","Name11"].我使用`objs.sort((a,b)=> a.last_nom.localeCompare(b.last_nom,undefined,{numberic:true}))进行排序正常工作; (4认同)

David Morrow.. 185

underscore.js

使用下划线,它小而且很棒......

sortBy_.sortBy(list,iterator,[context])返回列表的排序副本,按照通过迭代器运行每个值的结果按升序排列.迭代器也可以是要排序的属性的字符串名称(例如,长度).

var objs = [ 
  { first_nom: 'Lazslo',last_nom: 'Jamf' },
  { first_nom: 'Pig', last_nom: 'Bodine'  },
  { first_nom: 'Pirate', last_nom: 'Prentice' }
];

var sortedObjs = _.sortBy( objs, 'first_nom' );

  • 大卫,你能编辑答案说,`var sortedObjs = _.sortBy(objs,'first_nom');`.由于这个原因,'objs`将不会被自己排序.该函数将**返回**一个已排序的数组.这会使它更明确. (18认同)
  • 反向排序:`var reverseSortedObjs = _.sortBy(objs,'first_nom').reverse();` (10认同)
  • 也可以在[`Lodash`](https://lodash.com/docs/4.17.5#sortBy)中找到喜欢那个的人 (5认同)
  • 您需要加载javascript库“ underscore”:`&lt;script src =“ http://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.8.3/underscore-min.js”&gt; &lt;/ script&gt; ` (2认同)

p3lim.. 175

不要理解为什么人们会这么复杂:

objs.sort(function(a, b){
  return a.last_nom > b.last_nom;
});

对于更严格的引擎:

objs.sort(function(a, b){
  return a.last_nom == b.last_nom ? 0 : +(a.last_nom > b.last_nom) || -1;
});

交换运算符以按反向字母顺序排序.

  • 我建议编辑以取出第一个版本.它更简洁,所以看起来更有吸引力,但它不起作用,至少不可靠.如果有人在一个浏览器中尝试它并且它可以工作,他们可能甚至没有意识到他们有问题(特别是如果他们没有阅读评论).第二个版本正常工作,所以第一个版本确实没有必要. (19认同)
  • 这实际上是不正确的,因为sort中使用的函数应该返回-1,0或1,但上面的函数返回一个布尔值.排序在chrome中运行良好,但在PhantomJS中失败.请参阅https://code.google.com/p/phantomjs/issues/detail?id=1090 (16认同)
  • @Simon我真的很感激首先使用"略有错误"的版本,因为更严格的实现需要几秒钟来解析和理解,没有它会更难. (2认同)

kennebec.. 61

如果你有重复的姓氏,你可以按名字排序 -

obj.sort(function(a,b){
  if(a.last_nom< b.last_nom) return -1;
  if(a.last_nom >b.last_nom) return 1;
  if(a.first_nom< b.first_nom) return -1;
  if(a.first_nom >b.first_nom) return 1;
  return 0;
});

  • 那个`a <b``a> b`格式很有趣. (43认同)

Vinay Aggarw.. 45

使用原型继承简单快速地解决此问题:

Array.prototype.sortBy = function(p) {
  return this.slice(0).sort(function(a,b) {
    return (a[p] > b[p]) ? 1 : (a[p] < b[p]) ? -1 : 0;
  });
}

示例/用法

objs = [{age:44,name:'vinay'},{age:24,name:'deepak'},{age:74,name:'suresh'}];

objs.sortBy('age');
// Returns
// [{"age":24,"name":"deepak"},{"age":44,"name":"vinay"},{"age":74,"name":"suresh"}]

objs.sortBy('name');
// Returns
// [{"age":24,"name":"deepak"},{"age":74,"name":"suresh"},{"age":44,"name":"vinay"}]

更新:不再修改原始数组.

  • 它不仅仅是返回另一个数组.但实际上对原来的那个进行了分类! (5认同)
  • 从来没有建议过修改核心对象原型的解决方案 (3认同)

0leg.. 34

截至2018年,有一个更短,更优雅的解决方案.只是用.Array.prototype.sort().

例:

var items = [
  { name: 'Edward', value: 21 },
  { name: 'Sharpe', value: 37 },
  { name: 'And', value: 45 },
  { name: 'The', value: -12 },
  { name: 'Magnetic', value: 13 },
  { name: 'Zeros', value: 37 }
];

// sort by value
items.sort(function (a, b) {
  return a.value - b.value;
});

  • 在问题中,字符串用于比较而不是数字.您的答案非常适合按数字排序,但不太适合按字符串进行比较. (6认同)

Christoph.. 29

您也可以使用自定义toString()方法(由默认比较函数调用)创建对象类型,而不是使用自定义比较函数:

function Person(firstName, lastName) {
    this.firtName = firstName;
    this.lastName = lastName;
}

Person.prototype.toString = function() {
    return this.lastName + ', ' + this.firstName;
}

var persons = [ new Person('Lazslo', 'Jamf'), ...]
persons.sort();


Harshal.. 26

您可以使用

最简单的方法:Lodash

(https://lodash.com/docs/4.17.10#orderBy)

此方法类似于_.sortBy,但它允许指定迭代的排序顺序以进行排序.如果未指定订单,则所有值都按升序排序.否则,为降序指定"desc"的顺序,或为相应值的升序排序指定"asc".

参数

collection(Array | Object):要迭代的集合.[iteratees = [_.identity]](Array [] | Function [] | Object [] | string []):迭代次数排序依据.[orders](string []):迭代的排序顺序.

返回

(Array):返回新排序的数组.


var _ = require('lodash');
var homes = [
    {"h_id":"3",
     "city":"Dallas",
     "state":"TX",
     "zip":"75201",
     "price":"162500"},
    {"h_id":"4",
     "city":"Bevery Hills",
     "state":"CA",
     "zip":"90210",
     "price":"319250"},
    {"h_id":"6",
     "city":"Dallas",
     "state":"TX",
     "zip":"75000",
     "price":"556699"},
    {"h_id":"5",
     "city":"New York",
     "state":"NY",
     "zip":"00010",
     "price":"962500"}
    ];

_.orderBy(homes, ['city', 'state', 'zip'], ['asc', 'desc', 'asc']);


Nico Van Bel.. 23

Lodash.js(超集Underscore.js)

最好不要为每一个简单的逻辑片段添加一个框架,但依靠经过良好测试的实用程序框架,加快开发速度并减少写入的错误数量并不是一件容易的事.

Lodash生成非常干净的代码并提升了更多功能的编程风格,从而减少了错误.在一瞥中,很明显代码的意图是什么.

OP的问题可以简单地解决为:

const sortedObjs = _.sortBy(objs, 'last_nom');

更多信息?例如,我们有以下嵌套对象:

const users = [
  { 'user': {'name':'fred', 'age': 48}},
  { 'user': {'name':'barney', 'age': 36 }},
  { 'user': {'name':'wilma'}},
  { 'user': {'name':'betty', 'age': 32}}
];

我们现在可以使用_.property简写user.age来指定应匹配的属性的路径.我们将通过嵌套的age属性对用户对象进行排序.是的,它允许嵌套属性匹配!

const sortedObjs = _.sortBy(users, ['user.age']);

想要扭转吗?没问题.使用_.reverse.

const sortedObjs = _.reverse(_.sortBy(users, ['user.age']));

想要使用Chaining来结合两者吗?

const sortedObjs = _.chain(users).sortBy('user.age').reverse().value();


Tero Tolonen.. 22

这里有很多好的答案,但我想指出,它们可以非常简单地扩展,以实现更复杂的排序.您唯一要做的就是使用OR运算符链接比较函数,如下所示:

objs.sort((a,b)=> fn1(a,b) || fn2(a,b) || fn3(a,b) )

其中fn1,, fn2...是返回[-1,0,1]的排序函数.这导致"按fn1排序","按fn2排序",这几乎等于SQL中的ORDER BY.

此解决方案基于||运算符的行为,该行为计算为可转换为true第一个计算表达式.

最简单的形式只有一个内联函数,如下所示:

// ORDER BY last_nom
objs.sort((a,b)=> a.last_nom.localeCompare(b.last_nom) )

有两个步骤 last_nom,first_nom排序顺序将如下所示:

// ORDER_BY last_nom, first_nom
objs.sort((a,b)=> a.last_nom.localeCompare(b.last_nom) || 
                  a.first_nom.localeCompare(b.first_nom)  )

通用的比较函数可能是这样的:

// ORDER BY <n>
let cmp = (a,b,n)=>a[n].localeCompare(b[n])

此函数可以扩展为支持数字字段,大小写敏感,任意数据类型等.

您可以通过排序优先级链接它们来使用它:

// ORDER_BY last_nom, first_nom
objs.sort((a,b)=> cmp(a,b, "last_nom") || cmp(a,b, "first_nom") )
// ORDER_BY last_nom, first_nom DESC
objs.sort((a,b)=> cmp(a,b, "last_nom") || -cmp(a,b, "first_nom") )
// ORDER_BY last_nom DESC, first_nom DESC
objs.sort((a,b)=> -cmp(a,b, "last_nom") || -cmp(a,b, "first_nom") )

这里的要点是具有功能方法的纯JavaScript可以在没有外部库或复杂代码的情况下走很长的路.它也非常有效,因为不必进行字符串解析


Jamie Mason.. 21

用法示例:

objs.sort(sortBy('last_nom'));

脚本:

/**
 * @description
 * Returns a function which will sort an
 * array of objects by the given key.
 *
 * @param  {String}  key
 * @param  {Boolean} reverse
 * @return {Function}
 */
const sortBy = (key, reverse) => {

  // Move smaller items towards the front
  // or back of the array depending on if
  // we want to sort the array in reverse
  // order or not.
  const moveSmaller = reverse ? 1 : -1;

  // Move larger items towards the front
  // or back of the array depending on if
  // we want to sort the array in reverse
  // order or not.
  const moveLarger = reverse ? -1 : 1;

  /**
   * @param  {*} a
   * @param  {*} b
   * @return {Number}
   */
  return (a, b) => {
    if (a[key] < b[key]) {
      return moveSmaller;
    }
    if (a[key] > b[key]) {
      return moveLarger;
    }
    return 0;
  };
};


Patrick Robe.. 19

我没有看到这种特殊方法的建议,所以这里是一个简洁的比较方法我喜欢使用它适用于stringnumber:

const objs = [ 
  { first_nom: 'Lazslo', last_nom: 'Jamf'     },
  { first_nom: 'Pig',    last_nom: 'Bodine'   },
  { first_nom: 'Pirate', last_nom: 'Prentice' }
];

const sortBy = fn => (a, b) => {
  const fa = fn(a)
  const fb = fn(b)
  return -(fa < fb) || +(fa > fb)
}
const getLastName = o => o.last_nom
const sortByLastName = sortBy(getLastName)

objs.sort(sortByLastName)
console.log(objs.map(getLastName))

以下是对以下内容的解释sortBy():

sortBy()接受一个fn从对象中选择要用作比较的值,并返回一个可以直接传递给的函数Array.prototype.sort().在这个例子中,我们将使用o.last_nom作为比较的值,因此每当我们通过Array.prototype.sort()诸如此类接收两个对象时

{ first_nom: 'Lazslo', last_nom: 'Jamf' }

{ first_nom: 'Pig', last_nom: 'Bodine' }

我们用

(a, b) => {
  const fa = fn(a)
  const fb = fn(b)
  return -(fa < fb) || +(fa > fb)
}

比较它们.

记住这一点fn = o => o.last_nom,我们可以将比较功能扩展到等效功能

(a, b) => {
  const fa = a.last_nom
  const fb = b.last_nom
  return -(fa < fb) || +(fa > fb)
}

逻辑OR ||运算符具有短路功能,这在此非常有用.由于它的工作原理,上述功能的主体意味着

if (fa < fb) return -1
return +(fa > fb)

所以,如果fa < fb我们返回-1,否则如果fa > fb那时我们返回+1,但如果fa == fb,那么fa < fb并且fa > fb是假的,所以它返回false.

作为一个额外的奖励,这里是没有箭头功能的ECMAScript 5.1中的等价物,遗憾的是它并不那么简洁:

var objs = [ 
  { first_nom: 'Lazslo', last_nom: 'Jamf'     },
  { first_nom: 'Pig',    last_nom: 'Bodine'   },
  { first_nom: 'Pirate', last_nom: 'Prentice' }
];

var sortBy = function (fn) {
  return function (a, b) {
    var fa = fn(a)
    var fb = fn(b)
    return -(fa < fb) || +(fa > fb)
  }
}

var getLastName = function (o) { return o.last_nom }
var sortByLastName = sortBy(getLastName)

objs.sort(sortByLastName)
console.log(objs.map(getLastName))


Damjan Pavli.. 18

我有一段适合我的代码:

arr.sort((a, b) => a.name > b.name)

更新:不工作总是,所以它是不正确的:(

  • 这应该这样做:`arr.sort((a,b)=> a.name <b.name?-1:(a.name> b.name?1:0))` (10认同)

a8m.. 15

我知道这个问题太旧了,但我没有看到任何类似于我的实现.
此版本基于Schwartzian变换习语.

function sortByAttribute(array, ...attrs) {
  // generate an array of predicate-objects contains
  // property getter, and descending indicator
  let predicates = attrs.map(pred => {
    let descending = pred.charAt(0) === '-' ? -1 : 1;
    pred = pred.replace(/^-/, '');
    return {
      getter: o => o[pred],
      descend: descending
    };
  });
  // schwartzian transform idiom implementation. aka: "decorate-sort-undecorate"
  return array.map(item => {
    return {
      src: item,
      compareValues: predicates.map(predicate => predicate.getter(item))
    };
  })
  .sort((o1, o2) => {
    let i = -1, result = 0;
    while (++i < predicates.length) {
      if (o1.compareValues[i] < o2.compareValues[i]) result = -1;
      if (o1.compareValues[i] > o2.compareValues[i]) result = 1;
      if (result *= predicates[i].descend) break;
    }
    return result;
  })
  .map(item => item.src);
}

以下是如何使用它的示例:

let games = [
  { name: 'Pako',              rating: 4.21 },
  { name: 'Hill Climb Racing', rating: 3.88 },
  { name: 'Angry Birds Space', rating: 3.88 },
  { name: 'Badland',           rating: 4.33 }
];

// sort by one attribute
console.log(sortByAttribute(games, 'name'));
// sort by mupltiple attributes
console.log(sortByAttribute(games, '-rating', 'name'));


eljefedelrod.. 14

排序(更多)复杂的对象数组

由于您可能会遇到更复杂的数据结构,例如此数组,我会扩展解决方案.

TL; DR

更可插拔的版本基于@ ege-Özcan的非常可爱的答案.

问题

我遇到了下面的内容,无法改变它.我也不想暂时压扁物体.我也不想使用下划线/ lodash,主要是出于性能原因以及自己实现它的乐趣.

var People = [
   {Name: {name: "Name", surname: "Surname"}, Middlename: "JJ"},
   {Name: {name: "AAA", surname: "ZZZ"}, Middlename:"Abrams"},
   {Name: {name: "Name", surname: "AAA"}, Middlename: "Wars"}
];

目标

我们的目标是主要通过对它进行排序People.Name.name,其次通过People.Name.surname

障碍

现在,在基本解决方案中使用括号表示法来计算要动态排序的属性.但是,在这里,我们还必须动态构造括号表示法,因为你会期望一些像People['Name.name']工作一样 - 但事实并非如此.

People['Name']['name']另一方面,简单地说,它是静态的,只允许你下降到第n级.

这里的主要补充是走下对象树并确定最后一个叶子的值,你必须指定,以及任何中间叶子.

var People = [
   {Name: {name: "Name", surname: "Surname"}, Middlename: "JJ"},
   {Name: {name: "AAA", surname: "ZZZ"}, Middlename:"Abrams"},
   {Name: {name: "Name", surname: "AAA"}, Middlename: "Wars"}
];

People.sort(dynamicMultiSort(['Name','name'], ['Name', '-surname']));
// Results in...
// [ { Name: { name: 'AAA', surname: 'ZZZ' }, Middlename: 'Abrams' },
//   { Name: { name: 'Name', surname: 'Surname' }, Middlename: 'JJ' },
//   { Name: { name: 'Name', surname: 'AAA' }, Middlename: 'Wars' } ]

// same logic as above, but strong deviation for dynamic properties 
function dynamicSort(properties) {
  var sortOrder = 1;
  // determine sort order by checking sign of last element of array
  if(properties[properties.length - 1][0] === "-") {
    sortOrder = -1;
    // Chop off sign
    properties[properties.length - 1] = properties[properties.length - 1].substr(1);
  }
  return function (a,b) {
    propertyOfA = recurseObjProp(a, properties)
    propertyOfB = recurseObjProp(b, properties)
    var result = (propertyOfA < propertyOfB) ? -1 : (propertyOfA > propertyOfB) ? 1 : 0;
    return result * sortOrder;
  };
}

/**
 * Takes an object and recurses down the tree to a target leaf and returns it value
 * @param  {Object} root - Object to be traversed.
 * @param  {Array} leafs - Array of downwards traversal. To access the value: {parent:{ child: 'value'}} -> ['parent','child']
 * @param  {Number} index - Must not be set, since it is implicit.
 * @return {String|Number}       The property, which is to be compared by sort.
 */
function recurseObjProp(root, leafs, index) {
  index ? index : index = 0
  var upper = root
  // walk down one level
  lower = upper[leafs[index]]
  // Check if last leaf has been hit by having gone one step too far.
  // If so, return result from last step.
  if (!lower) {
    return upper
  }
  // Else: recurse!
  index++
  // HINT: Bug was here, for not explicitly returning function
  // /sf/ask/17360801/
  return recurseObjProp(lower, leafs, index)
}

/**
 * Multi-sort your array by a set of properties
 * @param {...Array} Arrays to access values in the form of: {parent:{ child: 'value'}} -> ['parent','child']
 * @return {Number} Number - number for sort algorithm
 */
function dynamicMultiSort() {
  var args = Array.prototype.slice.call(arguments); // slight deviation to base

  return function (a, b) {
    var i = 0, result = 0, numberOfProperties = args.length;
    // REVIEW: slightly verbose; maybe no way around because of `.sort`-'s nature
    // Consider: `.forEach()`
    while(result === 0 && i < numberOfProperties) {
      result = dynamicSort(args[i])(a, b);
      i++;
    }
    return result;
  }
}

关于JSBin的工作示例

  • 为什么?这不是原始问题的答案,"目标"可以通过People.sort简单解决((a,b)=> {return a.Name.name.localeCompare(b.Name.name)|| a.Name .surname.localeCompare(b.Name.surname)}) (2认同)

Ravshan Sama.. 11

还有一个选择:

var someArray = [...];

function generateSortFn(prop, reverse) {
    return function (a, b) {
        if (a[prop] < b[prop]) return reverse ? 1 : -1;
        if (a[prop] > b[prop]) return reverse ? -1 : 1;
        return 0;
    };
}

someArray.sort(generateSortFn('name', true));

默认情况下按升序排序.


Caio Ladisla.. 10

一个简单的方法:

objs.sort(function(a,b) {
  return b.last_nom.toLowerCase() < a.last_nom.toLowerCase();
});

看到'.toLowerCase()'在比较字符串时防止错误是必要的.

  • 您可以使用[箭头功能](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions)让代码更优雅:`objs.sort((a ,b)=> b.last_nom.toLowerCase()<a.last_nom.toLowerCase());` (4认同)
  • 箭头功能不是ES5值得的.大量的发动机仍然限于ES5.在我的情况下,我发现上面的答案显着更好,因为我在ES5引擎上(由我的公司强制) (2认同)

小智.. 9

EgeÖzcan代码的附加desc参数

function dynamicSort(property, desc) {
    if (desc) {
        return function (a, b) {
            return (a[property] > b[property]) ? -1 : (a[property] < b[property]) ? 1 : 0;
        }   
    }
    return function (a, b) {
        return (a[property] < b[property]) ? -1 : (a[property] > b[property]) ? 1 : 0;
    }
}


小智.. 9

将Ege的动态解决方案与Vinay的想法相结合,您将获得一个非常强大的解决方案:

Array.prototype.sortBy = function() {
    function _sortByAttr(attr) {
        var sortOrder = 1;
        if (attr[0] == "-") {
            sortOrder = -1;
            attr = attr.substr(1);
        }
        return function(a, b) {
            var result = (a[attr] < b[attr]) ? -1 : (a[attr] > b[attr]) ? 1 : 0;
            return result * sortOrder;
        }
    }
    function _getSortFunc() {
        if (arguments.length == 0) {
            throw "Zero length arguments not allowed for Array.sortBy()";
        }
        var args = arguments;
        return function(a, b) {
            for (var result = 0, i = 0; result == 0 && i < args.length; i++) {
                result = _sortByAttr(args[i])(a, b);
            }
            return result;
        }
    }
    return this.sort(_getSortFunc.apply(null, arguments));
}

用法:

// Utility for printing objects
Array.prototype.print = function(title) {
    console.log("************************************************************************");
    console.log("**** "+title);
    console.log("************************************************************************");
    for (var i = 0; i < this.length; i++) {
        console.log("Name: "+this[i].FirstName, this[i].LastName, "Age: "+this[i].Age);
    }
}

// Setup sample data
var arrObj = [
    {FirstName: "Zach", LastName: "Emergency", Age: 35},
    {FirstName: "Nancy", LastName: "Nurse", Age: 27},
    {FirstName: "Ethel", LastName: "Emergency", Age: 42},
    {FirstName: "Nina", LastName: "Nurse", Age: 48},
    {FirstName: "Anthony", LastName: "Emergency", Age: 44},
    {FirstName: "Nina", LastName: "Nurse", Age: 32},
    {FirstName: "Ed", LastName: "Emergency", Age: 28},
    {FirstName: "Peter", LastName: "Physician", Age: 58},
    {FirstName: "Al", LastName: "Emergency", Age: 51},
    {FirstName: "Ruth", LastName: "Registration", Age: 62},
    {FirstName: "Ed", LastName: "Emergency", Age: 38},
    {FirstName: "Tammy", LastName: "Triage", Age: 29},
    {FirstName: "Alan", LastName: "Emergency", Age: 60},
    {FirstName: "Nina", LastName: "Nurse", Age: 54}
];

//Unit Tests
arrObj.sortBy("LastName").print("LastName Ascending");
arrObj.sortBy("-LastName").print("LastName Descending");
arrObj.sortBy("LastName", "FirstName", "-Age").print("LastName Ascending, FirstName Ascending, Age Descending");
arrObj.sortBy("-FirstName", "Age").print("FirstName Descending, Age Ascending");
arrObj.sortBy("-Age").print("Age Descending");


Francois Gir.. 9

一个简单的函数,用于按属性对对象数组进行排序

function sortArray(array, property, direction) {
    direction = direction || 1;
    array.sort(function compare(a, b) {
        let comparison = 0;
        if (a[property] > b[property]) {
            comparison = 1 * direction;
        } else if (a[property] < b[property]) {
            comparison = -1 * direction;
        }
        return comparison;
    });
    return array; // Chainable
}

用法:

var objs = [ 
    { first_nom: 'Lazslo', last_nom: 'Jamf'     },
    { first_nom: 'Pig',    last_nom: 'Bodine'   },
    { first_nom: 'Pirate', last_nom: 'Prentice' }
];

sortArray(objs, "last_nom"); // Asc
sortArray(objs, "last_nom", -1); // Desc


agershun.. 8

根据您的示例,您需要按两个字段(姓氏,名字)排序,而不是一个.您可以使用Alasql库在一行中进行此排序:

var res = alasql('SELECT * FROM ? ORDER BY last_nom, first_nom',[objs]);

在jsFiddle上试试这个例子.


小智.. 8

objs.sort(function(a,b){return b.last_nom>a.last_nom})


小智.. 7

您可能需要将它们转换为小写以防止混淆.

objs.sort(function (a,b) {

var nameA=a.last_nom.toLowerCase(), nameB=b.last_nom.toLowerCase()

if (nameA < nameB)
  return -1;
if (nameA > nameB)
  return 1;
return 0;  //no sorting

})


Evgenii.. 7

function compare(propName) {
    return function(a,b) {
        if (a[propName] < b[propName])
            return -1;
        if (a[propName] > b[propName])
            return 1;
        return 0;
    };
}

objs.sort(compare("last_nom"));


Bob Stein.. 7

鉴于原始示例:

var objs = [ 
    { first_nom: 'Lazslo', last_nom: 'Jamf'     },
    { first_nom: 'Pig',    last_nom: 'Bodine'   },
    { first_nom: 'Pirate', last_nom: 'Prentice' }
];

按多个字段排序:

objs.sort(function(left, right) {
    var last_nom_order = left.last_nom.localeCompare(right.last_nom);
    var first_nom_order = left.first_nom.localeCompare(right.first_nom);
    return last_nom_order || first_nom_order;
});

笔记

  • a.localeCompare(b)普遍支持,并返回1,0,1如果a<b,a==b,a>b分别.
  • ||在最后一行last_nom优先于first_nom.
  • 减法适用于数字字段: var age_order = left.age - right.age;
  • 否定逆序, return -last_nom_order || -first_nom_order || -age_order;


Gil Epshtain.. 6

这是一个简单的问题,不知道为什么人们有这么复杂的解决方案.
一个简单的排序函数(基于快速排序算法):

function sortObjectsArray(objectsArray, sortKey)
        {
            // Quick Sort:
            var retVal;

            if (1 < objectsArray.length)
            {
                var pivotIndex = Math.floor((objectsArray.length - 1) / 2);  // middle index
                var pivotItem = objectsArray[pivotIndex];                    // value in the middle index
                var less = [], more = [];

                objectsArray.splice(pivotIndex, 1);                          // remove the item in the pivot position
                objectsArray.forEach(function(value, index, array)
                {
                    value[sortKey] <= pivotItem[sortKey] ?                   // compare the 'sortKey' proiperty
                        less.push(value) :
                        more.push(value) ;
                });

                retVal = sortObjectsArray(less, sortKey).concat([pivotItem], sortObjectsArray(more, sortKey));
            }
            else
            {
                retVal = objectsArray;
            }

            return retVal;
        }

使用示例:

var myArr = 
        [
            { val: 'x', idx: 3 },
            { val: 'y', idx: 2 },
            { val: 'z', idx: 5 },
        ];
myArr = sortObjectsArray(myArr, 'idx');

  • 如何在js中实现快速排序是一个简单的解决方案?简单算法但不是简单的解决方案. (5认同)
  • 好吧,让我尝试不同的话:如何重新发明轮子是一个简单的解决方案? (2认同)

小智.. 6

使用Ramda,

npm install ramda

import R from 'ramda'
var objs = [ 
    { first_nom: 'Lazslo', last_nom: 'Jamf'     },
    { first_nom: 'Pig',    last_nom: 'Bodine'   },
    { first_nom: 'Pirate', last_nom: 'Prentice' }
];
var ascendingSortedObjs = R.sortBy(R.prop('last_nom'), objs)
var descendingSortedObjs = R.reverse(ascendingSortedObjs)


Morteza Tour.. 5

我只是增强了EgeÖzcan的动态排序能力,以深入研究内部物体。如果数据如下所示:

obj = [
    {
        a: { a: 1, b: 2, c: 3 },
        b: { a: 4, b: 5, c: 6 }
    },
    { 
        a: { a: 3, b: 2, c: 1 },
        b: { a: 6, b: 5, c: 4 }
}];

如果您想对某个物业进行排序,我认为我的增强功能会非常有帮助。我向这样的对象添加新功能:

Object.defineProperty(Object.prototype, 'deepVal', {
    enumerable: false,
    writable: true,
    value: function (propertyChain) {
        var levels = propertyChain.split('.');
        parent = this;
        for (var i = 0; i < levels.length; i++) {
            if (!parent[levels[i]])
                return undefined;
            parent = parent[levels[i]];
        }
        return parent;
    }
});

并更改了_dynamicSort返回函数:

return function (a,b) {
        var result = ((a.deepVal(property) > b.deepVal(property)) - (a.deepVal(property) < b.deepVal(property)));
        return result * sortOrder;
    }

现在你可以通过排序AA是这样的:

obj.sortBy('a.a');

见Commplete脚本的jsfiddle


Harunur Rash.. 5

方式1:

您可以使用Underscore.js。首先导入下划线。

 import * as _ from 'underscore';
 let SortedObjs = _.sortBy(objs, 'last_nom');

方法2:使用比较功能。

function compare(first, second) {
     if (first.last_nom < second.last_nom)
         return -1;
     if (first.last_nom > second.last_nom)
       return 1;
    return 0;
 }

objs.sort(compare);


归档时间:

查看次数:

1365128 次

最近记录:

10 月,1 周 前