mozilla
Los resultados de tu búsqueda

    Array

    Resumen

    Permite trabajar con arreglos.

    Se crea con

    El constructor del objeto  Array:

    new Array(longitudArreglo)
    new Array(elemento0, elemento1, ..., elementoN)
    

    Un arreglo literal:

    [elemento0, elemento1, ..., elementoN]
    

    Parámetros

    arrayLength
    Es la longitud inicial del arreglo. Puede acceder a este valor utilizando la propiedad de longitud  length. Si el valor especificado no es un número, un arreglo de longitud 1 es creado, con el primer elemento teniendo el valor especificado. La longitud máxima permitida para un arreglo es de 4,294,967,295.
    elementN
    Una lista de valores para los elementos del arreglo. Cuando es especificada de esta manera, el arreglo es iniciado con los valores especificados como sus elementos y la propiedad de longitud del arreglo es configurada al número de argumentos.

    Descripción

    Un arreglo es un conjunto ordenado de valores asociados con un único nombre de variable. Nótese que usted no debería utilizarlo como un arrego asociativo, utilice en su lugar un objects.

    El siguiente ejemplo crea un objeto Array con un arreglo literal, el arreglo bebidas contiene tres elementos y posee una longitud de tres:

    bebidas = ["Café", "Té", "Chocolate"];
    

    Puede contruir un arreglo de dos o más elementos comenzando con el índice 0 si define valores iniciales para todos los elementos. El siguiente código crea un arreglo con tres elementos:

    miArreglo = new Array("Hola", miVariable, 3.14159);
    

    Indexando un arreglo

    Indexe un arreglo por sus números ordinales. Por ejemplo, se asume que define el siguiente arreglo:

    miArreglo = new Array("Viento", "Lluvia", "Fuego");
    

    Puede referirse a los elementos de esta forma:

    • miArreglo[0] es el primer elemento
    • miArreglo[1] es el segundo elemento
    • miArreglo[2] es el tercer elemento

    Especificando un sólo parámetro

    Cuando especifica un único parámetro numérico con el constructor de un Array, especifica la longitud inicial del arreglo. El siguiente código crea un arreglo de cinco elementos:

    Métodoconstructor = new Array(5);
    

    El comportamiento del constructor de un  Array depende de si el único parámetro es un número.

    • Si el valor especificado es un número, el constructor convierte el número a un tipo entero de 32-bits sin signo  unsigned y genera un arreglo con la propiedad longitud (tamaño del arreglo) convirtiéndolo en entero  integer. El arreglo inicialmente no contiene elementos, aún cuando se piense que se puede tener un valor de longitud distinto de cero.
    • Si el valor especificado no es un número, un arreglo de longitud es creado, con el primer elemento teniendo el valor especificado.

    El siguiente código crea un arreglo de longitud 25, luego asigna los valores para los tres primeros elementos:

    Tipomúsica = new Array(25);
    Tipomúsica[0] = "R&B";
    Tipomúsica[1] = "Blues";
    Tipomúsica[2] = "Jazz";
    

    Incrementar la longitud de un arreglo indirectamente

    La longitud de un arreglo se incrementa si se asigna un valor a un elemento mayor que la longitud actual de un arreglo. El siguiente código crea un arreglo de longitud cero 0, luego asigna un valor al elemento 99. Esto cambia la longitudo de un arreglo a 100.

    colores = new Array();
    colores[99] = "amarillopatito";
    

    Creación de un arreglo utilizando el resultado de una coincidencia encontrada

    El resultado de una coincidencia String.match entre una expresión regular y una cadena puede crear un arreglo. Este arreglo posee propiedades y elementos que proveen de información acerca de la coincidencia. Una arreglo es el valor retornado por la ejecución de una expresión regular String.exec, cadena coincidente String.match y cadena remplazante String.replace. Para explicar como ayudan estas propiedades y elementos, véase el siguiente ejemplo y refiérase a la table a continuación:

    // Coincidencia de una d seguida de uno o más b seguida de una d
    // Recordar las coincidencias de b y la siguiente d
    // Ignorar el resto del caso
    
    miexpresiónRegular = /d(b+)(d)/i;
    miArreglo  = miexpresiónRegular.exec("cdbBdbsbz");
    

    Las propiedades y elementos retornados desde una coincidencia son las siguientes:

    Propiedad/Elemento Descripción Ejemplo
    input Una propiedad sólo de lectura que refleja la cadena original con la expresión regular que fue coincidente. cdbBdbsbz
    index Una propiedad sólo de lectura que está basada en cero su índice de las cadenas coincidentes. 1
    [0] Un elemento sólo de lectura que especifica los últimos caracteres coincidentes. dbBd
    [1], ...[n] Elemento sólo de lectura que especifica las cadenas coincidentes parentizadas, si son incluidas en la expresión regular. El número de las posibles cadenas parentizadas es ilimitado. [1]: bB
    [2]: d

    Propiedades

    Array.constructor
    Especifica la función que crea un prototipo de Objeto.
    Array.length
    Refleja el número de elementos en un arreglo.
    Array.prototype
    Permite la adición de propiedades a todos los objetos.

    Métodos

    Métodos Transformadores [Mutator]

    Estos métodos modifican el arreglo:

    Array.prototype.pop()
    Remueve el último elemento de un arreglo y retorna este elemento.
    Array.prototype.push()
    Añade uno o más elementos al final de un arreglo y retorna la nueva longitud de un arreglo.
    Array.prototype.reverse()
    Reversa el orden de los elementos de un arreglo -- el primero llega a ser el último y el último llega aser el primero.
    Array.prototype.shift()
    Remueve el primer elemento de un arreglo y retorna este elemento.
    Array.prototype.sort()
    Ordena los elementos de un arreglo.
    Array.prototype.splice()
    Añade y/o remueve elementos de un arreglo.
    Array.prototype.unshift()
    Añade uno o más elementos al comienzo de un arreglo y retorna la nueva longitud del arreglo.

    Métodos accesores [Accessor methods]


    Estos métodos no modifican un arreglo y retornan alguna representación del arreglo.

    Array.prototype.concat()
    Retorna un nuevo arreglo que comprende este arreglo unido con otro arreglo(s) y/o valor(es).
    Array.prototype.join()
    Une todos los elementos de un arreglo en una cadena.
    Array.prototype.slice()
    Extrae una sección de un arreglo y retorna un nuevo arreglo.
    Array.prototype.toSource()
    Retorna un arreglo literal representando el arreglo especificado; Puede utilizar este valor para crea un nuevo arreglo. Sobre escribe al método Object.toSource.
    Array.prototype.toString()
    Retorna una cadena representando el arreglo y sus elementos. Sobre escribe el método Object.toString().
    Array.prototype.valueOf
    Retorna el valor primitivo de un arreglo. Sobre escribe el método Object.valueOf().
    Los siguientes métodos han sido introducidos en JavaScript 1.6, para más detalles  Novedades en JavaScript 1.6.
    Array.prototype.indexOf()
    Retorna el primer (el menor) índice de un elemento dentro de un arreglo igual al valor especificado, o -1 si ninguno es encontrado.
    Array.prototype.lastIndexOf()
    Retorna el último (el mayor) índice de un elemento dentro de un arreglo igual al valor especificado, o -1 si ninguno es encontrado.

    Métodos de repetición

    Los siguientes métodos han sido introducidos en JavaScript 1.6, para más detalles  Novedades en JavaScript 1.6.

    Varios métodos toman como argumentos funciones que son reinvocadas mientras se procesa el arreglo. Cuando estos métodos son invocados, la longitud  length del arreglo se muestrea y cualquier elemento añadido más allá de esta longitud desde el interior de la reinvocación no es visitado. Otros cambios a el arreglo (configuración del un valor o la eliminación de un elemento) puede afectar los resultados de la operacion si el método visita luego el elemento cambiado. el comportamiento específico de estos métodos en tales casos no está siempe bien definido y no debería confiarse sobre ello.

    Array.prototype.filter()
    Crea una nuevo arreglo con todos los elementos de este arreglo para los cuales la funcion de filtrado provista retorna verdadero true.
    Array.prototype.forEach()
    Invoca a una funcion por cada elemento en el arreglo.
    Array.prototype.every
    Retorna verdadero  true si cada elemento en este arreglo satisface la función de pruebas  testing provista.
    Array.prototype.map
    Crea una nuevo arreglo con los resultados de la invocación de una funcion provista sobre cda elemento en este arreglo.
    Array.prototype.some
    Retorna verdadero  true si al menos un elemento en este arreglo satisface la función de pruebas provista.

    Métodos en general

    Muchos métodos para el objeto Array de JavaScript están diseñados para ser aplicados generalmente a todos los objetos los cuales "se asemejan" a los arreglos. Esto es, ellos pueden se utilizados sobre cualquier objeto los cuales tien una propiedad de longitud  length y los cuales pueden ser útiles para ser accedidos utilizando nombres de propiedades numéricas (tal como con la indexación  array[5]).

    POR HACER: dar ejemplos con Array.prototype.forEach.call y añadir el método a un objeto como String.

    Algunos métodos, tales como join(), únicamente leen la longitud  length y las propiedades numéricas del objeto son invocados. Otros, como reverse(), requieren que las propiedades numéricas del objeto y la longitud  length sean mutables; estos métodos pueden sin embargo no ser invocados sobre objetos como String, los cuales no permiten que su propiedad  length o propiedades numéricas sintetizadas sean configuradas.

    Los métodos que trabajan sobre cualquier arreglo como objeto y  no necesitan alterar las propiedades numéricas o la longitud  length son:

    Los métodos que alteran las propiedades numéricas o la longitud  length de un objeto son invocados como:

    Este ejemplo muestra como utilizar Array.prototype.map() sobre un objeto String para obtener un arreglo de bytes codificados en representación de valores de caracteres ASCII:

    var a = Array.prototype.map.call("¡Hola Mundo!", 
                                     function(x) { return x.charCodeAt(0); })
    // y ahora igual a [72,101,108,108,111,32,87,111,114,108,100]
    

    Ejemplos

    Creando una Matriz

    el siguiente ejemplo crea una matriz, msgArray, con una longitud de 0, luego asigna valores para  msgArray[0] y  msgArray[99], cambiando la longitud del arreglo a 100.

    var msgMatriz = new Array();
    msgMatriz[0] = "Hola";
    msgMatriz[99] = "mundo";
    // La sentencia siguiene es verdadera,
    // debido al elemento msgMatriz[99] definido.
    if (msgMatriz.length == 100)
       myVar = "La longitud es 100.";
    

    Creación de una matriz de dos dimensiones

    El siguiente ejemplo crea una matriz bi-dimensional y asigna el resultado a  myVar.

    var myVar = "Prueba de una matriz multidimensional; ";
    var nb = 4; 
    var a = new Array(nb); //crea una matriz de longitud 4
    for (var i = 0; i < nb; i++) {
       a[i] = new Array(nb); //define cada elemento como una matriz de longitud 4
       for (var j = 0; j < nb; j++) {
          a[i][j] = "[" + i + "," + j + "]"; //asigna a cada elemento de la matriz bidimensional 
                                             //los valores de i y j
       }
    }
    for (var i = 0; i < nb; i++) {
       var str = "Fila " + i + ":";
       for (var j = 0; j < nb; j++) {
          str += a[i][j]; //añade a la cadena el contenido del vector bidimensional
       }
       myVar += str + "; "; //añade a la cadena original el resultado obtenido por cada iteración
    }
    

    La siguiente cadena es asignada a  myVar (las líneas separadas son usadas por legilibilidad):

    Prueba de una matriz multidimensional;
    Fila 0: [0,0][0,1][0,2][0,3];
    Fila 1: [1,0][1,1][1,2][1,3];
    Fila 2: [2,0][2,1][2,2][2,3];
    Fila 3: [3,0][3,1][3,2][3,3];
    

    También intente con  nb = 8 y véase como se expande.

    Etiquetas y colaboradores del documento

    Etiquetas: 
    Última actualización por: viartola,
    Ocultar la barra lateral