Ordenar una matriz de objetos JavaScript por propiedad

Leí los siguientes objetos usando Ajax y los almacené en una matriz:

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

¿Cómo creo una función para ordenar los objetos por la propiedad de price en orden ascendente o descendente usando solo JavaScript?

27 Solutions collect form web for “Ordenar una matriz de objetos JavaScript por propiedad”

Ordenar casas por precio en orden ascendente:

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

O después de la versión ES6:

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

Algunos documentos se pueden encontrar aquí .

Aquí hay una versión más flexible, que le permite crear funciones de clasificación reutilizables, y ordenar por cualquier 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)); } } 

Ahora puedes ordenar por cualquier campo a voluntad …

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

Para clasificarlo, necesita crear una función de comparación que tome dos argumentos. Luego, llame a la función de clasificación con esa función de comparación como sigue:

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

Si desea ordenar ascendente, cambie las expresiones en cada lado del signo menos.

para ordenar cadenas en caso de que alguien lo necesite,

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

Si tienes un navegador compatible con ES6 puedes usar:

  • Funciones de flecha
  • Función de número ()
  • función sort ()

La diferencia entre orden ascendente y descendente es el signo del valor devuelto por su función de comparación:

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

Aquí hay un fragmento de código de trabajo:

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

Quieres ordenarlo en Javascript, ¿verdad? Lo que quieres es la función sort() . En este caso, necesita escribir una función de comparación y pasarla a sort() , así que algo como esto:

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

Su comparador toma uno de cada uno de los hashes nesteds dentro de la matriz y decide cuál es más alto marcando el campo “precio”.

Recomiendo GitHub: Array sortBy : una mejor implementación del método sortBy que utiliza la transformada de Schwartz.

Pero por ahora vamos a probar este enfoque Gist: sortBy-old.js .
Vamos a crear un método para ordenar los arreglos, pudiendo organizar los objetos por alguna propiedad.

Creando la función de clasificación

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

Configuración de datos sin clasificar

 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

Organizar la matriz, por "date" como 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"} 

Si desea ignorar las mayúsculas y minúsculas, establezca la callback 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" } 

Si desea convertir el campo "date" como Tipo de 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" } 

Aquí puedes jugar con el código: jsbin.com/lesebi

Gracias a @Ozesh por sus comentarios, se solucionó el problema relacionado con las propiedades con valores falsos .

Use lodash.sortBy , (instrucciones usando commonjs, también puede poner la etiqueta include del script para el cdn en la parte superior de su html)

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

Orden descendiente

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

Orden ascendente

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

Esto podría haberse logrado a través de una simple función de clasificación de una línea valueof () . Ejecute el fragmento de código a continuación para ver la demostración.

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

Puede utilizar el método de sort JavaScript con una función de 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); 

Aquí es una culminación de todas las respuestas anteriores.

Validación de 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(); })); } } 

También trabajé con algún tipo de clasificación y clasificación de campos múltiples:

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

Resultado

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

Si usa Underscore.js , intente sortBy:

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

Este es un buen complemento de JQuery en:

http://plugins.jquery.com/project/sort (enlace de la máquina de Wayback)

Si bien es un poco excesivo para simplemente ordenar una sola matriz, esta función de prototipo permite clasificar las matrices de Javascript por cualquier tecla, en orden ascendente o descendente, incluidas las teclas anidadas , utilizando dot syntax de 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)" 

Clasificación por propiedades anidadas con syntax de puntos o syntax de matriz:

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

Clasificación por teclas múltiples:

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

Puede bifurcar el repository: https://github.com/eneko/Array.sortBy

Con ECMAScript 6, la respuesta de StoBor se puede hacer incluso más concisa:

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

Para una matriz normal de valores de elementos solamente:

 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] 

Para una matriz de objetos:

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

Para ordenar una matriz debe definir una función de comparación. Esta función siempre será diferente en su orden u patrón de clasificación deseado (es decir, ascendente o descendente).

Permite crear algunas funciones que ordenan una matriz ascendente o descendente y que contiene valores de objeto o cadena o numéricos.

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

Ordenar números (alfabéticamente y ascendente):

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

Ordenar números (alfabéticamente y descendente):

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

Ordenar números (numéricamente y ascendiendo):

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

Ordenar números (numéricamente y descendiendo):

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

Como se indicó anteriormente, utilice los métodos sorterPriceAsc y sorterPriceDes con su matriz con la clave deseada.

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

Aquí hay una versión ligeramente modificada de la implementación elegante del libro “JavaScript: The Good Parts”.

NOTA : Esta versión de by es estable . Conserva el orden del primer orden al realizar el siguiente ordenamiento en cadena.

Le he añadido el parámetro isAscending . También lo convirtió a estándares ES6 y partes buenas “más nuevas” según lo recomendado por el autor.

Puede clasificar las propiedades ascendentes y descendentes, así como las ordenadas en cadena por múltiples propiedades.

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

Necesitarás dos funciones

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

Entonces puedes aplicar esto a cualquier propiedad de objeto:

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

' );

Aunque soy consciente de que el OP quería ordenar una serie de números, esta pregunta se ha marcado como la respuesta a preguntas similares con respecto a las cadenas. En ese sentido, las respuestas anteriores no consideran la clasificación de una matriz de texto donde el encuadre es importante. La mayoría de las respuestas toman los valores de cadena y los convierten en mayúsculas / minúsculas y luego se ordenan de una forma u otra. Los requisitos que cumplo son simples:

  • Ordenar alfabéticamente AZ
  • Los valores en mayúsculas de la misma palabra deben aparecer antes que los valores en minúsculas
  • Los mismos valores de letras (A / a, B / b) deben agruparse

Lo que espero es [ A, a, B, b, C, c ] pero las respuestas anteriores devuelven A, B, C, a, b, c . De hecho, me rascé la cabeza con esto durante más tiempo del que quería (por eso lo estoy publicando con la esperanza de que ayude a al menos otra persona). Si bien dos usuarios mencionan la función localeCompare en los comentarios para la respuesta marcada, no lo vi hasta que me topé con la función mientras buscaba. Después de leer la documentación de String.prototype.localeCompare () pude encontrar esto:

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

Esto le dice a la función que ordene los valores en mayúscula antes que los valores en minúscula. El segundo parámetro en la función localeCompare es definir la configuración regional, pero si la deja como undefined , automáticamente determina la configuración regional para usted.

Esto funciona de la misma manera para ordenar una matriz de objetos también:

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

Llego un poco tarde para la fiesta, pero a continuación está mi lógica para clasificar.

 function getSortedData(data, prop, isAsc){ return data.sort((a, b)=>{ return (a[prop] < b[prob] ? -1: 1 ) * (isAsc ? 1 : -1) }); } 

Recientemente escribí una función universal para gestionar esto por usted si desea 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) }) 

Hola, después de leer este artículo, hice un sortComparator para mis necesidades, con la funcionalidad para comparar más de un atributo json, y quiero compartirlo con ustedes.

Esta solución compara solo las cadenas en orden ascendente, pero la solución puede extenderse fácilmente para que cada atributo admita: ordenación inversa, otros tipos de datos, uso de locale, conversión, etc.

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

y el resultado es

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

y otro tipo

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

con resultado

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

Para ordenar en el campo de objeto de matriz múltiple. Ingrese su nombre de campo en la matriz de arrprop como ["a","b","c"] luego pase el segundo parámetro a la fuente real que queremos ordenar.

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

Cree una función y ordene en base a la entrada usando el código de abajo

 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" }]; function sortList(list,order){ if(order=="ASC"){ return list.sort((a,b)=>{ return parseFloat(a.price) - parseFloat(b.price); }) } else{ return list.sort((a,b)=>{ return parseFloat(b.price) - parseFloat(a.price); }); } } sortList(homes,'DESC'); console.log(homes); 
  • Usos legítimos del constructor Array
  • Encontrar el número más cercano hacia abajo a un número diferente de un set
  • Declaración de matriz de Javascript: new Array (), new Array (3), crean matrices que se comportan de manera diferente
  • Anotación JavaScript vs PHP Array
  • Comprobando el elemento de la matriz en "indefinido" en JavaScript
  • Javascript: dividir cadena en 2d matriz
  • ¿Cuál es la forma más eficiente de manejar puntos / vectores pequeños en JavaScript?
  • Javascript: convierte textarea en una matriz
  • Javascript tiene muchos buenos JS marco (como Node.js AngularJS Vue.js React.js) es el mejor lenguaje de script.