В чем разница между "Array()" и "[]" при объявлении массива JavaScript? - программирование
Подтвердить что ты не робот

В чем разница между "Array()" и "[]" при объявлении массива JavaScript?

Какая реальная разница между объявлением массива следующим образом:

var myArray = new Array();

и

var myArray = [];
4b9b3361

ОТВЕТЫ

Ответ 1

Разница есть, но в этом примере нет разницы.

Используя более подробный метод: 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() вы можете установить размер массива, который влияет на размер стека. Это может быть полезно, если вы получаете переполнение стека (Performance of Array.push vs Array.unshift), что происходит, когда размер массива превышает размер стека, и его необходимо создать заново. Таким образом, на самом деле, в зависимости от варианта использования, может быть увеличение производительности при использовании new Array() потому что вы можете предотвратить переполнение.

Как указано в этом ответе, new Array(5) фактически не добавит пять undefined элементов в массив. Это просто добавляет место для пяти предметов. Имейте в array.length что использование Array таким способом затрудняет использование Array array.length для расчетов.

Ответ 2

Различие между созданием массива с неявным массивом и конструктором массива является тонким, но важным.

При создании массива с помощью

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", как вы ожидали. Второй не будет. В итоге вы увидите undefined. Вы также заметите, что b содержит все собственные объекты объекта Array, такие как push, а другой нет.

Пока вы можете ожидать, что это произойдет, это просто иллюстрирует тот факт, что [] не совпадает с new Array().

Вероятно, лучше всего использовать [], если вы знаете, что просто хотите массив. Я также не предлагаю обойти и переопределить массив...

Ответ 3

Существует огромная разница, о которой никто не упоминал.

Вы можете подумать, что new Array(2) эквивалентен [undefined, undefined] раньше, потому что у нас есть

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

НО ЭТО НЕ!

Пусть попробуйте 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).

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

UPDATE: оно уже исправлено. Теперь Chrome регистрируется как

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

Ответ 4

Как ни странно, new Array(size) почти в 2 раза быстрее, чем [] в Chrome, и примерно такой же в FF и IE (измеряется путем создания и заполнения массива). Это имеет значение, только если вы знаете приблизительный размер массива. Если вы добавите больше элементов, чем указано, увеличение производительности будет потеряно.

Точнее: Array( это быстрая операция с постоянным временем, которая не выделяет память, тогда как [] - это операция с линейным временем, которая устанавливает тип и значение.

Ответ 5

Для получения дополнительной информации на следующей странице описано, почему вам никогда не нужно использовать new Array()

Вам никогда не нужно использовать new Object() в JavaScript. Вместо этого используйте литерал объекта {}. Аналогично, не используйте new Array(), используйте вместо него массив literal []. Массивы в JavaScript не работают так же, как массивы в Java, и использование Java-подобного синтаксиса вас смущает.

Не используйте new Number, new String или new Boolean. Эти формы создают ненужные обертки объектов. Просто используйте простые литералы вместо этого.

Также просмотрите комментарии - new Array(length) форма new Array(length) не служит какой-либо полезной цели (по крайней мере, в современных реализациях JavaScript).

Ответ 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

Вышеупомянутый результат - из консоли Google Chrome в Windows 7.

Ответ 7

Первый - это вызов конструктора объекта по умолчанию. Вы можете использовать его параметры, если хотите.

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

Вторая дает вам возможность создавать не пустой массив:

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

Ответ 8

Я могу объяснить более конкретным образом, начиная с этого примера, который основан на хорошем 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 как ОБЪЕКТ с функциональностью массива и здесь есть несколько незначительных отличий.

Первое отличие состоит в том, что когда мы вызываем test1, он вызывает переменную без мышления, она просто возвращает значения, которые хранятся в этой переменной, не обращая внимания на ее тип данных! Но, когда мы вызываем test2, он вызывает функцию Array(), а затем сохраняет наши значения "push" в свойстве "Value", и это происходит, когда мы вызываем test2, оно возвращает свойство "Value" объекта массива.

Поэтому, когда мы проверяем, равенство test1 равно test2, они, конечно, никогда не вернут true, одна из них является функцией, а другая - переменной (с типом массива), даже если они имеют одинаковое значение!

Чтобы убедиться в этом, попробуйте 4-е оповещение, добавив к нему .value; он вернется. В этом случае мы говорим JS "Если не учитывать тип контейнера, будь то функция или переменная, пожалуйста, сравните значения, которые хранятся в каждом контейнере, и сообщите нам, что вы видели!" что именно происходит.

Надеюсь, я ясно сказал об этой идее и извиняюсь за плохой английский.

Ответ 9

Вот фрагмент кода JavaScript, который будет проверять, что обе декларации приводят к одному типу:

var test1 = [];
test1.push("value");

var test2 = new Array();
test2.push("value");

alert(typeof(test1) == typeof(test2));

Ответ 10

Первый - это вызов конструктора объекта по умолчанию, который обычно используется для динамических значений.

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

второй массив используется при создании статических значений

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

Ответ 11

Нет большой разницы, они в основном делают то же самое, но делают их по-разному, но читайте дальше, посмотрите на это утверждение в W3C:

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

и

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

Два приведенных выше примера делают то же самое. Нет необходимости использовать новый массив().
Для простоты, удобочитаемости и скорости выполнения используйте первый (метод литерала массива).

Но в то же время создание нового массива с использованием синтаксиса 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), как это, что также не рекомендуется.

Ответ 12

Разница в использовании

var arr = new Array(size);

или

arr = [];
arr.length = size;

Как обсуждалось достаточно в этом вопросе.

Я бы хотел добавить проблему скорости - самый быстрый способ current, на google chrome - второй.

Но обратите внимание, эти вещи, как правило, сильно меняются с обновлениями. Кроме того, время выполнения будет отличаться для разных браузеров.

Например, второй вариант, который я упомянул, работает на 2 миллиона [ops/second] на chrome, но если вы попробуете его на mozilla dev., вы получите удивительно более высокую ставку в 23 миллиона.

В любом случае, я предлагаю вам периодически проверять его на разных браузерах (и машинах), используя сайт как таковой

Ответ 13

Как я знаю, разность u может найти срез (или другие функции Array), например code1. и code2 показать u Массив и его экземпляры:

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

Вывод:

так как u может видеть [] и new Array() создать новый экземпляр массива. И все они получают функции прототипа от Array.prototype

Это просто разные экземпляры Array.so это объясняет, почему [] != []

:)

Ответ 14

Я понесла странное поведение, используя [].

У нас есть "классы классов" с полями, инициализированными некоторым значением. Например:

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

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

Я обнаружил, что когда поля инициализируются с помощью [], тогда он будет использоваться всеми объектами модели. Внесение изменений в один влияет на все остальные.

Это не произойдет, инициализируя их с помощью new Array(). То же самое для инициализации объектов ({} vs new Object())

TBH Я не уверен, что проблема с используемой нами картой (Dojo)

Ответ 15

Нет разницы, когда вы инициализируете массив без какой-либо длины. Так что var a = [] & var b = new Array() - это то же самое.

Но если вы инициализируете массив такой длины, как var b = new Array(1); , он установит длину объекта массива в 1. Таким образом, это эквивалентно var b = []; b.length=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

Ответ 16

Я обнаружил одно различие между двумя конструкциями, которые очень сильно били меня.

Скажем, у меня есть:

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

Ответ 17

Использование конструктора Array создает новый массив требуемой длины и заполняет каждый из индексов с помощью undefined, назначенный массив переменной генерирует индексы, которые вы даете им для.