Есть способы два разных для создания пустого объекта в JavaScript:
var objectA = {}
var objectB = new Object()
Есть ли разница в том, как скриптовый движок обрабатывает их? Есть ли причина использовать одно вместо другого?
Точно так же можно создать пустой массив, используя другой синтаксис:
var arrayA = []
var arrayB = new Array()
Стоит упомянуть, что в дополнение к var objectA = {} var objectB = new Object() есть третья конструкция, которая даст такой же результат: var objectC = Object.create(Object.prototype);
{} и [] Используйте {} вместо new Object(). Используйте [] вместо new Array(). Используйте массивы, если имена членов будут последовательными целыми числами. Используйте объекты, когда имена членов являются произвольными строками или именами. источникnew Object() и {} - это не совсем пустые объекты, это объекты с Object.prototype. Вы можете использовать Object.create(null) для действительно пустого объекта (по крайней мере, в соответствии с документами mozilla: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…)



![Безумие обратных вызовов в javascript [JS]](https://i.imgur.com/WsjO6zJb.png)


По сути, это одно и то же. Используйте то, что вам удобнее.
Возможно, я слишком глубоко вникаю в javascript, но они такие же? Разве {proto} Object не равен нулю, а {proto} {} - 'Object.prototype'?
@Izhaki Прототип Object нулевой, это правильно. Это потому, что Object завершает цепочку прототипов. Однако у объекта экземпляры нет прототипа, он есть только у конструкторов. И (new Object()).constructor === ({}).constructor -> true
Значит, это неверен?
Вот моя точка зрения: new Object() дает пустой экземпляр объекта. {} возвращает пустой экземпляр объекта. Оба эти случая абсолютно неотличимы. Пример, на который вы ссылаетесь, делает что-то еще (он изменяет цепочку прототипов) и на самом деле здесь не применим - или я не понимаю ваш аргумент.
Они имеют тот же конечный результат, но я бы просто добавил, что использование буквального синтаксиса может помочь привыкнуть к синтаксису JSON (строковое подмножество синтаксиса буквальных объектов JavaScript), поэтому может быть хорошей практикой войти в .
Еще одна вещь: у вас могут быть небольшие ошибки, если вы забудете использовать оператор new. Таким образом, использование литералов поможет вам избежать этой проблемы.
В конечном итоге это будет зависеть от ситуации, а также от предпочтений.
var objectA = {}
намного быстрее и, по моему опыту, используется чаще, поэтому, вероятно, лучше принять «стандарт» и сэкономить время на вводе текста.
Быстрее запускать или быстрее печатать?
Ну, по общему признанию, я имел в виду «напечатать», но, учитывая дополнительное время на синтаксический анализ, вероятно, немного более быстрое выполнение тоже :-)
Кроме того, литералы обычно создаются во время синтаксического анализа, а new Object должен выполняться во время выполнения.
Синтаксис литерала объекта и массива {} / [] был введен в JavaScript 1.2, поэтому он недоступен (и приведет к синтаксической ошибке) в версиях Netscape Navigator до 4.0.
Мои пальцы по-прежнему по умолчанию говорят new Array (), но я очень старый человек. К счастью, Netscape 3 - не тот браузер, о котором многие люди когда-либо думали сегодня ...
Netscape 3? Чувак, это было в предыдущем век! :-D
Я считаю, что {} был рекомендован в одном из видеороликов Javascript на здесь как хорошее соглашение о кодировании. new необходим для псевдоклассического наследования. способ var obj = {}; помогает напомнить вам, что это не классический объектно-ориентированный язык, а его прототип. Таким образом, единственный раз, когда вам действительно понадобится new, - это когда вы используете функции конструкторов. Например:
var Mammal = function (name) {
this.name = name;
};
Mammal.prototype.get_name = function () {
return this.name;
}
Mammal.prototype.says = function() {
return this.saying || '';
}
Затем он используется так:
var aMammal = new Mammal('Me warm-blooded');
var name = aMammal.get_name();
Еще одно преимущество использования {} по сравнению с new Object заключается в том, что вы можете использовать его для создания объектных литералов в стиле JSON.
Нет никаких преимуществ от использования new Object(); - тогда как {}; может сделать ваш код более компактным и более читаемым.
Для определения пустых объектов они технически одинаковы. Синтаксис {} короче, аккуратнее (менее Java-ish) и позволяет мгновенно заполнять объект встроенным, например так:
var myObject = {
title: 'Frog',
url: '/img/picture.jpg',
width: 300,
height: 200
};
Для массивов аналогично почти нет никакой пользы от использования new Array(); по сравнению с []; - за одним незначительным исключением:
var emptyArray = new Array(100);
создает массив длиной 100 элементов со всеми слотами, содержащими undefined, что может быть удобно / полезно в определенных ситуациях (например, (new Array(9)).join('Na-Na ') + 'Batman!').
new Object(); - он более неуклюжий, чем {};, и выглядит глупо.[]; - за исключением случаев, когда вам нужно быстро создать «пустой» массив с предопределенной длиной.Даже если вы используете синтаксис Array (100), тот же самый массив в 101-й позиции не определен; единственное, что действительно делает это число, - это изменяет значение свойства length.
да. новый массив (100); - хороший однострочный способ сделать это. .... ах ... Я вижу, что я случайно оставил слово "важный" ... отредактирую это.
Array(100) просто неправильный, он оставляет массив в недопустимом состоянии, так как его длина равна 100, и он равен [], пока вы не начнете добавлять материал не делай этого@Pablo В new Array(100) нет ничего недействительного. Почитайте литературу: developer.mozilla.org/en/JavaScript/Reference/Global_Objects /…
@ Мар, поверь мне, кто-то знает, о чем говорит: javascript.crockford.com/code.html#bonus
@Pablo Я понятия не имею, каков ваш аргумент. Как и Дуглас Крокфорд, я рекомендую использовать []. Никаких аргументов. Вы, однако, утверждали, что new Array(100) каким-то образом «недействителен», что не соответствует действительности.
Этот «ответ» на самом деле является просто мнением и игнорирует фактические различия, заявленные Гильермо.
ОП спрашивает о создании пустых объектов. Гильермо указывает на различия при создании непустых объектов, что правильно, но не совсем то, о чем спрашивал ОП.
new Array(len).fill(0);Также имейте в виду, что new Array(1,2,3) приводит к [1,2,3], а new Array(1) дает результат нет в [1]; таким образом, семантика Array непоследовательна и излишне сбивает с толку.
Есть очень важное различие: если вы создадите пустой объект, просто назначив его "{}", он будет таким же. Если вы создадите его с помощью «нового объекта ({})», он будет везде другим экземпляром объекта ...
Имейте в виду, что вы можете установить свойство "length" массива следующим образом: var a = []; a.length = 10;, что сделает массив из 10 неопределенных элементов.
Я считаю new Object () более читабельным, чем {}. Сказать, что это глупо и глупо, для меня звучит элитарно.
Я бы добавил, что Object.create(null) может быть полезен для создания пустого объекта, тогда как { } наследуется от прототипа объекта.
Будьте осторожны с new Array(len).fill(0) при заполнении объекта, например: с Array(len).fill([ ]) он будет ссылаться на тот же «[]», тогда, если вы сделаете что-то вроде let a = Array(len).fill([]), а затем a[0].push(1), он будет перенесен на все элементы в массиве.
Да, есть разница, они не такие. Это правда, что вы получите одинаковые результаты, но движок работает по-разному для них обоих. Один из них - литерал объекта, а другой - конструктор, два разных способа создания объекта в javascript.
var objectA = {} //This is an object literal
var objectB = new Object() //This is the object constructor
В JS все является объектом, но при использовании new Object () вы должны знать следующее: он может получать параметр и в зависимости от этого параметра создает строку, число или просто пустой объект.
Например: new Object(1), вернет число. new Object("hello") вернет строку, это означает, что конструктор объекта может делегировать - в зависимости от параметра - создание объекта другим конструкторам, таким как строка, число и т. д. Очень важно помнить об этом, когда вы управляете динамическими данными. создавать объекты ..
Многие авторы рекомендуют не использовать конструктор объекта, если вместо этого вы можете использовать определенную буквальную нотацию, чтобы вы были уверены, что создаваемое вами именно то, что вы ожидаете иметь в своем коде.
Я предлагаю вам продолжить чтение различий между буквальной нотацией и конструкторами в javascript, чтобы найти более подробную информацию.
Буквальные обозначения на самом деле более удобочитаемы и лаконичны для создания динамических объектов данных.
Если вы хотите создать массив без длины:
var arr = []; быстрее, чем var arr = new Array();
Если вы хотите создать пустой массив определенной длины:
var arr = new Array(x); быстрее, чем var arr = []; arr[x-1] = undefined;
Для тестов щелкните следующее: https://jsfiddle.net/basickarl/ktbbry5b/
Однако я не знаю, сколько памяти они занимают, я могу представить, что new Array() занимает больше места.
arr = new Array(x) эквивалентен arr = []; arr.length = x;, а не присвоению индекса x-1 с помощью undefined.
В ПОРЯДКЕ, есть всего 2 разных способа сделать то же самое! Один называется object literal, а другой - функция constructor!
Но читайте дальше, есть пара вещей, которыми я хотел бы поделиться:
Использование {} делает ваш код более читаемым, в то время как создание экземпляров Object или других встроенных функций не рекомендуется ...
Кроме того, функция Object получает параметры как функция, например Object(params) ... но {} - это чистый способ запустить объект в JavaScript ...
Использование литерала объекта делает ваш код более чистым и понятным для других разработчиков, и он соответствует лучшим практикам в JavaScript ...
В то время как объект в Javascript может быть практически любым, {} указывает только на объекты javascript, для проверки того, как он работает, выполните следующие действия в своем коде или консоли javascript:
var n = new Object(1); //Number {[[PrimitiveValue]]: 1}
Удивительно, но он создает число!
var a = new Object([1,2,3]); //[1, 2, 3]
И это создает массив!
var s = new Object('alireza'); //String {0: "a", 1: "l", 2: "i", 3: "r", 4: "e", 5: "z", 6: "a", length: 7, [[PrimitiveValue]]: "alireza"}
и этот странный результат для String!
Поэтому, если вы создаете объект, рекомендуется использовать литерал объекта, чтобы иметь стандартный код и избегать любых ошибок кода, как указано выше, а также с точки зрения производительности использование {}, по моему опыту, лучше!
ты Дезфоли? в Иране?
Привет, Эхсан, да, но я живу не в Иране, приятель, у тебя здесь отличный профиль! Приятно встретить тебя...
Могу я сохранить ваш номер телефона и получить от вас помощь по программированию?
Я вижу, вы пользуетесь телеграммой.
Да, конечно, мы точно можем поделиться некоторыми знаниями о Telegram! ___
очень хорошо, я отправляю вам сообщение прямо сейчас. сохраните мой номер, пожалуйста. спасибо alireza.
Var Obj = {};
Это наиболее используемый и простой метод.
С использованием
var Obj = new Obj()
не является предпочтительным.
Нет необходимости использовать new Object().
Для простоты, удобочитаемости и скорости выполнения используйте первый (метод литерала объекта).
Как это отвечает на исходные вопросы? «Есть ли разница в том, как обработчик сценариев обрабатывает их? Есть ли причина использовать одно вместо другого?»
Нет необходимости использовать new Object (). Для простоты, удобочитаемости и скорости выполнения используйте первый (метод литерала объекта).
Предупреждение: есть небольшая разница, которая может вызвать очень раздражающие ошибки! Создание пустого объекта, назначающего его "{}" в прототипе объекта, будет одним и тем же экземпляром объекта в каждом экземпляре объекта, созданном оператором "new". Пока вы используете «новый объект ({})», у вас будут разные экземпляры.