En el paradigma de la POO, gran parte del trabajo de programación consiste en el uso correcto de las clases existentes (reutilización de código). Por esa razón es muy importante conocer y saber emplear correctamente esas clases, así como extenderlas (heredarlas) o de ser conveniente, modificarlas.
Es en ese sentido que en este capítulo comienza el estudio de la clase Array, que es la clase JavaScript especializada em el manejo de vectores (arrays unidimensionales) y matrices (arrays multidimensionales).
Al estar conformado un Array por dos o más datos, se trata de un dato estructurado (todo dato que está conformado por dos o más datos es un dato estructurado).
En capítulos previos ya se han empleado arrays y se ha utilizado la declaración simplificada, es decir, escribir los elementos del array entre corchetes separados con comas. Esta es la forma más empleada en la práctica y la que se seguirá empleando con más frecuencia. No obstante, es conveniente conocer las otras formas de crear arrays porque, por una parte, permite comprender mejor su naturaleza de objetos de la clase Array y por otra, porque algunas de esas formas son más útiles o eficientes en la resolución de algunos tipos de problemas.
Como son objetos de una clase, los arrays pueden ser declarados como se declara cualquier objeto a partir de una clase, es decir empleando la palabra reservada new:
Como se puede ver en el último ejemplo, cuando se manda al constructor un solo elemento (12 en este ejemplo), en lugar de crear un vector con el valor de ese elemento (como se esperaría) el constructor crea un array con ese número de elementos indefinidos.
Los arreglos pueden ser creados también con el método estático of, que devuelve los mismos resultados que new Array, excepto que, cuando se manda un sólo número, crea un vector con ese número y no (como ocurre con new Array) un vector con ese número de elementos indefinidos:
Esta forma, igualmente, no se emplea con mucha frecuencia en la práctica.
Una tercera forma de crear arreglos, que resulta útil en algunas ocasiones, es con el método estático from, el cual crea un array a partir de los elementos de un objeto de tipo array o de un objeto iterable. Básicamente, un objeto de tipo array, es aquel que tiene la propiedad length, como es el caso, por ejemplo, de las cadenas de caracteres. La propiedad length devuelve el número de elementos del array (y en el caso de las cadenas el número de caracteres de la cadena).
Así, con las siguientes instrucciones se crean dos arreglos a partir de los caracteres de dos cadenas (de dos strings):
Sin embargo, a diferencia de new Array, cuando se crea un array a partir de un objecto literal que solo tiene el atributo length, se crea un array que tiene ese número de elementos con el valor undefined, mientras que new Array(n) sólo reserva espacio para "n" elementos (sólo asigna el valor de "n" a la propiedad length) pero en realidad no tiene ningún elemento.
Así, en la siguiente instrucción, se crea un array con 7 elementos iguales a undefined y se muestran esos elementos en un ciclo for:
El método Array.from admite, opcionalmente, una función que puede recibir el valor del elemento actual y su índice. Los resultados esta función pasan a ser los valores de los elementos del array.
Por ejemplo, en las siguientes instrucciones se crean tres array, con 5, 7 y 3 elementos, con valores iguales a 7, 12 y "JavaScript":
En este caso las funciones no reciben ningún valor, porque en los 3 casos son valores undefined, pero tampoco recibe ningún índice, porque lo que se quiere es que todos los elementos tengan el mismo valor: En el primer caso devuelve (en cada una de las 5 iteraciones) el número 7, en el segundo el número 12 y en el tercer la cadena "JavaScript".
En la siguiente instrucción se crea un array con 6 números enteros consecutivos que comienzan con el número 0:
Como se puede ver la función recibe dos parámetros: el elemento "_" y el índice "i" de cada iteración, sin embargo, sólo utiliza el índice "i". Para denotar ese hecho, al parámetro que no se emplea dentro de la función, se le da el nombre: "_". Si ben esta no es una norma, es una práctica frecuente en programación. En este ejemplo la función simplemente devuelve (en cada iteración) el valor del índice "i".
En la siguiente instrucción se crea un array con 7 números enteros consecutivos, comenzando con el número 2:
Este ejemplo es similar al anterior, sólo que ahora el primer elemento es 2, por lo que se debe sumar 2 al índice (i+2).
En la siguiente instrucción se crea un array con 5 números pares consecutivos, comenzando con el número 4:
Para generar números pares, simplemente se multiplica el índice "i" por 2 (i*2) y se le suma el primer número par que se quiere generar (en este caso 4).
En la siguiente instrucción se crea un array con 7 números impares a partir del número 5:
Al igual que en el ejemplo anterior, para generar números impares se multiplica el índice "i" por 2 (i*2) y se le suma el primer número impar que se quiere generar (en este caso 5).
En la siguiente instrucción se crean un array con una serie de 9 números enteros, que inician en 2 y cuya diferencia es 6 (2, 8, 14, 20, ...):
Al igual que en los anteriores ejemplos, para generar la serie, se multiplica el índice "i" por la separación entre los números (i*6) y se le suma el primer número de la serie (en este caso 2).
Sin embargo, si lo que se quiere crear es un array con elementos conocidos, la forma más sencilla de hacerlo es mediante un array literal, es decir escribir, entre corchetes, los elementos separados con comas.
Es importante recordar en todo momento que, en Javascript, el índice del primer elemento es 0, no 1 y que, como ya se vio previamente, cada uno de los elementos del array se emplean igual que cualquier variable, excepto que es necesario escribir el indice del elemento (su posición) entre corchetes. Así, dado el siguiente vector:
Para asignar nuevos valores a algunos de sus elementos, simplemente se escribe el nombre del array ("x"), el índice (el número entre corchetes [...]) y se le asigna ("=") el nuevo valor. Por ejemplo, en las siguientes instrucciones, se asigna al segundo elemento el número 40 y al quinto el número 90:
Y en la siguiente instrucción, se calcula la raíz cuadrada de la suma de sus elementos
Por defecto, los array en Javascript son dinámicos, es decir, que se le pueden añadir o quitar elementos según se requiera.
Algunos de los métodos estándar, disponibles en Javascript para el trabajo con arrays, son:
| Método | Descripción |
|---|---|
| concat(v1,v2,...) | Crea un nuevo vector con los elementos del vector desde el que se llama al método y los elementos de los vectores "v1", "v2", etc. |
| copyWithin(i,j,k) | Copia a partir de la posición "i", los elementos desde la posición "j" hasta la posición "k-1". Si no se manda "k" o "k" es mayor al número de elementos, se copian los elementos desde "j" hasta el final del array. |
| every(f) | Devuelve verdadero si todos los elementos del array cumplen con la condición especificada en la función "f". Esta función: f(e[,i[,a]]) recibe uno a uno (en cada repetición) los elementos "e" del array desde el cual se hizo la llamada. Opcionalmente también puede recibir: el índice "i" y el array "a" desde el cual se llamó al método. Debe devolver un valor booleano |
| fill(v[,i[,j]]) | Reemplaza los elementos del array original, por el valor "v". Si se manda "i", reemplaza los valores desde esa posición hasta el final. Si además se manda "j", reemplaza los elementos desde el elemento "i" hasta el elemento "j-1". |
| filter(f) | Devuelve un nuevo array con los elementos que cumplen la condición especificada en la función "f" ("f" recibe un elemento y debe devolver un valor booleano |
| find(f) | Devuelve el primer elemento que cumple la condición especificada en la función "f". La función: f(e[,i[,a]]) recibe, uno a uno (en cada repetición) los elementos "e" del array desde el cual se hizo la llamada. Opcionalmente también puede recibir: el índice "i" y el array "a" desde el cual se llamó al método. Debe devolver un valor booleano |
| findIndex(f) | Devuelve el índice del primer elemento que cumple la condición especificada en la función "f". La función: f(e[,i[,a]]) recibe uno a uno (en cada repetición) los elementos "e" del array desde el cual se hizo la llamada. Opcionalmente también puede recibir: el índice "i" y el array "a" desde el cual se llamó al método. Debe devolver un valor booleano |
| flat([p]) | Devuelve un nuevo array donde los elementos que a su vez son arrays, dejan de ser array y sus elementos pasan a ser parte del array externo. Si se manda "p" (por defecto 1) el procedimiento continúa con los array que a su vez son array de otros elementos hasta la profundidad indicada (2, 3, ..., hasta Infinity). |
| forEach(f) | Ejecuta la función "f" para cada uno de los elementos del array. La función: f(e[,i[,a]]) recibe uno a uno (en cada repetición) los elementos "e" del array desde el cual se hizo la llamada. Opcionalmente también puede recibir: el índice "i" y el array "a" desde el cual se llamó al método. |
| includes(v[,i]) | Devuelve "true" si "v" es uno de los elementos del array. Si se manda "i", la búsqueda comienza desde esa posición, si es negativo comienza desde esa posición, pero contando desde el final del array. |
| indexOf(v[,i]) | Devuelve el índice del primer elemento cuyo valor es igual a "v", o -1 si "v" no existe en el vector. Si se manda "i", la búsqueda comienza desde ese elemento. |
| join("s") | Devuelve una cadena con los elementos del vector, separados entres si, por la cadena "s" (valor por defecto ","). |
| lastIndexOf(v[,i]) | Devuelve el índice del último elemento cuyo valor es igual a "v", o -1 si "v" no existe en el vector. Si se manda "i", la búsqueda comienza desde ese elemento hacia atrás. |
| map(f) | Devuelve un nuevo array con los resultados de ejecutar la función "f" para cada uno de los elementos del array. La función: f(e[,i[,a]]) recibe uno a uno (en cada repetición) los elementos "e" del array desde el cual se hizo la llamada. Opcionalmente también puede recibir: el índice "i" y el array "a" desde el cual se llamó al método. |
| pop() | Quita el último elemento del vector y devuelve dicho elemento. |
| push(e1,e2,...) | Añade, al final del vector, los elementos e1, e2, etc. Devuelve el nuevo número de elementos del vector |
| reduce(f[, vi]) | Ejecuta la función "f" para cada elemento del array y devuelve el resultado de la última iteración ("f(a,e)", recibe dos parámetros: la variable "a" donde se guarda automáticamente el resultado devuelto por la función en la iteración anterior y el elemento actual "e"). Si se manda "vi", se emplea como valor inicial de "a", sino, el valor inicial de "a" es el primer elemento del array. |
| reduceRight(f[, vi]) | Igual que reduce, pero comenzando las iteraciones con el último elemento y terminando en el primero. |
| reverse() | Invierte el orden de los elementos del vector |
| shift() | Quita el primer elemento del vector y devuelve dicho elemento |
| slice(i,j) | Crea una copia de los elementos del vector desde el primer elemento (o desde el elemento "i") hasta el último elemento (o hasta el elemento "j-1"). |
| some(f) | Devuelve verdadero si, alguno de los elementos del array, cumple con la condición especificada en la función "f". La función: f(e[,i[,a]]) recibe uno a uno (en cada repetición) los elementos "e" del array desde el cual se hizo la llamada. Opcionalmente también puede recibir: el índice "i" y el array "a" desde el cual se llamó al método. Debe devolver un valor booleano. |
| sort([f]) | Ordena alfabéticamente los elementos del vector. Si se manda la función "f", ordena los elementos en base al resultado devuelto por la función: si el resultado es positivo, intercambia los elementos comparados, si es negativo o cero no los intercambia ("f(a,b)" recibe los elementos consecutivos "a" y "b" a comparar y debe devolver un valor numérico: positivo, negativo o cero. |
| splice(i[,n[,e1,e2,...]]) | Quita los elementos del vector desde la posición "i" hasta el final. Si se manda "n" quita "n" elementos desde la posición "i". Si se mandan los elementos e1, e2, etc., inserta esos elementos a partir de la posición "i". Devuelve el vector, desde el cual se llamó al método, con los elementos removidos y/o añadidos. |
| toReversed() | Funciona igual que "reverse" excepto que devuelve un nuevo array en lugar de modificar el array original. |
| toSorted([f]) | Funciona igual que "sort" excepto que devuelve un nuevo array en lugar de modificar el array original. |
| toSpliced(i[,n[,e1,e2,...]]) | Funciona igual que "splice" excepto que devuelve un nuevo array en lugar de modificar el array original. |
| unshift(e1,e2...) | Añade los elementos e1, e2, etc. al principio del vector. Devuelve el nuevo número de elementos del vector. |
Se recalca que esta es una lista incompleta de las funciones estándar disponibles para el trabajo con arreglos.
De estos métodos, generalmente se emplean con con mayor frecuencia, aquellos que añaden (push) o quitan (pop), elementos del final del vector y aquellos que los quitan (shift) y añaden (unshift) al principio. Sin embargo, los otros métodos son también de utilidad práctica (sobre todo en programación funcional) por lo que es conveniente aprender a utilizarlos.
Se recuerda también que, además de los métodos dinámicos presentados, la clase Array cuenta con la pseudo-propiedad length (que en realidad es un par de métodos getter-setter) que devuelve o asigna la longitud del array (el número de elementos que tiene el array).
Dado el siguiente vector:
En los siguientes ejemplos, para tener en mente que los métodos no sólo pueden modificar el array, sino que además suelen devolver algún valor, se imprime (con print) el valor devuelto por el método y se muestra el array resultante.
Con unshift:
Se añaden los números 0, 1 y 2, al principio del array y el método devuelve el nuevo número de elementos (su longitud: length = 8).
Con push:
Se añaden los números 10, 11 y 12, al final de array y el método devuelve el nuevo número de elementos (length = 11).
Con shift:
Se quita el primer elemento del array y el método devuelve el elemento quitado (el número 0):
Con pop:
Se quita el último elemento del array y el método devuelve el elemento quitado (el número 12)
Con splice:
Se quita desde el tercer elemento (desde la posición número 2), un elemento (1). El array queda sin ese elemento (sin el número 3) y devuelve un vector sin ese elemento.
Con splice:
En el lugar del quinto elemento (en la posición 4), sin quitar ningún elemento (quitando 0 elementos), se insertan los números 5.1, 5.2 y 5.3. Como en este caso no se quita ningún elemento, el método devuelve un vector vacío ([]).
Con splice:
En el lugar del séptimo elemento (en el lugar del número 5.3, es decir en la posición 6), se quitan 2 elementos (los números 5.3 y 8) y en su lugar se insertan los elementos 7.1 y 8.1, es decir que se reemplazan los números 5.3 y 8 por los números 7.1 y 8.1. El método devuelve un vector con los elementos extraídos ([5.3, 8])
En el siguiente ejemplo, se emplea la estructura for estandar para calcular la sumatoria de los elementos del array:
Sin embargo, el mismo resultado puede ser calculado, empleando el método reduce:
Como el método sólo recibe la función (no recibe el segundo parámetro: el valor inicial del acumulador), el valor inicial del acumulador "s" es el valor del primer elemento (el número 0), "e" inicia en 1 (el valor del segundo elemento) y la función devuelve su suma (0+1=1). En la siguiente iteración "s" recibe el resultado de la iteración anterior (1), "e" recibe el valor del siguiente elemento (2) y la función devuelve su suma (1+2=3). En la siguiente iteración "s" recibe el resultado de la iteración anterior (3), "e" recibe el valor del siguiente elemento (4) y la función devuelve su suma (3+4=7). El proceso continua de esa manera, sumando en cada repetición, al resultado de la anterior iteración (a la sumatoria de los elementos anteriores) el valor del nuevo elemento, hasta que, en la última iteración devuelve la sumatoria de todos los elementos (la sumatoria de los n-1 elementos anteriores más la suma del último elemento).
Si además de la función, se manda el valor inicial del acumulador, que en este caso debe ser 0 (el valor neutro de la suma):
Se obtiene el mismo resultado, sólo que ahora reduce hace una iteración adicional: En la primera iteración, el acumulador "s", recibe el valor inicial (0) y "e" recibe el valor del primer elemento (0), entonces la función devuelve su suma (0+0=0). Posteriormente las iteraciones continuan como en el anterior ejemplo.
En este caso en particular no es estrictamente necesario mandar un valor inicial, porque sólo causa un error cuando el array es vacío (porque en ese caso el acumulador no tiene un valor inicial). No obstante, en otros casos, cuando el valor del primer elemento no es adecuado como valor inicial, es impressincidible mandar, al método reduce un valor inicial adecuado.
Se crean los vectores "x1", "x2" y "x3" con los elementos (1, 3, 5, 7), (2, 4, 6, 8) y (9, 10, 11, 12):
Se crea el vector "x" con la concatenación de los tres vectores:
Se invierte el orden de los elementos del vector "x":
Se ordena alfabéticamente los elementos del vector "x":
Como se puede ver, el orden alfabético (el orden por defecto) no siempre es numéricamente correcto (los números 10, 11 y 12, deberían estar al final, no después del número 1).
Para que el orden sea numéricamente correcto, se debe mandar a "sort" una función que reciba dos valores (a, b) y devuelva un número positivo si el primer valor es mayor que el segundo, negativo si es menor y cero si son iguales. La expresión matemática que cumple con estas condiciones, es simplemente la resta: a-b, porque si "a" es mayor que "b" el resultado es positivo (por ejemplo con 5 y 2: 5-2=3), si son iguales el resultado es 0 (por ejemplo con 9 y 9: 9-9=0) y si "a" es menor que "b" el resultado es negativo (por ejemplo con 4 y 8: 4-8=-4):
Para un orden descendente, simplemente se invierte la resta: b-a
Se crea el vector "a" con los primeros 6 elementos del vector "x":
Se crea el vector "b" con los elementos cuarto a décimo del vector "x":
Se crea el vector "c" con los elementos séptimo al último del vector "x":
Se crea el vector "d" con una copia del vector "x" y en la copia se invierte el orden de los elementos:
Se puede conseguir el mismo resultado empleando el método "toReversed":
Finalmente, se crea un texto con los elementos del vector "d", separados con guiones.
En la calculadora Javascript, la mayoría de los métodos matemáticos han sido implementados también como métodos de las clases Array y Number, es decir que pueden ser llamados directamente desde variables o valores de uno de estos tipos y por supuesto, también desde cualquier resultado que sea de uno de esos tipos (como siempre, con la notación de punto).
Por ejemplo el resultado de las siguientes expresiones:
| \[ \begin{aligned} &\sin(3.25)\\[3px] &\ln(2.2)/\ln(2.1)\\[5px] &\sqrt[5]{45/12}\\[3px] &\log_5(5.4)+\exp(3.1)\\[3px] &\sqrt[3]{\sin(1.3/2)} \end{aligned} \] |
Pueden ser calculadas con:
Que en general son más cortas que las instrucciones escritas en la forma tradicional (la forma empleada en la PE), pero que (por lo menos al principio) son más difíciles de entender:
Como se muestra en el último ejemplo, los métodos pueden ser llamados también desde un resultado, así, la siguiente expresión:
| \[ \sqrt{|\tan(\log(3.45^4))|} \] |
Puede ser calculada, mostrando el resultado con 9 dígitos de precisión, con:
De igual formal, las funciones matemáticas pueden ser llamadas (en la calculadora) desde una variable o valor literal de tipo Array. Por ejemplo el seno, la raíz cuadrada, la raíz cúbica, el logaritmo natural y la raíz quinta de los elementos del vector: [1, 3, 9, 2, 5] (redondeados al segundo dígito después del punto) pueden ser calculados con:
Resultados que pueden ser obtenidos, igualmente, con el método estándar map (recuerde que map devuelve un nuevo array con los resultados de ejecutar la función que se le manda, con cada uno de los elementos del array):
Observe que, en el último ejemplo, se emplea una función flecha, debido a que nthroot requiere dos parámetros (el número y el orden de la raíz), pero map sólo envía a la función el valor de un elemento (los valores del vector "x"), por lo tanto se requiere una función que reciba ese valor ("x") y en su interior calcule su raíz quinta (Math.nthroot(x,5) o x.nthroot(5)).
Además de los métodos estándar del objeto Array, la calculadora cuenta con algunos más:
| Método | Descripción |
|---|---|
| abs() | Devuelve el valor absoluto del objeto desde el cual es llamado. |
| add(b) | Suma b al objeto desde el cual es llamado. |
| const([n[,m],][c]) | Crea un vector con 3 filas y 4 columnas de ceros. Si se manda "c", crea una matriz de 3 filas y 4 columnas con elementos iguales a "c". Si se manda "n" crea un vector con "n" elementos iguales a "c" y si se manda "m", crea una matriz con "n" filas y "m" columnas de elementos iguales a "c". |
| copy() | Devuelve una copia del objeto desde el cual es llamado. |
| div(b) | Divide, el objeto desde el cual es llamado, entre b. |
| isArray() | Devuelve verdadero si el objeto desde el cual es llamado es un array. |
| linspace([li[,ls[,n]) | Crea un vector, con 100 números del 1 al 100. Si se manda "li", crea un vector con 100 elementos, igualmente espaciados, entre "li" y "li"+99. Si se manda "ls", 100 elementos igualmente espaciados entre "li" y "ls" y si se manda "n", un vector con "n" elementos igualmente espaciados entre "li" y "ls". |
| mul(b) | Multiplica el objeto desde el cual es llamado por el objeto b. |
| neg() | Devuelve el valor negado del objeto desde el cual es llamado. |
| rand([n[,m][,li,ls]]) | Genera una matriz con 3 filas y 4 columnas de números aleatorios comprendidos entre 0 y 1. Si se manda "n", un vector con "n" números aleatorios comprendidos entre 0 y 1. Si se manda "li" y "ls", un vector con "n" números aleatorios comprendidos entre "li" y "ls". Si además se manda "m", devuelve una matriz con "n" filas y "m" columnas de números aleatorios comprendidos entre "li" y "ls". |
| range([li[,ls[,inc]]]) | Genera un vector con los números enteros del 1 al 10. Si se manda "li", un vector con los números enteros desde 1 hasta "li", o, si "li" es negativo, con los múmeros enteros entre entre "li" y 0. Si se manda "li" y "ls", un vector con los números enteros comprendidos entre "li" y "ls" y si, además, se manda "inc", un vector los números comprendidos entre "li" y "ls", espaciados con el incremento "inc". |
| sub(b) | Resta, al objeto desde el cual se llama al método, el objeto b. |
| sum() | Devuelve la sumatoria, de los elementos del vector desde el cual es llamado. |
| zeros([n[,m]]) | Genera una matriz con 3 filas y 4 columnas de ceros. Si se manda "n", devuelve un vector con "n" ceros y si además se manda "m", una matriz con "n" filas y "m" columnas de ceros. |
Algunos de estos métodos (zeros, const y rand) permiten generar no sólo vectores, sino también matrices.
Empleando estos métodos se puede calcular, por ejemplo, la sumatoria de los números impares que existen entre 1 y 25. Con ese fin se genera un vector con esos elementos (con el método range) y se suman (con el método sum):
Resultado que pueden ser obtenido, igualmente, con reduce:
E, igualmente, con Array.from y reduce:
Y con una función recursiva inmediatamente invocada:
En este caso, la función recursiva se llama a si misma, disminuyendo "n" en 2 en cada llamada hasta que "n" es igual a 1, entonces, a partir de ese resultado se va calculando el valor de la sumatoria: 1 + 3 = 4 + 5 = 9 + 7 = 16 +.... = 144 + 25 = 169.
Por supuesto, con reduce, no solo se pueden resolver sumatorias, sino productorias y muchas otras operaciones y procesos iterativos. Así, con la siguiente instrucción se calcula la productoria de los números pares existentes entre 2 y 30:
Mandando el valor inicial del acumulador (1, porque es una productoria) se obtiene el mismo resultado, sólo que ahora el método itera una vez más::
Con la siguiente instrucción se genera un vector con 50 números aleatorios comprendidos entre 1 y 100 (rand), redondeados a enteros (round):
Se ordenan los números de forma ascendente (sort):
Y se invierte su orden (reverse):
Cada vez que se llama al método rand, genera un nuevo vector con diferentes números aleatorios, sin embargo, en ocasiones se requiere volver a generar un vector con los mismos números aleatoarios (por ejemplo para comparar dos métodos o alternativas de solución).
Para generar la misma secuencia de números (números pseudoaleatorios), se debe iniciar la semilla de números aleatorios: la variable randseed, en el mismo valor numérico (por ejemplo 1). De esa manera, al repetir la instrucción, se vuelve a generar la misma secuencia:
Por supuesto, si se inicia la semilla en un número diferente, se genera una secuencia diferente:
Como se dijo, para un orden descendente, sólo se requiere invertir el orden de la resta, así, para ordenar de forma descendente el siguiente vector de números aleatorios:
Se escriben la siguiente instrucción:
Para calcular el seno de 20 números igualmente espaciados (linspace) comprendidos entre 1 y 30, redondeados al segundo dígito después del punto (round) se escribe la instrucción:
Con el constructor Array y la función estándar fill, así como con el método estático Array.from, se pueden conseguir los mismos resultados que con zeros y const:
El uso de Array.from ha sido explicado previamente. En cuanto a fill, como no se mandan los índices inicial y final, simplemente reemplaza todos los elementos del array con el valor que se le manda, inclusive si los elementos en realidad no existen, como ocurre con las instrucciones new Array(7) y new Array(5), que, como se vio previamente, no crean un array con ese número de elementos, sino que sólo establecen la dimensión del array (el número de elementos del array).
Los métodos add, sub, mul, div, copy, isArray, neg y abs, pueden ser llamados no sólo desde vectores y matrices, sino también desde números reales y complejos.
Es importante tener en mente que, cuando se asigna una variable de tipo array a otra variable, no se hace una copia del array, sino simplemente se da un nombre extra al mismo array. Así cuando se asigna la variable "vx" a la variable "vy":
Ahora, el vector [1, 2, 3, 4, 5, 6] tiene dos nombres: "vx" y "vy", por lo tanto, cualquier cambio en "vy", es también un cambio en "vx" y viceversa. Así, si se quita el último elemento de "vy", el cambio puede ser visto también con la variable "vx", porque, como se dijo, "vx" y "vy" son simplemente dos nombres para el mismo array:
Igualmente, si se quita el primer elemento de "vx", el cambio puede ser visto con "vy":
Para hacer una copia de un array (no sólo asignarle otro nombre) se puede emplear el método slice o el método copy. Por ejemplo, con las siguientes instrucciones se genera el vector "va" y se crean dos copias, una con copy y otra con slice:
Si ahora se modifica "vb", quitando por ejemplo el último elemento, ese cambio no afecta ni al vector original (va) ni a la otra copia (vc)
Igualmente, si se modifica "vc", añadiendo por ejemplo los elementos 0 y 1 al principio del vector, ese cambio no afecta ni a "va" ni a "vb" (porque ahora son tres vectores diferentes):
La calculadora JavaScript, cuenta con otros métodos más para el trabajo con arreglos, pero los mismos serán estudiados posteriormente, porque son de mayor utilidad en el trabajo con matrices.