En este capítulo se estudian los métodos y propiedades estándar de la clase Array.
Cuando un dato está conformado por dos o más datos, organizados en una estructura definida, como ocurre con los arreglos (arrays), se conoce como dato estructurado.
Formalmente, los objetos de una clase se crean empleando la palabra reservada new. Al ser los arreglos objetos (instancias) de la clase Array, pueden ser creados con new:
No obstante, en la práctica, los arreglos rara vez se crean empleando esta forma, sino la forma simplificada (array literal) empleada en los capítulos previos.
Como se puede ver en el último ejemplo, cuando se crea un arreglo con new Array y se manda solo un número (12 en el ejemplo), en lugar de crear un vector con ese valor (como se esperaría) el constructor asigna ese número a la propiedad length del array, por lo que el array reporta que tiene ese número de elementos, pero en realidad no tiene ninguno.
Por esa razón, cuando se intenta mostrar el valor de los elementos con, por ejemplo, el método forEach, se obtiene un resultado indefinido (el método forEach, que se estudiará más adelante, admite una función que recibe, en cada iteración, un elemento del array):
En este caso, el método forEach, sólo intenta imprimir el valor de los elementos que recibe, pero no imprime nada, porque, como se dijo, el array en realidad no tiene ningún elemento.
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 sin elementos, con su propiedad length igual a ese número:
Esta forma, igualmente, no se emplea con mucha frecuencia.
Una tercera forma de crear arreglos, que resulta de utilidad 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 definida, como es el caso, por ejemplo, de las cadenas de caracteres.
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 y Array.of, cuando se crea un array a partir de un objecto literal que únicamente tiene la propiedad length (un objeto tipo array), se crea un array que tiene realmente ese número de elementos sólo que todos los elementos tienen el valor undefined (no están indefinidos, sino que tienen el valor undefined).
Así, en la siguiente instrucción, se crea un array con 7 elementos iguales a undefined y se muestran esos valores con el método forEach:
El método Array.from admite, opcionalmente, una función que puede recibir el valor del elemento actual y su índice. Los resultados devueltos por la función constituyen los elementos del array resultante.
Por ejemplo, en las siguientes instrucciones se crean tres arrays, con 5, 7 y 3 elementos, con valores iguales a 7, 12 y "JavaScript":
En este caso las funciones no reciben ningún valor (ningún argumento), porque devuelven directamente una constante, por lo tanto no se requiere ni del valor del elemento ni de su índice. En el primer caso devuelve (para cada nuevo elemento) el número 7, en el segundo el número 12 y en el tercer la cadena "JavaScript".
En las siguientes instrucciones se crean arrays con números secuenciales del 0 hasta el 5, del 2 hasta el 8, números pares del 4 al 12, números impares del 5 al 17 y la serie aritmética: 2, 8, 14, ..., 50:
En todas las instrucciones, si bien la función recibe los dos parámetros, el primero (el valor del elemento) no se utiliza dentro de la función, por esa razón se le asigna un nombre que denota ese hecho: _. Aunque no es una norma, es una práctica frecuente denominar _, a un parámetro que es recibido, pero no es empleado, dentro de una función (o método).
El parámetro que sí se utiliza (en todos los casos) es el segundo: el índice "i" (que como siempre en JavaScript comienza en 0). En el primer caso simplemente se devuelve ese valor (para los 6 primeros índices) con lo que se obtiene el array con los números del 0 al 5. En el segundo caso, al índice se le suma 2, para que el primer valor sea 2 (0+2), el segundo 3 (1+2) y así sucesivamente (para los primeros 7 índices). En el tercer caso, el índice se multiplica por 2 y se le suma 4, para que el primer número par sea 4 (0*2+4), el segundo 6 (1*2+4) y así sucesivamente para los 5 números pares. En el cuarto caso, el índice se multiplica igualmente por 2 (la diferencia entre dos números impares sucesivos) y se le suma 5, para que el primer número impar sea 5 (0*2+5), luego 7 (1*2+5) y así sucesivamente para los 7 números impares y en el último caso (para la serie aritmética) se multiplica el índice por 6 (la razón de la serie) y se le suma 2, para que el primer elemento sea 2 (0*6+2), el segundo 8 (1*6+2), el tercero 14 (2*6+2) y así sucesivamente.
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 que, en Javascript, el índice del primer elemento es 0, no 1 y que cada uno de los elementos de un arreglo se emplean igual que cualquier variable, excepto que, en un arreglo, es necesario escribir el indice del elemento. 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 arreglos en Javascript son dinámicos, es decir, que se pueden añadir o quitar elementos del arreglo según se requiera.
Algunos de los métodos estándar, disponibles en Javascript para el trabajo con vectores, 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. |
| 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". |
| 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). |
| 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.). |
| 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"). |
| 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. |
| 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 propiedad length (en realidad una pseudo propiedad, pues son dos métodos getter-setter), que devuelve la longitud del vector: el número de elementos del vector y a la cual se le puede asignar un valor para cambiar las dimensiones (el número de elementos) del vector.
Se crea el vector "x" con los números 3, 4, 6, 8, 9:
Se añade al principio del vector los números 0, 1 y 2:
Se añade al final los números 10, 11 y 12:
Se quita el primer elemento y se muestre el vector resultante:
Se quita el último elemento y se muestra el vector resultante:
Se quita el tercer elemento del vector:
En este ejemplo, el primer argumento: 2, es la posición del elemento a quitar (el tercer elemento) y el segundo argumento: 1, es el número de elementos a quitar (en este caso uno):
Se insertan, en la quinta posición, los números 5.1, 5.2 y 5.3 y se muestra el vector resultante:
En este ejemplo, el primer argumento: 4, es la posición a partir de la cual se insertan los elemento (la quinta posición), el segundo argumento: 0, es el número de elementos a quitar, en este caso 0, porque no se quitan elementos (sólo se añaden elementos). Los siguientes 3 argumentos: 5.1, 5.2 y 5.3, son los elementos que se añaden al vector en la quinta posición:
Se reemplazan los números 5.3 y 8 por 7.1 y 8.1 y se muestra el vector resultante:
En este ejemplo, el primer argumento: 6, es la posición del primer número a reemplazar (5.3 se encuentra en la séptima posición), el segundo argumento: 2, es el número de elementos a quitar (como se reemplazan dos números, primero se quitan esos números), los siguientes argumentos: 7.1 y 8.1, son los números que se insertan a partir de la séptima posición, en lugar de los elementos removidos.
Con un ciclo for, se calcula la sumatoria de los elementos del vector:
Resultado que puede ser calculado, igualmente, con el método reduce:
Donde "s" (el acumulador) es la variable que guarda el último resultado devuelto por la función y "e" es el valor del elemento actual. Como no se proporciona un valor inicial (vi) "s" toma el valor del primero elemento: 1, entonces la función es llamada con ese valor y el valor del segundo elemento: 2, con los cuales se calcula el primer resultado: 1+2=3, luego, la función es llamada con ese resultado y el valor del tercer elemento: 4 y con esos valores se calcula el segundo resultado: 3+4=7, luego, con ese resultado y el valor del cuarto elemento: 6, se calcula el tercer resultado: 7+6=13 y así sucesivamente, hasta que la función es llamada con el penúltimo resultado (57.5) y el valor del último elemento: 11 y con esos valores se calcula el resultado final (el valor de la sumatoria): 57.5+11=68.5.
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 no es numéricamente correcto (los números 10, 11 y 12, deberían estar al final).
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 una resta: a-b, porque si a es mayor que b el resultado es positivo (por ejemplo 5 y 2: 5-2=3), si son iguales el resultado es 0 (por ejemplo 9 y 9: 9-9=0) y si a es menor que b el resultado es negativo (por ejemplo 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:
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, 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 ejecuta la función que se le manda, o programa, para 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 del elemento ("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. |
| Array.from(obj[,fun]) | Método estático que crea un nuevo vector con los elementos del objeto tipo array "obj" (objeto iterable). Si se manda la función "fun", la función recibe, uno a uno, los elementos del objeto tipo array y los resultados son los elementos del nuevo array. |
| 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:
En este caso reduce (porque no se manda un valor inicial) en la primera iteración, llama a la función con s=1 (el primer elemento del array) y e=3 (el segundo elemento del array), suma 1+3 y con ese resultado (guardado automáticamente en "s") y el valor del siguiente elemento (e=5) vuelve a llamar a la función (con lo que "s" ahora es igual a 1+3+5), entonces le suma el siguiente elemento (e=7), con lo que "s" es: 1+3+5+7, continuando así, hasta que el elemento es 25 (el último elemento del array), momento en el cual el valor de "s" es: 1+3+5+...+25 (es decir la sumatoria de los números impares).
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 de puede calcular la sumatoria de los elementos, sino también su productoria (y otras operaciones más):
En esta caso, la función se llama inicialmente con p=1 y e=3 (p=1 porque no se manda un valor inicial y e=3 por ser el segundo elemento del array). Entonces devuelve el resultado p*e = 1*3 = 3, el cual se guarda automáticamente en "p". En la siguiente iteración, la función es llamada con p=3 (el último resultado de la función) y e=5 (el valor del siguiente elemento), con lo que devuelve: p*e = 3*5 = 15, ahora la función se llama con p=15 (el último resultado) y e=7 (el siguiente elemento), continuando así, hasta que, en la última iteración, la función es llamada con p=316234143225 (el último resultado calculado) y e=25 (el ultimo elemento), con lo que reduce devuelve: p*e = 316234143225*25 = 7905853580625.
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 ejecuta la primera instrucción, el método rand genera un vector con diferentes elementos (haga la prueba). Con frecuencia, sin embargo, es necesario generar la misma secuencia de números (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: randseed, en algún 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:
Como otro ejemplo de los métodos adicionales del objeto Array, 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.