por - sort object javascript
Ordenar una matriz de objetos JavaScript (25)
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
// e.g.
// 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();
}));
}
}
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?
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"}
// ]
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, A-Z
homes.sort(sort_by(''city'', false, function(a){return a.toUpperCase()}));
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 publico con la esperanza de que ayude a al menos otra persona). Si bien dos usuarios mencionan la función localeCompare en los comentarios de la respuesta marcada, no lo vi hasta que encontré 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 igual 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" }));
Con ECMAScript 6, la respuesta de StoBor se puede hacer incluso más concisa:
homes.sort((a, b) => a.price - b.price)
Este es un buen complemento de JQuery en:
http://plugins.jquery.com/project/sort (enlace de la máquina de Wayback)
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);
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
Necesitaras 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'',
''<strong>DESCending sorted</strong><pre>'' + JSON.stringify(data) +''</pre>''
);
// ASC
data.sort((a, b) => asc(a.value, b.value));
document.body.insertAdjacentHTML(
''beforeend'',
''<strong>ASCending sorted</strong><pre>'' + JSON.stringify(data) +''</pre>''
);
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 here .
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 arrsource 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;
}
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 a-b;
}
function sorterDescending(a,b) {
return b-a;
}
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 los 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 antes, use el método sorterPriceAsc y sorterPriceDes con su matriz con la clave deseada.
homes.sort(sorterPriceAsc()) or homes.sort(sorterPriceDes())
Para ordenarlo, 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 de la siguiente manera:
// 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 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);
}
e.g. 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);
}
e.g. 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}]
Puede utilizar el método de sort JavaScript con una función de devolución de llamada:
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);
Quieres ordenarlo en Javascript, ¿verdad? Lo que quieres es la función sort() . En este caso, debe 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 anidados dentro de la matriz y decide cuál es más alto marcando el campo "precio".
Recientemente escribí una función universal para gestionar esto por ti si quieres 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);
}
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 devolución de llamada 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 .
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 sintaxis 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<l; i++) ptr = ptr[path[i]];
return ptr;
};
var comparer = function(a, b) {
for (var i = 0, l = keyPaths.length; i < l; i++) {
aVal = valueOf(a, keyPaths[i].path);
bVal = valueOf(b, keyPaths[i].path);
if (aVal > 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<l; i++) {
switch (typeof(arguments[i])) {
case "object": saveKeyPath(arguments[i]); break;
case "string": saveKeyPath(arguments[i].match(/[+-]|[^.]+/g)); break;
}
}
return this.sort(comparer);
};
})();
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 sintaxis de puntos o sintaxis 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 repositorio: https://github.com/eneko/Array.sortBy
Si tienes un navegador compatible con ES6 puedes usar:
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);
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);});
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}
]
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'' );
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;
} );
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)
})