Podemos omitir parênteses ao criar um objeto usando o operador "novo"?

Eu vi objetos sendo criados desta maneira:

const obj = new Foo;

Mas pensei que os parênteses não são opcionais ao criar um objeto:

const obj = new Foo();

A maneira anterior de criar objetos é válida e definida no padrão ECMAScript? Existem diferenças entre a maneira anterior de criar objetos e a posterior? Um prefere o outro?

Citando David Flanagan ¹ :

Como um caso especial, apenas para o newoperador, o JavaScript simplifica a gramática, permitindo que os parênteses sejam omitidos se não houver argumentos na chamada de função. Aqui estão alguns exemplos usando o newoperador:

o = new Object;  // Optional parenthesis omitted here
d = new Date();  

...

Pessoalmente, eu sempre uso parênteses, mesmo quando o construtor não aceita argumentos.

Além disso, o JSLint pode prejudicar seus sentimentos se você omitir o parêntese. Ele relata Missing '()' invoking a constructore não parece haver uma opção para a ferramenta tolerar a omissão de parênteses.

¹ David Flanagan: JavaScript, o Guia Definitivo: 4ª Edição (página 75)

Existem diferenças entre os dois:

• new Date().toString() funciona perfeitamente e retorna a data atual
• new Date.toString()lança " TypeError: Date.toString não é um construtor "

Isso acontece porque new Date()e new Datetem precedência diferente. De acordo com o MDN, a parte da tabela de precedência do operador JavaScript em que estamos interessados ​​se parece com:

╔════════════╦═════════════════════════════╦═══════════════╦═════════════╗
║ Precedence ║        Operator type        ║ Associativity ║  Operators  ║
╠════════════╬═════════════════════════════╬═══════════════╬═════════════╣
║     18     ║ Member Access               ║ left-to-right ║ … . …       ║
║            ║ Computed Member Access      ║ left-to-right ║  … [ … ]    ║
║            ║ new (with argument list)    ║ n/a           ║ new … ( … ) ║
╠════════════╬═════════════════════════════╬═══════════════╬═════════════╣
║     17     ║ Function Call               ║ left-to-right ║ … ( … )     ║
║            ║ new (without argument list) ║ right-to-left ║ new …       ║
╚════════════╩═════════════════════════════╩═══════════════╩═════════════╝

A partir desta tabela, segue-se o seguinte:

1. new Foo() tem precedência mais alta que new Foo

   new Foo()tem a mesma precedência que o .operador

   new Footem um nível de precedência menor que o .operador

   new Date().toString() funciona perfeitamente porque avalia como (new Date()).toString()

   new Date.toString()lança " TypeError: Date.toString não é um construtor " porque .tem precedência mais alta que new Date(e mais alta que "Chamada de Função") e a expressão é avaliada como(new (Date.toString))()

   A mesma lógica pode ser aplicada ao … [ … ]operador.

2. new Footem associatividade da direita para a esquerda e para new Foo()"associatividade" não é aplicável. Eu acho que na prática não faz nenhuma diferença. Para obter informações adicionais, consulte esta pergunta do SO

Um prefere o outro?

Sabendo tudo isso, pode-se presumir que new Foo()é o preferido.

Eu não acho que exista alguma diferença quando você estiver usando o operador "novo". Tenha cuidado ao entrar nesse hábito, pois essas duas linhas de código NÃO são iguais:

var someVar = myFunc; // this assigns the function myFunc to someVar
var someOtherVar = myFunc(); // this executes myFunc and assigns the returned value to someOtherVar

Se você não tiver argumentos para passar, os parênteses são opcionais. Omiti-los é apenas açúcar sintático.

https://people.mozilla.org/~jorendorff/es6-draft.html#sec-new-operator-runtime-semantics-evaluation

Aqui está a parte da especificação ES6 que define como as duas variantes operam. A variante sem parênteses passa uma lista de argumentos vazia.

Curiosamente, as duas formas têm significados gramaticais diferentes. Isso aparece quando você tenta acessar um membro do resultado.

new Array.length // fails because Array.length is the number 1, not a constructor
new Array().length // 0

Não há diferença entre os dois.