Mam tablicę obiektów JavaScript:

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

Jak mogę je posortować według wartości last_nomw JavaScript?

Wiem o tym sort(a,b), ale wydaje się, że działa to tylko na ciągi i liczby. Czy muszę dodać toString()metodę do moich obiektów?

Łatwo jest napisać własną funkcję porównania:

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

Lub inline (bez Marco Demaio):

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

Możesz także utworzyć funkcję dynamicznego sortowania, która sortuje obiekty według przekazywanej wartości:

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

Możesz mieć tablicę takich obiektów:

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

... i zadziała, gdy wykonasz:

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

Właściwie to już odpowiada na pytanie. Poniższa część została napisana, ponieważ wiele osób skontaktowało się ze mną, narzekając, że nie działa z wieloma parametrami .

Wiele parametrów

Poniższej funkcji można użyć do wygenerowania funkcji sortowania z wieloma parametrami sortowania.

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

Co pozwoli ci zrobić coś takiego:

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

Tablica podklas

Szczęście wśród nas, którzy mogą korzystać z ES6, który pozwala rozszerzać obiekty rodzime:

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

Umożliwiłoby to:

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

W ES6 / ES2015 lub nowszym możesz to zrobić w następujący sposób:

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

Przed ES6 / ES2015

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

underscore.js

użyj podkreślenia, jego małego i niesamowitego ...

sortBy_.sortBy (lista, iterator, [kontekst]) Zwraca posortowaną kopię listy, uszeregowaną w porządku rosnącym według wyników uruchomienia każdej wartości przez iterator. Iterator może być również nazwą ciągu właściwości do sortowania według (np. Długości).

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

Nie rozumiem, dlaczego ludzie komplikują to:

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

W przypadku bardziej rygorystycznych silników:

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

Zamień operatora, aby sortować go w odwrotnej kolejności alfabetycznej.

Jeśli masz zduplikowane nazwiska, możesz je posortować według imion -

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

Proste i szybkie rozwiązanie tego problemu za pomocą dziedziczenia prototypów:

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

Przykład / użycie

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

Aktualizacja: Nie modyfikuje już oryginalnej tablicy.

Od 2018 r. Istnieje znacznie krótsze i eleganckie rozwiązanie. Po prostu użyj. Array.prototype.sort () .

Przykład:

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

Stara odpowiedź, która jest nieprawidłowa:

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

AKTUALIZACJA

Z komentarza Beauchamp:

arr.sort((a, b) => a.name < b.name ? -1 : (a.name > b.name ? 1 : 0))

Bardziej czytelny format:

arr.sort((a, b) => {
  if (a.name < b.name) return -1
  return a.name > b.name ? 1 : 0
})

Bez zagnieżdżonych trójskładników:

arr.sort((a, b) => a.name < b.name ? - 1 : Number(a.name > b.name))

Objaśnienie: Number()będzie przesyłany truedo 1i falsedo 0.

Zamiast korzystać z niestandardowej funkcji porównania, możesz również utworzyć typ obiektu za pomocą niestandardowej toString()metody (która jest wywoływana przez domyślną funkcję porównania):

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

Lodash.js ( nadzbiór Underscore.js )

Dobrze jest nie dodawać frameworka dla każdej prostej logiki, ale poleganie na dobrze przetestowanych frameworkach użytkowych może przyspieszyć rozwój i zmniejszyć liczbę błędów.

Lodash tworzy bardzo czysty kod i promuje bardziej funkcjonalny styl programowania . Na pierwszy rzut oka staje się jasne, jaki jest cel kodu.

Problem OP można po prostu rozwiązać jako:

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

Więcej informacji? Np. Mamy następujący zagnieżdżony obiekt:

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

Teraz możemy użyć skrótu _.property,user.age aby określić ścieżkę do właściwości, która powinna być dopasowana. Posortujemy obiekty użytkownika według zagnieżdżonej właściwości age. Tak, pozwala na dopasowanie zagnieżdżonych właściwości!

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

Chcesz to odwrócić? Nie ma problemu. Użyj _.reverse .

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

Chcesz połączyć oba za pomocą łańcucha ?

const { chain } = require('lodash');
const sortedObjs = chain(users).sortBy('user.age').reverse().value();

Lub kiedy wolisz przepływ ponad łańcuchem

const { flow, reverse, sortBy } = require('lodash/fp');
const sortedObjs = flow([sortBy('user.age'), reverse])(users); 

Możesz użyć

Najłatwiejszy sposób: Lodash

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

Ta metoda jest podobna do _.sortBy, z tą różnicą, że pozwala na określenie kolejności sortowania iteratów do sortowania według. Jeśli zamówienia nie są określone, wszystkie wartości są sortowane w porządku rosnącym. W przeciwnym razie podaj porządek „malejący” dla malejącego lub „rosnący” dla rosnącego sortowania odpowiednich wartości.

Argumenty

kolekcja (Array | Object): kolekcja do iteracji. [iteratees = [_. tożsamość]] (Array [] | Function [] | Object [] | string []): Ieruje sortowanie według. [zamówienia] (ciąg []): Porządki sortowania iteratów.

Zwroty

(Array): Zwraca nową posortowaną tablicę.

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

Istnieje wiele dobrych odpowiedzi, ale chciałbym zauważyć, że można je bardzo łatwo rozszerzyć, aby uzyskać znacznie bardziej złożone sortowanie. Jedyne, co musisz zrobić, to użyć operatora OR do połączenia funkcji porównania w następujący sposób:

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

gdzie fn1,fn2 ... są zwracane funkcje sortowania [-1,0,1]. Powoduje to „sortowanie według fn1”, „sortowanie według fn2”, co jest prawie równe ORDER BY w SQL.

To rozwiązanie opiera się na zachowaniu ||operatora, który ocenia pierwsze ocenione wyrażenie, które można przekonwertować na true .

Najprostsza forma ma tylko jedną wbudowaną funkcję:

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

Mając dwa kroki z last_nom, first_nomporządek będzie wyglądać następująco:

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

Ogólna funkcja porównania może wyglądać mniej więcej tak:

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

Funkcję tę można rozszerzyć o obsługę pól numerycznych, rozróżnianie wielkości liter, arbitralne typy danych itp.

Możesz ich użyć do łączenia ich według priorytetów sortowania:

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

Chodzi o to, że czysty JavaScript z funkcjonalnym podejściem może zabrać cię daleko bez zewnętrznych bibliotek lub złożonego kodu. Jest również bardzo skuteczny, ponieważ nie trzeba wykonywać analizy ciągów

Przykładowe użycie:

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

Scenariusz:

/**
 * @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;
  };
};

Nie widziałem tego szczególnego podejścia sugerowanego, więc oto sposób porównanie lakoniczny Lubię używać który pracuje dla obu stringoraz number:

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

Oto wyjaśnienie sortBy() :

sortBy()akceptuje wartość a, fnktóra wybiera wartość z obiektu do użycia jako porównanie, i zwraca funkcję, do której można przekazać bezpośrednio Array.prototype.sort(). W tym przykładzie używamy o.last_nomjako wartości do porównania, więc za każdym razem, gdy otrzymujemy dwa obiekty, Array.prototype.sort()takie jak

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

i

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

Używamy

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

aby je porównać.

Pamiętając o tym fn = o => o.last_nom, możemy rozszerzyć funkcję porównania do odpowiednika

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

Logiczny ||operator OR ma funkcję zwarcia, która jest bardzo przydatna w tym przypadku. Z powodu tego, jak to działa, oznacza to powyższą treść

if (fa < fb) return -1;
if (fa > fb) return 1;
return 0;

Jako dodatkowy bonus, oto ekwiwalent w ECMAScript 5 bez funkcji strzałek, co jest niestety bardziej szczegółowe:

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

Wiem, że to pytanie jest za stare, ale nie widziałem żadnej implementacji podobnej do mojej.
Ta wersja oparta jest na idiomie transformacji Schwartziana .

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

Oto przykład, jak go używać:

let games = [
  { name: 'Mashraki',          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'));

Sortowanie (więcej) Złożone tablice obiektów

Ponieważ prawdopodobnie napotykasz bardziej złożone struktury danych, takie jak ta tablica, rozwinąłbym to rozwiązanie.

TL; DR

Są bardziej wtykową wersją opartą na bardzo uroczej odpowiedzi @ ege-Özcan .

Problem

Spotkałem poniżej i nie mogłem tego zmienić. Nie chciałem też tymczasowo spłaszczyć obiektu. Nie chciałem też używać podkreślenia / lodash, głównie ze względu na wydajność i zabawę, aby samodzielnie go wdrożyć.

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

Cel

Celem jest posortowanie go według People.Name.name a następnie wedługPeople.Name.surname

Przeszkody

Teraz w rozwiązaniu podstawowym używa notacji nawiasowej do obliczania właściwości do sortowania dynamicznego. Tutaj jednak musielibyśmy również dynamicznie konstruować notację nawiasową, ponieważ można by się spodziewać podobnychPeople['Name.name'] będą działać - co nie działa.

People['Name']['name']Z drugiej strony samo robienie jest statyczne i pozwala tylko zejść n ty poziom.

Rozwiązanie

Głównym dodatkiem tutaj będzie przejście po drzewie obiektów i określenie wartości ostatniego liścia, który musisz określić, a także dowolnego liścia pośredniego.

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
  // https://stackoverflow.com/a/17528613/3580261
  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;
  }
}

Przykład

Przykład roboczy na JSBin

Jeszcze jedna opcja:

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

domyślnie sortuje rosnąco.

Prosta funkcja sortująca tablicę obiektów według właściwości

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
}

Stosowanie:

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

Prosty sposób:

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

Zobacz, co '.toLowerCase()'jest konieczne, aby zapobiec błędom przy porównywaniu ciągów.

dodatkowe parametry opisowe dla kodu Ege Özcan

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

Łącząc dynamiczne rozwiązanie Ege z pomysłem Vinay, otrzymujesz ładne, solidne rozwiązanie:

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

Stosowanie:

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

Na przykład, musisz posortować według dwóch pól (nazwisko, imię), a nie jednego. Możesz użyć biblioteki Alasql, aby dokonać tego sortowania w jednym wierszu:

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

Spróbuj tego przykładu w jsFiddle .

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

Biorąc pod uwagę oryginalny przykład:

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

Sortuj według wielu pól:

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

Notatki

• a.localeCompare(b)jest powszechnie obsługiwana i wraca -1,0,1 jeśli a<b, a==b,a>b odpowiednio.
• ||w ostatnim wierszu daje last_nompierwszeństwofirst_nom .
• Odejmowanie działa na polach numerycznych: var age_order = left.age - right.age;
• Neguj do odwrotnej kolejności, return -last_nom_order || -first_nom_order || -age_order;

Spróbuj tego,

UPTO ES5

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


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


IN ES6 & above:

// Ascending sort
items.sort((a, b) => a.value - b.value);

// Descending Sort
 items.sort((a, b) => b.value - a.value);

Może być konieczne przekonwertowanie ich na małe litery, aby uniknąć pomyłek.

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

})

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

Korzystając z 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)

To prosty problem, nie wiem, dlaczego ludzie mają tak złożone rozwiązanie.
Prosta funkcja sortowania (oparta na algorytmie szybkiego sortowania ):

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

Użyj przykładu:

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