Cuando necesito declarar una nueva matriz, uso esta notación

var arr = new Array();

Pero cuando realizo pruebas en línea, por ejemplo en jsbin , una advertencia me indica "Usar la notación literal de matriz []".

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 en var arr = [];lugar de var arr = new Array();?

En su mayoría , 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 new Array()de crear una matriz con solo un elemento de número preespecificado.

¡El uso []es en realidad más eficiente y más seguro también ! Es posible sobrescribir el Arrayconstructor y hacer que haga cosas extrañas, pero no puede sobrescribir el comportamiento de [].

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

Una diferencia significativa es que siempre[] creará una nueva matriz, mientras que podría ser secuestrada para crear un objeto diferente .new Array

(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 Arrayfunción oculta del resto del alcance del documento, sin embargo, es más probable que si alguna vez te encuentras con este tipo de problema, el código no se haya dejado en un buen cierre, y lo hará probablemente sea difícil de localizar.

_{Descargo de responsabilidad : no es una buena idea secuestrar al Arrayconstructor.}

para mantenimiento, use []

El literal de matriz es más predecible, ya que la mayoría de los desarrolladores lo usan. La mayor parte del uso de la matriz usará el literal, y es valioso que su código coincida con lo que usan otros desarrolladores.

para matrices vacías, use []

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 gordo que el constructor Array.

para una matriz de tamaño conocido, use new Array(size)

Si se conoce el tamaño, el uso del constructor Array mejora significativamente el rendimiento. Sin embargo, también significa que tiene que lidiar con una matriz que ya tiene 'indefinido' 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 matrices muy pequeñas también .

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

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

Si necesita crear una matriz con un tamaño específico, necesita usar, x = new Array(10);por ejemplo, lo que crearía una matriz con 10 undefinedranuras.

• var arr = [] usa la matriz / objeto literal
• var arr = new Array () usa el constructor array / object

La forma más rápida de definir una matriz u objeto es literal, porque no es necesario llamar al constructor

var arr1 = new Array(1, 2, 3, 4);
var arr2 = [1, 2, 3, 4];

alert(arr1[0]); // 1
alert(arr2[0]); // 1

var arr3 = new Array(200);
var arr4 = [200];

alert(arr3[0]); // 'undefined'
alert(arr4[0]); // 200

Ambos son correctos solamente. Pero la mayoría de la gente usavar a = []

Tres formas de declarar una matriz en JavaScript.

Método 1 : podemos declarar explícitamente una matriz con la palabra clave "nueva" de JavaScript para crear una instancia de la matriz en la memoria (es decir, crearla y ponerla a disposición).

// Declare an array (using the array constructor)
var arlene1 = new Array();
var arlene2 = new Array("First element", "Second", "Last");

Método 2 : utilizamos un método alternativo para declarar matrices.

// Declare an array (using literal notation)
var arlene1 = [];
var arlene2 = ["First element", "Second", "Last"];

Método 3 : JavaScript también le permite crear matrices indirectamente, llamando a métodos específicos.

// Create an array from a method's return value
var carter = "I-learn-JavaScript";
var arlene3 = carter.split("-");

Hay un límite que el constructor puede tomar como argumentos.

En la mayoría de los sistemas, el límite es 2 ^ 16 (2 bytes):

var myFreshArr = new Array(0,1,2,3 ..... 65536);

Eso causará un error (demasiados argumentos ...)

Al usar el literal [] no tienes tales problemas.

En caso de que no te interesen esos arreglos tan grandes, creo que puedes usar lo que prefieras.

var array = [ 1, 2, 3, 4];

es azucar

var array = new Array(1, 2, 3, 4);

es sal

Es porque new Array()es ambiguo. Estos son los constructores correctos:

// Using brackets
[element0, element1, ..., elementN]

// Using new AND a list of elements
new Array(element0, element1, ..., elementN)

// Using new AND an integer specifying the array length
new Array(arrayLength)