Tri d'un tableau d'objets JavaScript par propriété
J'ai lu les objets suivants en utilisant Ajax et les ai stockés dans un tableau:
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"
}
];
Comment créer une fonction pour trier les objets en fonction de la propriété price dans croissant o ordre décroissant en utilisant uniquement JavaScript?
Trier les maisons par prix par ordre croissant:
homes.sort(function(a, b) {
return parseFloat(a.price) - parseFloat(b.price);
});
Ou après la version ES6:
homes.sort((a, b) => parseFloat(a.price) - parseFloat(b.price));
On peut trouver de la documentation ici .
Voici une version plus flexible, qui vous permet de créer des fonctions de tri réutilisables et de trier par n'importe quel champ.
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));
}
}
Maintenant, vous pouvez trier par n'importe quel champ à 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, A-Z
homes.sort(sort_by('city', false, function(a){return a.toUpperCase()}));
Pour le trier, vous devez créer une fonction de comparaison prenant deux arguments. Appelez ensuite la fonction de tri avec cette fonction de comparateur comme suit:
// 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 vous voulez trier par ordre croissant, changez les expressions de chaque côté du signe moins.
pour le tri des chaînes au cas où quelqu'un en aurait besoin,
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 vous avez un navigateur compatible ES6 , vous pouvez utiliser:
La différence entre les ordres de tri croissant et décroissant est le signe de la valeur renvoyée par votre fonction de comparaison:
var ascending = homes.sort((a, b) => Number(a.price) - Number(b.price));
var descending = homes.sort((a, b) => Number(b.price) - Number(a.price));
Voici un extrait de code fonctionnel:
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);Vous voulez le trier en Javascript, non? Ce que vous voulez, c'est _ [sort() function) . Dans ce cas, vous devez écrire une fonction de comparaison et la transmettre à sort(), afin que quelque chose ressemble à ceci:
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));
Votre comparateur prend chacun des hachages imbriqués dans le tableau et décide lequel est le plus élevé en cochant la case "price".
Je recommande GitHub: Array sortBy - une meilleure implémentation de la méthode sortBy qui utilise le transformation de Schwartzian
Mais pour le moment, nous allons essayer cette approche Gist: sortBy-old.js .
Créons une méthode pour trier des tableaux capables d’organiser des objets selon certaines propriétés.
Création de la fonction de tri
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));
});
};
}());
Définition de données non triées
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"}
];
En l'utilisant
Organiser le tableau, par "date" comme 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 vous souhaitez ignorer la casse, définissez le rappel 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 vous souhaitez convertir le champ "date" en Date, tapez:
// 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" }
Ici vous pouvez jouer avec le code: jsbin.com/lesebi
Grâce à @ Ozesh , le problème lié aux propriétés avec (== --- ==) valeurs a été fixée.
Utilisez lodash.sortBy , (les instructions utilisant commonjs, vous pouvez aussi simplement mettre le script include-tag pour le cdn en haut de votre code HTML)
var sortBy = require('lodash.sortby');
// or
sortBy = require('lodash').sortBy;
Ordre décroissant
var descendingOrder = sortBy( homes, 'price' ).reverse();
Ordre croissant
var ascendingOrder = sortBy( homes, 'price' );
Cela aurait pu être réalisé par une simple ligne valueof () fonction de tri. Exécutez l'extrait de code ci-dessous pour voir la démo.
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);Je suis un peu en retard pour la fête mais voici ma logique de tri.
function getSortedData(data, prop, isAsc) {
return data.sort((a, b) => {
return (a[prop] < b[prop] ? -1 : 1) * (isAsc ? 1 : -1)
});
}
Vous pouvez utiliser la méthode JavaScript sort avec une fonction de rappel:
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);
Bien que je sache que le PO voulait trier un tableau de nombres, cette question a été marquée comme la réponse à des questions similaires concernant les chaînes. Pour cela, les réponses ci-dessus n'envisagent pas de trier un tableau de texte lorsque la casse est importante. La plupart des réponses prennent les valeurs de chaîne et les convertissent en majuscules/minuscules, puis trient d'une manière ou d'une autre. Les exigences que je respecte sont simples:
- Trier alphabétiquement de A à Z
- Les valeurs majuscules du même mot doivent précéder les valeurs minuscules
- Les mêmes valeurs de lettre (A/a, B/b) doivent être regroupées
Ce que j'attends, c'est [ A, a, B, b, C, c ] mais les réponses ci-dessus retournent A, B, C, a, b, c. En fait, je me suis égratigné la tête plus longtemps que je ne le souhaitais (c'est pourquoi je publie ceci dans l'espoir que cela aidera au moins une autre personne). Tandis que deux utilisateurs mentionnent la fonction localeCompare dans les commentaires pour la réponse marquée, je ne l'ai pas vu jusqu'à ce que je sois tombé sur la fonction lors de la recherche. Après avoir lu la documentation de String.prototype.localeCompare () , je suis parvenu à trouver ceci:
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" ]
Cela indique à la fonction de trier les valeurs majuscules avant les valeurs minuscules. Le deuxième paramètre de la fonction localeCompare consiste à définir les paramètres régionaux, mais si vous le laissez comme undefined, il calcule automatiquement les paramètres régionaux pour vous.
Cela fonctionne de la même manière pour trier un tableau d'objets:
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" }));
J'ai aussi travaillé avec une sorte de classement et plusieurs types de champs:
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);
});
Résultat
[
{"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}
]
Voici le point culminant de toutes les réponses ci-dessus.
Validation 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();
}));
}
}
Si vous utilisez nderscore.js , essayez sortBy:
// price is of an integer type
_.sortBy(homes, "price");
// price is of a string type
_.sortBy(homes, function(home) {return parseInt(home.price);});
Voici une version légèrement modifiée de l'implémentation élégante du livre "JavaScript: The Good Parts".
NOTE: Cette version de by est stable. Il conserve l'ordre du premier tri lors de l'exécution du prochain tri en chaîne.
J'ai ajouté le paramètre isAscending. Également converti en ES6 normes et "nouvelles" bonnes parties comme recommandé par l'auteur.
Vous pouvez trier par ordre croissant, décroissant ou chaîné selon plusieurs propriétés.
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"}
// ]Bien que ce soit un peu excessif de ne trier qu'un seul tableau, cette fonction prototype permet de trier les tableaux Javascript par n'importe quelle clé, par ordre croissant ou décroissant , y compris les clés imbriquées , en utilisant la syntaxe 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);
};
})();
Usage:
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)"
Tri par propriétés imbriquées avec la syntaxe point ou la syntaxe tableau:
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)"
Tri par plusieurs clés:
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)"
Vous pouvez créer le référentiel: https://github.com/eneko/Array.sortBy
Pour un tableau d'éléments normal uniquement:
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]
Pour un tableau d'objets:
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}]
Pour trier un tableau, vous devez définir une fonction de comparaison. Cette fonction est toujours différente en fonction du modèle ou de l’ordre de tri souhaité (par exemple, croissant ou décroissant).
Permet de créer des fonctions permettant de trier un tableau par ordre croissant ou décroissant et contenant un objet, une chaîne ou des valeurs numériques.
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']);
}
Trier les numéros (par ordre alphabétique et croissant):
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.sort();
Trier les numéros (par ordre alphabétique et par ordre décroissant):
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.sort();
fruits.reverse();
Trier les nombres (numériquement et croissant):
var points = [40,100,1,5,25,10];
points.sort(sorterAscending());
Trier les nombres (numériquement et décroissant):
var points = [40,100,1,5,25,10];
points.sort(sorterDescending());
Comme ci-dessus, utilisez la méthode sorterPriceAsc et sorterPriceDes avec votre tableau avec la clé souhaitée.
homes.sort(sorterPriceAsc()) or homes.sort(sorterPriceDes())
Avec ECMAScript 6, StoBor répond de manière encore plus concise:
homes.sort((a, b) => a.price - b.price)
Créer une fonction et trier en fonction de l'entrée en utilisant le code ci-dessous
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);
Ordre décroissant du prix:
homes.sort((x,y) => {return y.price - x.price})
Ordre croissant du prix:
homes.sort((x,y) => {return x.price - y.price})
Vous aurez besoin de deux fonctions
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;
}
Ensuite, vous pouvez l'appliquer à n'importe quelle propriété d'objet:
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>'
);Pour trier sur plusieurs champs d'objet de tableau. Entrez votre nom de champ dans arrprop tableau comme ["a","b","c"] puis transmettez le deuxième paramètre arrsource la source réelle que nous voulons trier.
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;
}
Bonjour, après avoir lu cet article, j’ai mis au point un compilateur sortComparator, avec la fonctionnalité de comparaison de plus d’un attribut JSON, et je souhaite le partager avec vous.
Cette solution compare uniquement les chaînes par ordre croissant, mais elle peut facilement être étendue pour chaque attribut à prendre en charge: ordre inversé, autres types de données, utilisation de la locale, diffusion, 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);
});
et le résultat est
$ node sort
4 Bevery Hills CA 90210 319250
5 New York NY 00010 962500
3 Dallas TX 75201 162500
et une autre sorte
homes.sort(function(a, b) {
return sortComparator(a, b, ['city', 'Zip']);
});
avec résultat
$ node sort
4 Bevery Hills CA 90210 319250
3 Dallas TX 75201 162500
5 New York NY 00010 962500
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)
})
Un code simple:
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"
}
];
let sortByPrice = homes.sort(function (a, b)
{
return parseFloat(b.price) - parseFloat(a.price);
});
for (var i=0; i<sortByPrice.length; i++)
{
document.write(sortByPrice[i].h_id+' '+sortByPrice[i].city+' '
+sortByPrice[i].state+' '
+sortByPrice[i].Zip+' '+sortByPrice[i].price);
document.write("<br>");
}J'ai récemment écrit une fonction universelle pour gérer cela pour vous si vous voulez l'utiliser.
/**
* 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);
}