Execute o código acima. Você receberá o pedido 1, 15, 2. Isso ocorre porque o método converte tudo em uma string e usa a ordem lexicográfica padrão.

No artigo anterior, falamos sobre o que é e como trabalhar com isso. Neste artigo, vamos falar sobre matriz multidimensional.

É uma matriz que possui um ou mais elementos, que também são matrizes. Dependendo da profundidade do anúncio, em particular, ele pode ser chamado matriz bidimensional(2 níveis) também matriz tridimensional(3 níveis) também quadridimensional(4 níveis) e assim por diante.

O mais popular, depois do array unidimensional, o mais comumente usado é o array bidimensional. Vamos estudá-lo com mais detalhes.

Como você pode ver, os elementos de uma matriz bidimensional são matrizes unidimensionais. Se essas matrizes unidimensionais contivessem mais matrizes, a matriz arr já seria tridimensional.

Como exemplo, vamos criar três arrays simples e preenchê-los com dados. Vamos preencher o primeiro com números pares, o segundo com números ímpares e o terceiro com alguns dados arbitrários.

// Declara três arrays vazios var evenNumbers = new Array (); // Variável k - para índices de array evenNumbers var k = 0; var oddNumbers = new Array (); // Variável n - para índices de matriz oddNumbers var n = 0; var data = new Array ("carro", "avião", verdadeiro, 89, "m"); // Preencha a matriz números pares, com números pares para (var i = 1; i

Para ver o que está dentro do array, você pode usar uma ferramenta como console.

Por exemplo, queremos ver o conteúdo de uma matriz com números ímparesNúmeros ímpares. Para fazer isso, escreva a seguinte linha no código abaixo:

Console.log (oddNumbers);

Para ver o resultado, você precisa abrir console no navegador... No Google Chrome, isso é feito da seguinte forma: clique com o botão direito do mouse na página e, no menu de contexto, selecione a última opção “Exibir código”, ou seja, o inspetor. Na versão em inglês, essa opção é chamada de Inspecionar.

E abaixo a barra de ferramentas do desenvolvedor aparecerá. Nele, você precisa ir para a guia Console.

Agora para crie uma matriz bidimensional, você precisa declará-lo e adicionar a ele os arrays unidimensionais que você criou acima.

// Declara um array bidimensional twoDimens e preenche-o var twoDimens = new Array (números pares, números ímpares, dados); console.log (twoDimens);

Vamos ver o conteúdo desse array no console.

iterando em uma matriz bidimensional

Primeiro vamos aprender como acessar os elementos de uma matriz bidimensional.

Assim como acontece com matrizes simples, os elementos são acessados ​​por seus índices.

Por exemplo, vamos exibir o elemento no índice 3 de uma matriz com números ímpares (oddNumbers). O índice do número ímpar da matriz unidimensional na matriz bidimensional twoDimens é um (1).

Document.write ("O elemento com índice 3 da matriz de números ímpares oddNumbers é:" + twoDimens); // Elemento: 7

Na matriz twoDimens, nos referimos ao elemento no índice 1. O elemento nesse índice é a matriz oddNumbers. E neste array, já estamos acessando o elemento com índice 3, que é o número 7.

Agora vamos descer à própria questão como iterar em uma matriz bidimensional.

O loop em uma matriz bidimensional é feito usando um loop duplo. Por exemplo, vamos iterar nossa matriz twoDimens.

Para (var i = 0; i< twoDimens.length; i++){ for(var j = 0; j < twoDimens[i].length; j++){ document.write("

Elemento com índice "+ i +" "+ j +"é igual a: "+ twoDimens [i] [j] +"

No primeiro loop, iteramos sobre o próprio array twoDimens. No segundo loop, já estamos iterando sobre o próprio elemento (array). Primeiro, a variável i é igual a 0. Portanto, no segundo loop, iteramos primeiro sobre o primeiro array evenNumbers, que possui índice 0. E já dentro do segundo loop, acessamos os elementos deste array. Assim: twoDimens [j]. Onde j varia de 0 ao comprimento da matriz evenNumbers.

Depois de iterar sobre os elementos da primeira matriz, retornamos ao primeiro loop, incrementamos a variável i e continuamos a iterar sobre a segunda matriz oddNumbers, que tem índice 1. E assim, iteramos sobre cada elemento do array twoDimens.

Agora vamos dar uma olhada no resultado desta pesquisa:

Isso é tudo que eu queria falar neste artigo. Agora você sabe como criar uma matriz bidimensional, como acessar os elementos de uma matriz bidimensional e como iterar em uma matriz bidimensional. Espero que tudo esteja claro. Desejo-lhe um grande sucesso!

Matrizes

Variedadeé uma coleção ordenada de valores. Os valores em uma matriz são chamados de elementos e cada elemento é caracterizado por uma posição numérica na matriz, chamada de índice. Arrays em JavaScript não têm tipo: os elementos de um array podem ser de qualquer tipo, e diferentes elementos do mesmo array podem ser de tipos diferentes. Os elementos do array podem até ser objetos ou outros arrays, permitindo que você crie estruturas de dados complexas, como arrays de objetos e arrays de arrays.

Os índices de array em JavaScript são baseados em zero e usam inteiros de 32 bits - o primeiro elemento de um array tem índice 0. Os arrays de JavaScript são dinâmicos: eles podem aumentar e diminuir conforme necessário; não há necessidade de declarar tamanhos fixos de arrays quando eles são criados ou de realocar memória quando são redimensionados.

Arrays em JavaScript são uma forma especializada de objetos, e os índices de array significam pouco mais do que apenas nomes de propriedades, que coincidentemente são inteiros.

Criação de matrizes

A maneira mais fácil de criar um array é com um literal, que é uma lista simples de elementos do array separados por vírgulas entre colchetes. Os valores em um literal de matriz não precisam ser constantes - podem ser quaisquer expressões, incluindo literais de objeto:

Var vazio =; // array vazio var numbers =; // Array com cinco elementos numéricos var misc = [1.1, true, "a",]; // 3 elementos de tipos diferentes + vírgula final var base = 1024; var table =; // Array com variáveis ​​var arrObj = [,]; // 2 arrays dentro de objetos contendo

A sintaxe literal da matriz permite inserir uma vírgula final opcional, ou seja, literal [,] corresponde a uma matriz com dois elementos, não três.

Outra maneira de criar uma matriz é chamar o construtor Variedade ()... O construtor pode ser chamado de três maneiras diferentes:

Chame o construtor sem argumentos:

Var arr = novo Array ();

Nesse caso, um array vazio equivalente ao literal será criado.

Chame o construtor com um único argumento numérico especificando o comprimento da matriz:

Var arr = novo Array (10);

Nesse caso, uma matriz vazia com o comprimento especificado será criada. Essa forma de chamar o construtor Array () pode ser usada para pré-alocar memória para um array se o número de seus elementos for conhecido com antecedência. Observe que isso não armazena nenhum valor na matriz.

Especifique explicitamente os valores dos primeiros dois ou mais elementos da matriz ou de um elemento não numérico em uma chamada de construtor:

Var arr = novo Array (5, 4, 3, 2, 1, "teste");

Nesse caso, os argumentos do construtor tornam-se os valores dos elementos do novo array. Usar literais de array é quase sempre mais fácil do que usar o construtor Array () dessa maneira.

Ler e escrever elementos de array

Os elementos da matriz são acessados ​​usando o operador. Deve haver uma referência de array à esquerda dos parênteses. Uma expressão arbitrária que retorna um valor inteiro não negativo deve estar entre parênteses. Essa sintaxe é adequada para ler e gravar o valor de um elemento do array. Portanto, todas as seguintes instruções JavaScript são válidas:

// Cria um array com um elemento var arr = ["world"]; // Lê o item 0 var value = arr; // Escreva o valor no elemento 1 arr = 3.14; // Escreva o valor no elemento 2 i = 2; arr [i] = 3; // Escreva um valor para o elemento 3 arr = "hello"; // Leia os itens 0 e 2, escreva o valor no item 3 arr] = arr;

Deixe-me lembrá-lo de que os arrays são um tipo especializado de objeto. Os colchetes usados ​​para acessar os elementos do array agem exatamente da mesma forma que os colchetes usados ​​para acessar as propriedades de um objeto. O interpretador JavaScript converte os índices numéricos entre parênteses em strings - o índice 1 se torna a string "1" - e então usa as strings como nomes de propriedades.

Não há nada de especial na conversão de índices numéricos em strings: o mesmo pode ser feito com objetos regulares:

Var obj = (); // Cria um objeto simples obj = "um"; // Indexá-lo com inteiros

A peculiaridade das matrizes é que, ao usar nomes de propriedades que são inteiros não negativos, as matrizes determinam automaticamente o valor da propriedade comprimento... Por exemplo, o array arr foi criado acima com um único elemento. Em seguida, os valores foram atribuídos a seus elementos com os índices 1, 2 e 3. Como resultado dessas operações, o valor da propriedade de comprimento da matriz mudou e tornou-se igual a 4.

Você deve distinguir claramente entre índices em uma matriz e nomes de propriedade de objeto. Todos os índices são nomes de propriedades, mas apenas propriedades com nomes inteiros são índices. Todos os arrays são objetos e você pode adicionar propriedades a eles com qualquer nome. No entanto, se você tocar em propriedades que são índices de matriz, as matrizes reagem atualizando o valor da propriedade de comprimento conforme necessário.

Observe que números negativos e não inteiros são permitidos como índices de array. Nesse caso, os números são convertidos em strings, que são usadas como nomes de propriedades.

Adicionando e Removendo Elementos de Matriz

Já vimos que a maneira mais fácil de adicionar elementos a um array é atribuir valores a novos índices. Você também pode usar o método para adicionar um ou mais elementos ao final de uma matriz Empurre ():

Var arr =; // Cria um array vazio arr.push ("zero"); // Adicione um valor ao final arr.push ("um", 2); // Adicione mais dois valores

Você também pode adicionar um elemento ao final de uma matriz atribuindo um valor ao elemento arr. Para inserir um elemento no início de uma matriz, você pode usar o método não mudar () e os elementos existentes na matriz são deslocados para os índices mais altos.

Você pode excluir elementos de uma matriz usando o operador delete, como propriedades comuns de objetos:

Var arr =; delete arr; 2 na chegada; // falso, o índice 2 na matriz é indefinido arr.length; // 3: o operador de exclusão não altera a propriedade de comprimento da matriz

Remover um elemento é semelhante (mas ligeiramente diferente) atribuir um valor indefinido a esse elemento. Observe que a aplicação do operador delete a um elemento em uma matriz não altera o valor da propriedade length, nem move para baixo os elementos de índice superior para preencher o vazio deixado após o elemento ser excluído.

Além disso, é possível remover elementos no final de um array simplesmente atribuindo um novo valor à propriedade length. Matrizes têm um método pop ()(oposto a push ()), que diminui o comprimento da matriz em 1 e retorna o valor do elemento removido. Também existe um método mudança ()(oposto a unshift ()), que remove o elemento no início da matriz. Ao contrário do operador delete, o método shift () desloca todos os elementos uma posição abaixo de seus índices atuais.

Finalmente, existe um método polivalente splice (), que permite inserir, excluir e substituir elementos de matrizes. Ele altera o valor da propriedade de comprimento e desloca os elementos da matriz com índices mais baixos ou mais altos, conforme necessário. Discutiremos todos esses métodos um pouco mais tarde.

Matrizes multidimensionais

JavaScript não suporta arrays multidimensionais "reais", mas faz um bom trabalho em imitá-los usando arrays de arrays. Para acessar um item de dados em uma matriz de matrizes, é suficiente usar o operador duas vezes.

Por exemplo, suponha que a matriz variável seja uma matriz de matrizes de números. Cada elemento da matriz [x] é uma matriz de números. Você pode usar a expressão matrix [x] [y] para acessar um número específico em uma matriz. Abaixo está um exemplo específico onde uma matriz bidimensional é usada como uma tabela de multiplicação:

// Cria um array multidimensional var table = new Array (10); // Existem 10 linhas na tabela para (var i = 0; i

Métodos de classe Array

O padrão ECMAScript 3 define muitas funções convenientes para trabalhar com arrays como parte de Array.prototype, que estão disponíveis como métodos de qualquer array. Esses métodos serão apresentados nas subseções a seguir.

Método Join ()

O método Array.join () converte todos os elementos da matriz em strings, concatena-os e retorna a string resultante. Um argumento opcional pode ser passado para o método com uma string que será usada para separar os itens na string de resultado. Se nenhuma string delimitadora for especificada, uma vírgula será usada. Por exemplo, o seguinte snippet resulta na string "1,2,3":

Var arr =; arr.join (); // "1,2,3" arr.join ("-"); // "1-2-3"

O método reverse ()

O método Array.reverse () inverte a ordem dos elementos em uma matriz e retorna uma matriz reordenada. A permutação é feita diretamente na matriz original, ou seja, este método não cria uma nova matriz com elementos reordenados, mas os reordena em uma matriz já existente. Por exemplo, o seguinte snippet, que usa os métodos reverse () e join (), resulta na string "3,2,1":

Var arr =; arr.reverse (). join (); // "3,2,1"

Método Sort ()

O método Array.sort () classifica os elementos na matriz original e retorna a matriz classificada. Se o método sort () for chamado sem argumentos, a classificação será realizada em ordem alfabética (para comparação, os itens são temporariamente convertidos em strings, se necessário). Os elementos indefinidos são agrupados no final da matriz.

Você pode passar uma função de comparação como um argumento para sort () para classificar em qualquer outra ordem não alfabética. Esta função define qual dos seus dois argumentos deve vir primeiro na lista classificada. Se o primeiro argumento deve preceder o segundo, a função de comparação deve retornar um número negativo. Se o primeiro argumento vier após o segundo na matriz classificada, a função deve retornar um número maior que zero. E se os dois valores forem equivalentes (ou seja, sua ordem não é importante), a função de comparação deve retornar 0:

Var arr =; arr.sort (); // Ordem alfabética: 1111, 222, 33, 4 arr.sort (function (a, b) (// Ordem numérica: 4, 33, 222, 1111 return ab; // Retorna o valor 0 // dependendo da classificação peça a e b)); // Classifica de trás para frente, do maior para o menor arr.sort (function (a, b) (return b-a));

Observe como é conveniente usar uma função sem nome neste trecho. A função de comparação é usada apenas aqui, portanto, não há necessidade de dar-lhe um nome.

O método concat ()

O método Array.concat () cria e retorna uma nova matriz contendo os elementos da matriz original na qual o método concat () foi chamado e os valores de quaisquer argumentos passados ​​para o método concat (). Se qualquer um desses argumentos for uma matriz, seus elementos serão adicionados à matriz retornada. Deve-se observar, entretanto, que não há conversão recursiva de uma matriz de matrizes em uma matriz unidimensional. O método concat () não modifica a matriz original. Abaixo estão alguns exemplos:

Var arr =; arr.concat (4, 5); // Retorna arr.concat (); // Retorna arr.concat (,) // Retorna arr.concat (4,]) // Retorna]

Método Slice ()

O método Array.slice () retorna uma fatia, ou subarray, da matriz especificada. Os dois argumentos para o método definem o início e o fim do fragmento retornado. A matriz retornada contém o elemento numerado no primeiro argumento mais todos os elementos subsequentes até (mas não incluindo) o elemento numerado no segundo argumento.

Se apenas um argumento for especificado, a matriz retornada conterá todos os elementos da posição inicial ao final da matriz. Se algum dos argumentos for negativo, ele especifica o número do elemento relativo ao final da matriz. Portanto, o argumento -1 corresponde ao último elemento da matriz e o argumento -3 corresponde ao terceiro elemento da matriz a partir do final. aqui estão alguns exemplos:

Var arr =; arr.slice (0,3); // Retorna arr.slice (3); // Retorna arr.slice (1, -1); // Retorna arr.slice (-3, -2); // Retornará

Método Splice ()

O método Array.splice () é um método genérico que insere ou remove elementos de uma matriz. Ao contrário dos métodos slice () e concat (), o método splice () modifica a matriz original na qual foi chamado. Observe que os métodos splice () e slice () têm nomes muito semelhantes, mas executam operações completamente diferentes.

O método splice () pode remover elementos de uma matriz, inserir novos elementos ou fazer ambos ao mesmo tempo. Os elementos da matriz são deslocados conforme necessário para que, após a inserção ou exclusão, uma sequência contígua seja formada.

O primeiro argumento para o método splice () especifica a posição na matriz a partir da qual inserir e / ou excluir. O segundo argumento especifica o número de elementos a serem removidos (cortados) do array. Se o segundo argumento for omitido, todos os elementos da matriz da matriz especificada até o final da matriz serão removidos. O método splice () retorna um array dos elementos removidos ou (se nenhum dos elementos foi removido) um array vazio.

Os primeiros dois argumentos para o método splice () especificam os elementos da matriz a serem removidos. Esses argumentos podem ser seguidos por qualquer número de argumentos adicionais especificando os elementos a serem inseridos na matriz, começando na posição especificada no primeiro argumento.

Var arr =; arr.splice (4); // Retorna arr = arr.splice (1,2); // Retorna arr = arr.splice (1,1); // Retornará; arr = arr =; arr.splice (2,0, "a", "b"); // Retornará; arr =

Os métodos push () e pop ()

Os métodos push () e pop () permitem que você trabalhe com matrizes como pilhas. O método push () adiciona um ou mais novos elementos ao final da matriz e retorna seu novo comprimento. O método pop () realiza a operação oposta - remove o último elemento da matriz, diminui o comprimento da matriz e retorna o valor removido. Observe que ambos os métodos modificam a matriz original em vez de criar uma cópia modificada dela.

Os métodos unshift () e shift ()

Os métodos unshift () e shift () se comportam da mesma maneira que push () e pop (), exceto que eles inserem e removem elementos no início da matriz, em vez de no final. O método unshift () muda os elementos existentes para índices maiores para criar espaço, adiciona o elemento ou elementos ao início do array e retorna o novo comprimento do array. O método shift () remove e retorna o primeiro elemento da matriz, deslocando todos os elementos subsequentes uma posição para baixo para ocupar o espaço vazio no início da matriz.

Última atualização: 04.09.2018

As matrizes destinam-se a trabalhar com conjuntos de dados. A expressão new Array () é usada para criar uma matriz:

Var meuArray = novo Array ();

Também existe uma maneira mais curta de inicializar uma matriz:

Var myArray =;

Neste caso, estamos criando um array vazio. Mas você também pode adicionar dados iniciais a ele:

Var pessoas = ["Tom", "Alice", "Sam"]; console.log (pessoas);

Nesse caso, haverá três elementos no myArray. Graficamente, pode ser representado da seguinte forma:

Os índices são usados ​​para se referir aos elementos individuais de uma matriz. A contagem começa do zero, ou seja, o primeiro elemento terá índice 0 e o último terá índice 2:

Var pessoas = ["Tom", "Alice", "Sam"]; console.log (pessoas); // Tom var person3 = people; // Sam console.log (pessoa3); // Sam

Se tentarmos acessar um elemento em um índice maior que o tamanho da matriz, obtemos indefinidos:

Var pessoas = ["Tom", "Alice", "Sam"]; console.log (pessoas); // Indefinido

Além disso, pelo índice, os valores para os elementos da matriz são definidos:

Var pessoas = ["Tom", "Alice", "Sam"]; console.log (pessoas); // Tom people = "Bob"; console.log (pessoas); // Bob

Além disso, ao contrário de outras linguagens como C # ou Java, você pode instalar um elemento que não foi instalado inicialmente:

Var pessoas = ["Tom", "Alice", "Sam"]; console.log (pessoas); // undefined - existem apenas três elementos no array people = "Bob"; console.log (pessoas); // Bob

Também é importante notar que, ao contrário de várias linguagens de programação em JavaScript, os arrays não são fortemente tipados, um array pode armazenar dados de diferentes tipos:

Var objects = ["Tom", 12, verdadeiro, 3,14, falso]; console.log (objetos);

operador de propagação

O operador spread ... permite que você pegue valores de uma matriz separadamente:

Deixe números =; console.log (... números); // 1 2 3 4 console.log (números); //

O operador de propagação é especificado antes da matriz. Como resultado, a expressão ... números retornará um conjunto de números, mas não será uma matriz, mas valores individuais.

Matrizes multidimensionais

As matrizes podem ser unidimensionais e multidimensionais. Cada elemento em uma matriz multidimensional pode ser uma matriz separada. Acima consideramos uma matriz unidimensional, agora vamos criar uma matriz multidimensional:

Var numbers1 =; // array unidimensional var numbers2 = [,]; // array bidimensional

Visualmente, ambas as matrizes podem ser representadas da seguinte forma:

Números de matriz unidimensional1

Para obter um único elemento de uma matriz, um índice também é usado:

Var tomInfo = pessoas;

Só agora a variável tomInfo representará um array. Para obter um elemento dentro de uma matriz aninhada, precisamos usar sua segunda dimensão:

Console.log ("Nome:" + pessoas); // Tom console.log ("Idade:" + pessoas); // 25

Ou seja, se pudermos representar visualmente uma matriz bidimensional na forma de uma tabela, então o elemento pessoas se referirá à célula da tabela, que está localizada na interseção da primeira linha e da segunda coluna (a primeira dimensão é 0 - uma linha, a segunda dimensão - 1 - uma coluna).

Também podemos fazer a tarefa:

Var pessoas = [["Tom", 25, falso], ["Bill", 38, verdadeiro], ["Alice", 21, falso]]; pessoas = 56; // atribuir um valor separado console.log (pessoas); // 56 pessoas = ["Bob", 29, falso]; // atribuir um array console.log (pessoas); // Bob

Ao criar matrizes multidimensionais, não estamos limitados apenas a matrizes bidimensionais, mas também podemos usar matrizes de grandes dimensões:

Números de var =; números =; // agora os números são uma matriz bidimensional números =; // agora os números são uma matriz tridimensional números = 5; // o primeiro elemento do array 3D é 5 console.log (números);

Saudações a todos os interessados ​​em arrays e classificação multidimensionais em JavaScript. Na publicação atual, tentarei cobrir este tópico em todos os detalhes.

Portanto, depois de ler este artigo, você aprenderá por que os arrays multidimensionais são usados ​​em aplicativos da web, como são criados e como podem ser manipulados e classificados. Vamos começar a aprender!

Como as matrizes multidimensionais são criadas e para que servem?

Para começar, vale a pena lembrar como um array unidimensional regular é criado.

var array =

Agora, lembre-se de que um array multidimensional é um array de arrays. Eu concordo, parece uma tautologia. No entanto, leia a definição novamente. Na verdade, uma matriz multidimensional consiste em um certo número de matrizes aninhadas.

Considere a seguinte situação. No início da partida, o usuário insere seu nome e, após o término, uma tabela de classificação com os nomes dos jogadores e seus recordes é exibida na tela.

É claro que tais informações são armazenadas em um banco de dados. Mas quando o retiramos do banco de dados, obtemos um array multidimensional. Afinal, cada subarray contém o login do jogador e o número de pontos marcados.

Tudo ficará assim:

resultados de var = [["Markus", 333], ["Natasha", 211], ["Alexey", 124]];

Como você pode ver, as informações podem ser armazenadas de forma heterogênea. Podem ser strings, números e pares. Isso é possível porque os arrays em não são digitados.

Neste caso, o acesso aos elementos ocorre por meio de um operador duplo.

Para consolidar o material, analise um pequeno programa.

Resultados =

Os arrays são uma maneira bastante conveniente de armazenar dados complexos ordenados enquanto os processa. Além disso, é muito cómodo trabalhar com eles e, ao mesmo tempo, a velocidade do seu processamento é bastante elevada.

Métodos de classificação de dados

Para matrizes em JavaScript, existe um método integrado chamado ordenar ()... Esta ferramenta é muito flexível. E agora vou explicar o porquê.

Se você usar um método sem parâmetros, ele ordenará automaticamente os subarrays pelo primeiro elemento em ordem alfabética. Então, ao ligar resultados.ordenar () o objeto analisado terá a seguinte aparência:

Alexey, 124

Markus, 333

Natasha, 211

E se você trocar os elementos em cada array aninhado, você obtém:

124, Alexey

211, Natasha

333, Markus

Neste caso, para comparação, todos os elementos são temporariamente convertidos em strings.

Se, para resolver uma tarefa específica, você precisa de uma função que classifica os elementos de uma forma não padronizada, então você mesmo pode escrevê-la e passá-la como um parâmetro para ordenar ()... Deve-se observar que uma função definida pelo usuário deve retornar:

• um número positivo (geralmente escolha 1) se o primeiro item especificado seguir o segundo na comparação;
• um número negativo (geralmente -1) se o segundo item selecionado vier após o primeiro;
• zero se os dois valores testados forem iguais.

Como exemplo, vamos pegar a matriz inicial resultados classificar por pontos. Além disso, os resultados serão classificados do mais alto para o mais baixo. Isso pode ser feito de duas maneiras.

Na primeira versão, mudei a lógica de classificação, ou seja, em uma situação em que é necessário retornar um número positivo, eu retorno um negativo e vice-versa.

Tabela de registro:

Mas, no segundo método, deixei a lógica de classificação intacta, mas, adicionalmente, usei outro método - reverter ()... Como o nome sugere, o reverso inverte a ordem dos elementos.

Portanto, a função sort () será semelhante a esta:

função RecordSort (a, b) (if (a> b) retorna 1; senão if (a< b) return -1; else return 0; }

Depois disso, vamos adicionar o método acima.

A conclusão é feita de maneira semelhante.

Quero chamar sua atenção para um ponto importante. Ao usar essas funções, todas as alterações ocorrem na matriz à qual você as aplica. Portanto, se você precisar preservar a forma original dos dados, crie uma cópia e edite-a.

Bem, então falei sobre matrizes multidimensionais e sua classificação. Se você gostou do artigo, assine o blog e leia outras publicações igualmente interessantes. Eu ficaria grato pelas repostagens. Até a próxima vez!

Bye Bye!

Atenciosamente, Roman Chueshov