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 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 una 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 proporciona una buena manera 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 y B)); // 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. Aquí hay unos 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.

Buen día a todos los que decidieron aprender todo sobre arrays en JavaScript. En varias publicaciones anteriores ya he tocado algunos puntos. El artículo de hoy es una guía completa.

Hablaré sobre algunas opciones para crear matrices y cómo se "extrae" la longitud de una matriz en JavaScript, hablaré sobre sus características, enumeraré las principales propiedades y métodos para trabajar con ellas y, por supuesto, daré ejemplos de prueba. ¡Empecemos!

Hablemos de la tarea principal de las matrices.

Lo primero que debe comprender es que las matrices son un tipo que almacena datos estructurados en celdas de memoria específicas, cada una de las cuales tiene su propio identificador (número).

Se crean utilizando corchetes, tienen una variedad de capacidades y métodos y pueden ser multidimensionales. Su principal ventaja es que todos los elementos están numerados, por lo que se puede acceder a ellos mediante un identificador.

Sin embargo, existe otro tipo de matriz. De hecho, en el artículo sobre objetos dije que estos últimos también son matrices. De hecho, son matrices asociativas, que son una estructura de datos con un sistema de almacenamiento de información en forma de “clave => valor”. Esta estructura a menudo se denomina hash o, menos comúnmente, diccionario.

Veamos cada tipo con más detalle.

Cuando se trabaja con matrices asociativas, es muy fácil agregar y eliminar elementos. Dado que este lenguaje de secuencias de comandos no está escrito y no tiene muchas reglas estrictas, puede crear elementos de objeto de varias maneras: enumerarlos inmediatamente, inicializarlos después de crear el objeto y también crearlos a medida que avanza el código.

Ahora quiero mostrar ejemplos de la implementación de tales mecanismos. En el primer programa creé un objeto. paciente y luego enumeró sus elementos. Como puedes ver, por pacienteparámetro Hice un objeto anidado que tiene sus propios valores.

1 2 3 4 5 6 7 8 9 10

var paciente = nuevo Objeto(); paciente.firstName ="Inna" paciente.edad =34, paciente.param =( altura:169, peso: 55, enfermedad: "no") alerta(paciente.primerNombre) // mostrará "Inna" alerta(paciente.param . enfermedad) // imprimirá no

var paciente = nuevo Objeto(); paciente.firstName ="Inna" paciente.edad =34, paciente.param =( altura:169, peso: 55, enfermedad: "no") alerta(paciente.primerNombre) // mostrará "Inna" alerta(paciente.param . enfermedad) // imprimirá no

Si es necesario agregar un parámetro más a los existentes, por ejemplo, apellido, se hace de la siguiente manera. Agregue las siguientes líneas al código presentado anteriormente:

paciente.apellido = "Lutsenko"

alerta (paciente.apellido)

Así es como la colección se repone fácilmente con nuevas propiedades. Si deseas cambiar algún valor, solo necesitas asignarlo a la clave seleccionada:

paciente.primerNombre = "Katya"

Para los objetos, también existe una operación para eliminar propiedades innecesarias mediante el comando eliminar:

eliminar paciente.apellido

Matrices "reales"

A veces también se les denomina "matrices con índices numéricos". Si los comparamos con la versión anterior, aquí las claves se presentan en forma de números, pero los valores pueden ser absolutamente cualquier cosa. La colección puede ingresarse desordenadamente en dicho objeto.

Por lo tanto, un elemento se puede ingresar en una celda con índice "0" y el siguiente, con índice "4". Las celdas de memoria intermedia estarán vacías y darán como resultado "indefinido" si se accede a ellas.

Como ejemplo, escribí una pequeña aplicación en la que se creaba una variedad de productos.

1 2 3 4 5

var bienes = ["Carne de res","Pasta","Queso duro","Especias"]; alerta(bienes); alerta(bienes); bienes = alerta "Tomates" (bienes);

var bienes = ["Carne de res","Pasta","Queso duro","Especias"]; alerta(bienes); alerta(bienes); bienes = alerta "Tomates" (bienes);

Te mostré específicamente cómo mostrar la lista de compras completa y cómo seleccionar un artículo. Además, toqué la propiedad. longitud, del que hablaré específicamente más adelante. Mientras tanto, daré una pequeña explicación.

bienes = "tomates"

agrega un nuevo elemento al final de la matriz.

Métodos que le permiten trabajar con el principio y el final de una matriz

Hay 4 comandos que le permiten agregar y eliminar elementos desde el principio y el final de objetos estructurados.

Primero, le contaré acerca de los métodos que funcionan con el comienzo de una matriz. Éstas incluyen cambio Y desacelerar. El primer comando elimina un valor y el segundo lo agrega.

Como ejemplo, tomé el código del programa anterior y lo modifiqué.

1 2 3 4 5 6 7 8

var bienes = ["Carne de res","Pasta","Queso duro","Especias"]; document.writeln(bienes); //Carne de res,Pasta,Queso duro,Especias document.writeln(goods); //Productos de queso duro.unshift("Tomates"); mercancías.unshift("Cerdo cocido"); document.writeln(bienes); // Cerdo, Tomates, Carne de res, Pasta, Queso duro, Especias mercancías.shift() document.writeln(bienes); //Tomates, Carne de ternera, Pasta, Queso duro, Especias

var bienes = ["Carne de res","Pasta","Queso duro","Especias"]; document.writeln(bienes); //Carne de res,Pasta,Queso duro,Especias document.writeln(goods); //Productos de queso duro.unshift("Tomates"); bienes.unshift("Cerdo cocido"); document.writeln(bienes); // Cerdo, Tomates, Carne de res, Pasta, Queso duro, Especias mercancías.shift() document.writeln(bienes); //Tomates, Carne de ternera, Pasta, Queso duro, Especias

Anoté los resultados obtenidos en los comentarios a las acciones realizadas.

Ahora pasemos a los métodos que agregan y eliminan elementos al final de la lista. Entonces, estallido es responsable de eliminar valores, y empujar- para adiciones.

Agreguemos los comandos anteriores a la implementación de software anterior.

mercancías.push("hierbas italianas");

document.writeln(bienes);

Como resultado, se mostrará la última línea en la pantalla:

"Tomates, carne de res, pasta, queso duro, hierbas italianas".

Ahora contemos los elementos.

Para saber la cantidad de elementos escritos en la matriz, debe usar la propiedad del objeto: longitud. Ya he usado este comando arriba.

En ese momento, la longitud de la colección era 4 y necesitaba agregar un producto más. Dado que la numeración de los elementos de la matriz comienza desde cero, la primera celda libre en ese ejemplo estaba bajo el índice "4". Tenga en cuenta que la longitud no determina la cantidad de productos incluidos en la colección, sino la longitud de la matriz en sí. Por lo tanto, si entre esa lista los 2 elementos del medio estuvieran vacíos

(var bienes = ["Carne de res","Pasta","Queso duro","Especias"];)

esa propiedad daría como resultado el número 6.

Conociendo este comando, puede comenzar a analizar bucles. Son necesarios para recorrer los elementos de la colección. Este es un mecanismo muy conveniente del que es difícil prescindir. En los ciclos, puede especificar en qué dirección, desde qué elemento y a lo largo de qué elemento, así como con qué paso debe iterar a través de los valores.

El bucle más popular y de ejecución más rápida es el creado con la palabra clave for.

var bienes = ["Carne de res","Pasta","Queso duro","Especias"]; for (var i = bienes.longitud-1; i >=0; i=i-2) ( document.writeln((i+1)+"."+ bienes[i]); )

Quienes decidieron que la respuesta contendría la línea: “4 Especias 2. Pasta” tenían razón. ¡Bien hecho!

Algunas notas útiles

Los creadores del lenguaje js han proporcionado muchos métodos y funciones que simplifican enormemente el trabajo con matrices. Entre ellos se encuentran herramientas para copiar colecciones, cambiar el orden de los elementos, ordenarlos, convertir una matriz en cadenas y viceversa, y mucho más.

En esta lección nos familiarizaremos con las matrices, aprenderemos cómo crearlas, realizar operaciones en sus elementos y también veremos los métodos y propiedades básicos disponibles al trabajar con ellas.

¿Qué es una matriz en JavaScript?

Una matriz es colección ordenada de valores. Los valores de esta colección se denominan elementos. Cada elemento de la matriz tiene su propio número de serie (número), que se denomina índice. Los índices están numerados a partir de 0.

La siguiente figura muestra una matriz numérica que consta de 5 elementos. Los elementos de esta matriz contienen los siguientes datos: 123 (índice 0), 7 (índice 1), 50 (índice 2), -9 (índice 3), 24 (índice 4).

Crear (declarar) una matriz

La creación de matrices en JavaScript generalmente se realiza usando literal de matriz.

Un literal de matriz es un corchete que contiene una lista de elementos separados por una coma.

Por ejemplo:

Var vacío = ; // matriz vacía var números = ; // matriz numérica var arr = ; // matriz que contiene varios tipos de datos

Los valores de una matriz de JavaScript no tienen por qué ser del mismo tipo. Aquellos. Una matriz puede contener valores de diferentes tipos de datos.

Se accede a un elemento de matriz específico mediante su índice. Esta operación también se denomina operación de indexación.

Por ejemplo:

// crea una matriz que consta de 3 elementos var smartphoneColors = ["Negro", "Blanco", "Gris"]; // muestra en la consola del navegador los valores de los elementos de la matriz smartphoneColors con índices 0 y 2 console.log("Valor del elemento de la matriz smartphoneColors con índice 0: " + smartphoneColors); // "El valor del elemento de la matriz smartphoneColors con índice 0: Negro" console.log("El valor del elemento de la matriz smartphoneColors con índice 2: " + smartphoneColors); // "El valor del elemento de la matriz smartphoneColors con índice 0: Gris" // cambia el valor del elemento de la matriz smartphoneColors con índice 1 a "Rojo" smartphoneColors = "Red"; // ["Negro", "Rojo", "Gris"] // establece el elemento de matriz smartphoneColors con índice 3 en el valor "Azul" smartphoneColors = "Blue"; // ["Negro", "Rojo", "Gris", "Azul"]

Puede utilizar no solo valores estáticos, sino también expresiones como valores de elementos de matriz:

Var longitudA = 7, anchoA = 5; punto var = ;

Los objetos se pueden utilizar como valores de elementos de matriz.

Var puntos = [ (x1: 5, y1: 3), (x1: 7, y1: 10), (x1: 12; y1: 0) ]; // matriz que consta de 3 objetos

Otra forma de crear una matriz. Consiste en llamar a la función constructora del Array.

Se utiliza una llamada a una función constructora sin argumentos para crear una matriz vacía.

Var vacío = nueva matriz(); // matriz vacía

Este método de crear una matriz es equivalente a un literal.

Si especifica un número como argumento de la función constructora, creará una matriz que constará del número especificado de elementos. Además, todos estos elementos tendrán como valor indefinido.

Var arr = nueva matriz (5); // matriz que consta de 5 elementos (los valores de los elementos no están definidos)

Si pasa varios valores o un valor no numérico a la función constructora entre paréntesis, creará una matriz a partir de los argumentos que se le pasan.

A diferencia de muchos otros lenguajes de programación, las matrices en JavaScript cambian automáticamente su tamaño, es decir. son inherentemente dinámicos. No es necesario dar ninguna dimensión a estas matrices. Otra característica distintiva de las matrices de JavaScript es que diferentes elementos de una misma matriz pueden contener diferentes tipos de datos.

propiedad de longitud (longitud de la matriz)

La determinación de la longitud de la matriz (número de elementos) se realiza mediante la propiedad de longitud.

//crea una matriz enumerando los valores de los elementos en la función Array var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //asigna la variable lengthArray a la longitud de la matriz volumeHDDs var lengthArray = volumeHDDs.length;

Cómo obtener el primer elemento de una matriz

El valor del primer elemento de una matriz se obtiene especificando el número 0 entre corchetes de esta matriz:

//creando una matriz que consta de 3 elementos var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //obteniendo el valor del primer elemento de la matriz var firstValue = volumeHDDs;

Cómo obtener el último elemento de una matriz

El valor del último elemento de una matriz se obtiene especificando la expresión nombre_matriz.longitud-1 entre corchetes de esta matriz:

//creando una matriz que consta de 3 elementos var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //obteniendo el valor del último elemento de la matriz var lastValue = volumeHDDs;

Iterando sobre una matriz

La iteración a través de los elementos de la matriz se realiza mediante un bucle for.

Por ejemplo, repitamos todos los elementos de la matriz y mostremos sus valores en la consola del navegador (F12):

//creando una matriz nameStudents, que consta de 4 elementos var nameStudents = new Array("Petya","Vasya","Kolya","Maxim"); //iterar elementos de la matriz desde 0 hasta la longitud de la matriz-1 para (var i=0; i<= nameStudents.length-1; i++) { console.log(i+1 + " элемент массива = " + nameStudents[i]); }

¿Cuál es el propósito del operador de eliminación?

El operador de eliminación no se utiliza para eliminar un elemento de una matriz, sino para asignar el valor indefinido a un elemento de matriz determinado.

Var nombrePlanetas = new Array("Venus","Mercurio","Tierra","Marte"); eliminar nombrePlanetas; para (var i=0; i<= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }

Funciones para trabajar con matrices (métodos de objetos Array)

El objeto Array contiene los siguientes métodos (funciones) para trabajar con matrices:

• cambio
• desacelerar
• rebanada
• empalme
• dividir
• contrarrestar

Método push (agregar un elemento al final de la matriz)

El método push está diseñado para agregar un elemento al final de la matriz. El valor de este elemento se especifica como parámetro de este método. Como resultado, el método push devuelve la cantidad de elementos en la matriz, teniendo en cuenta lo que se agregó.

Var nombrePlanetas = ["Venus", "Mercurio", "Tierra", "Marte"]; nombrePlanets.push("Júpiter"); // 5 console.log(nombrePlanetas); // ["Venus", "Mercurio", "Tierra", "Marte", "Júpiter"]

método pop (eliminar el último elemento de una matriz)

El método pop está diseñado para eliminar el último elemento de una matriz. Este método no tiene parámetros. Como resultado, devuelve el valor del último elemento (eliminado) de la matriz.

Var nombrePlanetas = ["Venus", "Mercurio", "Tierra", "Marte"]; nombrePlanets.pop(); // "Marte" console.log(nombrePlanetas); // ["Venus", "Mercurio", "Tierra"]

Método Shift (eliminar el primer elemento de una matriz)

El método shift está diseñado para eliminar el primer elemento de la matriz, es decir elemento que tiene índice 0. Todos los demás elementos de la matriz se desplazan al principio, es decir para cada uno de ellos, el índice se reduce en 1. Este método devuelve como resultado el valor del elemento eliminado.

Var nombrePlanetas = ["Venus", "Mercurio", "Tierra", "Marte"]; nombrePlanetas.shift(); // "Venus" console.log(nombrePlanetas); // ["Mercurio", "Tierra", "Marte"]

método unshift (agregar un elemento al comienzo de la matriz)

El método unshift está diseñado para agregar un elemento al comienzo de la matriz (antes que otros elementos). El valor de este elemento se especifica como parámetro de este método. Como resultado, este método devuelve la cantidad de elementos de la matriz, teniendo en cuenta lo que se agregó.

Var nombrePlanetas = ["Mercurio", "Tierra", "Marte", "Júpiter"]; nombrePlanets.unshift("Venus"); // 5 console.log(nombrePlanetas); // ["Venus", "Mercurio", "Tierra", "Marte", "Júpiter"]

método de corte (copiar una sección de una matriz)

El método de corte está diseñado para copiar una sección de una matriz. Sin embargo, no cambia la matriz original, sino que devuelve como resultado una nueva matriz que consta de los elementos seleccionados.

El método de corte tiene 2 parámetros:

• 1 parámetro (obligatorio): está destinado a indicar el índice del elemento desde el cual comenzar a copiar elementos;
• Parámetro 2 (opcional): está destinado a indicar el índice del elemento al que es necesario copiar (en este caso, no está incluido en la nueva matriz). Si no lo especifica, se copiarán los elementos hasta el final de la matriz especificada.

var nombrePlanetas = ["Venus", "Mercurio", "Tierra", "Marte", "Júpiter"]; var newNamePlanets = namePlanets.slice(2, 4); // ["Tierra", "Marte"]

Método de empalme (cambiar el contenido de una matriz)

El método de empalme está diseñado para cambiar el contenido de una matriz. Se puede utilizar tanto para agregar elementos a una matriz como para eliminarlos.

La sintaxis del método de empalme es:

Array.splice(startIndex, deleteCount [, elemento1[, elemento2[, ...]]]); /* startIndex (obligatorio): el índice inicial del elemento desde el cual comenzar a cambiar la matriz. Si especifica un número mayor que la longitud de la matriz como startIndex, entonces el índice inicial se establecerá al final de la matriz. Si especifica un número negativo como startIndex, el elemento inicial se contará desde el final. deleteCount (obligatorio): un número que indica cuántos elementos deben eliminarse de la matriz. Si no es necesario eliminar elementos de la matriz, entonces deleteCount debe establecerse en 0. Después de esto, debe especificar al menos un elemento nuevo que se agregará a la matriz. Si especifica un número como deleteCount que excederá el número de elementos restantes en la matriz, comenzando desde startIndex, en este caso aún se eliminarán (es decir, todos los elementos hasta el final de la matriz, comenzando desde el índice inicial) elemento1, elemento2, .. (opcional): elementos que deben agregarse a la matriz. */

Ejemplos de uso del método de empalme.

Usar el método de empalme para eliminar algunos elementos de una matriz.

Var nombrePlanetas = ["Venus", "Mercurio", "Tierra", "Marte"]; nombrePlanets.splice(2, 2); //["Tierra", "Marte"] console.log(nombrePlanetas); // ["Venus", "Mercurio"]

Usar el método de empalme para eliminar un elemento de una matriz y agregarle otros nuevos.

Var nombrePlanetas = ["Venus", "Mercurio", "Tierra", "Marte"]; nombrePlanets.splice(1, 1, "Urano", "Neptuno", "Saturno"); // ["Mercurio"] console.log(nombrePlanetas); // ["Venus", "Urano", "Neptuno", "Saturno", "Tierra", "Marte"]

Usar el método de empalme solo para agregar nuevos elementos a una matriz.

Var nombrePlanetas = ["Júpiter", "Saturno", "Urano"]; nombrePlanets.splice(0, 0, "Venus", "Mercurio", "Tierra", "Marte"); // console.log(nombrePlanetas); // ["Venus", "Mercurio", "Tierra", "Marte", "Júpiter", "Saturno", "Urano"]

método de unión (convertir una matriz en una cadena)

El método de unión está diseñado para unir todos los elementos de una matriz en una cadena.

Sintaxis del método de unión:

matriz.unirse(); /* separador (opcional): un separador que se utiliza como cadena de conexión entre cada elemento de la matriz. Si no se especifica este parámetro, "," se utilizará como cadena de conexión. Si especifica una cadena vacía como parámetro, los elementos de la matriz en la cadena devuelta no estarán separados por nada */

Var bayas = ["Uvas", "Uvas", "Grosella", "Escaramujo"]; var bayasStr1 = bayas.join(); // "Uvas, uvas, grosellas, escaramujos" var berriesStr2 = berries.join(""); // "UvasUvasCurrantRosehip" var berriesStr3 = berries.join(", "); // "Uvas, Uvas, Grosellas, Escaramujos" var berriesStr4 = berries.join(" + "); // "Uvas + Uvas + Grosellas + Escaramujos"

Si utiliza algo que no es una cadena como separador, se convertirá en una cadena.

Var bayas = ["Uvas", "Uvas", "Grosella", "Escaramujo"]; var bayasStr1 = bayas.join(falso); // "UvasfalseGrapesfalseCurrantfalseRosehip" var berriesStr2 = berries.join(4/2); // "Grapes2Grapes2Currant2Rose Hip" Los elementos de la matriz que tienen un valor nulo o indefinido se convertirán en una cadena vacía. vararr = ; var arrStr = arr.join(", "); // "0, 5, -4"

Convertir una cadena en una matriz: dividir

El método de división está diseñado para convertir una cadena en una matriz. Este método tiene un parámetro, mediante el cual puede especificar una cadena, según la cual esta cadena se dividirá en una matriz de cadenas.

Var strElementComputers = "Unidad del sistema, monitor, teclado, mouse, parlantes, impresora"; var elementComputers = strElementComputers.split(", "); console.log("Número de elementos en la matriz: " + elementComputers.length); para (var i=0; i<= elementComputers.length-1; i++) { console.log(i + " элемент массива = " + elementComputers[i]); }

Reordenar elementos de la matriz en orden inverso - inverso

El método inverso está diseñado para reordenar los elementos de una matriz en orden inverso.

Var nombrePlanetas = new Array("Venus","Mercurio","Tierra","Marte"); nombrePlanetas.reverse(); console.log("Número de elementos en la matriz: " + nombrePlanets.length); para (var i=0; i<= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }

Ordenar elementos de una matriz - ordenar

El método de clasificación se utiliza para ordenar elementos de una matriz. De forma predeterminada, este método ordena la matriz como cadenas.

Var nombrePlanetas = new Array("Venus","Mercurio","Tierra","Marte"); nombrePlanets.sort(); console.log("Número de elementos en la matriz: " + nombrePlanets.length); para (var i=0; i<= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }

21/06/2017 a las 12:17

Para calcular el tamaño de una matriz de objetos en JavaScript, use la propiedad de longitud de la matriz.

Var arr = ["primero", "segundo"]; console.log(arr.longitud); // 2

A las matrices en javascript les pueden faltar índices. Por ejemplo

Vararr = ; arr = "primero"; arr = "segundo";

La propiedad de longitud devuelve el índice máximo de la matriz + 1. es decir en el ejemplo dado, longitud = 5.

Calcular el número de elementos en una matriz en javascript

Array.prototype.count = función())( var resultado = 0; for(var i = 0; i< this.length; i++) if (this[i] != undefined) result++; return result; }

Ejemplo de uso

Vararr = ; arr = "primero"; arr = "segundo"; console.log(arr.count()); //2

También puede asignar un valor a la propiedad de longitud. Esto le permite reducir la longitud de una matriz existente.

Var arr = ["primero", "segundo", "tercero"]; longitud de arreglo = 2; consola.log(arr); // ["primer segundo"]

Calcular el tamaño de una matriz en bytes en javascript

Las matrices son objetos normales, por lo que calcular el tamaño de una matriz en bytes no es diferente a calcular el tamaño de cualquier otro objeto. Desafortunadamente, JavaScript no proporciona una API para calcular el tamaño, por lo que tendrás que calcularlo tú mismo. Esto se hace de la siguiente manera: revisamos todas las propiedades del objeto; si la propiedad es de tipo primitivo, sumamos el tamaño de una instancia de este tipo al resultado general; si la propiedad contiene un objeto, calculamos de forma recursiva; su tamaño.

Función sizeOf(obj) ( var bytes = 0; if(obj !== null && obj !== indefinido) ( switch(typeof obj) ( case "number": bytes += 8; break; case "string": bytes += obj.length * 2; break; case "boolean": bytes += 4; break case "objeto": for(var clave en obj) ( bytes += sizeOf(obj); ) devolver bytes;

El método no es preciso y presenta muchos problemas; por ejemplo, existe la posibilidad de entrar en un bucle sin fin.

En este artículo veremos matrices de JavaScript estándar con índices numéricos. Las matrices se declaran entre corchetes:

var frutas = ["Manzana", "Naranja", "Burro"]

Para extraer un elemento, coloque su índice entre corchetes. Primer índice 0:

var frutas = ["Manzana", "Naranja", "Burro"] alerta(frutas) alerta(frutas) alerta(frutas)

También podemos obtener la longitud de una matriz de JavaScript:

var frutas = ["Manzana", "Naranja", "Burro"] alerta(frutas.longitud)

¡Ups! Creamos un arreglo con dos frutas y un burro. Ahora tenemos que sacar el burro.

métodos pop y push

El método pop en JavaScript elimina un elemento de una matriz y lo devuelve.

El siguiente ejemplo muestra cómo se recupera "Donkey" de una matriz:

var frutas = ["Apple", "Orange", "Donkey"] alert("Estoy eliminando "+fruits.pop()) // Ahora solo tenemos ["Apple","Orange"] alert("Ahora el tamaño de la matriz: "+frutas.longitud) // burro eliminado

Tenga en cuenta que pop modifica la matriz misma.

La contraparte de Pop es el método push, que agrega un elemento a una matriz. Por ejemplo, nos olvidamos de añadir un melocotón:

var frutas = ["Manzana", "Naranja"] frutas.push("Melocotón"); // ahora tenemos ["Manzana", "Naranja", "Melocotón"] alerta("Último elemento:"+frutas)

1. Crea una variedad de estilos con elementos “ Jazz”, “Blues”;
2. Añade el valor " Rock and roll«;
3. Reemplace el segundo valor desde el final con el valor " Clásico". Deberías terminar con una matriz: " Jazz”, ”Clásico”, ”Rock and roll" El código debería funcionar para cualquier longitud de matriz;
4. Recupere el último valor de la matriz y muéstrelo mediante alerta.

Solución

// 1 var estilos = ["Jazz", "Bluez"] // 2 estilos.push("Rock"n"Roll") // o: estilos = "Rock"n"Roll" // 3 estilos = "Clásico " // 4 alerta(estilos.pop())

Métodos de cambio/desplazamiento

Los métodos shift/unshift funcionan al final de la matriz, pero también puedes usar shift para mover elementos hacia arriba ( el primer valor de la matriz se elimina cambiando los elementos). El método unshift permite a JavaScript agregar un elemento a una matriz desde el final:

var frutas = ["Apple", "Orange"] var apple = frutas.shift() // ahora solo tenemos ["Orange"] frutas.unshift("Lemon") // ahora tenemos ["Lemon", " Naranja"] alerta(frutas.longitud) // 2

Tanto shift como unshift pueden operar en múltiples elementos a la vez:

var frutas = ["Apple"] frutas.push("Orange","Peach") frutas.unshift("Pineapple","Lemon") // ahora la matriz se ve así: ["Pineapple", "Lemon", "Manzana" ", "Naranja", "Melocotón"]

Tarea autoadministrada

Escriba el código para mostrar un valor aleatorio de la matriz arr mediante alerta:

var arr = ["Ciruela","Naranja","Burro","Zanahoria","JavaScript"]

Nota: El código para obtener un número aleatorio del valor mínimo al máximo (inclusive) es el siguiente:

var rand = min + Math.floor(Math.random()*(max+1-min))

Solución

Necesitamos extraer un número aleatorio de 0 a arr.length-1 (inclusive):

var arr = ["Ciruela","Naranja","Burro","Zanahoria","JavaScript"] var rand = Math.floor(Math.random()*arr.length) alert(arr)

Iterando sobre una matriz

En JavaScript, la iteración a través de una matriz se realiza mediante un bucle for:

var frutas = ["Piña", "Limón", "Manzana", "Naranja", "Melocotón"] for(var i=0; i

Tarea autoadministrada

Cree una función buscar (arr, valor) que encuentre un valor en una matriz determinada y devuelva su índice o -1 si no se encuentra el valor.

Por ejemplo:

arr = [ "prueba", 2, 1.5, false ] buscar(arr, "prueba") // 0 buscar(arr, 2) // 1 buscar(arr, 1.5) // 2 buscar(arr, 0) // -1

Solución

Una posible solución podría verse así:

función buscar(matriz, valor) ( ​​for(var i=0; i

Pero esto es incorrecto porque == no define la diferencia entre 0 y false.

Es más correcto utilizar === cuando se trabaja con matrices en JavaScript. Además, el último estándar ES5 incluye la función Array#indexOf. Con él podemos definir una función como esta:

función buscar (matriz, valor) (si (array.indexOf) devuelve matriz.indexOf (valor) para (var i=0; i

Aún más inteligente sería definir find con una condición para verificar si existe el método indexOf.

Tarea autoadministrada

Cree una función filterNumeric(arr) que tome una matriz y devuelva una nueva matriz que contenga solo los valores numéricos de arr.

Un ejemplo de cómo debería funcionar esto:

matriz = ["a", 1, "b", 2]; arr = filtroNumeric(arr); // ahora arr =

Solución

La solución es iterar a través de la matriz y agregar los valores a una nueva matriz si son numéricos.

unirse y dividir

A veces necesitas una forma rápida de convertir una matriz de JavaScript en una cadena. Para esto sirve el método de unión.

Concatena la matriz en una cadena usando el delimitador dado:

var frutas = ["Limón","Manzana","Naranja","Melocotón"]; var str = frutas.join(", "); alerta(cadena);

La conversión inversa se realiza fácilmente utilizando el método de división:

var frutas = "Manzana,Naranja,Melocotón"; var arr = frutas.split(","); // arr ahora contiene ["Apple", "Orange", "Peach"] alert(arr);

Tarea autoadministrada

El objeto incluye una propiedad className, que contiene los nombres de las clases, separados por espacios:

Escribe una función addClass(obj, cls) que agregue la clase cls , pero solo si no existe:

ddClass(obj, "new") // obj.className="abrir menú nuevo" addClass(obj, "open") // sin cambios (la clase ya existe) addClass(obj, "me") // obj.className= Alerta "abrir menú nuevo yo" (obj.className) //

Solución

Debe dividir el nombre de clase y el bucle en partes. Si no se encuentra la clase, se agrega.

El bucle se ha optimizado ligeramente para aumentar el rendimiento:

función addClass(elem, cls) ( for(var c = elem.className.split(" "), i=c.length-1; i>=0; i--) ( if (c[i] == cls ) return ) elem.className += " "+cls ) var obj = ( className: "abrir menú" ) addClass(obj, "new") addClass(obj, "open") alert(obj.className) // abrir menú nuevo

En el ejemplo anterior, la variable c se define al comienzo del ciclo y su último índice se establece en i.

El bucle en sí se procesa en la dirección opuesta y termina con la condición i>=0. Porque i>=0 es más rápido de verificar que i . Lo que en JavaScript acelera la búsqueda en una matriz.

Usar longitud para recortar una matriz

Usando la propiedad de longitud, puedes truncar una matriz como esta:

Usted especifica la longitud y el navegador trunca la matriz.

La matriz es un objeto, entonces, ¿qué significa esto?

De hecho, en JavaScript, una matriz es un objeto, completo con configuración automática de longitud y métodos especiales.

Esto es diferente del concepto en otros lenguajes, donde las matrices representan un segmento contiguo de memoria. Esto también es diferente de una cola o pila basada en listas vinculadas.

Teclas de matriz no numéricas

Las claves son números, pero pueden tener cualquier nombre:

arr = arr = 5 arr.prop = 10 // no hagas esto

En JavaScript, las matrices son tablas hash, que tienen ventajas de rendimiento pero también ciertas desventajas.

Por ejemplo, push/pop solo funciona en los elementos más externos de una matriz, por lo que son increíblemente rápidos.

push solo funciona con el final:

var arr = ["Mi", "matriz"] arr.push("algo") alert(arr) // cadena "matriz"

Los métodos de cambio/desplazamiento son lentos porque necesitan volver a numerar toda la matriz. El método de empalme también puede hacer que cambie la numeración:

Entonces shift/unshift son más lentos que push/pop . Cuanto más grande sea la matriz, más tiempo le llevará a JavaScript ordenarla.

Tarea autoadministrada

¿Cuál será el resultado? ¿Por qué?

arr = ["a", "b"] arr.push(función() ( alerta(esto) )) arr() // ?

Solución

Dado que las matrices son objetos, arr .. es en realidad una llamada a un método sobre un objeto como obj método:

arr() // igual que arr() // sintácticamente incorrecto, pero conceptualmente igual: arr.2() // reescrito en el mismo estilo que obj.method() this = arr en este caso se pasa a la función, entonces se imprimen los contenidos de arr. arr = ["a", "b"] arr.push(función() ( alerta(esto) )) arr() // "a","b",función

Matrices dispersas, descripción de longitud.

La propiedad de longitud le permite obtener no el tamaño de una matriz en JavaScript, sino el último índice + 1. Esto es importante cuando hablamos de matrices dispersas, con “huecos” en los índices.

En el siguiente ejemplo, agregaremos dos elementos a las frutas vacías, pero el valor de longitud seguirá siendo 100:

var frutas = // matriz vacía frutas = "Melocotón" frutas = "Apple" alerta(frutas.longitud) // 100 (pero solo hay 2 elementos en la matriz)

Si intenta generar una matriz dispersa, el navegador devolverá los valores de índice faltantes como elementos vacíos:

var frutas = // matriz vacía frutas = "Melocotón" frutas = "Manzana" alerta(frutas) //, Melocotón, Manzana (o algo así)

Pero una matriz es un objeto con dos claves. Los valores faltantes no ocupan espacio.

Las matrices dispersas se comportan de manera extraña cuando se les aplican métodos de matriz. No tienen idea de que faltan índices:

var frutas = frutas = "Melocotón" frutas = "Apple" alert(fruits.pop()) // pop "Apple" (al índice 9) alert(fruits.pop()) // pop un elemento no especificado (al índice 8 )

Intente evitar matrices dispersas. En cualquier caso, sus métodos no funcionarán con normalidad. Utilice Objeto en su lugar.

Quitar de una matriz

Como sabemos, las matrices son objetos, por lo que podríamos usar eliminar para eliminar un valor:

var arr = ["Ir", "a", "casa"] eliminar arr // ahora arr = ["Ir", undefinido, "casa"] alert(arr) // no definido

Puede ver que el valor se elimina, pero no de la manera que nos gustaría, porque la matriz contiene un elemento no especificado.

El operador de eliminación elimina un par clave-valor y listo. Naturalmente, dado que la matriz es solo un hash, la posición del elemento eliminado queda indefinida.

La mayoría de las veces necesitamos eliminar un elemento sin dejar "agujeros" entre los índices. Existe otro método que nos ayudará con esto.

método de empalme

El método de empalme puede eliminar elementos y reemplazarlos en matrices multidimensionales de JavaScript. Su sintaxis es:

arr.splice(índice, eliminarContar[, elem1, ..., elemN])

Elimina el elemento deleteCount que comienza en el índice y luego inserta elem1, ..., elemN en su lugar.

Veamos algunos ejemplos:

var arr = ["Ir", "a", "inicio"] arr.splice(1, 1) // eliminar 1 elemento comenzando en el índice 1 alert(arr.join(",")) // ["Ir " , "home"] (1 elemento eliminado)

Entonces puedes usar empalme para eliminar un elemento de una matriz. Los números de los elementos de la matriz se desplazan para llenar el espacio:

var arr = ["Go", "to", "home"] arr.splice(0, 1) // elimina 1 elemento, comenzando desde el índice 0 alert(arr) // "to" se convirtió en el primer elemento

El siguiente ejemplo muestra cómo reemplazar elementos:

El método de empalme devuelve una matriz de elementos eliminados:

var arr = ["Ir", "a", "casa", "ahora"]; // elimina los primeros 2 elementos var eliminado = arr.splice(0, 2) alert(eliminado) // "Ir", "a"<-- массив удаленных элементов splice может вставлять элементы, задайте 0 для deleteCount. var arr = ["Go", "to", "home"]; // со второй позиции // удаляем 0 // и вставляем "my", "sweet" arr.splice(2, 0, "my", "sweet") alert(arr) // "Go", "to", "my", "sweet", "home"

Este método también puede utilizar un índice negativo, que se cuenta desde el final de la matriz:

var arr = // para el elemento -1 (penúltimo) // elimina 0 elementos, // e inserta 3 y 4 arr.splice(-1, 0, 3, 4) alert(arr) // 1,2,3, 4.5

Tarea autoadministrada

El objeto contiene una propiedad className, que contiene los nombres de las clases, separados por espacios:

var obj = (nombre de clase: "abrir menú")

Escriba una función removeClass(obj, cls) que elimine la clase cls si se proporciona:

removeClass(obj, "open") // obj.className="menu" removeClass(obj, "blabla") // sin cambios (no hay ninguna clase para eliminar)

Solución

Debe dividir el nombre de clase en partes y recorrer estas partes. Si se encuentra una coincidencia, se elimina de la matriz de objetos de JavaScript y luego se vuelve a agregar al final.

Optimicemos esto un poco:

función removeClass(elem, cls) ( for(var c = elem.className.split(" "), i=c.length-1; i>=0; i--) ( if (c[i] == cls ) c.splice(i,1) ) elem.className = c.join(" ") ) var obj = ( className: "abrir menú" ) removeClass(obj, "open") removeClass(obj, "blabla") alerta (obj.className) // menú

En el ejemplo anterior, la variable c se establece al comienzo del ciclo y i se establece en su último índice.

El bucle en sí corre en la dirección opuesta y termina con la condición i>=0. Esto se hace porque i>=0 se verifica más rápido que i . Lo que agiliza la búsqueda de propiedades en c .

método de corte

Puede extraer parte de una matriz utilizando el método slice(begin[, end]): var arr = ["Why", "learn", "JavaScript"]; var arr2 = arr.slice(0,2) // toma 2 elementos, comenzando en 0 alert(arr2.join(", ")) // "Por qué, aprende"

Tenga en cuenta que este método no cambia la cantidad de elementos de la matriz en JavaScript, sino que copia parte de ella.

Puede omitir el segundo argumento para que todos los elementos comiencen en un índice específico:

var arr = ["Por qué", "aprender", "JavaScript"]; var arr2 = arr.slice(1) // toma todos los elementos comenzando desde 1 alert(arr2.join(", ")) // "aprender, JavaScript"

El método admite índices negativos, al igual que String#slice.

método inverso

Otro método útil es el inverso. Digamos que quiero obtener la última parte de un dominio como " com" de " mi.sitio.com" He aquí cómo hacerlo:

var dominio = "mi.sitio.com" var último = dominio.split(".").reverse() alerta (último)

Tenga en cuenta que las matrices de JavaScript admiten una sintaxis compleja (reverse()) para llamar a un método y luego recuperar un elemento de la matriz resultante.

Puedes crear llamadas más largas como inversa() 0] arr.sort() alerta(arr) // 1, 15, 2

Ejecute el código anterior. Obtendrá el orden 1, 15, 2. Esto se debe a que el método convierte todo en una cadena y utiliza el orden lexicográfico de forma predeterminada.

Comparte este artículo: