Q:

EcmaScript 6 Map() vs new Map()

To create a map in ES6, should you say Map() or new Map()?
Both seem to work fine in node --harmony.
The draft spec says "The Map constructor is the %Map% intrinsic object and the initial value of the Map property of the global object. When Map is called as a function rather than as a constructor, it initializes its this value with the internal state necessary to support the Map.prototype built-in methods." which also seems to suggest they should both work.
Given that, Map() would seem better because shorter, though that's a subjective judgment; objectively they seem interchangeable?

A:

Although current browsers appear to permit the use of Map() without new (as shown in @RobG's answer), this is in fact incorrect.
Because of a stability issue, Node.js v0.10 uses an older version of V8 (the JavaScript engine in Node.js) which does not throw if you do Map().
Node.js v0.10 uses V8 v3.14.5, but the issue with Map() not throwing was only fixed in v3.20.12.
Chrome, which uses a newer version of V8, throws an error if you don't use new. I'm not sure why Firefox doesn't throw an error though.

According to the current draft specification, it should be impossible to call Map() without new:

Let map be the this value.
If Type(map) is not Object then, throw a TypeError exception.
If map does not have a [[MapData]] internal slot, then throw a TypeError exception.
If map’s [[MapData]] internal slot is not undefined, then throw a TypeError exception.

Usually in a constructor the object that is supposed to be created is this. It requires that the object passed is an instance of Map, and that it has not been initialised yet ([[MapData]] must be undefined).
Apparently this is because it hinders the subclassing of native constructors, which will be possible in ES6.

A:

Edit
As of ECMAScript 2015 (ed. 6), calling Map as a function (i.e. without new) should throw an error:

Map is not intended to be called as a function and will throw an
  exception when called in that manner.

ECMA-262 ed 6 §23.1.1
Original answer for posterity.
Given that:
if (typeof Map != 'undefined') {
  var x = Map();
  var y = new Map();

  // x and y have same [[Prototype]]
  console.log(Object.getPrototypeOf(x) === Object.getPrototypeOf(y)); // true

  // x and y have same constructor
  console.log(x.constructor === y.constructor); // true

  // x [[Prototype]] is Map.prototype
  console.log(Object.getPrototypeOf(x) === Map.prototype); // true

  // x.constructor is Map
  console.log(x.constructor === Map); // true
}

returns true in browsers that support Map, it would seem both return an instance of Map, though the specification could have put that beyond doubt with much simpler language.
It seems the difference is evident when arguments are supplied: when called as a function, the argument should be an iterable object, whereas if called as a constructor, multiple arguments can be provided and the internal [[Construct]] method is called.
Edit
Given that ES6 is still in draft (and may be for some time) this behaviour may change. At the 25 July 2013 TC39 meeting it was discussed that allowing constructors to be behave like constructors even when called without new (Anti–pattern to call a constructor without new)was not a good idea, so it may well be modified in future.

