As palavras anteriores
Uma matriz é um conjunto de valores organizados em ordem e, em relação aos nomes de propriedades do objeto, estão fora de ordem. Essencialmente, as matrizes usam números como teclas de pesquisa, enquanto os objetos possuem nomes de atributos definidos pelo usuário. JavaScript não possui matrizes associativas reais, mas objetos podem ser usados para implementar a função da associativa
Array () é apenas um tipo especial de objeto (), ou seja, uma instância do Array () é basicamente uma instância do objeto () com alguma funcionalidade extra. As matrizes podem conter qualquer tipo de valores, que pode ser atualizado ou excluído a qualquer momento, e o tamanho da matriz é ajustado dinamicamente.
Além dos objetos, o tipo de matriz é provavelmente o tipo mais usado em JavaScript. Além disso, as matrizes em JavaScript são bem diferentes daqueles da maioria dos outros idiomas. Este artigo apresentará o tipo de matriz em JavaScript
Crie uma matriz
Existem duas maneiras de criar uma matriz: usando a sintaxe literal e usando o construtor Array ()
【Literal】
Usar os literais da matriz é a maneira mais fácil de criar uma matriz. Elementos de matriz separados com vírgulas entre colchetes
var em vazio = []; // matriz sem elementos var primos = [2,3,5,7,11]; // matriz com 5 valores
Embora as matrizes JavaScript sejam listas ordenadas de dados e matrizes em outros idiomas, diferentemente de outros idiomas, cada item de matrizes JavaScript pode conter qualquer tipo de dados
var misc = [1.1, verdadeiro, "a"]; // 3 elementos de diferentes tipos
Os valores nos literais da matriz não precisam ser constantes, podem ser qualquer expressão
var base = 1024; var tabela = [base, base+1, base+2, base+3];
Pode conter literais de objeto ou outros literais de matriz
var b = [[1, {x: 1, y: 2}], [2, {x: 3, y: 4}]];Se os elementos da matriz ainda forem matrizes, uma matriz multidimensional será formada
var a = [[1, 2], [3, 4]];
[Nota] Ao usar a notação literal numérica, o construtor da matriz não será chamado
【Construtor】
Existem três maneiras de chamar construtores
【1】 Sem parâmetros, crie uma matriz vazia
// Este método cria uma matriz vazia sem nenhum elemento, que é equivalente à quantidade direta da matriz [] var a = new Array ();
【2】 Existe um parâmetro numérico, que é usado para especificar o comprimento da matriz
var a = nova matriz (10); console.log (a); // [] console.log (a [0], A.Length); // indefinido 10
[Nota] Se houver outro tipo de parâmetro, uma matriz contendo apenas aqueles desse valor será criada
var a = new Array ('10 '); console.log (a); // [' 10 '] console.log (a [0], A.Length); // 10 1【3】 Quando existem vários parâmetros, os parâmetros são representados como elementos específicos da matriz
var a = nova matriz (1,2,3); console.log (a); // [1,2,3] console.log (a [0], a [1], a [2]); // 1 2 3
Ao usar o construtor Array (), o novo operador pode ser omitido
var a1 = array (); var a2 = matriz (10); var a3 = matriz (1,2,3); console.log (a1, a2, a3); // [] [] [1,2,3]
Natureza da Array
As matrizes são um conjunto de valores organizados em ordem. Em essência, as matrizes são objetos especiais.
Tipo de [1, 2, 3] // "objeto"
A particularidade de uma matriz se reflete em que seus nomes -chave são um conjunto de números inteiros (0, 1, 2…) organizados em ordem. Como os nomes dos membros da matriz são corrigidos, a matriz não precisa especificar um nome de chave para cada elemento, mas cada membro do objeto deve especificar um nome de chave.
var arr = ['a', 'b', 'c']; console.log (object.keys (arr)); // ["0", "1", "2"] var obj = {name1: 'a', name2: 'b', nome3: 'c'};Matrizes são formas especiais de objetos. O acesso a elementos da matriz com colchetes é como acessar as propriedades dos objetos com colchetes.
A linguagem JavaScript estipula que os nomes dos objetos são strings, de modo que os nomes das matrizes são realmente strings. A razão pela qual ele pode ser lido com valores numéricos é que nomes de chave não cortão serão convertidos em strings e depois usados como nomes de atributos
o = {}; // Crie um objeto comum o [1] = "um"; // indexá -lo com um número inteiro // o nome de chave numérico é automaticamente convertido em uma string var = ['a', 'b', 'c']; arr ['0'] // 'a'arr [0] //' a 'No entanto, é necessário distinguir entre o índice de matrizes e os nomes dos atributos de objeto: Todos os índices são nomes de atributos, mas apenas nomes de atributos inteiros entre 0 ~ 232-2 (4294967294) são índices
var a = []; // ÍNDICE A ['1000'] = 'ABC'; a [1000] // 'abc' // índice A [1,00] = 6; a [1] // 6
[Nota] Os valores individuais não podem ser usados como identificadores. Portanto, os membros da matriz só podem ser expressos entre colchetes
var arr = [1, 2, 3]; arr [0]; // 1arr.0; // SyntaxeRorror
Uma matriz pode ser indexada usando números negativos ou não inteiros. No entanto, como não está dentro da faixa de 0 ~ 2 à potência de 32-2, é apenas o nome do atributo da matriz, não o índice da matriz. A característica óbvia é que ele não altera o comprimento da matriz
var a = [1,2,3]; // Nome do atributo a [-1.23] = true; console.log (a.Length); // 3 // ÍNDICE A [10] = 5; console.log (A.Length); // 11 // Nome do atributo a ['abc' = '' testing '; Console.Log (A.Length);
Matrizes esparsas
Uma matriz esparsa é uma matriz contendo índices descontínuos a partir de 0.
【1】 A maneira mais direta de fazer matrizes esparsas é usar o operador de exclusão
var a = [1,2,3,4,5]; exclua um [1]; console.log (a [1]); // indefinedconsole.log (1 em a); // false
【2】 Os valores dos elementos podem ser omitidos entre vírgulas de matrizes, e matrizes esparsas podem ser criadas omitindo valores de elementos.
var a = [1 ,, 3,4,5]; console.log (a [1]); // undefinedconsole.log (1 em a); // false
[Nota] Há uma diferença entre o valor do elemento omitido e o valor do elemento cujo valor é indefinido.
var a = [1 ,, 3,4,5]; console.log (a [1]); // undefinedconsole.log (1 em a); // falsevar a = [1, indefinido, 3,4,5]; console.log (a [1]); /////1//10;
Se você usar vírgulas no final da matriz, existem diferenças entre os navegadores. A vírgula é ignorada pelo navegador padrão, enquanto o navegador IE8 agrega um valor indefinido no final
// Saída padrão do navegador [1,2], enquanto a saída do navegador IE8 [1,2, indefinido] var a = [1,2,]; console.log (a); // saída padrão do navegador 2, enquanto o IE8-Browser Output 3Var a = [,,]; Console.Log (A.Length);
Matrizes escassas o suficiente são geralmente mais lentas na implementação do que matrizes densas e têm maior utilização da memória, e o tempo para procurar elementos nessa matriz é o tempo que o tempo para procurar propriedades de objeto regular
Comprimento da matriz
Cada matriz possui um atributo de comprimento, que é esse atributo que o distingue dos objetos JavaScript convencionais. Para matrizes densas (ou seja, não-separadas), o valor do atributo de comprimento representa o número de elementos na matriz e seu valor é 1 maior que o maior índice da matriz.
[] .Length // => 0: A matriz não tem elementos ['a', 'b', 'c']. Comprimento // => 3: O índice máximo é 2 e o comprimento é 3
Quando uma matriz é uma matriz esparsa, o valor do atributo de comprimento é maior que o número de elementos. Da mesma forma, seu valor é 1 maior que o maior índice da matriz
[,,].comprimento; //3(Array(10)).length;
A particularidade das matrizes é refletida principalmente no fato de que a duração da matriz pode ser ajustada dinamicamente:
【1】 Se você atribuir um valor a um elemento de matriz e o índice I é maior ou igual ao comprimento da matriz existente, o valor do atributo de comprimento será definido como i+1
var arr = ['a', 'b']; arr.length // 2arr [2] = 'c'; arr.length // 3arr [9] = 'd'; arr.length // 10arr [1000] = 'e'; arr.length // 1001
【2】 Ao definir o atributo de comprimento a um número inteiro não negativo n menor que o comprimento atual, elementos com o valor do índice de matriz atual maior ou igual a n serão excluídos dele
a = [1,2,3,4,5]; // da matriz de 5 elementos A.Length = 3; // agora A é [1,2,3] A.Length = 0; // Exclua todos os elementos. a é [] A.Length = 5; // O comprimento é 5, mas não há elementos, assim como o novo
Array (5)
[Nota] Uma maneira eficaz de limpar a matriz é definir a propriedade de comprimento para 0
var arr = ['a', 'b', 'c']; arr.length = 0; arr // []
【3】 Defina o valor do atributo de comprimento da matriz como maior que o seu comprimento atual. Na verdade, isso não adiciona novos elementos à matriz, apenas cria uma área vazia no final da matriz
var a = ['a']; a.Length = 3; console.log (a [1]); // undefinedconsole.log (1 em a); // false
Se o comprimento estiver definido como um valor ilegal (ou seja, um valor fora do intervalo 0--232-2), o JavaScript relatará um erro
// Definir valor negativo [] Comprimento = -1 // RangeError: Comprimento da matriz inválida // O número de elementos da matriz é maior ou igual a 2 à potência de 32 []. Comprimento = Math.pow (2,32) // RangeError: Lengray inválido Array // Definir string [].
Como uma matriz é essencialmente um objeto, você pode adicionar atributos à matriz, mas isso não afeta o valor do atributo de comprimento
var a = []; a ['p'] = 'abc'; console.log (a.length); // 0a [2.1] = 'abc'; console.log (a.length); // 0
Array Traversal
A maneira mais comum de percorrer os elementos da matriz usando o loop
var a = [1, 2, 3]; para (var i = 0; i <a.length; i ++) {console.log (a [i]);}Claro, você também pode usar um loop de tempo
var a = [1, 2, 3]; var i = 0; while (i <A.Length) {console.log (a [i]); i ++;} var l = A.Length; while (l--) {console.log (a [l]);}Mas se a matriz for uma matriz esparsa, use um loop para loop e você precisará adicionar algumas condições
// pula o elemento inexistente var a = [1 ,,, 2]; para (var i = 0; i <A.Length; i ++) {if (! (I em a)) continue; console.log (a [i]);}Você também pode usar para/em loops para processar matrizes esparsas. O loop atribui um nome de atributo enumerável (incluindo índice de matriz) à variável loop por vez. O índice inexistente não será atravessado para
var a = [1 ,,, 2]; para (var i em a) {console.log (a [i]);}Como o loop for/in pode enumerar nomes de atributos herdados, como métodos adicionados ao Array.prototype. Por esse motivo, para/em loops não deve ser usado em matrizes, a menos que métodos de detecção adicionais sejam usados para filtrar propriedades indesejadas
var a = [1 ,,, 2]; ab = 'b'; para (var i em a) {console.log (a [i]); // 1 2 'b'} // pula ivar a = [1 ,,, 2]; ab = 'b'; para (var i em a) {if (string (string (math.fl.fl.F.Abs (número (var i em a) {if (string (string (math.fl. continue; console.log (a [i]); // 1 2}A especificação JavaScript permite que os loops percorram as propriedades de um objeto em diferentes ordens. Geralmente, a implementação de travessia dos elementos da matriz está em ordem ascendente, mas não é garantido que seja assim. Em particular, se uma matriz tiver atributos de objeto e elementos de matriz, os nomes de atributos retornados provavelmente estão na ordem em que foram criados e não na ordem do tamanho numérico. Se o algoritmo depende da ordem de travessia, é melhor não usar para/in, mas usar regularmente para loops
Array de aula
Objetos com atributos de comprimento e atributos inteiros não negativos correspondentes são chamados de objetos semelhantes a matrizes
// classe Demonstração de matriz var a = {}; var i = 0; while (i <10) {a [i] = i*i; i ++;} a.Length = i; var total = 0; para (var j = 0; j <A.Length; J ++) {total+= a [j];}Existem três objetos de matriz de classe comuns:
【1】 Objeto de argumentos
// Função do objeto de argumentos args () {return argumentos} var Arraylike = args ('a', 'b'); matriz [0] // 'a'arraylike.length // 2arraylike Instância de array // false【2】 Objeto retornado pelo método DOM (como Document.getElementsByTagName () Método)
// elemento dom var elts = document.getElementsByTagName ('H3'); ELTS.Length // 3elts Instância de Array // Falso【3】 String
// string 'abc' [1] // 'b''abc'.length // 3'abc' instância de array // false
[Nota] Strings são valores imutáveis; portanto, quando vistos como matrizes, são somente leitura. Por exemplo, push (), class (), reverse (), splice () e outros métodos de matriz modificarão a matriz. Eles são inválidos na string e relatarão um erro
var str = 'abc'; array.prototype.foreach.call (str, function (chr) {console.log (chr); // abc}); array.prototype.splice.call (str, 1); console.log (str);O método de fatia de uma matriz transforma o objeto da matriz em uma matriz real
var Arr = Array.prototype.slice.Call (Arraylike);
Os métodos de matriz JavaScript são definidos especificamente como gerais, portanto, eles funcionam corretamente não apenas em matrizes reais, mas também em objetos de matriz de classe. No ECMAScript5, todos os métodos de matriz são gerais. No ECMAScript3, todos os métodos, exceto ToString () e Tolocalestring () também são comuns
var a = {'0': 'a', '1': 'b', '2': 'c', comprimento: 3}; array.prototype.join.call (a, '+'); // 'a+b+c'array.p rototype.slice.call (a, 0); // ['a', 'b', 'c'] Array.prototype.map.call (a, função (x) {return x.toupPercase ();}); // ['a', 'b', 'c']