In JavaScript, what happens when you invoke a class constructor without `new` — for example `Point(1, 2)` where `Point` was declared with the `class` keyword — and how did the old constructor-function style behave in the same situation?

## What the language does A function created by `class` syntax is marked as a class constructor. When you call it as a function rather than constructing it, the call is rejected outright: ```js class Point { constructor(x, y) { console.log('running'); this.x = x; this.y = y; } } Point(1, 2); // TypeError: Class constructor Point cannot be invoked without 'new' ``` Nothing is logged: the rejection happens when the function is called, before the body is entered. That is an important detail — you cannot "catch" the mistake inside the constructor, because the constructor never starts. It is also why `new.target` is not a workaround here. `new.target` is `undefined` in a plain call and the class constructor when constructed, but for a class you never get the chance to read it in the new-less case. `new.target` is still useful for other purposes, such as detecting whether an instance is being created directly or through a subclass. ## Everything that counts as "calling" The restriction is broader than the obvious `Point(1, 2)`: ```js Point.call({}, 1, 2); // TypeError Point.apply({}, [1, 2]); // TypeError const f = Point.bind(null); f(); // TypeError (bind is fine; invoking the bound function is not) Reflect.apply(Point, {}, []); // TypeError [1, 2].map(Point); // TypeError — map calls the callback ``` Construction paths still work: `new Point(1, 2)` and `Reflect.construct(Point, [1, 2])`. `Object.create(Point.prototype)` also works, but it does not run the constructor at all, so it produces an object with the right prototype and none of the constructor's initialization — a useful trick for deserialization, and a trap if you expect initialized state. A related consequence: a class constructor cannot be borrowed to initialize an unrelated object. The old `Parent.call(this, args)` idiom for reusing initialization logic simply does not work when `Parent` is a class. ## How the pre-class pattern behaved ```js function Point(x, y) { this.x = x; this.y = y; } const p = Point(1, 2); // no error ``` In sloppy mode, `this` inside that call is the global object, so `this.x = x` creates a global `x`; the expression evaluates to `undefined`, and the caller ends up with `undefined` instead of an object, usually failing much later and far from the cause. In strict mode, `this` is `undefined` and you get a `TypeError: Cannot set property 'x' of undefined` — better, but still a run-time surprise from inside the body. Because that was so easy to do by accident, library code commonly opened with a self-correcting guard: ```js function Point(x, y) { if (!(this instanceof Point)) return new Point(x, y); this.x = x; this.y = y; } ``` Some APIs kept that deliberately so callers could write `Point(1, 2)` as a shorthand. Class syntax removed the choice: the failure is now immediate, loud, and at the call site. ## What to do when you want new-less creation Since the class itself refuses, put the ergonomics beside it: ```js class Point { constructor(x, y) { this.x = x; this.y = y; } static of(x, y) { return new Point(x, y); } } const make = (x, y) => new Point(x, y); [[1, 2], [3, 4]].map(([x, y]) => new Point(x, y)); // callbacks need a wrapper ``` A static factory also gives you a place for validation, caching, or returning a subclass — things a constructor cannot do cleanly. ## Why the restriction exists A class constructor may be part of a hierarchy, and the initialization protocol for derived classes depends on being constructed rather than merely called; a plain call cannot satisfy it. Making the failure unconditional keeps the model simple and turns a whole category of silent global-leaking bugs into an immediate error at the exact line that caused it. Built-in constructors such as `Map` and `Set` behave the same way — `Map()` throws "Constructor Map requires 'new'" — while a few legacy built-ins keep special new-less behaviour for historical reasons, `Date()` returning a string being the classic example.