Búsqueda de sitios web

¿Cuáles son las mejores prácticas a seguir al declarar un arreglo en Javascript?

Cuando necesito declarar un nuevo arreglo uso esta notación

var arr = new Array();

Pero al hacer pruebas en línea, por ejemplo en jsbin, una advertencia me indica "Usa la notación literal de arreglos []."

No encontré una razón para evitar usar el constructor. ¿Es de alguna manera menos eficiente que usar []? ¿O es una mala práctica?

¿Hay una buena razón para usar var arr=[]; en lugar de var arr=new Array();?

Respuesta #1

Mayormente, la gente usa var a=[] porque Douglas Crockford lo dice.

Sus razones incluyen el comportamiento no intuitivo e inconsistente de new Array():

var a = new Array(5);     // an array pre-sized to 5 elements long
var b = new Array(5, 10); // an array with two elements in it

¡Tenga en cuenta que no hay forma con new Array() de crear un arreglo con solo un elemento numérico preespecificado!

Usar [] en realidad es más eficiente y también más seguro. Es posible sobrescribir el constructor Array y hacer que haga cosas extrañas, pero no se puede sobrescribir el comportamiento de [].

Personalmente, siempre uso la sintaxis [], y de manera similar siempre uso la sintaxis {} en lugar de new Object().

Respuesta #2

Una diferencia significativa es que [] siempre instanciará un nuevo Array, mientras que new Array podría ser secuestrado para crear un objeto diferente.

(function () {
    "use strict";
    var foo,
        bar;
    //don't do this, it's a bad idea
    function Array() {
        alert('foo');
    }
    foo = new Array();
    bar = [];
}());

En mi código de ejemplo, he mantenido la función Array oculta del resto del ámbito del documento, sin embargo, es más probable que si alguna vez te encuentras con este tipo de problema, el código no haya sido dejado en un buen closure, y probablemente será difícil de localizar.

Aviso: No es una buena idea secuestrar el constructor Array.

Respuesta #3

para mantenimiento, usa []

El literal de arreglo es más predecible, ya que la mayoría de los desarrolladores lo usan. La mayor parte del uso de arreglos será utilizando el literal, y hay valor en que tu código coincida con lo que otros desarrolladores usan.

para arrays vacíos, utiliza []

var ns = [];
var names = [ 'john', 'brian' ];

Como se muestra aquí, usar el literal para vacío y un par de elementos conocidos es más rápido que el constructor Array.

para un arreglo de tamaño conocido, usa new Array(size)

Si se conoce el tamaño, entonces usar el constructor Array mejora significativamente el rendimiento. Sin embargo, también significa que tienes que lidiar con un arreglo que ya tiene 'undefined' llenando todos sus valores.

Como se muestra aquí

// fill an array with 100 numbers
var ns = new Array( 100 );
for ( var i = 0; i < 100; i++ ) {
    ns[i] = i;
}

Esto también funciona para arrays muy pequeños.

Respuesta #4

No, en realidad no hay ninguna razón para usar una notación sobre la otra para arrays vacíos.

Sin embargo, la mayoría de los navegadores muestran un rendimiento ligeramente mejor usando x=[]; que llamando al Constructor.

Si necesitas crear un Array con un tamaño específico, de alguna manera necesitas usar x=new Array(10); por ejemplo, lo que crearía un Array con 10 casillas undefined.

Artículos relacionados