Quelle est la différence entre “Array()” et “ []”, tout en déclarant un tableau JavaScript?

Il y a une différence, mais il n'y a pas de différence dans cet exemple.

À l'aide de la méthode plus détaillée: new Array() n'ont une option supplémentaire dans les paramètres: si vous passez un numéro pour le constructeur, vous obtiendrez un tableau de cette longueur:

x = new Array(5);
alert(x.length); //5

Pour illustrer les différentes façons de créer un tableau:

var a = [],            //these are the same
    b = new Array(),   //a and b are arrays with length 0

    c = ['foo', 'bar'],           //these are the same
    d = new Array('foo', 'bar'),  //c and d are arrays with 2 strings

    //these are different:
    e = [3]             //e.length == 1, e[0] == 3
    f = new Array(3),   //f.length == 3, f[0] == undefined

;

Une autre différence est que lors de l'utilisation de new Array() vous êtes en mesure de définir la taille de la matrice, ce qui affecte la taille de la pile. Cela peut être utile si vous avez des débordements de pile (Les performances de la pile.push vs Tableau.unshift) qui est ce qui se passe lorsque la taille du tableau dépasse la taille de la pile, et il doit être re-créé. Donc, il peut en effet, suivant le cas, une augmentation des performances lors de l'utilisation de new Array() parce que vous pouvez empêcher le débordement de passe.

Comme l'a souligné dans cette réponse, new Array(5) ne sera pas réellement ajouter cinq undefined des éléments dans le tableau. Il suffit d'ajouter de l'espace de cinq éléments. Être conscient que l'utilisation de Array de cette façon rend difficile de s'appuyer sur array.length pour les calculs.

Il existe une différence importante qu'aucune réponse n'a encore été mentionnée.

De:

new Array(2).length           //2
new Array(2)[0] === undefined //true
new Array(2)[1] === undefined //true

Vous pourriez penser que le new Array(2) est équivalent à [undefined, undefined], mais il n'est PAS!

Essayons map():

[undefined, undefined].map(e => 1)  //[1, 1]
new Array(2).map(e => 1)            //"(2) [undefined × 2]" in Chrome

Voir? La sémantique est totalement différent! Alors, pourquoi est-ce?

Selon ES6 Spec 22.1.1.2, le travail de Array(len) est juste la création d'un nouveau tableau dont la propriété length est définie à l'argument len et qui, par conséquent, il n'est pas tout élément réel à l'intérieur de ce tableau nouvellement créé.

Fonction map(), selon les spec 22.1.3.15 serait tout d'abord de vérifier HasProperty ensuite appeler la fonction de rappel, mais il s'avère que:

new Array(2).hasOwnProperty(0) //false
[undefined, undefined].hasOwnProperty(0) //true

Et c'est pourquoi vous ne pouvez pas attendre tout de l'itération des fonctions de travail comme d'habitude sur les tableaux créés à partir de new Array(len).

BTW, Safari et Firefox ont une bien meilleure "l'impression" de cette situation:

//Safari
new Array(2)             //[](2)
new Array(2).map(e => 1) //[](2) 
[undefined, undefined]   //[undefined, undefined] (2) 

//Firefox
new Array(2)             //Array [ <2 empty slots> ]
new Array(2).map(e => 1) //Array [ <2 empty slots> ]
[undefined, undefined]   //Array [ undefined, undefined ]

J'ai déjà présenté une question de Chrome et de leur demander de corriger cette confusion de l'impression:
https://bugs.chromium.org/p/chromium/issues/detail?id=732021

Mise à JOUR: Il est déjà fixé. Chrome maintenant imprimés comme:

new Array(2)             //(2) [empty × 2]

Pour plus d'informations, la page suivante explique pourquoi vous ne devez jamais utiliser new Array()

Vous n'avez jamais besoin d'utiliser new Object() dans
Le JavaScript. Utilisation de l'objet littéral {}
au lieu de cela. De même, ne pas utiliser new Array(),
utilisez le tableau littéral []
au lieu de cela. Les tableaux en JavaScript travail
rien de tel que les tableaux en Java, et
l'utilisation de Java comme de la syntaxe
vous confondre.

Ne pas utiliser new Number, new String, ou
new Boolean. Ces formes produire
inutile de l'objet de la demande. Utilisez simplement
simple littéraux de la place.

Découvrez également les commentaires - le new Array(length) formulaire ne sert aucun but utile (au moins aujourd'hui, dans les implémentations de JavaScript).

La première est la valeur par défaut du constructeur d'objet de l'appel. Vous pouvez utiliser les paramètres si vous le souhaitez.

var array = new Array(5); //initialize with default length 5

Le second vous donne la possibilité de créer pas de tableau vide:

var array = [1, 2, 3]; //this array will contain numbers 1, 2, 3.

Il n'y a pas de différence lors de l'initialisation d'une matrice, sans aucune longueur. Donc var a = [] & var b = new Array() est le même.

Mais si vous initialiser le tableau avec la longueur comme var b = new Array(1);, il va mettre en objet de tableau de longueur 1. De sorte que son équivalent à var b = []; b.length=1;.

Cela va être problématique lorsque vous ne array_object.pousser, ajouter l'élément suivant le dernier élément & augmenter la longueur.

var b = new Array(1);
b.push("hello world");
console.log(b.length); //print 2

vs

var v = [];
a.push("hello world");
console.log(b.length); //print 1

Il n'y a pas de grande différence, ils se sont contentés de faire la même chose, mais le faire de différentes manières, mais à lire, regarder cette déclaration au W3C:

var cars = ["Saab", "Volvo","BMW"];

et

var cars = new Array("Saab", "Volvo", "BMW");

Les deux exemples ci-dessus font exactement la même. Il n'est pas nécessaire d'utiliser
new Array().
Pour des raisons de simplicité, la lisibilité et la vitesse d'exécution, utilisez la
premier (le littéral de tableau de la méthode).

Mais en même temps, créant un nouveau tableau à l'aide de new Array syntaxe considéré comme une mauvaise pratique:

Éviter de new Array()

Il n'est pas nécessaire d'utiliser le code JavaScript intégré dans la gamme du constructeur
new Array().

Utilisez [] à la place.

Ces deux états à la fois de créer un nouveau tableau vide nommé
points:

var points = new Array();         //Bad
var points = [];                  //Good 

Ces deux états à la fois de créer un nouveau tableau contenant 6
numéros:

var points = new Array(40, 100, 1, 5, 25, 10); //Bad    
var points = [40, 100, 1, 5, 25, 10];          //Good

La nouveau mot-clé ne fait que compliquer le code. Il peut également générer des
des résultats inattendus:

var points = new Array(40, 100);  //Creates an array with two elements (40 and 100)

Ce que si je supprime l'un des éléments?

var points = new Array(40);       //Creates an array with 40 undefined elements !!!!!

Donc, fondamentalement, n'est pas considéré comme la meilleure pratique, il y a aussi une différence mineure de là, vous pouvez passer à longueur de new Array(length) comme ça, qui a également pas une méthode recommandée.

Que je sais que la diference u peut trouver de la tranche(ou les autres funcitons de Tableau) comme code1.et code2 montrer u Tableau et son instances:

code1:

[].slice; //find slice here
var arr = new Array();
arr.slice //find slice here
Array.prototype.slice //find slice here

code2:

[].__proto__ == Array.prototype; //true
var arr = new Array();
arr.__proto__ == Array.prototype; //true

conclusion:

que u peut voir [] et new Array() créer une nouvelle instance de Array.Et ils ont tous le prototype des fonctions de Array.prototype

Ils sont juste différents instance de Array.donc, ce qui explique pourquoi
[] != []

🙂

Il n'y a plus que rencontre l'oeil. La plupart des autres réponses sont correctes MAIS AUSSI..

new Array(n)

• Du moteur permet de réallouer l'espace pour n éléments
• Optimisé pour le tableau création
• Créé tableau est marqué éparses qui a le moins performant opérations de matrice, c'est parce que chaque index d'accès doit vérifier les limites, voir si la valeur existe et à pied de la chaîne de prototype
• Si le tableau est marqué comme étant incomplet, il n'y a pas de retour (au moins en V8), il sera toujours plus lent au cours de sa durée de vie, même si vous le remplissez avec le contenu (packed array) 1ms ou 2 heures plus tard, n'a pas d'importance

[1, 2, 3] || []

• Créé tableau est marqué paniers (sauf si vous utilisez delete ou [1,,3] syntaxe)
• Optimisé pour le tableau opérations (for .., forEach, map, etc)
• Moteur doit redistribuer l'espace comme le tableau de pousse

Ce probablement n'est pas le cas pour les anciennes versions de navigateur/navigateur.

À l'aide de la Matrice de constructeur fait un nouveau tableau de la longueur désirée et remplit chacun des indices est pas défini, la affecté à un tableau à une variable on crée les indices que vous donner les infos pour.