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 array, con 5, 7 y 3 elementos, con valores iguales a 7, 12 y "JavaScript":
En este caso las funciones no reciben ningún dato (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 (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 el parámetro que no es empleado se denomina: "_". 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 que están espaciados entre sí en 6 unidades (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 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-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 |
| 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-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. |
| 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 (un par de métodos getter-setter) que devuelve la longitud del vector (el número de elementos del vector). Se puede cambiar la longitud del vector, asignando la nueva longitud a esta propiedad.
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 4) y devuelve un vector con ese elemento ([3]).
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, 4])
En el siguiente ejemplo, se emplea la estructura for estandar para calcular la sumatoria de los elementos del array:
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:
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 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 (uno de los elementos de "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:
Si se manda el valor inicial del acumulador, Como en este caso es una productoria, ese valor debe ser igual a 1:
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:
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.