声明JavaScript数组时，“Array（）”和“[]”有什么区别？

有区别，但在那个例子中没有区别。

使用更详细的方法：new Array()在参数中确实有一个额外的选项：如果您将数字传递给构造函数，您将获得一个长度为该长度的数组：

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

为了说明创建数组的不同方法：

var a = [],            // these are the sameb = new Array(),   // a and b are arrays with length 0
c = ['foo', 'bar'],           // these are the samed = new Array('foo', 'bar'),  // c and d are arrays with 2 strings
// these are different:e = [3]             // e.length == 1, e[0] == 3f = new Array(3),   // f.length == 3, f[0] == undefined
;

另一个区别是，当使用new Array()时，您可以设置数组的大小，这会影响堆栈大小。如果您遇到堆栈溢出（Array.pushvsArray.unshift），这很有用，这是当数组大小超过堆栈大小时会发生的情况，并且必须重新创建。因此，根据用例，使用new Array()时实际上可以提高性能，因为您可以防止溢出发生。

正如在这个答案中指出的，new Array(5)实际上不会向数组中添加五个undefined项。它只是为五个项目添加了空间。请注意，以这种方式使用Array会使依赖array.length进行计算变得困难。

第一个是默认的对象构造函数调用。如果需要，您可以使用它的参数。

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

第二个使您能够创建非空数组：

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

有关更多信息，以下页面描述了为什么您永远不需要使用new Array()

你永远不需要使用new Object()JavaScript。使用对象文字{}相反。同样，不要使用new Array()，使用数组文字[]相反。JavaScript中的数组工作不像Java中的数组使用类似Java的语法将迷惑你

不要使用new Number、new String或new Boolean.这些表单产生不必要的对象包装。只需使用而不是简单的文字。

还要查看注释-new Array(length)表单没有任何有用的目的（至少在今天的JavaScript实现中）。

使用隐式数组和数组构造函数创建数组之间的区别是微妙但重要的。

当您使用创建数组时

var a = [];

您正在告诉解释器创建一个新的运行时数组。根本不需要额外的处理。完成。

如果您使用：

var a = new Array();

你告诉解释器，我想调用构造函数“Array”并生成一个对象。然后它通过您的执行上下文查找要调用的构造函数，并调用它，创建您的数组。

你可能会想“好吧，这根本不重要。它们是一样的！”不幸的是，你不能保证这一点。

举个例子：

function Array() {this.is = 'SPARTA';}
var a = new Array();var b = [];
alert(a.is);  // => 'SPARTA'alert(b.is);  // => undefineda.push('Woa'); // => TypeError: a.push is not a functionb.push('Woa'); // => 1 (OK)

在上面的例子中，第一个调用会像你期望的那样提醒'SPARTA'。第二个不会。你最终会看到untex。你还会注意到b包含所有本机数组对象函数，例如push，而另一个没有。

虽然你可能期望这种情况发生，但它只是说明了[]与new Array()不同的事实。

如果你知道你只是想要一个数组，最好只使用[]。我也不建议四处重新定义数组…

奇怪的是，在Chrome中，new Array(size)几乎比[]快2倍，在FF和IE中也差不多（通过创建和填充数组来衡量）。只有知道数组的大致大小才重要。如果添加的项目超过给定的长度，性能提升就会丢失。

更准确地说：Array(是一个不分配内存的快速常数时间操作，而[]是一个设置类型和值的线性时间操作。

为了更好地理解[]和new Array()：

> [][]> new Array()[]> [] == []false> [] === []false> new Array() == new Array()false> new Array() === new Array()false> typeof ([])"object"> typeof (new Array())"object"> [] === new Array()false> [] == new Array()false

以上结果来自Windows 7上的GoogleChrome控制台。

我可以用更具体的方式来解释，从这个基于Fredrik的好例子开始。

var test1 = [];test1.push("value");test1.push("value2");
var test2 = new Array();test2.push("value");test2.push("value2");
alert(test1);alert(test2);alert(test1 == test2);alert(test1.value == test2.value);

我刚刚为数组添加了另一个值，并发出了四个警报：第一个和第二个是给我们存储在每个数组中的值，以确定值。它们将返回相同的！现在尝试第三个，它返回false，这是因为

JS将test1视为具有数组数据类型的VARIABLE，将test2视为具有数组功能的OBJECT，并且这里有一些细微的差异。

第一个区别是当我们调用test1时，它会不假思索地调用一个变量，它只是返回存储在这个变量中的值，而不管它的数据类型！但是，当我们调用test2时，它会调用Array（）函数，然后它会将我们的“被推”值存储在其“价值”属性中，当我们提醒test2时，它会返回数组对象的“价值”属性。

因此，当我们检查test1是否等于test2时，它们当然永远不会返回true，一个是函数，另一个是变量（具有数组类型），即使它们具有相同的值！

为了确保这一点，请尝试第4个警报，并向其添加. value；它将返回true。在这种情况下，我们告诉JS“忽略容器的类型，无论是函数还是变量，请比较存储在每个容器中的值并告诉我们你看到了什么！”这正是会发生的事情。

我希望我说清楚背后的想法，对不起我的英语不好。

我发现这两种结构之间的一个差异让我很难受。

假设我有：

function MyClass(){this.property1=[];this.property2=new Array();};var MyObject1=new MyClass();var MyObject2=new MyClass();

在现实生活中，如果我这样做：

MyObject1.property1.push('a');MyObject1.property2.push('b');MyObject2.property1.push('c');MyObject2.property2.push('d');

我的结论是：

MyObject1.property1=['a','c']MyObject1.property2=['b']MyObject2.property1=['a','c']MyObject2.property2=['d']

我不知道语言规范说应该发生什么，但如果我希望我的两个对象在我的对象中具有唯一的属性数组，我必须使用new Array()。

使用Array构造函数创建一个所需长度的新数组，并用未定义填充每个索引，将数组分配给变量one会创建您为其提供信息的索引。

使用的区别

var arr = new Array(size);

或

arr = [];arr.length = size;

在这个问题上已经讨论得够多了。

我想添加速度问题-当前最快的方式，在google chrome是第二个。

但请注意，这些东西往往会随着更新而发生很大变化。不同浏览器之间的运行时间也会有所不同。

例如，我提到的第二个选项在chrome上以200万[ops/秒]运行，但是如果你在mozilla dev.上尝试它，你会得到一个令人惊讶的更高的2300万率。

无论如何，我建议您每隔一段时间在不同的浏览器（和机器）上使用站点因此查看一下

第一个是默认对象构造函数call.mostly用于动态值。

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

创建静态值时使用第二个数组

var array = [red, green, blue, yellow, white]; // this array will contain values.

我知道差异u可以找到切片（或Array的其他函数），如code1.andcode2 show u数组和他的实例：

代码1

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

code2：

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

结论：

如你所见，[]和new Array()创建了一个新的Array实例。他们都从Array.prototype中获得原型函数

它们只是不同的Array.so这解释了为什么[] != []

：）

它们基本上做同样的事情，但以不同的方式做，但请继续阅读，看看W3C的声明：

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

和

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

上面的两个示例完全相同。没有必要使用
为了简单、易读性和执行速度，使用第一个（数组文字方法）。

但与此同时，使用new Array语法创建新数组被认为是一种糟糕的做法：

避免新的数组（）

无需使用JavaScript的内置数组构造函数new Array（）.
使用[]代替。
这两个不同的语句都创建了一个新的空数组，名为点：

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

这两个不同的语句都创建了一个包含6的新数组数字：

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

新的关键字只会使代码复杂化。它还会产生一些意外结果：

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

如果我删除其中一个元素呢？

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

所以基本上不被认为是最佳实践，还有一个细微的区别，你可以像这样将长度传递给new Array(length)，这也不是推荐的方式。

有一个重要的区别，还没有答案提到。

从这个：

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

你可能会认为new Array(2)相当于[undefined, undefined]、但事实并非如此！

让我们试试map()：

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

看到了吗？语义学完全不同！那为什么呢？

根据ES6 Spec22.1.1.2，Array(len)的任务只是创建一个新数组，其属性length设置为参数len，仅此而已，这意味着在这个新创建的数组中没有任何实元素。

函数map()，根据规范22.1.3.15首先检查HasProperty然后调用回调，但事实证明：

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

这就是为什么你不能期望任何迭代函数在从#0创建的数组上照常工作.

顺便说一句，Safari和Firefox对这种情况有更好的“打印”：

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

我已经向Chromium提交了一个问题，并要求他们修复这个令人困惑的打印：https://bugs.chromium.org/p/chromium/issues/detail?id=732021

更新：它已经固定。Chrome现在打印为：

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

我在使用[]时发生了奇怪的行为。

我们有模型“类”，其字段初始化为某个值。例如：

require(["dojo/_base/declare","dijit/_WidgetBase",], function(declare, parser, ready, _WidgetBase){
declare("MyWidget", [_WidgetBase], {field1: [],field2: "",function1: function(),function2: function()});});

我发现，当字段用[]初始化时，它将被所有Model对象共享。对一个进行更改会影响所有其他对象。

使用new Array()初始化它们不会发生这种情况。对象的初始化也是如此（{} vs newObject()）

TBH我不确定这是否是我们使用的框架的问题（Dojo）

初始化没有任何长度的数组时没有区别。所以var a = []和var b = new Array()是一样的。

但是如果你初始化长度为var b = new Array(1);的数组，它会将数组对象的长度设置为1。所以它相当于var b = []; b.length=1;。

这将是有问题的，每当你做array_object.push，它添加项目后，最后一个元素和增加长度。

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

还有更多的比满足眼睛。大多数其他答案是正确的但也。

new Array(n)

• 允许引擎为n元素重新分配空间
• 针对数组创造进行了优化
• 创建的数组被标记为稀疏，它具有最低性能的数组操作，这是因为每个索引访问都必须检查边界，看看值是否存在和走原型链
• 如果数组被标记为稀疏，就没有退路了（至少在V8中），它在其生命周期内总是会变慢，即使你在1ms或2小时后用内容（打包数组）填满它，也没关系

[1, 2, 3] || []

• 创建的数组标记为包装（除非您使用delete或[1,,3]语法）
• 针对数组业务（for ..、forEach、map等）进行了优化
• 随着数组的增长，引擎需要重新分配空间

此可能不适用于较旧的浏览器版本/浏览器。

好吧，var x = new Array()不同于var x = []在某些功能上是不同的，我将解释其中最有用的两个（在我看来）。

在解释差异之前，我将首先设置一个base；当我们使用x = []定义一个数据类型为Array的新变量时，它继承了属于数组原型的所有方法，这与扩展类非常相似（但不完全）。然而，当我们使用x = new Array()时，它初始化了分配给变量x的数组原型的克隆。

现在让我们看看有什么区别

第一个区别是使用new Array(x)，其中x是整数，初始化一个包含x未定义值的数组，例如new Array(16)将初始化一个包含16个项目的数组，所有这些项目都是未定义的。当您异步填充预定义长度的数组时，这非常有用。例如（再次：））假设你得到100个竞争对手的结果，并且你从远程系统或数据库异步接收它们，那么一旦收到每个结果，你需要根据排名在数组中分配它们。在这种非常罕见的情况下，你会做类似myArray[result.rank - 1] = result.name的事情，因此排名1将设置为索引0，依此类推。

第二个区别是使用new Array()，如你所知，实例化数组原型的一个全新克隆并将其分配给你的变量，这允许你做一些魔法（不推荐顺便说一句）。这种魔力是你可以覆盖遗留数组方法的特定方法。因此，例如，你可以设置Array.push方法将新值推送到数组的开头而不是结尾，你还可以向数组原型的这个特定克隆添加新方法（这更好）。这将允许你在整个项目中使用自己添加的方法定义更复杂的数组类型并将其用作类。

最后一件事，如果你来自极少数人（我真的很喜欢），他们关心你的应用程序的处理开销和内存消耗，你永远不会在不急于使用它的情况下艰难new Array()：）。

我希望这已经足够解释了野兽new Array()：）

我在使用Promise时发现了一个区别。在使用Promise数组（例如arr，初始化为arr=[]）时，在Promise.all（arr）中出现错误。而当声明为arr=Array（）时，没有得到编译问题。希望这有帮助。