Hogar › Servicios › Un ejemplo sencillo de creación de una matriz en javascript. Todas las formas de iterar a través de una matriz en JavaScript. ¿Cuál es el propósito del operador de eliminación?

Un ejemplo sencillo de creación de una matriz en javascript. Todas las formas de iterar a través de una matriz en JavaScript. ¿Cuál es el propósito del operador de eliminación?

JavaScript, al igual que otros lenguajes de programación, utiliza diferentes métodos para trabajar con matrices.

Los métodos simplifican la construcción de la lógica y su implementación en un script.

A continuación se muestran los métodos básicos para trabajar con matrices en JS.

empujar

El método push() agrega un valor al final de la matriz.

Sea arr = ; arr.push(312); consola.log(arr); // →

estallido

El método pop() elimina el último elemento de la matriz o devuelve su valor.

Sea arr = ; arr.pop(); consola.log(arr); // →

Usando la capacidad de obtener el valor del último elemento de una matriz como ejemplo, podemos obtener el formato de la imagen:

Let img = "https://ejemplo.com/img/nombre.png"; let formato = img.split(".").pop(); consola.log(formato); // → png console.log(img.split(".")); // → ["https://ejemplo", "com/img/nombre", "png"]

desacelerar

El método unshift() agrega un elemento al comienzo de la matriz.

Sea arr = ; arr.unshift(312); consola.log(arr); // →

cambio

El método shift() elimina el primer elemento de la matriz.

Sea arr = ; arr.shift(); consola.log(arr); // → ;

Debe comprender que cuando se utilizan los métodos shift y unshift, cada elemento de la matriz cambia su índice. Esto puede ralentizar la ejecución del programa si la matriz es grande.

dividir

El método split() se utiliza para transformar una cadena en una matriz. Split divide una cadena según el parámetro especificado.

Sea str = "Anya, Masha, Sasha, Dasha"; // esta es una cadena let arr = str.split(", "); consola.log(arr); // → ["Anya", "Masha", "Sasha", "Dasha"] es una matriz

unirse

El método join() combina elementos de una matriz en una cadena utilizando el delimitador especificado en el parámetro.

Let arr = ["Notpad++", "Sublime", "VSCode"]; // esta es una matriz let str = arr.join(", "); console.log("Editores de código: " + str); // → "Editores de código: Notpad++, Sublime, VSCode"

rebanada

El método slice() crea una nueva matriz en la que copia elementos del origen, comenzando desde el elemento con el índice del primer parámetro pasado al método, hasta el elemento con el índice del segundo parámetro.

Por ejemplo: segmento(3, 7) devolverá elementos con índices 3, 4, 5, 6. El elemento con índice 7 no se incluirá en la matriz.

Si se pasa un parámetro con un valor negativo a slice(), entonces devuelve una nueva matriz con el número de elementos especificados en el parámetro, pero ya tomados del final de la matriz original.

El método de corte no cambia la matriz original.

A continuación se muestran algunos ejemplos del método slice() en acción:

Sea arr = ["A", "B", "C", "D", "E", "F", "G"]; // Devuelve una matriz que contiene elementos con índices del 2 al 5 console.log(arr.slice(2, 5)); // → ["C", "D", "E"] // Devuelve una nueva matriz que contiene elementos con índices de 3 a arr.length console.log(arr.slice(3)); // → ["D", "E", "F", "G"] // Devuelve una copia de la matriz original console.log(arr.slice()); // → ["A", "B", "C", "D", "E", "F", "G"] // Devuelve una nueva matriz que consta de los últimos tres elementos del console.log original (arr.slice (-3)); // → ["E", "F", "G"]

empalme

El método splice() modifica el contenido de una matriz eliminando elementos existentes y/o agregando otros nuevos.

Sintaxis:

Array.splice(inicio, eliminarContar[, elemento1[, elemento2[, ...]]])

Parámetros:

comenzar- El índice en el que comenzar a cambiar la matriz. Si es mayor que la longitud de la matriz, el índice real se establecerá en la longitud de la matriz. Si es negativo, especifica el índice del elemento desde el final.
eliminarContar- Un número entero que indica el número de elementos antiguos que se eliminarán de la matriz. Si deleteCount es 0, no se elimina ningún elemento. En este caso, debe especificar al menos un elemento nuevo. Si deleteCount es mayor que el número de elementos restantes en la matriz a partir del inicio del índice, se eliminarán todos los elementos hasta el final de la matriz.
elementoN- Parámetros opcionales. Elementos que se agregarán a la matriz. Si no especifica ningún elemento, splice() simplemente eliminará elementos de la matriz.

Valor de retorno

Descripción

Si la cantidad de elementos especificados para insertar es diferente de la cantidad de elementos que se eliminarán, la matriz cambiará de longitud después de la llamada.

Let arr = ["Barca", "Shakhtar", "Manchester United", "Milán", "Real", "Ajax", "Juventus"]; let nax = arr.splice(2, 3); arr.splice(2, 3); consola.log(nax); // → ["Manchester United", "Milán", "Real"] console.log(arr); // → ["Barca", "Shakhtar"] arr.splice(1, 0, "Zenit", "CSKA", "Spartak"); consola.log(arr); // → [Barça, Zenit, CSKA, Spartak, Shakhtar]

contrarrestar

El método reverse() invierte el orden de los elementos de la matriz. Como resultado, el primer elemento de la matriz se convierte en el último y el último elemento en el primero.

Sea arr = ; console.log(arr.reverse()); // → console.log(["Alice", "BG", "GO", "DDT"].reverce()); // → ["DDT", "GO", "BG", "Alicia"]

mapa

El método map() recorre los elementos de la matriz, realiza acciones específicas sobre ellos y devuelve una copia de la matriz con los elementos modificados.

En el siguiente ejemplo, a cada elemento de la matriz agregamos el valor de índice de este elemento (7 + 0, 2 + 1, 15 + 2, 4 + 3, 31 + 4):

Sea arr = ; let testMap = arr.map((elemento, índice) => elemento + índice); console.log(testMap); //

o multiplicar cada valor del array, por ejemplo, por 12

Sea arr = ; let testMap = arr.map(a => a * 12); console.log(testMap); // →

filtrar

El método filter() se utiliza para filtrar matrices. Itera a través de la matriz y devuelve solo aquellos elementos que pasan una condición determinada.

Por ejemplo, filtremos los valores de una matriz de números, dejando solo aquellos que sean mayores que 21.

Sea arr = ; let testFilter = arr.filter(elemento => elemento > 21); console.log(testFilter); // →

Tenga en cuenta que 21 no se incluyó en el resultado de la matriz, ya que la condición era devolver algo mayor que 21. Para que 21 se incluya en la matriz, establecemos la condición como mayor o igual a: elemento >= 21

reducir

El método reduce() recorre secuencialmente los elementos del array, acumulando el resultado intermedio según la función especificada en la condición de la función. En el resultado final, devuelve sólo un valor.

Este método se utiliza a menudo para encontrar la suma de todos los números de una matriz. Ejemplo:

Sea arr = ; let summa = arr.reduce((acc, elemento) => acc + elemento); console.log(suma); // → 370

clasificar

El método sort() se utiliza para ordenar elementos de una matriz según parámetros especificados.

Ejemplo: tomemos una serie de números y ordénelos en orden ascendente:

Sea arr = ; let testSortArr = arr.sort((a, b) => a - b); console.log(testSortArr); // →

incluye

El método incluye() determina si la matriz contiene un elemento en particular, devolviendo verdadero o falso dependiendo de ello.

Ejemplo de uso de include() .

He aquí una expresión lógica:

Sea animal = "perro"; if (animal == "gato" || animal == "perro" || animal == "león" || animal == "caballo") ( // ........ )

Usando el método de inclusión puedes escribirlo así:

Sea animal = "perro"; const animales = ["gato", "perro", "león", "caballo"]; if (animales.incluye(animal)) ( // ........... )

Se puede trabajar con matrices a través de varios métodos proporcionados por el constructor de matrices.

Métodos pop/push y shift/unshift

Veamos los métodos pop() y push(). Estos métodos le permiten trabajar con matrices como si fueran pilas. Una pila es una estructura de datos en la que el acceso a los elementos se organiza según el principio LIFO (en inglés: último en entrar, primero en salir, “último en entrar, primero en salir”). El principio de funcionamiento de la pila se puede comparar con una pila de placas: para tomar la segunda de arriba, es necesario quitar la superior. Cómo funciona se muestra en la figura:

Entonces volvamos a mirar los métodos push() y pop(). El método push() agrega uno o más elementos nuevos al final de la matriz y devuelve su nueva longitud. Método pop(): elimina el último elemento de la matriz, reduce la longitud de la matriz y devuelve el valor que eliminó. Vale la pena señalar que ambos métodos modifican la matriz en su lugar, en lugar de crear una copia modificada de la misma.

Varfoo = ; // foo: foo.push(1,2); // foo: Devuelve 2 foo.pop(); // foo: Devuelve 2 foo.push(3); // foo: Devuelve 2 foo.pop(); // foo: Devuelve 3 foo.push(); // foo: ] Devuelve 2 foo.pop() // foo: Devuelve foo.pop(); // foo: Devuelve 1 var frutas = ["peras", "plátanos", "manzanas"]; var elegido = frutas.pop(); document.write("Tú elegiste mi " + elegiste);

Intentar "

Los métodos shift() y unshift() se comportan de forma muy similar a pop() y push(), excepto que insertan y eliminan elementos al principio de la matriz. El método unshift() cambia los elementos existentes a índices más grandes para dejar espacio para nuevos elementos, agrega uno o más elementos al comienzo de la matriz y devuelve la nueva longitud de la matriz. El método shift() elimina el primer elemento de una matriz y devuelve su valor, desplazando todos los elementos posteriores para ocupar el espacio libre al comienzo de la matriz.

Var f = ; // f: f.unshift(1); // f: Devuelve: 1 f.unshift(22); // f: Devuelve: 2 f.shift(); // f: Devuelve: 22 f.unshift(3,); // f:,1] Devuelve: 3 f.shift(); // f:[,1] Devuelve: 3 f.shift(); // f: Devuelve: f.shift(); // f: Devuelve: 1

método de unión

El método Array.join() se utiliza para unir los elementos de una matriz en una sola cadena. Al método se le puede pasar un argumento de cadena opcional, que se utilizará para separar elementos en la cadena. Si no se especifica el delimitador, el carácter delimitador predeterminado al llamar al método será una coma.
Var a = ["Viento","Lluvia","Fuego"]; var miVar1 = a.join(); //"Viento,Lluvia,Fuego" var myVar2 = a.join(", "); //"Viento, Lluvia, Fuego" var myVar3 = a.join(" + "); //"Viento + Lluvia + Fuego" document.write(myVar1 + "
" + miVar2 + "

" + myVar3); Pruebe "

El método Array.join() es el inverso del método String.split(), que crea una matriz dividiendo una cadena en fragmentos.

método inverso

Var myArr = ["uno", "dos", "tres"]; document.write(myArr.reverse());

Intentar "

método concat

El método Array.concat() crea y devuelve una nueva matriz que contiene los elementos de la matriz original en la que se llamó a concat(), aumentada secuencialmente con los valores de todos los argumentos pasados a concat(). Si alguno de estos argumentos es en sí mismo una matriz, se agregarán todos sus elementos. Los nombres de las matrices se utilizan como argumentos y se especifican en el orden en que se combinarán sus elementos.

Var a = ; a.concat(4, 5) //Devuelve a.concat(); //lo mismo - devuelve a.concat() //Devuelve

método de clasificación

El método Array.sort() ordena los elementos de la matriz en su lugar y devuelve la matriz ordenada. Si se llama al método sort() sin un argumento, ordena los elementos de la matriz en orden alfabético (convirtiéndolos temporalmente en cadenas para realizar la comparación). El método sort() puede tomar una función de comparación como argumento, que determina el orden de clasificación de los elementos.

Var a = ["Kiwi", "Naranjas", "Peras"]; a.sort(); var s = a.join(", "); //Naranjas, peras y kiwis document.write(s); //ejemplo con números var myArr = ; myArr.sort(); documento.write(myArr); //1,10,2 Intentar »

Probablemente esperabas ver un resultado ligeramente diferente al ordenar números. Esta clasificación se produce porque el método sort() clasifica elementos convirtiéndolos en cadenas. Por lo tanto, su orden resulta ser una cadena; después de todo, "10"

Para ordenar en un orden que no sea alfabético, puede pasar una función de comparación como argumento al método sort(). Sin embargo, hay que tener en cuenta que la función de comparación la tendrás que escribir tú mismo. Esta función debe tener dos parámetros porque establece cuál de sus dos argumentos debe aparecer primero en la lista ordenada. Para que sea más fácil comprender y escribir dicha función, existen varias reglas mediante las cuales se determinará el orden de los elementos:
Si el primer argumento debe ir antes del segundo, la función de comparación devuelve un número negativo (si
Si el primer argumento debe seguir al segundo, entonces la función de comparación devuelve un número positivo (si a > b)

Si dos valores son equivalentes (es decir, su orden no es importante), la función de comparación devuelve 0 (si a == b)

Función foo(a,b) ( //definir la función de verificación si (a b) devuelve 1; devuelve 0; //si a == b ) var a = ; a.sort(foo); //solo se pasa el nombre de la función como argumento document.write(a.join(", ")); //escribe lo mismo más brevemente var a = ; a.sort(function(a,b) ( //usa la función anónima return a - b; //la función devuelve el valor 0 )); documento.write(a); //1,2,5,10 Intentar »

La primera entrada del ejemplo está escrita de esta manera para que sea más fácil entender cómo funciona. Observe lo conveniente que es utilizar una función anónima en el segundo fragmento. Se llama sólo una vez, por lo que no es necesario darle un nombre.

Nota: Si hay elementos no definidos en la matriz, se mueven al final de la matriz.

método de corte

El método Array.slice() se utiliza para copiar una sección específica de una matriz y devuelve una nueva matriz que contiene los elementos copiados. La matriz original no cambia.

Sintaxis del método:

ArrayName.slice(comienzo, fin);

Array_name debe reemplazarse con el nombre de la matriz de la que desea extraer un conjunto específico de elementos para la nueva matriz. El método toma dos argumentos que especifican el principio y el final de la matriz devuelta. El método copia una sección de la matriz, desde el principio hasta el final, sin incluir el final. Si solo se proporciona un argumento, la matriz devuelta contendrá todos los elementos desde la posición especificada hasta el final de la matriz. Puede utilizar índices negativos: se cuentan desde el final de la matriz.

Vararr = ; arr.slice(0,3); //Devuelve arr.slice(3); //Devuelve arr.slice(1,-1); //Devuelve arr.slice(-3,-2); //Devoluciones

método de empalme

El método Array.splice() es un método universal para trabajar con matrices. Modifica la matriz en su lugar en lugar de devolver una nueva matriz modificada como lo hacen los métodos slice() y concat(). El método de empalme puede eliminar elementos de una matriz, insertar nuevos elementos, reemplazar elementos, uno a la vez y simultáneamente. Devuelve una matriz que consta de los elementos eliminados; si no se eliminó ningún elemento, devolverá una matriz vacía.

Sintaxis del método:

Array_name.splice(índice, cantidad, elem1, ..., elemN);

El primer argumento especifica el índice de la matriz en el que comenzar a insertar o eliminar elementos. El segundo argumento especifica la cantidad de elementos que deben eliminarse de la matriz a partir del índice especificado en el primer argumento; si el segundo argumento es 0, no se eliminará ningún elemento; Si se omite el segundo argumento, se eliminan todos los elementos de la matriz desde el índice especificado hasta el final de la matriz. Cuando se utiliza un número de posición negativo, los elementos se contarán desde el final de la matriz.

Var frutas = ["naranjas", "manzanas", "peras", "uvas"]; var eliminado = frutas.splice(2,2); //devuelve ["peras", "uvas"] document.write(eliminado); vararr = ; arr.empalme(4); //Devuelve; la matriz se convirtió en: arr.splice(1,2); //Devuelve; la matriz se convirtió en: arr.splice(1,1); //Devuelve; la matriz se convirtió en: Pruebe »

Los dos primeros argumentos del método splice() especifican los elementos de la matriz que se eliminarán. Estos dos argumentos pueden ir seguidos de cualquier número de argumentos adicionales que especifiquen los elementos que se insertarán en la matriz, comenzando en la posición especificada por el primer argumento.

Var frutas = ["naranjas", "manzanas"]; frutas.splice(2,0, "sandías"); //devuelve document.write(frutas); //se convirtió en ["naranjas", "manzanas", "sandías"] var arr = ; arr.splice(2,0,"a","b"); //Devuelve; se convirtió en arr.splice(2,2,); //Devuelve ["a","b"]; se convirtió en ,3,4,5] Intentar »

Vale la pena señalar que, a diferencia de concat(), el método splice() no divide las matrices pasadas como argumentos en elementos individuales. Es decir, si al método se le pasa una matriz para insertar, inserta la matriz en sí y no los elementos de esa matriz.

método toString

El método toString() convierte los elementos de una matriz en una cadena usando una coma como carácter delimitador.

Var arr = ["Leche","Pan","Galletas"]; var comida = arr.toString(); documento.write(comida); //Leche,Pan,Galletas Pruebe »

Tenga en cuenta que el método devuelve la misma cadena que join() cuando se llama sin argumentos.

índice de y último índice de

El método indexOf devuelve el índice de un elemento cuyo valor es igual al valor pasado como argumento al método.

Sintaxis de los métodos indexOf() y lastIndexOf():

nombre_matriz.indexOf(elemento_búsqueda, índice) nombre_matriz.lastIndexOf(elemento_búsqueda, índice)

El primer argumento del método especifica el valor del elemento cuyo índice se debe encontrar, el segundo argumento (opcional) especifica el índice desde el cual comenzará la búsqueda. Si hay varias apariciones idénticas, se selecciona el índice más pequeño (el primero). Si no se encuentra un elemento con el valor deseado, el método devolverá -1. Dentro del método, se utiliza una comparación estricta (===) para la búsqueda.

Var a = ; a.indexOf(3); //devuelve 2 a.indexOf(3,4); //regresa 6 a.indexOf(35); //return -1: no hay ningún elemento con este valor a.indexOf(2); // 1

El método lastIndexOf() también devuelve el índice del elemento cuyo valor es igual al valor pasado al método como argumento. La única diferencia es que el método lastIndexOf() selecciona el índice más grande (último).

Var a = ; a.lastIndexOf(3); //regresa 7 a.lastIndexOf(35); //return -1: no hay ningún elemento con este valor a.lastIndexOf(2); // 6

Métodos iteradores

Los métodos que se describen a continuación son iteradores. Todos los navegadores modernos tienen métodos para trabajar con matrices que están diseñadas para iterar sobre elementos y realizar diversas acciones sobre ellos. Estos métodos son forEach(), map(), filter(), each(), some, reduce() y reduceRight().

Iteran sobre los elementos de la matriz desde 0 hasta la longitud - 1 y, si el elemento existe, lo pasan a la función del controlador de devolución de llamada.

para cada uno

Sintaxis del método:

ArrayName.forEach (devolución de llamada, thisArg)

El primer argumento especifica la función de devolución de llamada que llamará el método forEach() para cada elemento de la matriz. Debe escribir usted mismo la implementación de la función del controlador llamado. La función llamada debe tener tres parámetros: el primer parámetro toma como argumento el valor del elemento de la matriz, el segundo, el índice del elemento y el tercero, la matriz misma. Sin embargo, si solo necesita usar los valores de los elementos de la matriz, puede escribir una función con un solo parámetro. El segundo argumento, thisArg (opcional), se pasará como valor de this.

Vararr = ; función foo(valor) ( var suma = valor * esto; devolver document.write(suma + "
"); ) arr.forEach(foo, 5); //el segundo argumento se pasará como el valor de este //ejemplo con tres parámetros var a = ; a.forEach(function(el, idx, a) ( documento .write( "a["+idx+"] = "+el+" en ["+a+"]
"); )); Intentar "

filtrar

Sintaxis del método:

Array_name.filter (devolución de llamada, este objeto)

El método filter() crea y devuelve una nueva matriz que contendrá solo aquellos elementos de la matriz para los cuales la función de devolución de llamada devuelve verdadero.

Función isBig(elemento, índice, matriz) ( //devuelve números mayores o iguales a 10 return (elemento >= 10); //si el valor del elemento es mayor o igual a 10, la expresión devolverá verdadero) var filtrado = .filter(isBig); //filtrado

mapa

El método map() crea y devuelve una nueva matriz, que consistirá en los resultados de llamar a la función callback(item, idx, ar) para cada elemento de la matriz.

Var a = ; var b = a.map(function(item, idx, arr) (devolver item * item;)); // b =

todos y algunos

El método each() devuelve verdadero si, para todos los elementos de la matriz, la función especificada utilizada para verificarlos devuelve verdadero.

El método some() devuelve verdadero si uno o más elementos devuelven verdadero durante la prueba en la función especificada.

Var a = ; a.every(function(x) ( return x 10; )) //verdadero: un número > 10

reducir y reducirDerecha

Sintaxis del método:

nombre_matriz.reduce(devolución de llamada, valor inicial) nombre_matriz.reduceRight(devolución de llamada, valor inicial)

El método reduce() aplica la función de devolución de llamada especificada a dos valores de la matriz a la vez, iterando a través de los elementos de izquierda a derecha, mientras almacena el resultado intermedio.

Argumentos de la función de devolución de llamada: (valor anterior, elemento actual, índice, matriz)

valor anterior: el resultado devuelto por la función de devolución de llamada (también conocido como resultado intermedio)
currentItem: elemento actual de la matriz (los elementos se ordenan de izquierda a derecha)
índice - índice del elemento actual
matriz - matriz procesada

valorinicial es el objeto utilizado como primer argumento de la primera llamada a la función de devolución de llamada. En pocas palabras, el valor de valor anterior cuando se llama por primera vez es igual a valor inicial. Si no hay un valor inicial, entonces es igual al primer elemento de la matriz y la búsqueda comienza desde el segundo:

Var a = ; función foo(prevNum,curNum) ( suma = prevNum + curNum; alerta(suma); devolver suma; ) var resultado = a.reduce(foo, 0); documento.write(resultado);

Intentar "

Veamos cómo funciona este ejemplo. Los primeros argumentos de la función foo son:
prevNum = 0 (ya que el valor inicial es 0)

curNum = 1 (el elemento actual es el primer elemento de la matriz)

1 se suma al número 0. Este resultado (suma: 1) se pasará como prevNum la próxima vez que se ejecute la función. Y así sucesivamente hasta llegar al último elemento. El resultado devuelto, la suma de la última ejecución, será 15 (1+2+3+4+5).

El método reduceRight funciona de manera similar al método reduce, pero recorre la matriz de derecha a izquierda:

Las matrices son uno de los tipos de variables más utilizados que le permiten almacenar muchos valores secuenciales en "un solo lugar". Sin embargo, cuando se trata de JavaScript, hay margen de mejora.

En este artículo, veremos tres técnicas poco conocidas que se pueden utilizar al trabajar con matrices.

1. Agregar propiedades personalizadas a las matrices

Si utiliza una búsqueda para encontrar la definición de una matriz dentro del lenguaje JavaScript, la mayoría de las fuentes indicarán que este tipo de valor de variable se representa como un objeto.

En términos generales, muchas de las cosas que encontramos en JavaScript son objetos. Sería justo señalar que el lenguaje también contiene tipos de datos "primitivos", pero sus valores se utilizan de alguna manera en propiedades dentro de los objetos.

2. Acceder a elementos de una matriz dentro de un bucle

Dado que los índices de una matriz sólo pueden tomar valores positivos, el conteo comienza desde cero. Posteriormente podemos usar este índice para acceder al elemento de la matriz en una iteración de bucle determinada.

ECMAScript6 introdujo una forma de desplazarse por una matriz sin utilizar índices, sino a través de un nuevo bucle for…of.

El bucle for...of está diseñado para iterar a través de los elementos de una matriz sin afectar el índice del elemento.

Var ary = ["naranja","manzana","lichi"]; for (let item of ary)( console.log(item); ) // "orange", "apple", "lychee" A modo de comparación: generar índices de elementos en un bucle for. var ary = ["naranja","manzana","lichi"]; para (var elemento = 0; elemento< ary.length; item++){ console.log(item); } // 0, 1, 2

3. El número de elementos no es la dimensión de la matriz.

Cuando hablamos del tamaño de una matriz, generalmente pensamos en ella como la cantidad de elementos almacenados en ella. De hecho, esto no es del todo cierto: la propiedad de longitud se calcula en función del índice máximo del elemento.

La propiedad de longitud es muy ambigua. Para verificar esto, basta con mirar las siguientes manipulaciones:

Var aria = ; longitud.aria = 3; console.log(ary.length); // 3 aria = "abcd"; console.log(ary.length); // 6

En el último ejemplo, fue suficiente colocar el elemento en la quinta posición, como resultado de lo cual la longitud de la matriz pasó a ser 6. Si cree que los índices del 0 al 4 se crearán automáticamente, está equivocado. Esto se puede comprobar utilizando el operador in.

Var aria = ; longitud.aria = 3; console.log(ary.length); // 3 aria = "abcd"; console.log(ary.length); // 6 console.log(0 en ary); // FALSO

En este caso, sería justo llamar a la matriz aria "escasa".

También podemos manipular la propiedad de longitud para recortar matrices. El siguiente ejemplo demuestra "perder" el elemento en el índice 5 al disminuir la propiedad de longitud de la matriz aria.

Var aria = ; longitud.aria = 3; console.log(ary.length); // 3 aria = "abcd"; console.log(ary.length); // 6 ary.longitud = 2; console.log(ary.length); // 2 console.log(ario); // indefinido

En este artículo veremos una matriz de JavaScript y sus componentes. JavaScript está idealmente diseñado para la programación. De hecho, implementa el lenguaje ECMAScript (estándar ECMA-262).

¿Dónde se utiliza JavaScript? Se utiliza como lenguaje integrado para definir la ruta del programa al tema de la aplicación. Se puede encontrar en navegadores donde se utiliza como lenguaje de programación que hace que las páginas web sean interactivas.

Las características arquitectónicas más importantes de este producto son escritura dinámica y débil, administración automática de memoria, programación perfecta y funciones de objetos de primera clase.

En general, JavaScript estuvo influenciado por varias razones, porque durante el desarrollo querían crear un lenguaje similar a Java, pero fácil de usar para los programadores. Por cierto, el lenguaje JavaScript no es propiedad de ninguna empresa u organización, lo que lo diferencia de varios estilos de programación utilizados por los desarrolladores web.

Cabe señalar que JavaScript es una marca registrada de Oracle Corporation.

¿Qué es una matriz?

Una matriz es aquella que almacena valores numerados. Cada uno de estos valores se denomina componente de matriz y el dígito al que está asociado el componente se denomina índice. La matriz de JavaScript no está escrita. Esto significa que las partes de una matriz pueden ser de cualquier tipo, y diferentes partes que pertenecen a la misma matriz tienen tipos completamente diferentes.

Además, la matriz de JavaScript es dinámica, lo que significa que no es necesario declarar un tamaño fijo. Después de todo, puedes agregar nuevos detalles en cualquier momento.

producción de matrices

Usando JavaScript, crear una matriz no es nada difícil. Hay dos métodos para esto. El primero implica crear una matriz usando un literal: corchetes, dentro de los cuales hay una lista de partes, separadas por comas.

var vacío =; //matriz vacía;
números var = ; //matriz con cinco componentes digitales;
diferencia var = ; //matriz con tres elementos de diferentes tipos.

Normalmente, no es necesario que los valores aquí sean simples (cadenas y números). También puede ser cualquier otra expresión, por ejemplo, literales de sujeto, otras funciones y matrices.

La segunda forma de crear una matriz es llamar al diseñador Array(). Puedes invitarlo de tres maneras:

Llamar al diseñador sin argumentos: var b - new Array(). Esto prevé la creación de una matriz vacía, equivalente a un literal vacío.
El constructor especifica explícitamente el valor de los n componentes de la matriz: var b = new Array (1, 3, 5, 8, “cadena”, verdadero). En este caso, al diseñador se le presenta una lista de argumentos que se convierten en componentes de una nueva matriz. Los argumentos se escriben en la matriz en la ubicación en la que se especifican.
Definición del área para posterior asignación de valores. Esto se hace especificando, al identificar una matriz, un único número entre paréntesis: var b = new Array(5). Este método de identificación implica asignar la cantidad requerida de componentes a la matriz (cada uno de los cuales figura como indefinido) con la posibilidad de asignar valores posteriormente durante el proceso de presentación. Este formulario se utiliza normalmente para preasignar una matriz de Javascript cuya longitud se conoce de antemano.

Escribir, leer y agregar detalles de matriz

Puede acceder a los componentes de una matriz utilizando el operador. Por cierto, todos los componentes de JavaScript, empezando desde cero, están numerados. Para obtener el elemento requerido, su número se indica en Como regla general, los detalles se pueden cambiar. Y para agregar JavaScript a la matriz, solo necesita asignar un nuevo valor.

Cabe señalar que las matrices de JavaScript pueden almacenar cualquier cantidad de elementos de cualquier tipo.

longitud de la matriz

Entonces, sabemos que la longitud de una matriz es generalmente un fenómeno interesante. Echemos un vistazo más de cerca. Todas las matrices, ya sea construidas utilizando el diseñador Array() o reveladas a través de un literal de matriz, tienen una propiedad de longitud específica que indica el número total de elementos almacenados. Dado que una matriz puede contener partes indefinidas (denotadas por indefinidas), una expresión más precisa es: la calidad de la longitud es siempre uno mayor que el número más grande (índice) del componente de la matriz. La calidad de la longitud se ajusta automáticamente y permanece precisa cuando aparecen nuevas piezas en la matriz.

Para que aparezca el componente final de la matriz, puede utilizar la propiedad de longitud.

La última parte tiene un índice uno menor que el tamaño de la matriz. Al fin y al cabo, la cuenta atrás siempre empieza desde cero. ¡Oh, este JavaScript! La longitud de la matriz depende del número exacto de elementos. Entonces, si no sabe cuántos debería haber, pero necesita acceder al elemento final de la matriz, debe usar la notación: v.length - 1.

Iterando sobre los detalles de la matriz

Muy a menudo, la propiedad de longitud se utiliza para iterar sobre los detalles de una matriz en un bucle:

var frutas = [“fresa”, “melocotón”, “manzana”, “plátano”];
para(var I = 0; yo< fruits.lenght; i++);
document.write(frutas[i] + "...").

En este ejemplo, los componentes parecen estar colocados de forma continua y comienzan con la primera parte con un índice de cero. Si este no es el caso, antes de llamar a cada elemento de la matriz, debe verificar si está definido.

A veces también se utiliza un bucle para inicializar componentes.

Hacer crecer y truncar una matriz

Me pregunto cómo agregar una cadena a una matriz usando JavaScript. A medida que trabajamos con matrices, la longitud de la calidad mejora automáticamente, por lo que tenemos que ocuparnos de ello nosotros mismos. Es necesario recordar un detalle: la propiedad de longitud no sólo es legible, sino también escribible. Si a la calidad de longitud se le asigna un valor que es menor que el actual, entonces la matriz se reduce al tamaño especificado. Cualquier componente que no esté en el nuevo rango de índice se descarta y sus valores se pierden, incluso si luego se devuelve la longitud; los valores no se restauran.

Es bastante fácil borrar la matriz de esta manera: foo.length = 0.

Si la calidad de la longitud es mayor que su valor actual, aparecerán nuevas partes no identificadas al final de la matriz, lo que la aumentará al tamaño deseado.

Quitar partes del patrón

El operador de eliminación especifica un valor indefinido en un componente de matriz, pero sigue existiendo. Si necesita eliminar un elemento de una matriz de JavaScript para que las partes restantes se muevan al espacio libre, debe utilizar uno de los métodos de matriz proporcionados. El método Array.shift() elimina el primer componente, pop() elimina el componente final y el método splice() elimina uno o varios componentes en cualquier parte de la matriz.

matrices multidimensionales

Parece que lo hemos descubierto un poco. Las matrices bidimensionales son lo que debemos considerar a continuación. ¿Recuerdas que las matrices de JavaScript pueden contener otros elementos como componentes? Esta característica se utiliza para producir matrices multidimensionales. Para visitar componentes en una serie de matrices, simplemente use corchetes dos veces.

Matrices asociativas

Ahora exploremos cómo la marca JavaScript utiliza matrices asociativas. Para hacer esto, necesitamos profundizar en la teoría: las matrices asociativas a veces se denominan tablas hash. Gracias a ellos, se utilizan cadenas en lugar de índices. El uso de tales construcciones recuerda al uso del nombre de propiedad de un objeto simple, pero en esta versión cuando se trabaja en formato de matriz. Dado que JavaScript carece de formas de operar con matrices asociativas, se utilizan con mucha menos frecuencia que las normales. Cabe señalar que aún pueden resultar útiles para almacenar datos y facilitar el recuerdo de los detalles a los que es necesario acceder.

salida de matriz

¿Qué vamos a aprender sobre JavaScript ahora? Mostrar la matriz en un cuadro de diálogo (en la pantalla del monitor), así como mostrar los valores de los componentes de la matriz.

Si necesita mostrar los valores de todos los componentes de un programa, entonces es conveniente utilizar la declaración for. Curiosamente, la variable contador de reglas se utiliza como índice de un componente de matriz.

Limpieza

Para filtrar una matriz de JavaScript, debe restablecer su longitud a cero:

var miArray = ;
miArray.longitud = 0.

claro: función() (;
esta.longitud = 0;
devolver esto;

Agregar y quitar componentes

Bueno, sigamos estudiando este interesante lenguaje JavaScript. Un elemento de matriz se puede eliminar o agregar de la misma manera que las propiedades normales de otros objetos. Pero existen algunas diferencias: agregar propiedades numéricas puede cambiar la calidad de la longitud y modificar la propiedad de longitud puede eliminar las cualidades numéricas. En principio, el algoritmo para establecer cualidades de matrices es el siguiente:

Al agregar una propiedad digital desconocida i, si la longitud es igual o menor que i, la longitud se define como i+1.
Cuando cambia la calidad de la longitud, se realizan las siguientes acciones: si el valor asignado es menor que cero, se genera un RangeError. Se eliminan todas las calidades e índices numéricos que sean iguales a la nueva longitud y que sean mayores.

En general, eliminar un elemento de una matriz de JavaScript no es difícil. Después de todo, incluso al configurar la longitud, es necesario eliminar los componentes "extra". Esto lleva a la opción de borrar la matriz. Si la variable asignada de una nueva matriz vacía no es adecuada por algún motivo y es necesario restablecer la actual, basta con asignar el valor cero a su calidad de longitud.

métodos unshift, shift, pop y push

Aunque los componentes de la matriz se modifican manualmente, muchas personas recomiendan utilizar métodos integrados para ello. Es este matiz el que garantiza el valor de calidad de longitud correcto y la ausencia de espacios en la matriz. Por cierto, la calidad de la longitud correcta corresponderá al número de componentes.

El método push mueve las partes pasadas al final de la matriz. El método pop devuelve el componente final y lo elimina.

En general, en Internet Explorer anterior a la octava versión, unshift puede devolver indefinido en otros navegadores, un nuevo valor de longitud. Por lo tanto, es mejor no confiar en el valor devuelto por unshift.

Agregar y eliminar partes en medio de una matriz

Si necesito eliminar una matriz de JavaScript, ¿qué debo hacer? Se sabe que el método de empalme tiene la firma Array.prototype.splice.

Elimina los componentes deleteCount de la matriz, comenzando con el indicador de inicio. Si se pasan más de dos argumentos, se colocan todos los argumentos subsiguientes en la matriz en lugar de los eliminados. Si el inicio es negativo, entonces el índice a partir del cual se reanudará el retiro será igual a duración + inicio. La matriz se devuelve a partir de los elementos eliminados.

De hecho, al utilizar el método de empalme, puede eliminar componentes del medio de la matriz o agregar cualquier cantidad de componentes en cualquier parte de la matriz.

En la versión más simple, si necesita eliminar un componente con índice i, debe solicitar el método de empalme de la matriz con los parámetros i y 1.

En principio, el segundo parámetro del método de empalme es opcional, pero el comportamiento de una función con un argumento es diferente en cada navegador.

Por ejemplo, en Firefox, en las últimas versiones de Opera, en Safari y en Chrome, se eliminarán todos los detalles hasta el final de la matriz.

Ningún componente será eliminado en IE. En las primeras variaciones de Opera, es imposible predecir el comportamiento: se eliminará una parte con inicio de índice - 1. Por lo tanto, siempre es necesario pasar al menos dos componentes a este método.

Llaves

Por supuesto, al aprender JavaScript, también se deben tener en cuenta las matrices asociativas, como se mencionó anteriormente. Este es un tipo abstracto de información (una interfaz para un almacenamiento de datos), que le permite guardar pares de la forma "(clave, valor)" y admitir las operaciones de agregar un par, así como eliminar y buscar un par. por clave:

ENCONTRAR (tecla).

INSERTAR (valor, clave).

QUITAR (tecla).

Se supone que dos pares con claves similares no se pueden almacenar en una matriz asociativa. En un par k + v, v se denomina valor asociado con la clave k. La semántica y los nombres de las operaciones anteriores pueden ser diferentes en diferentes implementaciones de dichas matrices.

Por lo tanto, la acción ENCONTRAR (clave) devuelve el valor asociado con la clave dada, o algún objeto UNDEF específico que indica que no hay ningún valor asociado con la clave dada. Las otras dos acciones no devuelven nada (excepto si la operación fue exitosa).

En general, desde el punto de vista de la interfaz, es conveniente considerar una matriz asociativa como una matriz simple en la que no solo se pueden usar números enteros, sino también valores de otros tipos, por ejemplo, cadenas, como índices.

Por cierto, la compatibilidad con este tipo de matrices está disponible en muchos lenguajes de programación de alto nivel, como PHP, Perl, Ruby, Python, Tcl, JavaScript y otros. Para los lenguajes que no tienen herramientas integradas para trabajar con matrices asociativas, se ha creado una cantidad colosal de implementaciones en forma de bibliotecas.

Un ejemplo de matriz asociativa es una guía telefónica. En esta versión, el significado es el complejo “F. I. O. + dirección”, y la clave es el número de teléfono. Un número de teléfono tiene un propietario, pero una persona puede poseer varios números.

Extensiones asociativas

Cabe señalar que entre las extensiones más famosas se incluyen las siguientes:

CADA UNO: “revisa” todos los pares guardados.
BORRAR: elimina todos los registros.
MIN: busque el par con el valor clave más pequeño.
MAX: busque el par con el valor clave más grande.

Las dos últimas opciones requieren que la acción de comparación esté indicada en las teclas.

Implementaciones de matrices asociativas.

Hay muchas implementaciones diferentes de una matriz asociativa. La implementación más común podría basarse en una matriz simple cuyos componentes son pares (valor, clave). Para acelerar las operaciones de búsqueda, puede ordenar los componentes de una matriz determinada por clave y realizar la búsqueda usando Pero esto aumentará el período de tiempo requerido para agregar un nuevo par, ya que será necesario “separar” los componentes de la matriz para empaquetar un registro nuevo en la celda vacía que aparece.

Las implementaciones más conocidas son las basadas en varios árboles de búsqueda. Por ejemplo, en un lector STL de C++ típico, el contenedor de mapas se implementa en base a un árbol de caoba negra. Los estilos Ruby, Tcl y Python utilizan un tipo de tabla hash. Hay otras implementaciones.

En general, cada implementación tiene sus propias desventajas y ventajas. Es importante que las tres acciones se realicen tanto en promedio como en el peor matiz durante el período O(log n), donde n es el número actual de pares que se guardan. Para árboles de búsqueda coincidentes (incluidos árboles negro-rojo), se cumple esta condición.

Se sabe que las implementaciones basadas en tablas hash tienen un tiempo promedio de O(1), que es mejor que las implementaciones basadas en árboles de búsqueda. Por supuesto, esto no garantiza la ejecución de alta velocidad de operaciones individuales: el tiempo de INSERT en el peor de los casos es O(n). El proceso INSERT se ejecuta durante un tiempo prolongado cuando el factor de llenado alcanza su punto más alto y es necesario reconstruir el índice de la tabla hash.

Por cierto, estas listas hash son malas porque, a partir de ellas, es imposible realizar acciones adicionales rápidas MAX, MIN y un algoritmo para recorrer todos los pares guardados en orden descendente o ascendente de claves.

matrices

Formación es una colección ordenada de valores. Los valores de una matriz se denominan elementos y cada elemento se caracteriza por una posición numérica en la matriz, denominada índice. Las matrices en JavaScript no tienen tipo: los elementos de una matriz pueden ser de cualquier tipo y diferentes elementos de la misma matriz pueden tener diferentes tipos. Los elementos de una matriz pueden incluso ser objetos u otras matrices, lo que le permite crear estructuras de datos complejas, como matrices de objetos y matrices de matrices.

Los índices de las matrices de JavaScript comienzan en cero y utilizan números enteros de 32 bits; el primer elemento de la matriz tiene el índice 0. Las matrices de JavaScript son dinámicas: pueden crecer y reducirse en tamaño según sea necesario; no es necesario declarar tamaños de matriz fijos al crearlos, ni reasignar memoria cuando cambian sus tamaños.

Las matrices en JavaScript son una forma especializada de objetos, y los índices de matrices significan poco más que nombres de propiedades, que coincidentemente son números enteros.

Creando matrices

La forma más sencilla de crear una matriz es utilizar un literal, que es una lista simple de elementos de la matriz separados por comas y entre corchetes. Los valores en un literal de matriz no tienen que ser constantes; pueden ser cualquier expresión, incluidos los literales de objetos:

Var vacío = ; // Matriz vacía var números = ; // Matriz con cinco elementos numéricos var misc = [ 1.1, true, "a", ]; // 3 elementos de diferentes tipos + coma final var base = 1024; tabla var = ; // Matriz con variables var arrObj = [, ]; // 2 matrices dentro que contienen objetos

La sintaxis literal de matriz le permite insertar una coma final opcional, es decir, el literal [,] coincide con una matriz con dos elementos, no tres.

Otra forma de crear una matriz es llamar al constructor. Formación(). Puedes llamar al constructor de tres maneras diferentes:

Llame al constructor sin argumentos:

Var arr = nueva matriz();

En este caso se creará una matriz vacía, equivalente al literal.

Llame al constructor con un único argumento numérico que especifique la longitud de la matriz:

Var arr = nueva matriz (10);

En este caso, se creará una matriz vacía de la longitud especificada. Esta forma de llamar al constructor Array() se puede utilizar para preasignar memoria para una matriz si se conoce de antemano el número de sus elementos. Tenga en cuenta que esto no almacena ningún valor en la matriz.

Especifique explícitamente los valores de los primeros dos o más elementos de la matriz o un elemento no numérico en la llamada al constructor:

Var arr = nueva matriz(5, 4, 3, 2, 1, "prueba");

En este caso, los argumentos del constructor se convierten en los valores de los elementos de la nueva matriz. Usar literales de matriz casi siempre es más fácil que usar el constructor Array().

Lectura y escritura de elementos de matriz

Se accede a los elementos de la matriz mediante el operador. A la izquierda de los corchetes debe haber una referencia a la matriz. Dentro del paréntesis debe haber una expresión arbitraria que devuelva un valor entero no negativo. Esta sintaxis es útil tanto para leer como para escribir el valor de un elemento de matriz. Por lo tanto, todas las siguientes instrucciones de JavaScript son válidas:

// Crea una matriz con un elemento var arr = ["mundo"]; // Leer elemento 0 var valor = arr; // Escribe el valor en el elemento 1 arr = 3.14; // Escribe el valor en el elemento 2 i = 2; arreglo[i] = 3; // Escribe el valor en el elemento 3 arr = "hola"; // Lee los elementos 0 y 2, escribe el valor en el elemento 3 arr] = arr;

Permítanme recordarles que las matrices son un tipo de objeto especializado. Los corchetes utilizados para acceder a los elementos de la matriz actúan exactamente igual que los corchetes utilizados para acceder a las propiedades del objeto. El intérprete de JavaScript convierte los índices numéricos entre paréntesis en cadenas (el índice 1 se convierte en la cadena "1") y luego usa las cadenas como nombres de propiedades.

No hay nada especial en convertir índices numéricos en cadenas: puedes hacer lo mismo con objetos normales:

Var obj = (); // Crea un objeto simple obj = "one"; // Indexarlo con números enteros

Lo que pasa con las matrices es que cuando usas nombres de propiedades que son números enteros no negativos, las matrices determinan automáticamente el valor de la propiedad. longitud. Por ejemplo, arriba creamos una matriz arr con un solo elemento. Luego asignó valores a sus elementos en los índices 1, 2 y 3. Como resultado de estas operaciones, el valor de la propiedad de longitud de la matriz cambió a 4.

Debes distinguir claramente los índices en una matriz de los nombres de propiedades de los objetos. Todos los índices son nombres de propiedades, pero sólo las propiedades con nombres representados por números enteros son índices. Todas las matrices son objetos y puede agregarles propiedades con cualquier nombre. Sin embargo, si toca propiedades que son índices de matriz, las matrices responden actualizando el valor de la propiedad de longitud según sea necesario.

Tenga en cuenta que los números negativos y no enteros se pueden utilizar como índices de matriz. En este caso, los números se convierten en cadenas, que se utilizan como nombres de propiedades.

Agregar y eliminar elementos de matriz

Ya hemos visto que la forma más sencilla de agregar elementos a una matriz es asignar valores a nuevos índices. También puede utilizar el método para agregar uno o más elementos al final de la matriz. empujar():

Vararr = ; // Crea una matriz vacía arr.push("zero"); // Agrega un valor al final arr.push("one",2); // Agrega dos valores más

También puede agregar un elemento al final de la matriz asignando un valor al elemento arr. Para insertar un elemento al principio de una matriz, puede utilizar el método desactivar(), que mueve los elementos existentes en la matriz a posiciones con índices más altos.

Puede eliminar elementos de la matriz utilizando el operador de eliminación, al igual que las propiedades de objetos normales:

Vararr = ; eliminar llegada; 2 en orden; // falso, el índice 2 de la matriz no está definido arr.length; // 3: el operador de eliminación no cambia la propiedad de longitud de la matriz

Eliminar un elemento es similar (pero ligeramente diferente) a asignar el valor indefinido a ese elemento. Tenga en cuenta que aplicar el operador de eliminación a un elemento de matriz no cambia el valor de la propiedad de longitud ni desplaza hacia abajo los elementos con índices más altos para llenar el vacío dejado al eliminar el elemento.

También es posible eliminar elementos al final de la matriz simplemente asignando un nuevo valor a la propiedad de longitud. Las matrices tienen un método. estallido()(lo opuesto al método push()), que reduce la longitud de la matriz en 1 y devuelve el valor del elemento eliminado. También hay un método cambio()(lo opuesto al método unshift()), que elimina el elemento al principio de la matriz. A diferencia del operador de eliminación, el método shift() desplaza todos los elementos a una posición debajo de su índice actual.

Finalmente existe un método multipropósito. empalme(), que le permite insertar, eliminar y reemplazar elementos de la matriz. Cambia el valor de la propiedad de longitud y cambia los elementos de la matriz a índices más bajos o más altos según sea necesario. Veremos todos estos métodos un poco más adelante.

matrices multidimensionales

JavaScript no admite matrices multidimensionales "verdaderas", pero tiene una buena forma de simularlas utilizando matrices de matrices. Para acceder a un elemento de datos en una matriz de matrices, simplemente use el operador dos veces.

Por ejemplo, supongamos que la matriz variable es una matriz de matrices de números. Cada elemento de la matriz [x] es una matriz de números. Para acceder a un número específico en una matriz, puede utilizar la expresión matriz[x][y]. A continuación se muestra un ejemplo específico en el que se utiliza una matriz bidimensional como tabla de multiplicar:

// Crea una matriz multidimensional var table = new Array(10); // Hay 10 filas en la tabla for(var i = 0; i

Métodos de la clase Array

El estándar ECMAScript 3 define Array.prototype como un conjunto de funciones convenientes para trabajar con matrices, que están disponibles como métodos en cualquier matriz. Estos métodos se presentarán en las siguientes subsecciones.

método unirse ()

El método Array.join() convierte todos los elementos de la matriz en cadenas, los une y devuelve la cadena resultante. Como argumento opcional, puede pasar una cadena al método que se utilizará para separar los elementos en la cadena resultante. Si no se especifica una cadena delimitadora, se utiliza una coma. Por ejemplo, el siguiente fragmento da como resultado la cadena "1,2,3":

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

método inverso ()

El método Array.reverse() invierte el orden de los elementos de una matriz y devuelve una matriz reordenada. La permutación se realiza directamente en la matriz original, es decir Este método no crea una nueva matriz con los elementos reordenados, sino que los reordena en una matriz ya existente. Por ejemplo, el siguiente fragmento, utilizando los métodos reverse() y join(), da como resultado la cadena "3,2,1":

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

método ordenar()

El método Array.sort() ordena los elementos de la matriz fuente y devuelve la matriz ordenada. Si se llama al método sort() sin argumentos, la clasificación se realiza en orden alfabético (los elementos se convierten temporalmente en cadenas para comparar si es necesario). Los elementos no definidos se mueven al final de la matriz.

Para ordenar en un orden que no sea alfabético, puede pasar una función de comparación como argumento al método sort(). Esta función establece cuál de sus dos argumentos debería aparecer primero en la lista ordenada. Si el primer argumento debe ir antes del segundo, la función de comparación debe devolver un número negativo. Si el primer argumento va a seguir al segundo en una matriz ordenada, entonces la función debe devolver un número mayor que cero. Y si dos valores son equivalentes (es decir, su orden no importa), la función de comparación debería devolver 0:

Vararr = ; arr.sort(); // Orden alfabético: 1111, 222, 33, 4 arr.sort(function(a,b) ( // Orden numérico: 4, 33, 222, 1111 return a-b; // Devuelve 0 // dependiendo del orden de clasificación a yb)); // Ordenar en la dirección opuesta, de mayor a menor arr.sort(function(a,b) (return b-a));

Observe lo conveniente que es utilizar una función sin nombre en este fragmento. La función de comparación solo se usa aquí, por lo que no es necesario darle un nombre.

método concat()

El método Array.concat() crea y devuelve una nueva matriz que contiene los elementos de la matriz original en la que se llamó a concat() y los valores de los argumentos pasados a concat(). Si alguno de estos argumentos es en sí mismo una matriz, sus elementos se agregan a la matriz devuelta. Sin embargo, cabe señalar que no existe una transformación recursiva de una matriz de matrices en una matriz unidimensional. El método concat() no cambia la matriz original. A continuación se muestran algunos ejemplos:

Vararr = ; arr.concat(4, 5); // Devuelve arr.concat(); // Devuelve arr.concat(,) // Devuelve arr.concat(4, ]) // Devuelve ]

método de corte()

El método Array.slice() devuelve una porción o submatriz de la matriz especificada. Los dos argumentos del método especifican el principio y el final del fragmento devuelto. La matriz devuelta contiene el elemento cuyo número se especifica en el primer argumento, más todos los elementos posteriores, hasta (pero sin incluir) el elemento cuyo número se especifica en el segundo argumento.

Si solo se proporciona un argumento, la matriz devuelta contiene todos los elementos desde la posición inicial hasta el final de la matriz. Si alguno de los argumentos es negativo, determina el número de elemento relativo al final de la matriz. Entonces, el argumento -1 corresponde al último elemento de la matriz y el argumento -3 corresponde al tercer elemento de la matriz desde el final. A continuación se muestran algunos ejemplos:

Vararr = ; arr.slice(0,3); // Devuelve arr.slice(3); // Devuelve arr.slice(1,-1); // Devuelve arr.slice(-3,-2); // Devolver

método de empalme ()

El método Array.splice() es un método genérico que realiza la inserción o eliminación de elementos de una matriz. A diferencia de los métodos slice() y concat(), el método splice() modifica la matriz original en la que fue llamado. Tenga en cuenta que los métodos splice() y slice() tienen nombres muy similares, pero realizan operaciones completamente diferentes.

El método splice() puede eliminar elementos de una matriz, insertar nuevos elementos o hacer ambas cosas al mismo tiempo. Los elementos de la matriz se desplazan según sea necesario para crear una secuencia continua después de la inserción o eliminación.

El primer argumento del método splice() especifica la posición en la matriz desde la cual se realizará la inserción y/o eliminación. El segundo argumento especifica la cantidad de elementos que deben eliminarse (cortarse) de la matriz. Si se omite el segundo argumento, se eliminan todos los elementos de la matriz desde el especificado hasta el final de la matriz. El método splice() devuelve una matriz de los elementos eliminados o (si no se eliminaron elementos) una matriz vacía.

Los dos primeros argumentos del método splice() especifican los elementos de la matriz que se eliminarán. Estos argumentos pueden ir seguidos de cualquier número de argumentos adicionales que especifiquen los elementos que se insertarán en la matriz, comenzando en la posición especificada en el primer argumento.

Vararr = ; arr.empalme(4); // Retorno, arr = arr.splice(1,2); // Retorno, arr = arr.splice(1,1); // Devolver ; arr = arr = ; arr.splice(2,0,"a","b"); // Devolver ; llegar =

métodos push() y pop()

Los métodos push() y pop() te permiten trabajar con matrices como si fueran pilas. El método push() agrega uno o más elementos nuevos al final de la matriz y devuelve su nueva longitud. El método pop() realiza la operación inversa: elimina el último elemento de la matriz, reduce la longitud de la matriz y devuelve el valor que eliminó. Tenga en cuenta que ambos métodos modifican la matriz original en lugar de crear una copia modificada de la misma.

métodos unshift() y shift()

Los métodos unshift() y shift() se comportan casi igual que push() y pop(), excepto que insertan y eliminan elementos al principio de la matriz en lugar de al final. El método unshift() cambia los elementos existentes a índices más grandes para liberar espacio, agrega el elemento o elementos al comienzo de la matriz y devuelve la nueva longitud de la matriz. El método shift() elimina y devuelve el primer elemento de la matriz, desplazando todos los elementos posteriores una posición hacia abajo para ocupar el espacio desocupado al principio de la matriz.

Popular en la categoría: