В чем разница между "Array()" и "[]" при объявлении массива в 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);  // => undefined
a.push('Woa'); // => TypeError: a.push is not a function
b.push('Woa'); // => 1 (OK)

В этом примере первое предупреждение выведет 'SPARTA', как и ожидалось. Но второе не покажет ничего, кроме undefined. Также вы заметите, что массив b имеет все функции, характерные для объекта Array, такие как push, в то время как a – нет.

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

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

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

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

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

var array = new Array(5); // инициализация массива с длиной 5

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

var array = [1, 2, 3]; // этот массив будет содержать числа 1, 2 и 3.

Чтобы лучше понять разницу между [] и 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.

Объяснение:

1. Создание массивов:

   • [] и new Array() оба создают новые массивы, которые выглядят одинаково. Однако, с точки зрения JavaScript, они не идентичны.

2. Сравнение массивов:

   • Оператор == и === сравнивают ссылки на объекты в JavaScript. Поскольку каждый раз при использовании [] и new Array() создаются новые массивы, результат сравнения всегда будет false.

3. Тип данных:

   • Оба выражения возвращают "object" при проверке типа, что подтверждает, что они являются объектами или массивами, но, как упоминалось ранее, они разные экземпляры.

4. Сравнение между [] и new Array():

   • Сравнения между массивами, созданными с помощью обоих синтаксисов, также возвращают false, потому что они являются разными объектами.

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

Я могу объяснить это более конкретно, начиная с примера, основанного на хорошем примере Фредрика.

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, потому что

JavaScript рассматривает test1 как ПЕРЕМЕННУЮ с типом данных массив, а test2 как ОБЪЕКТ с функциональностью массива, и здесь есть несколько небольших отличий.

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

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

Чтобы убедиться в этом, попробуйте четвертое уведомление с добавленным .value; оно вернет true. В этом случае мы говорим JavaScript: "Не обращая внимания на тип контейнера — функция это или переменная, пожалуйста, сравните значения, которые содержатся в каждом контейнере, и скажите нам, что вы увидели!" Именно это и происходит.

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