Un breve análisis del sistema de tipo de matriz en JavaScript

Las palabras anteriores

Una matriz es un conjunto de valores organizados en orden, y en relación con los nombres de propiedad del objeto están fuera de servicio. Esencialmente, las matrices usan números como claves de búsqueda, mientras que los objetos tienen nombres de atributos definidos por el usuario. JavaScript no tiene matrices asociativas reales, pero los objetos se pueden usar para implementar la función de asociativa

Array () es solo un tipo especial de objeto (), es decir, una instancia de array () es básicamente una instancia de objeto () con alguna funcionalidad adicional. Las matrices pueden contener cualquier tipo de valores, que se puede actualizar o eliminar en cualquier momento, y el tamaño de la matriz se ajusta dinámicamente.

Además de los objetos, el tipo de matriz de matriz es probablemente el tipo más utilizado en JavaScript. Además, las matrices en JavaScript son bastante diferentes de las de la mayoría de los otros idiomas. Este artículo presentará el tipo de matriz de matriz en JavaScript

Crear una matriz

Hay dos formas de crear una matriz: usar sintaxis literal y usar el constructor Array ()

【Literal】

Usar literales de matriz es la forma más fácil de crear una matriz. Elementos de matriz separados con comas en corchetes

 var vacía = []; // matriz sin elementos var primero = [2,3,5,7,11]; // matriz con 5 valores

Aunque las matrices JavaScript se ordenan listas de datos, así como matrices en otros idiomas, a diferencia de otros idiomas, cada elemento de matrices de JavaScript puede contener cualquier tipo de datos

 var misc = [1.1, verdadero, "A"]; // 3 elementos de diferentes tipos

Los valores en los literales de matriz no tienen que ser constantes, pueden ser cualquier expresión

 var base = 1024; table var = [base, base+1, base+2, base+3];

Puede contener literales de objetos u otros literales de matriz

 var b = [[1, {x: 1, y: 2}], [2, {x: 3, y: 4}]];

Si los elementos de la matriz todavía son matrices, se forma una matriz multidimensional

 var a = [[1, 2], [3, 4]];

[Nota] Al usar notación literal numérica, no se llamará al constructor de matriz

【Constructor】

Hay tres formas de llamar a constructores

【1】 Sin parámetros, cree una matriz vacía

 // Este método crea una matriz vacía sin ningún elemento, que es equivalente a la cantidad directa de la matriz [] var a = new Array ();

【2】 Hay un parámetro numérico, que se utiliza para especificar la longitud de la matriz

 var a = nueva matriz (10); console.log (a); // [] console.log (a [0], a.length); // indefinido 10

[Nota] Si hay otro tipo de parámetro, se creará una matriz que contiene solo una de ese valor

 var a = nueva matriz ('10 '); console.log (a); // [' 10 '] console.log (a [0], a.length); // 10 1

【3】 Cuando hay múltiples parámetros, los parámetros se representan como elementos específicos de la matriz

 var a = nueva matriz (1,2,3); console.log (a); // [1,2,3] console.log (a [0], a [1], a [2]); // 1 2 3

Al usar el constructor de array (), se puede omitir el nuevo operador

 var a1 = array (); var a2 = array (10); var a3 = array (1,2,3); console.log (a1, a2, a3); // [] [] [1,2,3]

Naturaleza de la matriz

Las matrices son un conjunto de valores dispuestos en orden. En esencia, las matrices son objetos especiales.

 typeof [1, 2, 3] // "objeto"

La particularidad de una matriz se refleja en que sus nombres clave son un conjunto de enteros (0, 1, 2 ...) dispuestos en orden. Dado que los nombres clave de los miembros de la matriz se fijan, la matriz no necesita especificar un nombre de clave para cada elemento, pero cada miembro del objeto debe especificar un nombre de clave.

 var arr = ['a', 'b', 'c']; console.log (object.keys (arr)); // ["0", "1", "2"] var obj = {name1: 'a', name2: 'b', name3: 'c'};

Las matrices son formas especiales de objetos. Acceder a elementos de matriz con soportes cuadrados es como acceder a las propiedades de los objetos con soportes cuadrados.

El lenguaje JavaScript estipula que los nombres clave de los objetos son cadenas, por lo que los nombres clave de las matrices son en realidad cadenas. La razón por la que se puede leer con valores numéricos es que los nombres de claves que no son de cuerda se convertirán en cadenas y luego se utilizarán como nombres de atributos

 o = {}; // crear un objeto ordinario o [1] = "uno"; // indexarlo con un entero // El nombre de la clave numérica se convierte automáticamente en una cadena var arr = ['a', 'b', 'c']; arr ['0'] // 'a'arr [0] //' a '

Sin embargo, es necesario distinguir entre el índice de matriz y los nombres de los atributos del objeto: todos los índices son nombres de atributos, pero solo los nombres de atributos enteros entre 0 ~ 232-2 (4294967294) son índices

 var a = []; // index a ['1000'] = 'ABC'; A [1000] // 'ABC' // índice A [1.00] = 6; A [1] // 6

[Nota] Los valores individuales no se pueden usar como identificadores. Por lo tanto, los miembros de la matriz solo se pueden expresar en soportes cuadrados

 var arr = [1, 2, 3]; arr [0]; // 1arr.0; // syntaxError

Una matriz se puede indexar utilizando números negativos o no enteros. Sin embargo, dado que no está dentro del rango de 0 ~ 2 al poder de 32-2, es solo el nombre del atributo de la matriz, no el índice de la matriz. La característica obvia es que no cambia la longitud de la matriz

 var a = [1,2,3]; // nombre de atributo A [-1.23] = true; console.log (a.length); // 3 // index a [10] = 5; console.log (a.length); // 11 // Nombre de atributo A ['ABC'] = 'Testing'; Console.log (A.LoLength); // 11

Matrices escasas

Una matriz escasa es una matriz que contiene índices discontinuos a partir de 0.

【1】 La forma más directa de hacer matrices dispersas es usar el operador Eliminar

 var a = [1,2,3,4,5]; eliminar a [1]; console.log (a [1]); // undefinedconsole.log (1 en a); // falso

【2】 Los valores de los elementos se pueden omitir entre comas de matrices, y las matrices dispersas se pueden crear omitiendo los valores de los elementos.

 var a = [1 ,, 3,4,5]; console.log (a [1]); // UndefinedConsole.log (1 en a); // falso

[Nota] Hay una diferencia entre el valor de elemento omitido y el valor del elemento cuyo valor está indefinido.

 var a = [1 ,, 3,4,5]; console.log (a [1]); // UndefinedConsole.log (1 en a); // falsevar a = [1, indefinido, 3,4,5]; console.log (a [1]); // incinedConsole.log (1 en A); // verdadero

Si usa comas al final de la matriz, hay diferencias entre los navegadores. El navegador estándar ignora la coma, mientras que el navegador IE8 agrega un valor indefinido al final

 // Salida del navegador estándar [1,2], mientras que la salida IE8-Browser [1,2, indefinida] var a = [1,2,]; console.log (a); // salida del navegador estándar 2, mientras que la salida del navegador IE8 3VAR a = [,,]; console.log (a.llength);

Las matrices que son lo suficientemente escasas son generalmente más lentas en la implementación que las matrices densas y tienen una mayor utilización de la memoria, y el tiempo para buscar elementos en dicha matriz es siempre que el tiempo de buscar las propiedades del objeto regular

Longitud de la matriz

Cada matriz tiene un atributo de longitud, que es este atributo que lo distingue de los objetos JavaScript convencionales. Para las matrices densas (es decir, no sesiones), el valor de atributo de longitud representa el número de elementos en la matriz, y su valor es 1 más grande que el índice más grande en la matriz.

 [] .length // => 0: la matriz no tiene elementos ['a', 'b', 'c']. Longitud // => 3: el índice máximo es 2, y la longitud es 3

Cuando una matriz es una matriz escasa, el valor del atributo de longitud es mayor que el número de elementos. Del mismo modo, su valor es 1 más grande que el índice más grande en la matriz

 [,,].longitud; //3(array(10)).length ;//10var a = [1,2,3]; console.log (a.length); // 3delete a [1]; console.log (a.length); // 3

La particularidad de las matrices se refleja principalmente en el hecho de que la longitud de la matriz se puede ajustar dinámicamente:

【1】 Si asigna un valor a un elemento de matriz y el índice I es mayor o igual a la longitud de la matriz existente, el valor del atributo de longitud se establecerá en 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】 Al establecer el atributo de longitud a un entero no negativo n menor que la longitud actual, los elementos con el valor del índice de matriz actual mayor o igual a n se eliminarán de él

 a = [1,2,3,4,5]; // de la matriz de 5 elementos a.length = 3; // ahora A es [1,2,3] A.Length = 0; // Eliminar todos los elementos. A es [] A.Length = 5; // La longitud es 5, pero no hay elementos, como nuevos

Matriz (5)

[Nota] Una forma efectiva de borrar la matriz es establecer la propiedad de longitud en 0

 var arr = ['a', 'b', 'c']; arr.length = 0; arr // []

【3】 Establezca el valor de atributo de longitud de la matriz para que sea mayor que su longitud de corriente. En realidad, esto no agrega nuevos elementos a la matriz, solo crea un área vacía al final de la matriz

 var a = ['a']; a.length = 3; console.log (a [1]); // undefinedconsole.log (1 en a); // falso

Si la longitud se establece en un valor ilegal (es decir, un valor fuera del rango 0-232-2), JavaScript informará un error

 // establece el valor negativo []. Longitud = -1 // RangeError: Longitud de matriz no válida // El número de elementos de matriz es mayor o igual a 2 a la potencia de 32 []. Longitud = Math.Pow (2,32) // RangeError: Longitud de la matriz inválida // Establezca una cadena []. Longitud = 'ABC' // RangeerRor: Longitud de la matriz invalida Invalida

Dado que una matriz es esencialmente un objeto, puede agregar atributos a la matriz, pero esto no afecta el valor del atributo de longitud

 var a = []; a ['p'] = 'ABC'; console.log (a.length); // 0a [2.1] = 'ABC'; console.log (a.length); // 0

Transmisión

La forma más común de recorrer elementos de matriz usando para bucle

 var a = [1, 2, 3]; para (var i = 0; i <a.length; i ++) {console.log (a [i]);}

Por supuesto, también puedes usar un bucle de tiempo

 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]);}

Pero si la matriz es una matriz escasa, use un bucle for y debe agregar algunas condiciones

 // omita el elemento inexistente var a = [1 ,,, 2]; para (var i = 0; i <a.length; i ++) {if (! (I in a)) continúa; console.log (a [i]);}

También puede usar para/en bucles para procesar matrices dispersas. El bucle asigna un nombre de atributo enumerable (incluido el índice de matriz) a la variable de bucle a la vez. El índice inexistente no se atravesará

 var a = [1 ,,, 2]; para (var i in a) {console.log (a [i]);}

Porque el bucle for/in puede enumerar los nombres de atributos heredados, como los métodos agregados a Array.Prototype. Por esta razón, no se deben usar bucles para/en matrices a menos que se usen métodos de detección adicionales para filtrar propiedades no deseadas

 var a = [1 ,,, 2]; ab = 'b'; para (var i en a) {console.log (a [i]); // 1 2 'b'} // omita ivar a = [1 ,,, 2]; ab = 'b'; para (var i en a) {if (string (math.floor (math.abs (número (i)))))) continuar; console.log (a [i]); // 1 2}

La especificación de JavaScript permite/en bucles atravesar las propiedades de un objeto en diferentes órdenes. Por lo general, la implementación transversal de elementos de matriz está en orden ascendente, pero no se puede garantizar que sea así. En particular, si una matriz tiene ambos atributos del objeto y elementos de matriz, los nombres de los atributos devueltos probablemente en el orden se crearon en lugar de en el orden del tamaño numérico. Si el algoritmo depende del orden de recorrido, es mejor no usar para/in pero usar regularmente para bucles

Matriz de clases

Los objetos con atributos de longitud y los atributos enteros no negativos correspondientes se denominan objetos similares a la matriz

 // demostración de matriz de clase var a = {}; var i = 0; while (i <10) {a [i] = i*i; i ++;} a.length = i; var en total = 0; para (var j = 0; j <a.length; j ++) {total+= a [j];}

Hay tres objetos de matriz de clase comunes:

【1】 Objeto de argumentos

 // argumentos objeto function args () {return arguments} var arreraylike = args ('a', 'b'); arraylike [0] // 'a'arraylike.length // 2arraylike de matriz // falso

【2】 Objeto devuelto por el método DOM (como document.getElementsByTagName () Método)

 // DOM Eleman var Elts = document.getElementsBytagName ('H3'); Elts.length // 3elts instanceof array // falso

【3】 cadena

 // String 'ABC' [1] // 'B''abc'.length // 3'abc' instancia de Array // falso

[Nota] Las cadenas son valores inmutables, por lo que cuando se consideran matrices, son de solo lectura. Por ejemplo, push (), sort (), reverse (), splice () y otros métodos de matriz modificarán la matriz. No son válidos en la cadena e informarán un error

 var str = 'abc'; array.prototype.forach.call (str, function (chr) {console.log (chr); // abc}); array.prototype.splice.call (str, 1); console.log (str); // typeerRor: no puede eliminar la propiedad '2' de [Cadena de objetos]]

El método de corte de una matriz convierte el objeto de matriz de clases en una matriz real

 var arrr = array.prototype.slice.call (Array Like);

Los métodos de matriz de JavaScript se definen específicamente como generales, por lo que funcionan correctamente no solo en matrices reales sino también en objetos de matriz de clase. En ECMAScript5, todos los métodos de matriz son generales. En ECMAScript3, todos los métodos excepto ToString () y TolocalEstring () también son comunes

 var a = {'0': 'a', '1': 'b', '2': 'c', longitud: 3}; array.prototype.join.call (a, '+'); // 'a+b+c'array.p rototype.slice.call (a, 0); // ['a', 'b', 'c'] array.prototype.map.call (a, function (x) {return X.ToUpperCase ();}); // ['A', 'B', 'C']