“Array()”和“Array()”有什么区别？ 和“[]” 声明 JavaScript 数组时？

Question

像这样声明数组之间的真正区别是什么：

var myArray = new Array();

和

var myArray = [];

Answer 1

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

当您使用创建数组时，

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);  // => undefined
a.push('Woa'); // => TypeError: a.push is not a function
b.push('Woa'); // => 1 (OK)

在上面的示例中，第一个呼叫将如您所期望的那样提醒“SPARTA”。 第二个不会。 你最终会看到未定义的。 您还会注意到，b 包含所有本机 Array 对象函数，例如 push，而另一个则不包含。

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

如果您知道只需要一个数组，最好只使用 [] 。 我也不建议四处走动并重新定义数组......

Answer 2

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

由此看来：

new Array(2).length           // 2
new Array(2)[0] === undefined // true
new 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 Spec 22.1.1.2，Array(len) 的工作只是创建一个新数组，其属性 length 设置为参数 len 就是这样，这意味着这个新创建的数组中没有任何真实元素。

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

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

这就是为什么你不能期望任何迭代函数在从 new Array(len) 创建的数组上照常工作。

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

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

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

更新：它已经修复了。 Chrome 现在打印为：

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

Answer 3

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

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

Answer 4

有关详细信息，以下页面介绍了为什么你永远不需要使用 new Array()

你永远不需要使用new Object()
JavaScript。 使用对象字面量 {}
反而。 同样，不要使用new Array()，
使用数组文字 []
反而。 JavaScript 中的数组工作原理
与 Java 中的数组不同，并且
使用类似 Java 的语法将
让你困惑。

请勿使用新数字、新字符串或
新布尔值。 这些形式产生
不必要的对象包装。 只需使用
相反，使用简单的文字。

另请查看注释 - new Array(length) 形式没有任何有用的目的（至少在当今的 JavaScript 实现中）。

Answer 5

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

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

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

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

Answer 6

为了更好地理解[]和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上的Google Chrome控制台。

Answer 7

我可以从这个基于 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() 函数，然后将我们的 “Pushed” 值存储在其 “Value” 属性中，当我们警告 test2 时，也会发生同样的情况，它返回数组对象的“Value”属性。

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

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

我希望我清楚地表达了背后的想法，并为我糟糕的英语感到抱歉。

Answer 8

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

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

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

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

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

最后一件事，如果您属于极少数关心应用程序的处理开销和内存消耗的人（我真正喜欢的人），那么您永远不会在不绝望的情况下接触 new Array()用它 ：）。

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

Answer 9

当您初始化没有任何长度的数组时，没有任何区别。 所以 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

与

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

Answer 10

这里面的内容远比表面上看到的还要多。 大多数其他答案都是正确的但也..

new Array(n)

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

<代码>[1,2,3]|| []

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

这可能对于较旧的浏览器版本/浏览器来说并非如此。

Answer 11

第一个是默认的对象构造函数调用。主要用于动态值。

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

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

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

Answer 12

的区别

var arr = new Array(size);

使用Or

arr = [];
arr.length = size;

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

我想补充一下速度问题 - 当前最快的方法，在 google chrome 上是第二个。

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

例如 - 我提到的第二个选项在 chrome 上以 200 万次[操作/秒]运行，但如果您在 mozilla dev. 上尝试它，您会获得了令人惊讶的更高的2300万的比率。

无论如何，我建议您每隔一段时间在不同的浏览器（和机器）上使用网站 这样

Answer 13

据我所知，您可以找到切片（或数组的其他功能），例如code1。和code2显示您Array和他的< em>实例：

代码1：

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

代码2：

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

结论：

正如你所看到的[]和< code>new Array() 创建一个新的 Array 实例。它们都从 Array.prototype 获取原型函数，

它们只是 Array 的不同实例。所以这解释了为什么
[] != []

:)

Answer 14

没有什么大的区别，它们基本上做同样的事情，但是以不同的方式做，但是请继续阅读，看看 W3C 的这个声明：

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

和

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

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

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

避免使用 new Array()

无需使用 JavaScript 的内置数组构造函数
新数组()。
请使用 [] 代替。
这两个不同的语句都创建一个名为的新空数组
点：

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

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

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

new 关键字只会使代码变得复杂。 它还可以产生一些
意想不到的结果：

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) ，这也不是推荐的方式。

Answer 15

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

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

require([
  "dojo/_base/declare",
  "dijit/_WidgetBase",
], function(declare, parser, ready, _WidgetBase){

   declare("MyWidget", [_WidgetBase], {
     field1: [],
     field2: "",
     function1: function(),
     function2: function()
   });    
});

我发现当字段用 [] 初始化时，它将被所有模型对象共享。 对其中一项的更改会影响所有其他项。

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

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

Answer 16

我在使用 Promise 时发现了差异。 在使用 Promise 数组（比如 arr，初始化为 arr=[]）时，在 Promise.all(arr) 中出现错误。 而当声明为 arr = Array() 时，没有出现编译问题。 希望这可以帮助。

Answer 17

请记住：

使用 new 或跳过它，不会对代码的功能产生影响。

考虑这个例子：

const x = Array(1, 2, 3); //an array defined simply
const y = new Array(1, 2, 3); // an array defined with new keyword

 
console.log(x); // output: [1, 2, 3]
console.log(y); // output: [1, 2, 3]


console.log(x.length);  // output: 3
console.log(y.length);  // output: 3

使用理由：

• 新的 new Array() 比 Array() 多做一件事：你可以将一个数字传递给构造函数，然后你将得到一个该长度的数组。

var myArray = new Array(); // some output
var myArray = []; // will return te same output as above

• 使用此方法的另一个优点是它预先在堆栈中创建所需大小的数组。

不使用的原因：新

- 避免额外的编码，因为有时代码几乎成为同义词。

希望能帮助到你。

Answer 18

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

假设我有：

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()。

Answer 19

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

Answer 20

有区别，但在该示例中没有区别。

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

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

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

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

;

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

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