Objektų masyvo rūšiavimas pagal eilutės savybės vertę

Turiu „JavaScript“ objektų masyvą:

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

Kaip galiu rūšiuoti juos pagal last_nom vertę javascript'e?

Žinau apie sort(a,b) , bet tai atrodo tik stringais ir skaičiais. Ar turiu objektams pridėti metodą „ toString() ?

1948 m
15 июля '09 в 6:17 2009-07-15 06:17 Tyrone Slothrop paklausė liepos 15 d., 06:17, 2009-07-15 06:17
@ 39 atsakymų
  • 1
  • 2

Paprasta parašyti savo palyginimo funkciją:

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

Arba inline (c / o Marco Demaio):

 objs.sort((a,b) => (a.last_nom > b.last_nom) ? 1 : ((b.last_nom > a.last_nom) ? -1 : 0)); 
2875
15 июля '09 в 6:35 2009-07-15 06:35 atsakymą pateikė Woganas liepos 15 d., 09:35, 2009-07-15 06:35

Taip pat galite sukurti dinaminę rūšiavimo funkciją, kuri rūšiuoja objektus pagal jų vertę, kurią perduodate:

 function dynamicSort(property) { var sortOrder = 1; if(property[0] === "-") { sortOrder = -1; property = property.substr(1); } return function (a,b) { var result = (a[property] < b[property]) ? -1 : (a[property] > b[property]) ? 1 : 0; return result * sortOrder; } } 

Taigi, galite turėti tokių objektų masyvą:

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

... ir tai veiks, kai tai padarysite:

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

Tiesą sakant, jis jau atsako į klausimą. Žemiau pateikta dalis parašyta, nes daug žmonių susisiekė su manimi ir skundėsi, kad jis neveikia su keliais parametrais .

Keletas parametrų

Toliau pateiktą funkciją galite naudoti, kad sukurtumėte rūšiavimo funkcijas su keliomis rūšiavimo parinktimis.

 function dynamicSortMultiple() {  var props = arguments; return function (obj1, obj2) { var i = 0, result = 0, numberOfProperties = props.length;  while(result === 0  i < numberOfProperties) { result = dynamicSort(props[i])(obj1, obj2); i++; } return result; } } 

Kuris leis jums tai padaryti:

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

Pridėta prie prototipo

(Vos žemiau pateiktas įgyvendinimas įkvėptas Mike R atsakymo )

Nerekomenduočiau keisti jūsų paties objekto prototipo, bet tiesiog pateikite pavyzdį, kad galėtumėte jį įgyvendinti savo objektuose . Aplinkoms , kurios ją palaiko, taip pat galite naudoti Object.defineProperty , kaip parodyta kitame skyriuje, kuris bent jau neturi neigiamo skaičiavimo šalutinio poveikio, kaip aprašyta paskutinėje dalyje.

Prototipo įgyvendinimas atrodys panašus ( čia yra darbo pavyzdys ):

 //Don't just copy-paste this code. You will break the "for-in" loops !function() { function _dynamicSortMultiple(attr) {  } function _dynamicSort(property) {  } Array.prototype.sortBy = function() { return this.sort(_dynamicSortMultiple.apply(null, arguments)); } }(); 

„Gerai“, kaip pridėti jį prie prototipo

Jei nukreipiate į „IE v9.0“ ir naujesnę versiją, tada, kaip jau minėjau, naudokite „ Object.defineProperty“ ( darbo pavyzdys ):

 //Won't work below IE9, but totally safe otherwise !function() { function _dynamicSortMultiple(attr) {  } function _dynamicSort(property) {  } Object.defineProperty(Array.prototype, "sortBy", { enumerable: false, writable: true, value: function() { return this.sort(_dynamicSortMultiple.apply(null, arguments)); } }); }(); 

Tai gali būti priimtinas kompromisas, kol pasirodys privalomas pareiškimas .

Visi šie prototipai leidžia:

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

Turėtumėte tai perskaityti

Jei naudojate tiesioginės prieigos prototipo metodą (Object.defineProperty yra gerai), o kitas kodas nekontroliuoja hasOwnProperty , kačiukai miršta! Na, kad būtų sąžiningas, jokios žalos kačiukui nepadaroma, bet tikriausiai kažkas sulaužys ir visi kiti jūsų komandos kūrėjai nekenks tavęs:

2019

674
21 янв. atsakymą pateikė Ege Özcan 21 Jan. 2011-01-21 18:03 '11, 18:03, 2011-01-21 18:03

underscore.js

naudoti pabraukimą, mažus ir nuostabius ...

sortBy_.sortBy (sąrašas, iteratorius, [kontekstas]) Grąžina suskirstytą sąrašo kopiją, reitingą didėjančia tvarka pagal kiekvieno iteratoriaus vertę. Iteratorius taip pat gali būti nuosavybės eilutės pavadinimas, pagal kurį galima rūšiuoti (pvz., Ilgis).

 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' ); 
162
11 мая '12 в 0:24 2012-05-11 00:24 Atsakymą davė Davidas Morrow gegužės 12 d., 12 val. 0:24 2012-05-11 00:24

ES6 / ES2015 arba naujesnėje versijoje galite tai padaryti:

 objs.sort((a, b) => a.last_nom.localeCompare(b.last_nom)); 
159
29 янв. Atsakymą pateikė Vladas Bezdenas sausio 29 d. 2016-01-29 22:44 '16 at 22:44 pm 2016-01-29 22:44

Nesupraskite, kodėl žmonės taip sudėtingi:

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

Dėl griežtesnių variklių:

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

Išversti operatorių taip, kad jis būtų surūšiuotas pagal atvirkštinę abėcėlę.

146
24 янв. atsakymas pateikiamas p3lim 24 sausis 2014-01-24 22:35 '14, 10:35 pm 2014-01-24 22:35

Jei turite pasikartojančių pavardžių, galite juos rūšiuoti pagal vardą -

 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; }); 
52
15 июля '09 в 7:03 2009-07-15 07:03 atsakymas pateikiamas kennebec liepos 15 d., 09:03, 2009-07-15 07:03

Paprastas ir greitas šios problemos sprendimas yra naudojant prototipo paveldėjimą:

 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"}] 

Atnaujinimas: nebesikeičia šaltinio masyvas.

37
10 июля '12 в 14:54 2012-07-10 14:54 atsakymą pateikė „ Vinay Aggarwal“ liepos 12 d. 12:54 val. 2012-07-10 14:54

Užuot naudoję pasirinktinį palyginimo funkciją, galite sukurti objekto tipą, naudodami pasirinktinį „ toString() metodą (kuris vadinamas numatytuoju palyginimo funkcija):

 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(); 
24
15 июля '09 в 10:21 2009-07-15 10:21 Christofo atsakymas liepos 15 d., 09:21, 2009-07-15 10:21

Lodash.js (superset Underscore.js )

Gerai ne įtraukti rėmelių kiekvienai paprastai logikos daliai, bet pasikliauti gerai išbandytomis naudingumo aplinkomis, greičio plėtra ir sumažintų rašytinių klaidų skaičius nėra gaila.

„Lodash“ gamina labai švarų kodą ir prisideda prie funkcionalesnio programavimo stiliaus, todėl atsiranda mažiau klaidų. Iš pirmo žvilgsnio tampa aišku, koks yra ketinimas, jei kodas.

OP problemą galima išspręsti kaip:

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

Daugiau informacijos? Pavyzdžiui, mes turime tokį įterptąjį objektą:

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

Dabar galime naudoti sutrumpintą user.age kad nurodytume kelią į turtą, kuris turi būti nuoseklus. Mes suskirstysime naudotojo objektus pagal įdėto amžiaus. Taip, tai leidžia suderinti įdėtas savybes!

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

Norite, kad tai pasikeistų? Jokių problemų. Naudokite _.reverse .

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

Norite derinti abu su grandine ?

 const sortedObjs = _.chain(users).sortBy('user.age').reverse().value(); 
15
30 авг. Atsakymą pateikė Nico Van Belle 30 rug. 2017-08-30 17:15 '17 17:15 pm 2017-08-30 17:15

Čia yra daug gerų atsakymų, bet norėčiau pabrėžti, kad jie gali būti labai išplėsti, kad būtų pasiektas sudėtingesnis rūšiavimas. Vienintelis dalykas, kurį jums reikia padaryti, yra palyginimo grandinės „OR“ operatorius, pavyzdžiui:

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

Kur fn1 , fn2 , ... yra rūšiavimo funkcijos, kurios grąžina [-1,0,1]. Dėl to „rūšiavimas pagal fn1“, „rūšiavimas pagal fn2“, kuris iš esmės yra lygus ORDER BY SQL.

Šis sprendimas grindžiamas operatoriaus elgesiu || kuri įvertina pirmąją vertinamą išraišką, kuri gali būti konvertuojama į tikrąją .

Paprasčiausia forma turi tik vieną integruotą funkciją:

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

Po dviejų žingsnių su rūšiavimo tvarka last_nom , first_nom atrodys taip:

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

Bendra palyginimo funkcija gali būti tokia:

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

Ši funkcija gali būti išplėsta, kad palaikytų skaitmeninius laukus, atvejų jautrumą, savavališkus duomenų tipus ir kt.

Jį galite naudoti pagal juos pagal rūšiavimo prioritetą:

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

Faktas yra tai, kad grynasis JavaScript su funkciniu požiūriu gali eiti ilgą kelią be išorinių bibliotekų ar sudėtingo kodo. Tai taip pat labai veiksminga, nes nereikia analizuoti styginių.

15
05 мая '16 в 14:36 2016-05-05 14:36 atsakymas suteiktas Tero Tolonen 05 gegužės 16 d. 14:36 2016-05-05 14:36

Žinau, kad šis klausimas yra pernelyg senas, bet nemačiau jokio įgyvendinimo, kaip mano.
Ši versija yra pagrįsta Schwartz transformacijos idėja .

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

Čia pateikiamas pavyzdys, kaip jį naudoti:

 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')); 
14
06 нояб. atsakymą pateikė a8m . 2016-11-06 16:18 '16 at 16:18 2016-11-06 16:18

Naudojimo pavyzdys:

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

Scenarijaus:

  function 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. var 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. var moveLarger = reverse ? -1 : 1;  return function(a, b) { if (a[key] < b[key]) { return moveSmaller; } if (a[key] > b[key]) { return moveLarger; } return 0; }; } 
14
30 апр. atsakymas pateikiamas fold_left balandžio 30 d 2014-04-30 13:02 '14, 13:02 2014-04-30 13:02

Turiu kodą, kuris veikia man:

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

UPDATE: ne visada veikia, todėl tai netiesa: (

13
20 окт. Atsakymą pateikė Damjan Pavlica spalio 20 d. 2017-10-20 15:10 '17 15:10 2017-10-20 15:10

Rūšiuoti (daugiau) Sudėtingos objektų grupės

Kadangi jūs greičiausiai susidursite su sudėtingesnėmis duomenų struktūromis, pvz., Šiuo masyvu, išplėčiau sprendimą.

Tl; DR

Sklandžesnė versija, pagrįsta @ ege-Özcan, yra labai malonus atsakymas .

Problema

Aš bėgo į žemyn ir negalėjau jos pakeisti. Aš taip pat nenorėjau laikinai išlyginti objekto. Aš taip pat nenorėjau naudoti pabraukimo / pateikimo, daugiausia dėl veiklos priežasčių ir smagu ją įgyvendinti.

 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; }; }  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 // https://stackoverflow.com/a/17528613/3580261 return recurseObjProp(lower, leafs, index) }  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`- nature // Consider: `.forEach()` while(result === 0  i < numberOfProperties) { result = dynamicSort(args[i])(a, b); i++; } return result; } } 

Pavyzdys

JSBin darbo pavyzdys

12
10 авг. atsakymas duotas eljefedelrodeodeljefe 10 rug . 2015-08-10 18:52 '15, 18:52, 2015-08-10 18:52

Nuo 2018 m. Yra daug trumpesnis ir elegantiškesnis sprendimas. Tiesiog naudokite. Array.prototype.sort () .

Pavyzdys:

 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; }); 
11
04 июня '18 в 18:24 2018-06-04 18:24 atsakymas suteiktas Olegui birželio 18 d. 18 val. 18:24 2018-06-04 18:24

Lengvas būdas:

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

Pažiūrėkite, kad '.toLowerCase()' būtina norint išvengti klaidų lyginant stygas.

9
15 янв. atsakymą pateikė Caio Ladislau sausio 15 d. 2016-01-15 16:32 '16 at 16:32 2016-01-15 16:32

Derindami dinamišką „Ege“ sprendimą su „Vinay“ idėja, gausite patikimą sprendimą:

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

Naudoti:

 // 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"); 
8
23 апр. Atsakymą pateikė Mike R 23 balandžio. 2013-04-23 19:07 '13, 07:07 pm 2013-04-23 19:07

Kita galimybė:

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

pagal numatytuosius nustatymus pagal nutylėjimą.

7
26 июня '16 в 12:10 2016-06-26 12:10 Atsakymą davė Ravshan Samandarov , birželio 26 d. 16, 12:10 2016-06-26 12:10

Pagal jūsų pavyzdį turite surūšiuoti pagal du laukus (pavardę, vardą), o ne vieną. Galite naudoti „ Alasql“ biblioteką, kad šis vaizdas būtų rodomas vienoje eilutėje:

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

Išbandykite šį pavyzdį jsFiddle .

7
18 дек. Atsakymas pateikiamas agershun . 2014-12-18 14:09 „14, 14:09 2014-12-18 14:09

papildomi Ege Özcan kodo parametrai

 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; } } 
7
16 сент. Atsakymą pateikė Behnam Yousefi . 2012-09-16 23:22 '12 11:22 pm 2012-09-16 23:22

Gali tekti juos konvertuoti į mažąsias, kad būtų išvengta painiavos.

 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 }) 
6
14 авг. atsakymas, kurį pateikė Burak Keceli 14 rug . 2013-08-14 13:40 '13, 13:40 2013-08-14 13:40
 objs.sort(function(a,b){return b.last_nom>a.last_nom}) 
6
08 марта '16 в 12:51 2016-03-08 12:51 Roshni Bokade atsakymas kovo 8 d. 16 d. 12:51 2016-03-08 12:51
 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")); 
6
29 окт. atsakymas į Evgenii 29 okt. 2015-10-29 16:09 '15 - 16:09 2015-10-29 16:09

Nematau šio pasiūlyto požiūrio, todėl naudoju trumpą palyginimo metodą, kurį norėčiau naudoti ir string ir number :

 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) { return -(fn(a) < fn(b)) || +(fn(a) > fn(b)) } } var getLastName = function (o) { return o.last_nom } var sortByLastName = sortBy(getLastName) objs.sort(sortByLastName) console.log(objs.map(getLastName)) 
6
18 июля '18 в 12:53 2018-07-18 12:53 Patrick Roberts atsakė liepos 18 d. 18 val. 12:53 val. 2018-07-18 12:53

Naudojant „Ramda“

npm įdiegti 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) 
5
05 июля '17 в 10:43 2017-07-05 10:43 atsakymą pateikė Sridhar Sg liepos 5 d. 17 d. 10:43 2017-07-05 10:43

Tai yra paprasta problema, aš nežinau, kodėl žmonės turi tokį sudėtingą sprendimą.
Paprasta rūšiavimo funkcija (pagal greitojo rūšiavimo algoritmą):

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

Naudojimo pavyzdys:

 var myArr = [ { val: 'x', idx: 3 }, { val: 'y', idx: 2 }, { val: 'z', idx: 5 }, ]; myArr = sortObjectsArray(myArr, 'idx'); 
5
19 нояб. atsakymą pateikė Gil Epshtain 19 lapkritis 2015-11-19 17:27 '15, 17:27, 2015-11-19 17:27

Aš tiesiog padidina dinaminį Ege Özcan rūšiavimą, kad galėčiau nardyti gilius vidinius objektus. Jei duomenys atrodo taip:

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

ir jei norite surūšiuoti jį pagal savybes, manau, kad mano gerinimas labai padeda. Tokiems objektams pridedu naują funkciją:

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

ir _dynamicSort funkcija pakeista:

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

Ir dabar galite rūšiuoti pagal aa :

 obj.sortBy('a.a'); 

Žr. „Skripto scenarijus“ JSFiddle

4
ответ дан Morteza Tourani 29 июня '15 в 4:10 2015-06-29 04:10