Introdução
Nos sistemas de informação centrados em dados, é uma maneira comum de exibir dados em forma de tabular. A classificação de dados é um recurso essencial. A classificação pode ser dividida em classificação por campo único e classificação por diferentes direções de classificação de vários campos. A classificação de campo único é altamente limitado e não pode atender às necessidades do usuário de alterações nas preocupações dos dados. A classificação de vários campos pode compensar melhor esse defeito.
Classificação de vários campos, o método de implementação pode ser dividido na implementação de back-end e na implementação front-end de um grande nível.
Classificação de back -end
A classificação de implementação de back-end pode ser implementada no nível do banco de dados ou no nível do aplicativo.
É muito simples implementar a classificação de vários campos no nível do banco de dados. Basta usar o comando de classificação SQL "Ordem por" - Ordem de Field1 ASC, Field2 desc, Field3 ASC - .... ....
O nível de aplicativo refere-se à camada de aplicativos da Web (a arquitetura C/S não é discutida aqui), como PHP, Java Web, ASP.NET, etc. A implementação no nível do aplicativo deve usar linguagens de serviço de back-end, como PHP, Java e .NET (C#/VB) para classificar dados. Tomar asp.net C# como exemplo, porque o LINQ em C# possui operações internas nos tipos de coleta e suporta a classificação de múltiplos atributos, o uso do LINQ pode atingir facilmente esse objetivo-a partir de F no Fos Orderby F.Name Descending, F.Num, que está de acordo com a seleção F (pode-se encontrar que a síntox de classificação do LINQ é quase exatamente o mesmo do QL). Se outros idiomas não tiverem suporte semelhante embutido, eles serão implementados de acordo com os algoritmos de classificação, que são gerais e não têm nada a ver com linguagens de programação.
Classificação front-end
No JavaScript, as matrizes têm um método de classificação "classificação". Quando uma matriz é uma matriz simples (os elementos da matriz são tipos simples - strings, valores e booleanos), esse método pode ser usado para alcançar facilmente o objetivo de classificar. No entanto, quando um elemento de matriz é do tipo não simples, como um objeto de um par de nome/valor, e você deseja classificá-lo em diferentes direções de classificação de acordo com os atributos especificados, uma chamada simples para o método de "classificação" não pode conseguir isso.
Felizmente, o método de "classificação" se reserva uma interface de classificação personalizada, que pode implementar o método de classificação desejado.
Vamos ver como é o método de matriz "classificação".
Classificar protótipo da função
// Classifique os elementos da matriz no lugar e retorne esta matriz. // Por padrão, classifique pelo ponto de código Unicode da string. Array.prototype.sort ([CompareFunction]: número); // Número: -1 | 0 | 1. // Função de comparação típica (ordem ascendente classificada). função comparefunção (item1, item2) {if (item1> item2) {return 1; // Se classificado em ordem descendente, retorne -1. } else if (item1 === item2) {return 0;} else {return -1; // se classificado em ordem descendente, retorne 1.}}NOTA: Se a CompareFunction não for especificada, os elementos serão convertidos em caracteres da string e classificados no Unicode Bit Order. Por exemplo, "Cherry" será organizado antes de "banana". Ao classificar os números, 9 aparecerão antes de 80 porque serão convertidos em cordas primeiro e "80" está à frente de "9".
• Se a comparação (a, b) for menor que 0, a será organizado antes de B;
• Se compararfunção (a, b) for igual a 0, a e b
A posição relativa permanece inalterada. Nota: os padrões do ECMAScript não garantem esse comportamento, e nem todos os navegadores cumprirão (por exemplo, Mozilla em 2003
versões antes de 2019);
• Se a comparação (a, b) for maior que 0, B será organizado antes de a.
• Comparefunção (a, b) deve sempre retornar o mesmo resultado de comparação para a mesma entrada, caso contrário, o resultado classificado será incerto.
Nota: Os resultados de classificação obtidos pelas regras acima estão em ordem crescente. Se você deseja obter um resultado descendente, retornará um resultado menor que 0 quando o resultado da comparação for maior que 0. Se o resultado da comparação for menor que 0, poderá retornar um resultado maior que 0.
Para implementar a classificação multi-atributo, a chave é comparar a implementação de funções. De acordo com as regras acima, a ordem de vários atributos em diferentes direções é implementada e a relação de tamanho entre os dois itens de comparação ainda é retornada.
Então, como determinar o tamanho do relacionamento de muitos objetos de atributo? Isso pode ser feito em duas etapas.
A primeira etapa é registrar os resultados obtidos comparando os dois itens de classificação de acordo com seus atributos e direções de classificação.
var propridores = {"prop1": "ASC", "prop2": "desc", "prop3": "ASC"}; função cmp (item1, item2, proformans) {var cps = []; // usado para registrar os resultados da comparação de cada atributo de classificação, -1 | 0 | 1. var isasc = true; // Classifique a direção. for (var p em propordiais) {isasc = proporders [p] === "ASC"; if (item1 [p]> item2 [p]) {cps.push (isasc? 1: -1); quebra; // Você pode pular do loop, porque aqui você já sabe que o item1 é "maior que o item2". } else if (item1 [p] === item2 [p]) {cps.push (0);} else {cps.push (isasc? -1: 1); quebra; // Você pode pular do loop, Item1 "menor que" Item2. }} /*...*/}A segunda etapa é julgar de forma abrangente o relacionamento final do tamanho dos dois termos de comparação com base nos resultados da comparação de cada atributo de classificação.
/ * ... */for (var j = 0; j <cps.length; j ++) {if (cps [j] === 1 || cps [j] === -1) {return cps [j];}} retornar 0;Com a ideia acima, é fácil implementar toda a função de comparação. Aqui está o código JavaScript completo para a função de comparação:
Função de comparação
função SortByProps (Item1, Item2) {"Use Strict"; var Props = []; para (var _i = 2; _i <argumentos.Length; _i ++) {props [_i - 2] = argumentos [_i];} var cps = []; // Armazene os resultados da comparação de atributos de classificação. // Se o atributo de classificação não for especificado, classifique -o em ordem crescente de todos os atributos. var asc = true; if (props.length <1) {for (var p em item1) {if (item1 [p]> item2 [p]) {cps.push (1); break; // Se maior que o loop irá quebrar. } else if (item1 [p] === item2 [p]) {cps.push (0);} else {cps.push (-1); break; // Se for menor que o loop pulará. }}} else {for (var i = 0; i <props.length; i ++) {var prop = props [i]; para (var o em prop) {aSC = prop [o] === "ASC"; if (item1 [o]> item2 [o]) {cps.push (asc? 1: --1); quebra; // Se maior que o loop irá quebrar. } else if (item1 [o] === item2 [o]) {cps.push (0);} else {cps.push (asc? -1: 1); quebra; // Se for menor que o loop pulará. }}}} para (var j = 0; j <cps.length; j ++) {if (cps [j] === 1 || cps [j] === -1) {return cps [j];}} retornar 0; }Casos de teste
// --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- proporders);}); console.log (itens);} função testsC () {test ({"name": "ASC", "value": "ASC"});} function testdesc () {teste ({"name": "desct", "value": "desc"});}} testascdc () {"testsc (" test ":" desc "}); });} função testdescasc () {test ({"name": "desc", "value": "asc"});} tipycript code/**** classificar direção. */tipo Direct = "ASC" | "Desc";/**** atributo de classificação. ** ** @Interface iPropertyOrder*/Interface iPropertyOrder {[Nome: String]: Direct;}/**** Nome/Valor simples objeto. ** ** @Interface isImpLeObject*/interface isImpLeObject {[nome: string]: string | número | boolean;}/**** Classifique o nome/valor simples de acordo com o atributo especificado e a direção de classificação (de acordo com o atributo de classificação e a direção de classificação, ** compara os dois itens por sua vez e retorna o valor que representa a posição de classificação). ** ** @Template t Nome/Valor Simples. ** @param {t} item1 Classificar o item 1. ** @param {t} item2 classificar por comparação Item 2. ** @returns Se o item 1 for maior que o item 2, retorne 1, se o item 1 for igual ao item 2, retorne 0, caso contrário, retorne -1. */function SortByProps <t estende o isimpLeObject> (Item1: t, Item2: T, ... Props: iPropertyOrder []) {"Use Strict"; var cps: Array <número> = []; // armazena os resultados da comparação de atributos de classificação. // Se o atributo de classificação não for especificado, classifique -o em ordem crescente de todos os atributos. var asc = true; if (props.length <1) {for (var p em item1) {if (item1 [p]> item2 [p]) {cps.push (1); break; // Se maior que o loop irá quebrar. } else if (item1 [p] === item2 [p]) {cps.push (0);} else {cps.push (-1); break; // Se for menor que o loop pulará. }}} else {// Classificar por atributos especificados e direções de levantamento. para (var i = 0; i <props.Length; i ++) {var prop = props [i]; para (var o em prop) {aSC = prop [o] === "ASC"; if (item1 [o]> item2 [o]) {cps.push (asc? 1: -1); quebra; // Se maior que o loop irá quebrar. } else if (item1 [o] === item2 [o]) {cps.push (0);} else {cps.push (asc? -1: 1); quebra; // Se for menor que o loop pulará. }}}} para (var j = 0; j <cps.length; j ++) {if (cps [j] === 1 || cps [j] === -1) {return cps [j];}} retornar 0; }Use cenários e limitações
O uso do JavaScript para implementar a classificação multi-atributo no front-end reduz as solicitações para o lado do servidor e reduz a pressão de computação no lado do servidor, mas é adequado apenas para situações em que apenas dados locais precisam ser classificados. Se você precisar classificar todo o conjunto de dados em vários atributos, ele será feito no nível do banco de dados do lado do servidor.
O exposto acima é a descrição completa de como as matrizes de objeto JavaScript são classificadas pelos atributos especificados e instruções de classificação que o editor apresentou a você. Espero que eles sejam úteis para você. Se você tiver alguma dúvida, deixe -me uma mensagem e o editor responderá a você a tempo. Muito obrigado pelo seu apoio ao site wulin.com!