Saya memiliki berbagai objek JavaScript:

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

Bagaimana saya bisa mengurutkannya berdasarkan nilai last_nomdalam JavaScript?

Saya tahu sort(a,b), tapi itu hanya bekerja pada string dan angka. Apakah saya perlu menambahkan toString()metode ke objek saya?

Cukup mudah untuk menulis fungsi perbandingan Anda sendiri:

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

Atau sebaris (c / o Marco Demaio):

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

Anda juga bisa membuat fungsi sortir dinamis yang mengurutkan objek berdasarkan nilainya yang Anda berikan:

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

Jadi Anda dapat memiliki berbagai objek seperti ini:

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

... dan itu akan berfungsi ketika Anda melakukannya:

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

Sebenarnya ini sudah menjawab pertanyaan. Bagian di bawah ini ditulis karena banyak orang menghubungi saya, mengeluh bahwa itu tidak berfungsi dengan beberapa parameter .

Beberapa parameter

Anda dapat menggunakan fungsi di bawah ini untuk menghasilkan fungsi sortir dengan beberapa parameter sortir.

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

Yang memungkinkan Anda melakukan hal seperti ini:

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

Array subkelas

Untuk yang beruntung di antara kita yang dapat menggunakan ES6, yang memungkinkan memperluas objek asli:

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

Itu akan memungkinkan ini:

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

Di ES6 / ES2015 atau yang lebih baru, Anda dapat melakukan ini:

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

Sebelum ke ES6 / ES2015

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

underscore.js

gunakan garis bawah, kecil dan mengagumkan ...

sortBy_.sortBy (daftar, iterator, [konteks]) Mengembalikan salinan daftar yang diurutkan, diberi peringkat dalam urutan naik dengan hasil menjalankan setiap nilai melalui iterator. Iterator juga bisa berupa nama string properti yang akan disortir berdasarkan (mis. Panjang).

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

Jangan mengerti mengapa orang membuatnya begitu rumit:

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

Untuk mesin yang lebih ketat:

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

Tukar operator untuk mengaturnya berdasarkan urutan abjad terbalik.

Jika Anda memiliki nama belakang yang sama, Anda bisa mengurutkannya berdasarkan nama depan-

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

Solusi sederhana dan cepat untuk masalah ini menggunakan pewarisan prototipe:

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

Contoh / Penggunaan

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

Pembaruan: Tidak lagi memodifikasi array asli.

Pada 2018 ada solusi yang jauh lebih pendek dan elegan. Gunakan saja. Array.prototype.sort () .

Contoh:

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

Jawaban lama yang tidak benar:

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

MEMPERBARUI

Dari komentar Beauchamp:

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

Format yang lebih mudah dibaca:

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

Tanpa terary bersarang:

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

Penjelasan: Number()akan dilemparkan trueke 1dan falseke0 .

Alih-alih menggunakan fungsi perbandingan kustom, Anda juga bisa membuat tipe objek dengan toString()metode kustom (yang dipanggil oleh fungsi perbandingan default):

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 (superset dari Underscore.js )

Adalah baik untuk tidak menambahkan kerangka kerja untuk setiap bagian sederhana dari logika, tetapi mengandalkan kerangka kerja utilitas yang teruji dapat mempercepat pengembangan dan mengurangi jumlah bug.

Lodash menghasilkan kode yang sangat bersih dan mempromosikan pemrograman yang lebih fungsional gaya . Dalam sekejap menjadi jelas apa maksud dari kode tersebut.

Masalah OP dapat dengan mudah dipecahkan sebagai:

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

Info lebih lanjut? Misalnya kita memiliki objek bersarang berikut:

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

Kita sekarang dapat menggunakan singkatan _.propertyuser.age untuk menentukan jalur ke properti yang harus dicocokkan. Kami akan mengurutkan objek pengguna berdasarkan properti umur bersarang. Ya, ini memungkinkan pencocokan properti bersarang!

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

Ingin dibalik? Tidak masalah. Gunakan _.reverse .

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

Ingin menggabungkan keduanya menggunakan rantai ?

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

Atau kapan Anda lebih suka mengalir dari rantai

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

Kamu bisa menggunakan

Cara termudah: Lodash

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

Metode ini seperti _.sortBy kecuali bahwa itu memungkinkan menentukan urutan perintah dari iterate untuk mengurutkan berdasarkan. Jika pesanan tidak ditentukan, semua nilai diurutkan dalam urutan naik. Kalau tidak, tentukan urutan "desc" untuk turun atau "asc" untuk urutan urutan naik dari nilai yang sesuai.

Argumen

koleksi (Array | Objek): Koleksi untuk beralih. [iteratees = [_. identity]] (Array [] | Function [] | Object [] | string []): The iteratees untuk mengurutkan berdasarkan. [order] (string []): Urutan pesanan iteratees.

Kembali

(Array): Mengembalikan array yang diurutkan baru.

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

Ada banyak jawaban bagus di sini, tetapi saya ingin menunjukkan bahwa mereka dapat diperluas sangat sederhana untuk mencapai penyortiran yang jauh lebih kompleks. Satu-satunya hal yang harus Anda lakukan adalah menggunakan operator OR untuk rantai fungsi perbandingan seperti ini:

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

Di mana fn1,, fn2... adalah fungsi sortir yang mengembalikan [-1,0,1]. Ini menghasilkan "sorting by fn1", "sorting by fn2" yang hampir sama dengan ORDER BY dalam SQL.

Solusi ini didasarkan pada perilaku ||operator yang mengevaluasi ekspresi pertama yang dievaluasi yang dapat dikonversi menjadi true .

Bentuk paling sederhana hanya memiliki satu fungsi inline seperti ini:

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

Dengan dua langkah last_nom, first_nomurutan akan terlihat seperti ini:

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

Fungsi perbandingan generik bisa jadi seperti ini:

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

Fungsi ini dapat diperluas untuk mendukung bidang angka, sensitivitas huruf, tipe data arbiter, dll.

Anda dapat mereka menggunakannya dengan merantai mereka dengan mengurutkan prioritas:

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

Intinya di sini adalah bahwa JavaScript murni dengan pendekatan fungsional dapat membawa Anda jauh tanpa perpustakaan eksternal atau kode kompleks. Ini juga sangat efektif, karena tidak ada parsing string yang harus dilakukan

Contoh penggunaan:

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

Naskah:

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

Saya belum melihat pendekatan khusus ini disarankan, jadi inilah metode perbandingan singkat yang saya suka gunakan yang bekerja untuk keduanya stringdan 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));

Berikut penjelasan tentang sortBy():

sortBy()menerima a fnyang memilih nilai apa dari objek untuk digunakan sebagai perbandingan, dan mengembalikan fungsi yang dapat diteruskan langsung ke Array.prototype.sort(). Dalam contoh ini, kami menggunakan o.last_nomsebagai nilai untuk perbandingan, jadi setiap kali kami menerima dua objek melalui Array.prototype.sort()seperti

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

dan

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

kita gunakan

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

untuk membandingkannya.

Mengingat itu fn = o => o.last_nom, kita dapat memperluas fungsi bandingkan ke yang setara

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

OR logis || memiliki fungsi hubungan arus pendek yang sangat berguna di sini. Karena cara kerjanya, fungsi tubuh di atas berarti

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

Sebagai bonus tambahan, inilah yang setara di ECMAScript 5 tanpa fungsi panah, yang sayangnya lebih bertele-tele:

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

Saya tahu pertanyaan ini terlalu lama, tetapi saya tidak melihat implementasi yang serupa dengan saya.
Versi ini didasarkan pada idiom transformasi 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);
}

Berikut ini contoh cara menggunakannya:

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

Menyortir (lebih banyak) Susunan Kompleks Objek

Karena Anda mungkin menemukan struktur data yang lebih kompleks seperti array ini, saya akan memperluas solusinya.

TL; DR

Adalah versi yang lebih pluggable berdasarkan jawaban yang sangat bagus dari @ ege-Özcan .

Masalah

Saya menemukan di bawah dan tidak bisa mengubahnya. Saya juga tidak ingin meratakan objek untuk sementara waktu. Saya juga tidak ingin menggunakan garis bawah / lodash, terutama karena alasan kinerja dan kesenangan untuk mengimplementasikannya sendiri.

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

Tujuan

Tujuannya adalah untuk mengurutkannya berdasarkan People.Name.name dan olehPeople.Name.surname

Rintangan

Sekarang, dalam solusi dasar menggunakan notasi braket untuk menghitung properti untuk mengurutkan secara dinamis. Namun, di sini, kita harus membuat notasi braket secara dinamis, karena Anda akan mengharapkannyaPeople['Name.name'] berfungsi - yang tidak.

Cukup melakukan People['Name']['name'], di sisi lain, bersifat statis dan hanya memungkinkan Anda untuk turun n ke tingkat .

Larutan

Penambahan utama di sini adalah berjalan menyusuri objek pohon dan menentukan nilai daun terakhir, Anda harus menentukan, serta setiap daun perantara.

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

Contoh

Contoh kerja di JSBin

Satu opsi lagi:

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

macam naik secara default.

Fungsi sederhana yang mengurutkan array objek berdasarkan properti

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
}

Pemakaian:

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

Cara sederhana:

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

Lihat itu '.toLowerCase()'perlu untuk mencegah erro dalam membandingkan string.

tambahan desc params untuk kode 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;
    }
}

Menggabungkan solusi dinamis Ege dengan ide Vinay, Anda mendapatkan solusi tangguh yang bagus:

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

Pemakaian:

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

Berdasarkan contoh Anda, Anda perlu mengurutkan berdasarkan dua bidang (nama belakang, nama depan), bukan satu. Anda bisa menggunakan pustaka Alasql untuk membuat ini dalam satu baris:

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

Coba contoh ini di jsFiddle .

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

Diberikan contoh asli:

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

Urutkan berdasarkan beberapa bidang:

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

Catatan

• a.localeCompare(b)adalah universal didukung dan kembali -1,0,1 jika a<b, a==b,a>b masing-masing.
• ||di baris terakhir memberi last_nomprioritas lebihfirst_nom .
• Pengurangan bekerja pada bidang numerik: var age_order = left.age - right.age;
• Negasikan ke urutan terbalik, return -last_nom_order || -first_nom_order || -age_order;

Coba ini,

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

Anda mungkin perlu mengubahnya menjadi huruf kecil untuk mencegah kebingungan.

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

Menggunakan Ramda,

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

Ini adalah masalah yang sederhana, tidak tahu mengapa orang memiliki solusi yang begitu rumit.
Fungsi sortir sederhana (berdasarkan algoritma sortir cepat):

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

Gunakan contoh:

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