Einführung
In datenzentrierten Informationssystemen ist es eine häufige Möglichkeit, Daten in tabellarischer Form anzuzeigen. Sortierdaten sind ein wesentliches Merkmal. Sortierung kann durch ein einzelnes Feld und die Sortierung durch verschiedene Sortieranweisungen mehrerer Felder in Sortierung unterteilt werden. Die Sortierung des Einzelfeldes ist stark begrenzt und kann die Bedürfnisse des Benutzers nach Änderungen der Datenbedenken nicht erfüllen. Die Sortierung von Multi-Field-Sortierungen kann diesen Defekt besser ausmachen.
Die Multi-Feld-Sortierung, die Implementierungsmethode kann aus großer Ebene in Back-End-Implementierung und Front-End-Implementierung unterteilt werden.
Backend -Sortierung
Die Back-End-Implementierungssortierung kann auf Datenbankebene oder auf Anwendungsebene implementiert werden.
Es ist sehr einfach, die Sortierung von Mehrfeld-Sortieren auf Datenbankebene zu implementieren. Verwenden Sie einfach den Befehl SQL Sorting "Order By" - Order by Field1 ASC, Field2 Desc, Field3 ASC - ....
Die Anwendungsstufe bezieht sich auf die Webanwendungsschicht (die C/S-Architektur wird hier nicht erörtert) wie PHP, Java Web, ASP.NET usw. Die Implementierung auf Anwendungsebene besteht darin, Back-End-Dienstsprachen wie PHP, Java und .NET (C#/VB) zum Sortieren von Daten zu verwenden. Wenn LINQ in C# als Beispiel ASP.NET C# integrierte und integrierte Operationen zu Sammelstypen hat und die Sortierung von Multi-Attribut-Sortiern unterstützt, kann die Verwendung von LINQ dieses Ziel leicht erreichen-von f in fos orderby f.name absteigend, F.Num Guting Select F (es kann festgestellt werden, dass die Sortiersyntax von linq fast genau das gleiche ist wie bei SQL). Wenn andere Sprachen keine ähnliche Unterstützung integriert haben, werden sie nach Sortieralgorithmen implementiert, was allgemein ist und nichts mit Programmiersprachen zu tun hat.
Front-End-Sortierung
In JavaScript haben Arrays eine Sortiermethode "Sortierung". Wenn ein Array ein einfaches Array ist (Array -Elemente sind einfache Typen - Zeichenfolgen, Werte und Booleschen), kann diese Methode verwendet werden, um den Sortierzweck einfach zu erreichen. Wenn ein Array-Element jedoch ein nicht einfacher Typ ist, z. B. ein Objekt eines Namens/Wertpaares, und Sie es gemäß den angegebenen Attributen in verschiedenen Sortierrichtungen sortieren möchten, kann ein einfacher Aufruf der "Sortier" -Methode dies nicht erreichen.
Glücklicherweise behält sich die "Sortier" -Methode eine benutzerdefinierte Sortierschnittstelle vor, mit der die gewünschte Sortiermethode implementiert werden kann.
Mal sehen, wie die Array -Methode "Sortier" aussieht.
Sortieren Sie den Funktionsprototyp
// Sortieren Sie die Elemente des Arrays an Ort und Stelle und geben Sie dieses Array zurück. // Standardmäßig sortieren Sie nach Unicode -Codepunkt der Zeichenfolge. Array.Prototype.sort ([CompareFunction]: Nummer); // Nummer: -1 | 0 | 1. // Typische Vergleichsfunktion (sortierte Aufstiegsreihenfolge). Funktion CompareFunction (Item1, Item2) {if (item1> item2) {return 1; // Wenn in absteigender Reihenfolge sortiert wird, geben Sie -1 zurück. } else if (item1 === item2) {return 0;} else {return -1; // Wenn in absteigender Reihenfolge sortiert, kehren Sie 1.}} Zurück,}}Hinweis: Wenn die Vergleichsfunktion nicht angegeben ist, werden die Elemente in Zeichen der Zeichenfolge konvertiert und in Unicode -Bitreihenfolge sortiert. Zum Beispiel wird "Cherry" vor "Bananen" arrangiert. Wenn Sie Nummern sortieren, erscheint 9 vor 80, weil sie zuerst in Saiten umgewandelt werden und "80" vor "9" voraus ist.
• Wenn die Vergleichung (a, b) weniger als 0 beträgt, wird A vor b angeordnet.
• Wenn Vergleichefunktion (a, b) gleich 0, a und b entspricht
Die relative Position bleibt unverändert. Hinweis: ECMAScript -Standards garantieren dieses Verhalten nicht und nicht alle Browser entsprechen es (z. B. Mozilla im Jahr 2003
Versionen vor 2019);
• Wenn die Vergleichung (a, b) größer als 0 ist, wird B vor a angeordnet.
• Vergleichefunktion (a, b) muss immer das gleiche Vergleichsergebnis mit demselben Eingang zurückgeben, andernfalls ist das sortierte Ergebnis ungewiss.
HINWEIS: Die nach den oben genannten Regeln erzielten Sortierergebnisse sind in steigender Reihenfolge. Wenn Sie ein absteigendes Ergebnis erzielen möchten, geben Sie ein Ergebnis weniger als 0 zurück, wenn das Vergleichsergebnis größer als 0 ist. Wenn das Vergleichsergebnis weniger als 0 liegt, können Sie ein Ergebnis von mehr als 0 zurückgeben.
Um die Sortierung von mehreren Attributen zu implementieren, besteht der Schlüssel darin, die Implementierung von Funktionen zu vergleichen. Gemäß den obigen Regeln wird die Reihenfolge mehrerer Attribute in verschiedene Richtungen implementiert, und die Größenbeziehung zwischen den beiden Vergleichselementen wird noch zurückgegeben.
Wie kann man die Größenbeziehung vieler Attributobjekte bestimmen? Dies kann in zwei Schritten erfolgen.
Der erste Schritt besteht darin, die Ergebnisse zu erfassen, indem die beiden Sortierelemente gemäß ihren Sortierattributen und -anweisungen verglichen werden.
var proporters = {"prop1": "asc", "prop2": "desc", "prop3": "asc"}; Funktion cmp (item1, item2, proporders) {var cps = []; // Wird verwendet, um die Vergleichsergebnisse jedes Sortierattributs aufzuzeichnen, -1 | 0 | 1. var isasc = true; // Richtung sortieren. für (var p in Propodiern) {isasc = Proportern [p] === "ASC"; if (item1 [p]> item2 [p]) {cps.push (isasc? 1: -1); break; // Sie können aus der Schleife springen, denn hier wissen Sie bereits, dass Artikel1 "größer als Item2" ist. } else if (item1 [p] === item2 [p]) {cps.push (0);} else {cps.push (isasc? -1: 1); break; // Sie können aus der Schleife springen, Artikel 1 "weniger als" Artikel2. }} /*...*/}Der zweite Schritt besteht darin, die endgültige Größenbeziehung der beiden Vergleichsbegriffe auf der Grundlage der Vergleichsergebnisse jedes Sortierattributs umfassend zu beurteilen.
/ * ... */for (var j = 0; j <cps.length; j ++) {if (cps [j] === 1 || cps [j] === -1) {return CPS [j];}} return 0;Mit der obigen Idee ist es einfach, die gesamte Vergleichsfunktion zu implementieren. Hier ist der vollständige JavaScript -Code für die Vergleichsfunktion:
Vergleichsfunktion
Funktion SortByProps (Item1, Element2) {"Strikt verwenden"; var props = []; für (var _i = 2; _i <argumente.length; _i ++) {props [_i - 2] = argumente [_i];} var cps = []; // Speichern Sie die Ergebnisse des Sortierattributvergleichs. // Wenn das Sortierattribut nicht angegeben ist, sortieren Sie es in aufsteigender Reihenfolge aller Attribute. var asc = true; if (props.length <1) {for (var p in item) {if (item1 [p]> item2 [p]) {cps.push (1); break; // Wenn größer als die Schleife ausbricht. } else if (item1 [p] === item2 [p]) {cps.push (0);} else {cps.push (-1); break; // Wenn es weniger als ist, springt die Schleife heraus. }}} else {for (var i = 0; i <props.length; i ++) {var prop = props [i]; für (var o in prop) {asc = prop [o] === "asc"; if (item [o]> item2 [o]) {cps.push (asc? 1: -1); break; // Wenn größer als die Schleife ausbricht. } else if (item1 [o] === item2 [o]) {cps.push (0);} else {cps.push (asc? -1: 1); break; // Wenn es weniger als ist, springt die Schleife heraus. }}}} für (var j = 0; j <cps.length; j ++) {if (cps [j] === 1 || cps [j] === -1) {return cps [j];}} return 0; }Testfälle
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- proportern);}); console.log (items);} function testasc () {test ({"name": "asc", "value": "asc"}); });} Funktion testDescasc () {test ({"name": "desc", "value": "asc"});} TypeScript -Code/**** Sortierrichtung. */Typ Direct = "ASC" | "Desc";/**** sortieren Attribut. ** ** @Interface iPropertyOrder*/interface iPropertyOrder {[Name: String]: Direct;}/**** Einfacher Name/Wertobjekt. ** ** @Interface IsimpleObject*/Schnittstelle IsimpleObject {[Name: String]: String | Nummer | boolean;}/**** Sortieren Sie einfache Name/Wertobjekte nach dem angegebenen Attribut und Sortierrichtung (gemäß dem Sortierattribut und der Sortierrichtung ** vergleicht ** die beiden Elemente nacheinander und gibt den Wert zurück, der die Sortierposition darstellt). ** ** @template t einfaches Name/Wertobjekt. ** @param {t} item1 sortieren Vergleichselement 1. ** @param {t} item2 sortieren nach Vergleichselement. ** @returns Wenn Punkt 1 größer als Punkt 2 ist, Rückgabe 1, wenn Punkt 1 gleich Punkt 2, zurücksetzt, zurücksend, zurück -1. */Funktion SortByProps <T erweitert IsimpleObject> (Item1: t, Item2: t, ... Requisiten: iPropertyOrder []) {"Strict"; var cps: array <number> = []; // speichert die Ergebnisse des Sortierattributvergleichs. // Wenn das Sortierattribut nicht angegeben ist, sortieren Sie es in aufsteigender Reihenfolge aller Attribute. var asc = true; if (props.length <1) {for (var p in item) {if (item1 [p]> item2 [p]) {cps.push (1); break; // Wenn größer als die Schleife ausbricht. } else if (item1 [p] === item2 [p]) {cps.push (0);} else {cps.push (-1); break; // Wenn es weniger als ist, springt die Schleife heraus. }}} else {// sortieren nach angegebenen Attributen und Hebeanweisungen. für (var i = 0; i <props.length; i ++) {var prop = props [i]; für (var o in prop) {asc = prop [o] === "asc"; if (item [o]> item2 [o]) {cps.push (asc? 1: -1); break; // Wenn größer als die Schleife ausbricht. } else if (item1 [o] === item2 [o]) {cps.push (0);} else {cps.push (asc? -1: 1); break; // Wenn es weniger als ist, springt die Schleife heraus. }}}} für (var j = 0; j <cps.length; j ++) {if (cps [j] === 1 || cps [j] === -1) {return cps [j];}} return 0; }Verwenden Sie Szenarien und Einschränkungen
Die Verwendung von JavaScript zum Implementieren von Multi-Attribut-Sortierungen im vorderen Ende reduziert die Anforderungen auf die Serverseite und reduziert den Rechendruck auf der Serverseite, ist jedoch nur für Situationen geeignet, in denen nur lokale Daten sortiert werden müssen. Wenn Sie den gesamten Datensatz in mehreren Attributen sortieren müssen, erfolgt dies schließlich auf der serverseitigen Datenbankebene.
Das obige ist die vollständige Beschreibung, wie JavaScript -Objekt -Arrays nach den angegebenen Attributen und Sortieranweisungen sortiert werden, die der Editor Ihnen vorgestellt hat. Ich hoffe, sie werden Ihnen hilfreich sein. Wenn Sie Fragen haben, hinterlassen Sie mir bitte eine Nachricht und der Editor wird Ihnen rechtzeitig antworten. Vielen Dank für Ihre Unterstützung auf der Wulin.com -Website!