Introduction
Dans les systèmes d'information centrés sur les données, c'est un moyen courant d'afficher les données sous forme tabulaire. Les données de tri sont une caractéristique essentielle. Le tri peut être divisé en tri par champ unique et tri par différentes directions de tri de plusieurs champs. Le tri à champ est très limité et ne peut pas répondre aux besoins de l'utilisateur pour les modifications des problèmes de données. Le tri à plusieurs champs peut mieux compenser ce défaut.
Tri à plusieurs champs, la méthode de mise en œuvre peut être divisée en implémentation back-end et implémentation frontale à partir d'un grand niveau.
Tri backend
Le tri de l'implémentation arrière peut être implémenté au niveau de la base de données ou au niveau de l'application.
Il est très simple d'implémenter le tri multi-champs au niveau de la base de données. Utilisez simplement la commande de tri SQL "Ordre par" - Ordre par champ1 ASC, Field2 Desc, Field3 ASC - ....
Le niveau d'application fait référence à la couche d'application Web (l'architecture C / S n'est pas discutée ici), comme PHP, Java Web, ASP.NET, etc. L'implémentation au niveau de l'application consiste à utiliser des langages de service arrière tels que PHP, Java et .NET (C # / VB) pour trier les données. Prendre ASP.NET C # comme exemple, car Linq en C # a des opérations intégrées sur les types de collecte et prend en charge le tri multi-attributs, en utilisant LINQ peut facilement atteindre cet objectif - de F dans Fos OrderBy F.Name DESCENDING, F.NUM ASSENTION SELECT F (on peut trouver que la syntax de type de Linq est presque exactement la même que celle de SQL). Si d'autres langages n'ont pas de support similaire intégré, ils sont implémentés en fonction des algorithmes de tri, qui sont généraux et n'ont rien à voir avec les langages de programmation.
Tri avant
Dans JavaScript, les tableaux ont une méthode de tri "tri". Lorsqu'un tableau est un tableau simple (les éléments du tableau sont des types simples - chaînes, valeurs et booléens), cette méthode peut être utilisée pour atteindre facilement l'objectif de tri. Cependant, lorsqu'un élément de tableau est un type non simple, comme un objet d'une paire de nom / valeur, et que vous souhaitez le trier dans différentes directions de tri selon les attributs spécifiés, un simple appel à la méthode "tri" ne peut pas y parvenir.
Heureusement, la méthode "Sort" réserve une interface de tri personnalisée, qui peut implémenter la méthode de tri souhaitée.
Voyons à quoi ressemble la méthode du tableau de «tri».
Trier le prototype de fonction
// trie les éléments du tableau en place et renvoyez ce tableau. // Par défaut, tri par point de code Unicode de la chaîne. Array.prototype.sort ([CompareFonction]: numéro); // Numéro: -1 | 0 | 1. // Fonction de comparaison typique (Ordre ascendant trié). fonction compareFunction (item1, item2) {if (item1> item2) {return 1; // Si trié dans l'ordre descendant, retournez -1. } else if (item1 === item2) {return 0;} else {return -1; // Si trié par ordre décroissant, retournez 1.}}Remarque: Si la fonction de comparaison n'est pas spécifiée, les éléments sont convertis en caractères de la chaîne et triés dans l'ordre du bit Unicode. Par exemple, "Cherry" sera organisé avant "banane". Lors du tri des numéros, 9 apparaîtra avant 80 car ils seront d'abord convertis en chaînes, et "80" est en avance sur "9".
• Si la fonction de comparaison (A, B) est inférieure à 0, alors A sera organisé avant B;
• Si comparefonction (a, b) est égal à 0, a et b
La position relative reste inchangée. Remarque: les normes ECMAScript ne garantissent pas ce comportement, et tous les navigateurs ne le respecteront pas (par exemple, Mozilla en 2003
versions avant 2019);
• Si la fonction de comparaison (a, b) est supérieure à 0, b sera disposée avant a.
• CompareFonction (a, b) doit toujours renvoyer le même résultat de comparaison à la même entrée, sinon le résultat trié sera incertain.
Remarque: Les résultats de tri obtenus par les règles ci-dessus sont dans l'ordre croissant. Si vous souhaitez obtenir un résultat décroissant, vous renverrez un résultat inférieur à 0 lorsque le résultat de comparaison est supérieur à 0. Si le résultat de comparaison est inférieur à 0, vous pouvez retourner un résultat supérieur à 0.
Pour implémenter le tri multi-attributs, la clé est de comparer la mise en œuvre des fonctions. Selon les règles ci-dessus, l'ordre de plusieurs attributs dans différentes directions est mis en œuvre et la relation de taille entre les deux éléments de comparaison est toujours retournée.
Alors, comment déterminer la relation de taille de nombreux objets d'attribut? Cela peut être fait en deux étapes.
La première étape consiste à enregistrer les résultats obtenus en comparant les deux éléments de tri en fonction de leurs attributs de tri et des directions.
var proporders = {"Prop1": "ASC", "prop2": "desc", "prop3": "ASC"}; fonction cmp (item1, item2, proporders) {var cps = []; // Utilisé pour enregistrer les résultats de comparaison de chaque attribut de tri, -1 | 0 | 1 et 1 var isasc = true; // Trier la direction. pour (var p dans les proporteurs) {Isasc = proporders [p] === "ASC"; if (item1 [p]> item2 [p]) {cps.push (isasc? 1: -1); break; // Vous pouvez sauter de la boucle, car ici vous savez déjà que l'élément1 est "supérieur à l'élément2". } else if (item1 [p] === item2 [p]) {cps.push (0);} else {cps.push (isasc? -1: 1); break; // Vous pouvez sauter de la boucle, item1 "moins que" item2. }} /*...*/}La deuxième étape consiste à juger de manière approfondie la relation de taille finale des deux termes de comparaison en fonction des résultats de comparaison de chaque attribut de tri.
/ * ... * / for (var j = 0; j <cps.length; j ++) {if (cps [j] === 1 || cps [j] === -1) {return cps [j];}} return 0;Avec l'idée ci-dessus, il est facile d'implémenter toute la fonction de comparaison. Voici le code JavaScript complet pour la fonction de comparaison:
Fonction de comparaison
Fonction SortByProps (item1, item2) {"Utiliser Strict"; var props = []; for (var _i = 2; _i <arguments.length; _i ++) {props [_i - 2] = arguments [_i];} var cps = []; // Stockez les résultats de la comparaison d'attribut de tri. // Si l'attribut de tri n'est pas spécifié, triez-le dans l'ordre croissant de tous les attributs. var asc = true; if (props.length <1) {for (var p dans item1) {if (item1 [p]> item2 [p]) {cps.push (1); break; // Si plus grand que, la boucle éclatera. } else if (item1 [p] === item2 [p]) {cps.push (0);} else {cps.push (-1); break; // Si c'est moins que, la boucle sautera. }}} else {for (var i = 0; i <props.length; i ++) {var prop = props [i]; for (var o in prop) {asc = prop [o] === "ASC"; if (item1 [o]> item2 [o]) {cps.push (asc? 1: -1); Break; // Si plus grand que, la boucle éclatera. } else if (item1 [o] === item2 [o]) {cps.push (0);} else {cps.push (asc? -1: 1); break; // Si c'est moins que, la boucle sautera. }}}} pour (var j = 0; j <cps.length; j ++) {if (cps [j] === 1 || cps [j] === -1) {return cps [j];}} return 0; }Cas de test
// ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Propricteurs);}); console.log (items);} fonction testasc () {test ({"name": "ASC", "Value": "ASC"});} fonction testDesc () {test ({"name": "desc", "valeur": "desc"});} fonction testascdeSC () {test ({"name": "Asc": ":": ":": ": DESC" });} fonction testDescasc () {test ({"name": "desc", "valeur": "asc"});} Code TypeScript / **** Direction de tri. * / Type Direct = "ASC" | "desc"; / **** Tri attribut. ** ** @Interface iPropertyOrder * / Interface iPropertyOrder {[name: String]: Direct;} / **** Nom / Value Nom / Value Objet. ** ** @Interface IsImpleObject * / Interface isImpleObject {[Name: String]: String | Numéro | booléen;} / **** Trier les objets de nom / valeur simples en fonction de l'attribut spécifié et de la direction de tri (selon l'attribut de tri et la direction de tri, ** compare les deux éléments à leur tour et renvoie la valeur représentant la position de tri). ** ** @Template T Objet simple Nom / Value. ** @param {t} item1 trie Comparaison Item 1. ** @param {t} item2 Trier par comparaison Item 2. ** @param {... iPropertyOrder []} Propriété de tri des accessoires. ** @returns Si l'article 1 est supérieur à l'article 2, renvoyez 1, si l'article 1 est égal à l'article 2, renvoyez 0, sinon renvoyez -1. * / fonction sortbyprops <t étend isImpLeObject> (item1: t, item2: t, ... accessoires: iPropertyOrder []) {"Utiliser strict"; var cps: array <nom> = []; // stocke les résultats de la comparaison d'attribut de tri. // Si l'attribut de tri n'est pas spécifié, triez-le dans l'ordre croissant de tous les attributs. var asc = true; if (props.length <1) {for (var p dans item1) {if (item1 [p]> item2 [p]) {cps.push (1); break; // Si plus grand que, la boucle éclatera. } else if (item1 [p] === item2 [p]) {cps.push (0);} else {cps.push (-1); break; // Si c'est moins que, la boucle sautera. }}} else {// Trier par des attributs spécifiés et des directions de levage. pour (var i = 0; i <props.length; i ++) {var prop = props [i]; for (var o dans prop) {asc = prop [o] === "ASC"; if (item1 [o]> item2 [o]) {cps.push (asc? 1: -1); break; // Si plus grand que, la boucle éclatera. } else if (item1 [o] === item2 [o]) {cps.push (0);} else {cps.push (asc? -1: 1); break; // Si c'est moins que, la boucle sautera. }}}} pour (var j = 0; j <cps.length; j ++) {if (cps [j] === 1 || cps [j] === -1) {return cps [j];}} return 0; }Utilisez des scénarios et des limitations
L'utilisation de JavaScript pour implémenter le tri multi-attribution à l'extrémité frontale réduit les demandes du côté serveur et réduit la pression informatique du côté du serveur, mais elle convient uniquement aux situations où seules les données locales doivent être triées. Si vous devez trier l'intégralité de l'ensemble de données dans plusieurs attributs, cela se fera éventuellement au niveau de la base de données côté serveur.
Ce qui précède est la description complète de la façon dont les tableaux d'objets JavaScript sont triés par les attributs spécifiés et les directions de tri que l'éditeur vous a présentées. J'espère qu'ils vous seront utiles. Si vous avez des questions, veuillez me laisser un message et l'éditeur vous répondra à temps. Merci beaucoup pour votre soutien au site Web Wulin.com!