Quand j'ai besoin de déclarer un nouveau tableau, j'utilise cette notation

var arr = new Array();

Mais lors des tests en ligne, par exemple sur jsbin , un avertissement me signale "Utiliser la notation littérale du tableau []".

Je n'ai pas trouvé de raison d'éviter d'utiliser le constructeur. Est-ce en quelque sorte moins efficace que l'utilisation []? Ou est-ce une mauvaise pratique?

Y a-t-il une bonne raison d'utiliser à la var arr = [];place de var arr = new Array();?

Surtout , les gens utilisent var a = []parce que Douglas Crockford le dit .

Ses raisons incluent le comportement non intuitif et incohérent 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

Notez qu'il n'y a aucun moyen new Array()de créer un tableau avec un seul élément numérique pré-spécifié!

L'utilisation []est en fait plus efficace et plus sûre ! Il est possible d'écraser le Arrayconstructeur et de lui faire faire des choses étranges, mais vous ne pouvez pas écraser le comportement de [].

Personnellement, j'utilise toujours la []syntaxe, et de la même manière, j'utilise toujours la {}syntaxe à la place de new Object().

Une différence importante est que []sera toujours instancier un nouveau tableau, alors que new Arraypourrait être pris en otage pour créer un objet différent .

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

Dans mon exemple de code, j'ai gardé la Arrayfonction cachée du reste de la portée du document, mais il est plus probable que si vous rencontrez un jour ce type de problème, le code n'aura pas été laissé dans une belle fermeture, et le sera probablement difficile à localiser.

_{Avertissement : ce n'est pas une bonne idée de détourner le Arrayconstructeur.}

pour la maintenabilité, utiliser []

Le littéral du tableau est plus prévisible, car la plupart des développeurs l'utilisent. La plupart des tableaux utilisent le littéral, et il est intéressant de faire correspondre votre code avec ce que les autres développeurs utilisent.

pour les tableaux vides, utilisez []

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

Comme indiqué ici , utiliser le littéral pour empty et quelques éléments connus est plus gros que le constructeur Array.

pour un tableau de taille connue, utilisez new Array(size)

Si la taille est connue, l'utilisation du constructeur Array améliore considérablement les performances. Cependant, cela signifie également que vous devez gérer un tableau qui a déjà «indéfini» remplissant toutes ses valeurs.

Comme montré ici

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

Cela fonctionne également pour les très petits tableaux .

Non, il n'y a en fait aucune raison d'utiliser une notation plutôt qu'une autre pour les tableaux vides.

Cependant, la plupart des navigateurs affichent des performances légèrement meilleures en utilisant x = [];que d'appeler le constructeur .

Si vous devez créer un tableau avec une taille spécifique, vous sorte de besoin d'utiliser , x = new Array(10);par exemple, ce qui créerait un tableau avec 10 undefinedemplacements.

• var arr = [] utilise le littéral tableau / objet
• var arr = new Array () utilise le constructeur de tableau / objet

La manière la plus rapide de définir un tableau ou un objet est la manière littérale, car vous n'avez pas besoin d'appeler le constructeur

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

Les deux sont corrects seulement. Mais la plupart des gens utilisentvar a = []

Trois façons de déclarer un tableau en JavaScript.

méthode 1 : Nous pouvons explicitement déclarer un tableau avec le mot-clé JavaScript "new" pour instancier le tableau en mémoire (c'est-à-dire le créer et le rendre disponible).

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

méthode 2 : nous utilisons une méthode alternative pour déclarer les tableaux.

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

méthode 3 : JavaScript vous permet également de créer des tableaux indirectement, en appelant des méthodes spécifiques.

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

Il y a une limite que le constructeur peut prendre comme arguments.

Sur la plupart des systèmes que j'ai rencontrés, la limite est de 2 ^ 16 (2 octets):

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

Cela provoquera une erreur (trop d'arguments ....)

Lorsque vous utilisez le littéral [], vous n'avez pas de tels problèmes.

Au cas où vous ne vous souciez pas de ces grands tableaux, je pense que vous pouvez utiliser ce que vous préférez.

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

est du sucre

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

est du sel

C'est parce que new Array()c'est ambigu. Voici les bons constructeurs:

// 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)