首页 文章

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

提问于
浏览 次
721

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

var myArray = new Array();

和

var myArray = [];
javascript arrays declaration

15 回答

  • -1

    有关详细信息，the following page描述了为什么您永远不需要使用 new Array()

    您永远不需要在JavaScript中使用新的Object（） . 请改用对象文字{} . 同样，不要使用new Array（），而是使用数组文字[] . JavaScript中的数组与Java中的数组完全不同，使用类似Java的语法会让您感到困惑 . 不要使用新的Number，new String或new Boolean . 这些表单会产生不必要的对象包装 . 只需使用简单的文字即可 .

    另请查看注释 - new Array(length) 表单没有任何用处（至少在今天的JavaScript实现中） .

    回复于
  • 729

    我使用[]引起了一种奇怪的行为 .

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

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

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

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

    这不会发生在 new Array() 初始化它们 . 对象的初始化相同（ {} vs new Object() ）

    TBH我不确定它是否与我们使用的框架有关（Dojo）

    回复于
  • 819

    存在差异，但该示例没有区别 .

    使用更详细的方法： 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

;
    回复于
  • 3

    使用的区别

    var arr = new Array(size);

    要么

    arr = [];
arr.length = size;

    正如在这个问题中讨论得足够多 .

    我想添加速度问题 - current 最快的方式， google chrome 是第二个 .

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

    例如 - 我提到的第二个选项，在 chrome 上以200万[ops / second]运行，但是如果你在 mozilla dev. 上尝试它，你将获得惊人的2300万的更高比率 .

    无论如何，我建议你每隔一段时间，在不同的浏览器（和机器）上查看它，使用网站as such

    回复于
  • 2

    为了更好地理解 [] 和 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控制台 .

    回复于
  • 5

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

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

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

    var array = [1, 2, 3]; // this array will contain numbers 1, 2, 3.
    回复于
  • 0

    据我所知，差异你可以找到切片（或数组的其他功能），如 code1 . 和 code2 show u Array和他的实例：

    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:

    你可以看到 [] 和 new Array() 创建一个新的Array实例 . 他们都从 Array.prototype 获取原型函数

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

    :)

    回复于
  • 9

    我发现这两个结构之间有一点不同，这让我非常努力 .

    假设我有：

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

    回复于
  • 45

    我可以从更具体的方式开始解释，这个例子基于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，一个是函数而另一个是变量（带有一种数组），即使它们具有相同的值！

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

    我希望我能清楚地说出这个想法，对不起我的英语不好 .

    回复于
  • 45

    没有什么大不同，他们基本上做同样的事情，但以不同的方式做，但阅读，看看W3C的这个声明：

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

    和

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

    上面的两个例子完全相同 . 无需使用新的Array（） . 为简单起见，可读性和执行速度，请使用第一个（数组文字方法） .

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

    避免使用新的Array（）不需要使用JavaScript的内置数组构造函数new Array（） . 请改用[] . 这两个不同的语句都创建了一个名为points的新空数组：

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

    回复于
  • 2

    第一个是默认对象构造函数调用 . 最常用于动态值 .

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

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

    var array = [red, green, blue, yellow, white]; // this array will contain values.
    回复于
  • -3

    奇怪的是， new Array(size) 几乎比Chrome中的 [] 快2倍，在FF和IE中大致相同（通过创建和填充数组来衡量） . 只有了解阵列的大致尺寸才有意义 . 如果您添加的项目数量超过了您提供的项目数量，则会失去性能提升 .

    回复于
  • 35

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

    回复于
  • 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 ，而另一个则不包含.455904_ .

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

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

    回复于
  • 8

    没有人提到，存在巨大差异 .

    您可能认为 new Array(2) 之前等同于 [undefined, undefined] 因为我们有

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

    BUT IT'S NOT!

    我们试试 map() ：

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

    看到？这不一样！但那是为什么呢？

    根据ES6规范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

    That's why you can not expect any iteration functions work as usual to array created from new Array(len) .

    BTW，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 ]

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

    更新：它已经修好了 . Chrome现在登录为

    new Array(2)             // (2) [empty × 2]
    回复于

相关问题