Introducción
En los sistemas de información centrados en datos, es una forma común de mostrar datos en forma tabular. La clasificación de los datos es una característica esencial. La clasificación se puede dividir en clasificación por campo único y clasificación por diferentes direcciones de clasificación de múltiples campos. La clasificación de un solo campo es altamente limitada y no puede satisfacer las necesidades del usuario para los cambios en las preocupaciones de los datos. La clasificación de múltiples campos puede compensar mejor este defecto.
Clasificación de múltiples campos, el método de implementación se puede dividir en la implementación de back-end y la implementación front-end desde un nivel grande.
Clasificación de backend
La clasificación de implementación de back-end se puede implementar a nivel de base de datos o en el nivel de aplicación.
Es muy simple implementar la clasificación de múltiples campos a nivel de base de datos. Simplemente use el comando de clasificación SQL "Orden por" - Orden por campo1 ASC, Field2 Desc, Field3 ASC - ....
El nivel de aplicación se refiere a la capa de aplicación web (la arquitectura C/S no se discute aquí), como PHP, Java Web, ASP.Net, etc. La implementación a nivel de aplicación es utilizar lenguajes de servicio de back-end como PHP, Java y .NET (C#/VB) para ordenar datos. Tomar ASP.NET C# como ejemplo, debido a que Linq en C# tiene operaciones incorporadas en los tipos de recolección y admite la clasificación de atributos múltiples, el uso de LINQ puede lograr fácilmente este objetivo, desde F en Fos Orderby F.Name Descendiendo, F.Num Assended Select F (se puede encontrar que la sintaxis de Linq es casi exactamente lo mismo como el de SQL). Si otros idiomas no tienen soporte similar, se implementan de acuerdo con los algoritmos de clasificación, que es general y no tiene nada que ver con los lenguajes de programación.
Clasificación frontal
En JavaScript, las matrices tienen un método de clasificación "ordenar". Cuando una matriz es una matriz simple (los elementos de matriz son tipos simples: cadenas, valores y booleanos), este método se puede usar para lograr fácilmente el propósito de clasificación. Sin embargo, cuando un elemento de matriz es un tipo no simple, como un objeto de un par de nombre/valor, y desea ordenarlo en diferentes direcciones de clasificación de acuerdo con los atributos especificados, una llamada simple para el método "clasificar" no puede lograr esto.
Afortunadamente, el método "Ordenar" reserva una interfaz de clasificación personalizada, que puede implementar el método de clasificación deseado.
Veamos cómo se ve el método de matriz "clasificar".
ordenar prototipo de función
// Ordene los elementos de la matriz en su lugar y devuelva esta matriz. // Por defecto, ordene el punto de código Unicode de la cadena. Array.prototype.sort ([comparación comparable]: número); // Número: -1 | 0 | 1. // Función de comparación típica (orden ascendente ordenado). función compare comparación (item1, item2) {if (item1> item2) {return 1; // Si se clasifica en orden descendente, return -1. } else if (item1 === item2) {return 0;} else {return -1; // si se clasifica en orden descendente, return 1.}}Nota: Si no se especifica la Función Compare, los elementos se convierten en caracteres de la cadena y se clasifican en un orden de bits Unicode. Por ejemplo, "Cherry" se organizará antes de "Banana". Al clasificar los números, 9 aparecerán antes de 80 porque primero se convertirán en cuerdas, y "80" está por delante de "9".
• Si la formación comparable (a, b) es inferior a 0, entonces se organizará antes b;
• Si la formación comparable (a, b) es igual a 0, A y B
La posición relativa permanece sin cambios. Nota: Las normas de ECMAScript no garantizan este comportamiento, y no todos los navegadores cumplirán (por ejemplo, Mozilla en 2003
versiones antes de 2019);
• Si la formación comparable (a, b) es mayor que 0, b se organizará antes de a.
• CompareFunction (A, B) siempre debe devolver el mismo resultado de comparación a la misma entrada, de lo contrario, el resultado ordenado será incierto.
Nota: Los resultados de clasificación obtenidos por las reglas anteriores están en orden ascendente. Si desea obtener un resultado descendente, devolverá un resultado inferior a 0 cuando el resultado de comparación es mayor que 0. Si el resultado de la comparación es inferior a 0, puede devolver un resultado superior a 0.
Para implementar la clasificación de atributos múltiples, la clave es comparar la implementación de funciones. De acuerdo con las reglas anteriores, se implementa el orden de múltiples atributos en diferentes direcciones, y todavía se devuelve la relación de tamaño entre los dos elementos de comparación.
Entonces, ¿cómo determinar la relación de tamaño de muchos objetos de atributos? Esto se puede hacer en dos pasos.
El primer paso es registrar los resultados obtenidos comparando los dos elementos de clasificación de acuerdo con sus atributos y direcciones de clasificación.
VAR PROPERDERS = {"PROP1": "ASC", "PROP2": "DESC", "PROP3": "ASC"}; function cmp (item1, item2, proparders) {var cps = []; // utilizado para registrar los resultados de comparación de cada atributo de clasificación, -1 | 0 | 1. var isasc = true; // Ordena la dirección. for (var p en proporciones) {isasc = propors [p] === "asc"; if (item1 [p]> item2 [p]) {cps.push (isasc? 1: -1); break; // Puede saltar del bucle, porque aquí ya sabe que el item1 es "mayor que el item2". } else if (item1 [p] === item2 [p]) {cps.push (0);} else {cps.push (isasc? -1: 1); break; // Puede saltar del bucle, elemento1 "menos que" item2. }} /*...*/}El segundo paso es juzgar exhaustivamente la relación de tamaño final de los dos términos de comparación basados en los resultados de comparación de cada atributo de clasificación.
/ * ... */for (var j = 0; j <cps.length; j ++) {if (cps [j] === 1 || cps [j] === -1) {return cps [j];}} return 0;Con la idea anterior, es fácil implementar toda la función de comparación. Aquí está el código JavaScript completo para la función de comparación:
Función de comparación
function sortByProps (item1, item2) {"use estricto"; var props = []; for (var _i = 2; _i <arguments.length; _i ++) {props [_i - 2] = argumentos [_i];} var cps = []; // Almacene los resultados de la comparación de atributos de clasificación. // Si no se especifica el atributo de clasificación, ordenelo en orden ascendente de todos los atributos. var asc = true; if (props.length <1) {for (var p en item1) {if (item1 [p]> item2 [p]) {cps.push (1); break; // Si es mayor que el bucle se explotará. } else if (item1 [p] === item2 [p]) {cps.push (0);} else {cps.push (-1); break; // Si es menos que, el bucle saltará. }}} else {para (var i = 0; i <props.length; i ++) {var prop = props [i]; for (var o en prop) {asc = prop [o] === "asc"; if (item1 [o]> item2 [o]) {cps.push (asc? 1: -1); ruptura; // Si es mayor que el bucle se explotará. } else if (item1 [o] === item2 [o]) {cps.push (0);} else {cps.push (asc? -1: 1); break; // Si es menos que, el bucle saltará. }}}} para (var j = 0; j <cps.length; j ++) {if (cps [j] === 1 || cps [j] === -1) {return cps [j];}} return 0; }Casos de prueba
// --------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- propors);}); console.log (elementos);} function testasc () {test ({"name": "asc", "valor": "asc"});} function testDesc () {test ({"name:" desc "," valor ":" desc "});} testascdesc () {test ({" name ":" asc "," desc: "desc:" desc: "desc:" desc " });} function testDescasc () {test ({"nombre": "Desc", "Valor": "ASC"});} Código de tipos de mecanografiado/**** Dirección de clasificación. */type direct = "asc" | "Desc";/**** Atributo de clasificación. ** ** @interface ipropertyorder*/interface ipropertyorder {[name: string]: direct;}/**** Objeto de nombre/valor simple. ** ** @Interface isImpleObject*/Interface isImpleObject {[name: string]: string | Número | boolean;}/**** OBJETOS SIMPLES de nombre/valor de valor según el atributo especificado y la dirección de clasificación (de acuerdo con el atributo de clasificación y la dirección de clasificación, ** Compara los dos elementos a su vez y devuelve el valor que representa la posición de clasificación). ** ** @template t objeto de nombre/valor simple. ** @param {t} item1 Sorteo Comparación Elemento 1. ** @param {t} item2 Orden por comparación Elemento 2. ** @param {... iPropertyorder []} Propiedad de clasificación de propios. ** @returns Si el elemento 1 es mayor que el ítem 2, return 1, si el elemento 1 es igual al elemento 2, return 0, de lo contrario, devuelve -1. */function sortByProps <t extiende isImpleObject> (item1: t, item2: t, ... props: iPropertyorder []) {"use estricto"; var cps: array <número> = []; // almacena los resultados de la comparación de atributos de clasificación. // Si no se especifica el atributo de clasificación, ordenelo en orden ascendente de todos los atributos. var asc = true; if (props.length <1) {for (var p en item1) {if (item1 [p]> item2 [p]) {cps.push (1); break; // Si es mayor que el bucle se explotará. } else if (item1 [p] === item2 [p]) {cps.push (0);} else {cps.push (-1); break; // Si es menos que, el bucle saltará. }}} else {// Ordenar por atributos especificados y direcciones de elevación. for (var i = 0; i <props.length; i ++) {var prop = props [i]; for (var o en prop) {asc = prop [o] === "asc"; if (item1 [o]> item2 [o]) {cps.push (asc? 1: -1); romper; // Si es mayor que el bucle se explotará. } else if (item1 [o] === item2 [o]) {cps.push (0);} else {cps.push (asc? -1: 1); break; // Si es menos que, el bucle saltará. }}}} para (var j = 0; j <cps.length; j ++) {if (cps [j] === 1 || cps [j] === -1) {return cps [j];}} return 0; }Use escenarios y limitaciones
El uso de JavaScript para implementar la clasificación de múltiples atributos en el extremo frontal reduce las solicitudes al lado del servidor y reduce la presión informática en el lado del servidor, pero solo es adecuado para situaciones en las que solo los datos locales deben clasificarse. Si necesita ordenar todo el conjunto de datos en múltiples atributos, eventualmente se realizará a nivel de base de datos del lado del servidor.
Lo anterior es la descripción completa de cómo las matrices de objetos JavaScript están ordenadas por los atributos especificados y las instrucciones de clasificación que el editor le presentó. Espero que te tean útiles. Si tiene alguna pregunta, déjame un mensaje y el editor le responderá a tiempo. ¡Muchas gracias por su apoyo al sitio web de Wulin.com!