Ordinamento di una matrice di oggetti JavaScript

Ho letto i seguenti oggetti usando Ajax e li ho archiviati in un array:

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": "5", "city": "New York", "state": "NY", "zip": "00010", "price": "962500" } ]; 

Come posso creare una funzione per ordinare gli oggetti in base alla proprietà del price in ordine ascendente o discendente utilizzando solo JavaScript?

Ordina case per prezzo in ordine crescente:

 homes.sort(function(a, b) { return parseFloat(a.price) - parseFloat(b.price); }); 

O dopo la versione ES6:

 homes.sort((a, b) => parseFloat(a.price) - parseFloat(b.price)); 

Alcuni documenti possono essere trovati qui .

Ecco una versione più flessibile, che consente di creare funzioni di ordinamento riutilizzabili e di ordinare in base a qualsiasi campo.

 var sort_by = function(field, reverse, primer){ var key = primer ? function(x) {return primer(x[field])} : function(x) {return x[field]}; reverse = !reverse ? 1 : -1; return function (a, b) { return a = key(a), b = key(b), reverse * ((a > b) - (b > a)); } } 

Ora puoi ordinare da qualsiasi campo a volontà …

 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": "5", "city": "New York", "state": "NY", "zip": "00010", "price": "962500" }]; // Sort by price high to low homes.sort(sort_by('price', true, parseInt)); // Sort by city, case-insensitive, AZ homes.sort(sort_by('city', false, function(a){return a.toUpperCase()})); 

Per ordinarlo è necessario creare una funzione di confronto prendendo due argomenti. Quindi chiamare la funzione di ordinamento con tale funzione di confronto come segue:

 // a and b are object elements of your array function mycomparator(a,b) { return parseInt(a.price, 10) - parseInt(b.price, 10); } homes.sort(mycomparator); 

Se si desidera ordinare in ordine ascendente, commutare le espressioni su ciascun lato del segno meno.

per l’ordinamento delle stringhe nel caso in cui qualcuno ne avesse bisogno,

 var dataArr = { "hello": [{ "id": 114, "keyword": "zzzzzz", "region": "Sri Lanka", "supportGroup": "administrators", "category": "Category2" }, { "id": 115, "keyword": "aaaaa", "region": "Japan", "supportGroup": "developers", "category": "Category2" }] }; var sortArray = dataArr['hello']; sortArray.sort(function(a,b) { if ( a.region < b.region ) return -1; if ( a.region > b.region ) return 1; return 0; } ); 

Se hai un browser compatibile con ES6 puoi usare:

  • Funzioni della freccia
  • Funzione Number ()
  • funzione sort ()

La differenza tra ordine crescente e decrescente è il segno del valore restituito dalla funzione di confronto:

 var ascending = homes.sort((a, b) => Number(a.price) - Number(b.price)); var descending = homes.sort((a, b) => Number(b.price) - Number(a.price)); 

Ecco uno snippet di codice funzionante:

 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": "5", "city": "New York", "state": "NY", "zip": "00010", "price": "962500" }]; homes.sort((a, b) => Number(a.price) - Number(b.price)); console.log("ascending", homes); homes.sort((a, b) => Number(b.price) - Number(a.price)); console.log("descending", homes); 

Vuoi ordinarlo in Javascript, giusto? Quello che vuoi è la funzione sort() . In questo caso è necessario scrivere una funzione di confronto e passarla a sort() , quindi qualcosa di simile:

 function comparator(a, b) { return parseInt(a["price"], 10) - parseInt(b["price"], 10); } var json = { "homes": [ /* your previous data */ ] }; console.log(json["homes"].sort(comparator)); 

Il tuo comparatore prende uno degli hash annidati all’interno dell’array e decide quale è più alto controllando il campo “prezzo”.

Raccomando GitHub: Array sortBy – una migliore implementazione del metodo sortBy che utilizza la trasformazione di Schwartz

Ma per ora proveremo questo approccio Gist: sortBy-old.js .
Creiamo un metodo per ordinare gli array che sono in grado di disporre gli oggetti secondo alcune proprietà.

Creazione della funzione di ordinamento

 var sortBy = (function () { var toString = Object.prototype.toString, // default parser function parse = function (x) { return x; }, // gets the item to be sorted getItem = function (x) { var isObject = x != null && typeof x === "object"; var isProp = isObject && this.prop in x; return this.parser(isProp ? x[this.prop] : x); }; /** * Sorts an array of elements. * * @param {Array} array: the collection to sort * @param {Object} cfg: the configuration options * @property {String} cfg.prop: property name (if it is an Array of objects) * @property {Boolean} cfg.desc: determines whether the sort is descending * @property {Function} cfg.parser: function to parse the items to expected type * @return {Array} */ return function sortby (array, cfg) { if (!(array instanceof Array && array.length)) return []; if (toString.call(cfg) !== "[object Object]") cfg = {}; if (typeof cfg.parser !== "function") cfg.parser = parse; cfg.desc = !!cfg.desc ? -1 : 1; return array.sort(function (a, b) { a = getItem.call(cfg, a); b = getItem.call(cfg, b); return cfg.desc * (a < b ? -1 : +(a > b)); }); }; }()); 

Impostazione dei dati non ordinati

 var data = [ {date: "2011-11-14T16:30:43Z", quantity: 2, total: 90, tip: 0, type: "tab"}, {date: "2011-11-14T17:22:59Z", quantity: 2, total: 90, tip: 0, type: "Tab"}, {date: "2011-11-14T16:28:54Z", quantity: 1, total: 300, tip: 200, type: "visa"}, {date: "2011-11-14T16:53:41Z", quantity: 2, total: 90, tip: 0, type: "tab"}, {date: "2011-11-14T16:48:46Z", quantity: 2, total: 90, tip: 0, type: "tab"}, {date: "2011-11-14T17:25:45Z", quantity: 2, total: 200, tip: 0, type: "cash"}, {date: "2011-11-31T17:29:52Z", quantity: 1, total: 200, tip: 100, type: "Visa"}, {date: "2011-11-14T16:58:03Z", quantity: 2, total: 90, tip: 0, type: "tab"}, {date: "2011-11-14T16:20:19Z", quantity: 2, total: 190, tip: 100, type: "tab"}, {date: "2011-11-01T16:17:54Z", quantity: 2, total: 190, tip: 100, type: "tab"}, {date: "2011-11-14T17:07:21Z", quantity: 2, total: 90, tip: 0, type: "tab"}, {date: "2011-11-14T16:54:06Z", quantity: 1, total: 100, tip: 0, type: "Cash"} ]; 

Usandolo

Disporre la matrice, per "date" come String

 // sort by @date (ascending) sortBy(data, { prop: "date" }); // expected: first element // { date: "2011-11-01T16:17:54Z", quantity: 2, total: 190, tip: 100, type: "tab" } // expected: last element // { date: "2011-11-31T17:29:52Z", quantity: 1, total: 200, tip: 100, type: "Visa"} 

Se si desidera ignorare la distinzione tra maiuscole e minuscole, impostare la richiamata del parser :

 // sort by @type (ascending) IGNORING case-sensitive sortBy(data, { prop: "type", parser: (t) => t.toUpperCase() }); // expected: first element // { date: "2011-11-14T16:54:06Z", quantity: 1, total: 100, tip: 0, type: "Cash" } // expected: last element // { date: "2011-11-31T17:29:52Z", quantity: 1, total: 200, tip: 100, type: "Visa" } 

Se si desidera convertire il campo "date" come tipo di Date :

 // sort by @date (descending) AS Date object sortBy(data, { prop: "date", desc: true, parser: (d) => new Date(d) }); // expected: first element // { date: "2011-11-31T17:29:52Z", quantity: 1, total: 200, tip: 100, type: "Visa"} // expected: last element // { date: "2011-11-01T16:17:54Z", quantity: 2, total: 190, tip: 100, type: "tab" } 

Qui puoi giocare con il codice: jsbin.com/lesebi

Grazie a @Ozesh dal suo feedback, è stato risolto il problema relativo alle proprietà con valori falsi .

Usa lodash.sortBy , (istruzioni che usano commonjs, puoi anche inserire lo script include-tag per il cdn nella parte superiore del tuo html)

 var sortBy = require('lodash.sortby'); // or sortBy = require('lodash').sortBy; 

Ordine decrescente

 var descendingOrder = sortBy( homes, 'price' ).reverse(); 

Ordine ascendente

 var ascendingOrder = sortBy( homes, 'price' ); 

Ciò avrebbe potuto essere ottenuto attraverso una semplice funzione di ordinamento di una riga valueof () . Esegui lo snippet di codice qui sotto per vedere la demo.

 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": "5", "city": "New York", "state": "NY", "zip": "00010", "price": "962500" } ]; console.log("To sort descending/highest first, use operator '<'"); homes.sort(function(a,b) { return a.price.valueOf() < b.price.valueOf();}); console.log(homes); console.log("To sort ascending/lowest first, use operator '>'"); homes.sort(function(a,b) { return a.price.valueOf() > b.price.valueOf();}); console.log(homes); 

È ansible utilizzare il metodo di sort JavaScript con una funzione di callback:

 function compareASC(homeA, homeB) { return parseFloat(homeA.price) - parseFloat(homeB.price); } function compareDESC(homeA, homeB) { return parseFloat(homeB.price) - parseFloat(homeA.price); } // Sort ASC homes.sort(compareASC); // Sort DESC homes.sort(compareDESC); 

Ecco il culmine di tutte le risposte sopra.

Convalida Fiddle: http://jsfiddle.net/bobberino/4qqk3/

 var sortOn = function (arr, prop, reverse, numeric) { // Ensure there's a property if (!prop || !arr) { return arr } // Set up sort function var sort_by = function (field, rev, primer) { // Return the required a,b function return function (a, b) { // Reset a, b to the field a = primer(a[field]), b = primer(b[field]); // Do actual sorting, reverse as needed return ((a < b) ? -1 : ((a > b) ? 1 : 0)) * (rev ? -1 : 1); } } // Distinguish between numeric and string to prevent 100's from coming before smaller // eg // 1 // 20 // 3 // 4000 // 50 if (numeric) { // Do sort "in place" with sort_by function arr.sort(sort_by(prop, reverse, function (a) { // - Force value to a string. // - Replace any non numeric characters. // - Parse as float to allow 0.02 values. return parseFloat(String(a).replace(/[^0-9.-]+/g, '')); })); } else { // Do sort "in place" with sort_by function arr.sort(sort_by(prop, reverse, function (a) { // - Force value to string. return String(a).toUpperCase(); })); } } 

Ho anche lavorato con un tipo di classificazione e ordinamento di più campi:

 arr = [ {type:'C', note:834}, {type:'D', note:732}, {type:'D', note:008}, {type:'F', note:474}, {type:'P', note:283}, {type:'P', note:165}, {type:'X', note:173}, {type:'Z', note:239}, ]; arr.sort(function(a,b){ var _a = ((a.type==='C')?'0':(a.type==='P')?'1':'2'); _a += (a.type.localeCompare(b.type)===-1)?'0':'1'; _a += (a.note>b.note)?'1':'0'; var _b = ((b.type==='C')?'0':(b.type==='P')?'1':'2'); _b += (b.type.localeCompare(a.type)===-1)?'0':'1'; _b += (b.note>a.note)?'1':'0'; return parseInt(_a) - parseInt(_b); }); 

Risultato

 [ {"type":"C","note":834}, {"type":"P","note":165}, {"type":"P","note":283}, {"type":"D","note":8}, {"type":"D","note":732}, {"type":"F","note":474}, {"type":"X","note":173}, {"type":"Z","note":239} ] 

Se usi Underscore.js , prova a ordinare:

 // price is of an integer type _.sortBy(homes, "price"); // price is of a string type _.sortBy(homes, function(home) {return parseInt(home.price);}); 

Questo è un bel plug-in di JQuery:

http://plugins.jquery.com/project/sort (Wayback Machine Link)

Sebbene sia un po ‘eccessivo per l’ordinamento di un singolo array, questa funzione di prototipo consente di ordinare gli array Javascript con qualsiasi chiave, in ordine crescente o decrescente, comprese le chiavi annidate , usando la syntax del dot .

 (function(){ var keyPaths = []; var saveKeyPath = function(path) { keyPaths.push({ sign: (path[0] === '+' || path[0] === '-')? parseInt(path.shift()+1) : 1, path: path }); }; var valueOf = function(object, path) { var ptr = object; for (var i=0,l=path.length; i bVal) return keyPaths[i].sign; if (aVal < bVal) return -keyPaths[i].sign; } return 0; }; Array.prototype.sortBy = function() { keyPaths = []; for (var i=0,l=arguments.length; i 

Uso:

 var data = [ { name: { first: 'Josh', last: 'Jones' }, age: 30 }, { name: { first: 'Carlos', last: 'Jacques' }, age: 19 }, { name: { first: 'Carlos', last: 'Dante' }, age: 23 }, { name: { first: 'Tim', last: 'Marley' }, age: 9 }, { name: { first: 'Courtney', last: 'Smith' }, age: 27 }, { name: { first: 'Bob', last: 'Smith' }, age: 30 } ] data.sortBy('age'); // "Tim Marley(9)", "Carlos Jacques(19)", "Carlos Dante(23)", "Courtney Smith(27)", "Josh Jones(30)", "Bob Smith(30)" 

Ordinamento per proprietà nidificate con syntax a punti o syntax di matrice:

 data.sortBy('name.first'); // "Bob Smith(30)", "Carlos Dante(23)", "Carlos Jacques(19)", "Courtney Smith(27)", "Josh Jones(30)", "Tim Marley(9)" data.sortBy(['name', 'first']); // "Bob Smith(30)", "Carlos Dante(23)", "Carlos Jacques(19)", "Courtney Smith(27)", "Josh Jones(30)", "Tim Marley(9)" 

Ordinamento per più chiavi:

 data.sortBy('name.first', 'age'); // "Bob Smith(30)", "Carlos Jacques(19)", "Carlos Dante(23)", "Courtney Smith(27)", "Josh Jones(30)", "Tim Marley(9)" data.sortBy('name.first', '-age'); // "Bob Smith(30)", "Carlos Dante(23)", "Carlos Jacques(19)", "Courtney Smith(27)", "Josh Jones(30)", "Tim Marley(9)" 

È ansible sborsare il repo: https://github.com/eneko/Array.sortBy

Solo per un normale array di valori di elementi:

 function sortArrayOfElements(arrayToSort) { function compareElements(a, b) { if (a < b) return -1; if (a > b) return 1; return 0; } return arrayToSort.sort(compareElements); } eg 1: var array1 = [1,2,545,676,64,2,24] output : [1, 2, 2, 24, 64, 545, 676] var array2 = ["v","a",545,676,64,2,"24"] output: ["a", "v", 2, "24", 64, 545, 676] 

Per una serie di oggetti:

 function sortArrayOfObjects(arrayToSort, key) { function compareObjects(a, b) { if (a[key] < b[key]) return -1; if (a[key] > b[key]) return 1; return 0; } return arrayToSort.sort(compareObjects); } eg 1: var array1= [{"name": "User4", "value": 4},{"name": "User3", "value": 3},{"name": "User2", "value": 2}] output : [{"name": "User2", "value": 2},{"name": "User3", "value": 3},{"name": "User4", "value": 4}] 

Per ordinare una matrice è necessario definire una funzione di confronto. Questa funzione è sempre diversa sul modello o sull’ordine di ordinamento desiderati (ad es. Ascendente o discendente).

Lasciamo creare alcune funzioni che ordinano una matrice crescente o decrescente e che contiene oggetti, stringhe o valori numerici.

 function sorterAscending(a,b) { return ab; } function sorterDescending(a,b) { return ba; } function sorterPriceAsc(a,b) { return parseInt(a['price']) - parseInt(b['price']); } function sorterPriceDes(a,b) { return parseInt(b['price']) - parseInt(b['price']); } 

Ordina i numeri (alfabeticamente e in ordine crescente):

 var fruits = ["Banana", "Orange", "Apple", "Mango"]; fruits.sort(); 

Ordina i numeri (in ordine alfabetico e decrescente):

 var fruits = ["Banana", "Orange", "Apple", "Mango"]; fruits.sort(); fruits.reverse(); 

Ordina i numeri (numericamente e ascendente):

 var points = [40,100,1,5,25,10]; points.sort(sorterAscending()); 

Ordina i numeri (numericamente e discendente):

 var points = [40,100,1,5,25,10]; points.sort(sorterDescending()); 

Come sopra, usa il metodo sorterPriceAsc e sorterPriceDes con l’array con la chiave desiderata.

 homes.sort(sorterPriceAsc()) or homes.sort(sorterPriceDes()) 

Con ECMAScript 6 la risposta di StoBor può essere fatta in modo ancora più conciso:

 homes.sort((a, b) => a.price - b.price) 

Ecco una versione leggermente modificata di un’elegante implementazione dal libro “JavaScript: The Good Parts”.

NOTA : questa versione di è stabile . Conserva l’ordine del primo tipo mentre esegue il successivo ordinamento a catena.

Ho aggiunto isAscending parameter ad esso. Anche convertito in standard ES6 e “nuove” parti buone come raccomandato dall’autore.

È ansible ordinare ordinamento crescente e discendente e a catena per più proprietà.

 const by = function (name, minor, isAscending=true) { const reverseMutliplier = isAscending ? 1 : -1; return function (o, p) { let a, b; let result; if (o && p && typeof o === "object" && typeof p === "object") { a = o[name]; b = p[name]; if (a === b) { return typeof minor === 'function' ? minor(o, p) : 0; } if (typeof a === typeof b) { result = a < b ? -1 : 1; } else { result = typeof a < typeof b ? -1 : 1; } return result * reverseMutliplier; } else { throw { name: "Error", message: "Expected an object when sorting by " + name }; } }; }; let s = [ {first: 'Joe', last: 'Besser'}, {first: 'Moe', last: 'Howard'}, {first: 'Joe', last: 'DeRita'}, {first: 'Shemp', last: 'Howard'}, {first: 'Larry', last: 'Fine'}, {first: 'Curly', last: 'Howard'} ]; // Sort by: first ascending, last ascending s.sort(by("first", by("last"))); console.log("Sort by: first ascending, last ascending: ", s); // "[ // {"first":"Curly","last":"Howard"}, // {"first":"Joe","last":"Besser"}, <====== // {"first":"Joe","last":"DeRita"}, <====== // {"first":"Larry","last":"Fine"}, // {"first":"Moe","last":"Howard"}, // {"first":"Shemp","last":"Howard"} // ] // Sort by: first ascending, last descending s.sort(by("first", by("last", 0, false))); console.log("sort by: first ascending, last descending: ", s); // "[ // {"first":"Curly","last":"Howard"}, // {"first":"Joe","last":"DeRita"}, <======== // {"first":"Joe","last":"Besser"}, <======== // {"first":"Larry","last":"Fine"}, // {"first":"Moe","last":"Howard"}, // {"first":"Shemp","last":"Howard"} // ] 

Avrai bisogno di due funzioni

 function desc(a, b) { return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN; } function asc(a, b) { return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; } 

Quindi puoi applicarlo a qualsiasi proprietà dell’object:

  data.sort((a, b) => desc(parseFloat(a.price), parseFloat(b.price))); 
 let data = [ {label: "one", value:10}, {label: "two", value:5}, {label: "three", value:1}, ]; // sort functions function desc(a, b) { return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN; } function asc(a, b) { return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; } // DESC data.sort((a, b) => desc(a.value, b.value)); document.body.insertAdjacentHTML( 'beforeend', 'DESCending sorted
' + JSON.stringify(data) +'

' ); // ASC data.sort((a, b) => asc(a.value, b.value)); document.body.insertAdjacentHTML( 'beforeend', 'ASCending sorted

' + JSON.stringify(data) +'

' );

Recentemente ho scritto una funzione universale per gestirla per te se vuoi usarla.

 /** * Sorts an object into an order * * @require jQuery * * @param object Our JSON object to sort * @param type Only alphabetical at the moment * @param identifier The array or object key to sort by * @param order Ascending or Descending * * @returns Array */ function sortItems(object, type, identifier, order){ var returnedArray = []; var emptiesArray = []; // An array for all of our empty cans // Convert the given object to an array $.each(object, function(key, object){ // Store all of our empty cans in their own array // Store all other objects in our returned array object[identifier] == null ? emptiesArray.push(object) : returnedArray.push(object); }); // Sort the array based on the type given switch(type){ case 'alphabetical': returnedArray.sort(function(a, b){ return(a[identifier] == b[identifier]) ? 0 : ( // Sort ascending or descending based on order given order == 'asc' ? a[identifier] > b[identifier] : a[identifier] < b[identifier] ) ? 1 : -1; }); break; default: } // Return our sorted array along with the empties at the bottom depending on sort order return order == 'asc' ? returnedArray.concat(emptiesArray) : emptiesArray.concat(returnedArray); } 
 homes.sort(function(a, b){ var nameA=a.prices.toLowerCase(), nameB=b.prices.toLowerCase() if (nameA < nameB) //sort string ascending return -1 if (nameA > nameB) return 1 return 0 //default return value (no sorting) }) 

Salve dopo aver letto questo articolo, ho creato un sortComparator per le mie esigenze, con la funzionalità per confrontare più di un attributo json e voglio condividerlo con te.

Questa soluzione confronta solo le stringhe in ordine ascendente, ma la soluzione può essere facilmente estesa per ciascun attributo a supporto: ordine inverso, altri tipi di dati, per utilizzare le impostazioni internazionali, il casting ecc.

 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": "5", "city": "New York", "state": "NY", "zip": "00010", "price": "962500" }]; // comp = array of attributes to sort // comp = ['attr1', 'attr2', 'attr3', ...] function sortComparator(a, b, comp) { // Compare the values of the first attribute if (a[comp[0]] === b[comp[0]]) { // if EQ proceed with the next attributes if (comp.length > 1) { return sortComparator(a, b, comp.slice(1)); } else { // if no more attributes then return EQ return 0; } } else { // return less or great return (a[comp[0]] < b[comp[0]] ? -1 : 1) } } // Sort array homes homes.sort(function(a, b) { return sortComparator(a, b, ['state', 'city', 'zip']); }); // display the array homes.forEach(function(home) { console.log(home.h_id, home.city, home.state, home.zip, home.price); }); 

e il risultato è

 $ node sort 4 Bevery Hills CA 90210 319250 5 New York NY 00010 962500 3 Dallas TX 75201 162500 

e un altro tipo

 homes.sort(function(a, b) { return sortComparator(a, b, ['city', 'zip']); }); 

con risultato

 $ node sort 4 Bevery Hills CA 90210 319250 3 Dallas TX 75201 162500 5 New York NY 00010 962500 

Per ordinare su più campi object array. Immettere il nome del campo nell’array arrprop come ["a","b","c"] quindi passare nel secondo parametro sorgente effettiva di arrsource che si desidera ordinare.

 function SortArrayobject(arrprop,arrsource){ arrprop.forEach(function(i){ arrsource.sort(function(a,b){ return ((a[i] < b[i]) ? -1 : ((a[i] > b[i]) ? 1 : 0)); }); }); return arrsource; } 

Mentre sono consapevole che l’OP voleva ordinare una serie di numeri, questa domanda è stata contrassegnata come la risposta a domande simili relative alle stringhe. A tale proposito, le risposte di cui sopra non considerano l’ordinamento di una matrice di testo in cui l’involucro è importante. La maggior parte delle risposte prende i valori di stringa e li converte in maiuscolo / in minuscolo e quindi ordina in un modo o nell’altro. I requisiti a cui aderisco sono semplici:

  • Ordina alfabeticamente AZ
  • I valori maiuscoli della stessa parola dovrebbero arrivare prima dei valori minuscoli
  • I valori della stessa lettera (A / a, B / b) dovrebbero essere raggruppati insieme

Quello che mi aspetto è [ A, a, B, b, C, c ] ma le risposte di cui sopra restituiscono A, B, C, a, b, c . In realtà mi sono grattato la testa più a lungo di quanto volessi (ecco perché sto postando questo nella speranza che possa aiutare almeno un’altra persona). Mentre due utenti menzionano la funzione localeCompare nei commenti per la risposta contrassegnata, non l’ho visto fino a dopo che mi sono imbattuto nella funzione durante la ricerca in giro. Dopo aver letto la documentazione di String.prototype.localeCompare () sono riuscito a trovare questo:

 var values = [ "Delta", "charlie", "delta", "Charlie", "Bravo", "alpha", "Alpha", "bravo" ]; var sorted = values.sort((a, b) => a.localeCompare(b, undefined, { caseFirst: "upper" })); // Result: [ "Alpha", "alpha", "Bravo", "bravo", "Charlie", "charlie", "Delta", "delta" ] 

Questo dice alla funzione di ordinare i valori maiuscoli prima dei valori minuscoli. Il secondo parametro nella funzione localeCompare è quello di definire la localizzazione, ma se la si lascia come undefined , automaticamente rileva le impostazioni locali.

Funziona allo stesso modo per ordinare una matrice di oggetti:

 var values = [ { id: 6, title: "Delta" }, { id: 2, title: "charlie" }, { id: 3, title: "delta" }, { id: 1, title: "Charlie" }, { id: 8, title: "Bravo" }, { id: 5, title: "alpha" }, { id: 4, title: "Alpha" }, { id: 7, title: "bravo" } ]; var sorted = values .sort((a, b) => a.title.localeCompare(b.title, undefined, { caseFirst: "upper" }));