Which of JavaScript's callable forms carry a `.prototype` property — function declarations, arrow functions, object-literal method shorthand, classes, and generator functions?

## The property is not universal It is easy to assume `.prototype` comes with every function. It does not. Whether a callable gets one depends on how it was written: ```js (function f() {}).prototype; // object (class C {}).prototype; // object (function* g() {}).prototype; // object (async function* ag() {}).prototype; // object (() => {}).prototype; // undefined ({ m() {} }).m.prototype; // undefined (async function a() {}).prototype; // undefined (function f() {}).bind(null).prototype; // undefined ``` ## The forms that have one, and what it holds A **function declaration or expression** gets a freshly created plain object whose own `constructor` property points back at the function and whose own prototype is `Object.prototype`. The property is writable, non-enumerable and non-configurable, which is why you can replace it wholesale and why it never appears in enumeration. A **class** gets the same arrangement with one difference: `C.prototype` is non-writable as well as non-enumerable and non-configurable, so an assignment to it throws in strict mode (and class bodies are always strict). The instance methods you write in the class body land on that object. ```js class C { m() {} } Object.getOwnPropertyDescriptor(C, 'prototype'); // { value: {...}, writable: false, enumerable: false, configurable: false } Object.getOwnPropertyNames(C.prototype); // ['constructor', 'm'] ``` A **generator function** has a `.prototype` too, but it plays a different role. It is not for instances — a generator function is not a constructor at all, and `new g()` throws a `TypeError`. Instead, calling `g()` returns a generator object whose prototype is `g.prototype`, and `g.prototype` itself inherits the generator machinery (`next`, `return`, `throw`). Consequently it has no `constructor` back-pointer, unlike a normal function's prototype object. Putting a method on `g.prototype` makes it available on every generator that function produces. **Async generator functions** work the same way. ## The forms that have none **Arrow functions** are defined without a `prototype` property. They were designed as lightweight callables that do not create instances — which is the same design decision that makes `new (() => {})` throw. **Method shorthand** — `{ m() {} }` in an object literal, and every method in a class body including static ones and accessors — also has no `prototype`. Writing `{ m: function () {} }` instead *does* produce one, because that is an ordinary function expression assigned to a property. The two spellings look interchangeable and are not. **Async functions** have no `prototype` property either; they always return a promise and never produce instances. Note the asymmetry with async *generators*, which do have one. **Bound functions** are their own kind of exotic object. `f.bind(null)` produces a callable that has no `prototype` property of its own, even when `f` had one — yet `new boundF()` still works, because construction is forwarded to the original target function, and the resulting object inherits from the *target's* `.prototype`. ## Why an interviewer asks this The practical payoff is diagnosing a specific class of bug. Code that inspects functions generically — a decorator, a mixin helper, a serialiser — often reaches for `fn.prototype` to find methods or to build an instance, and then fails on exactly the inputs that have none: ```js function listMethods(fn) { return Object.getOwnPropertyNames(fn.prototype); } listMethods(() => {}); // TypeError: Cannot convert undefined to object ``` The same shape explains why converting a method to an arrow function, or a function expression to method shorthand during a refactor, can break code that was quietly depending on `.prototype` existing. A defensive helper checks first: ```js const hasProto = typeof fn === 'function' && typeof fn.prototype === 'object'; ``` ## A consistent way to remember it The property exists when the function is meant to hand a prototype to objects it produces — instances for constructors and classes, generator objects for generator functions. It is absent for the forms defined as "just a callable": arrows, methods, async functions, and bound wrappers. That framing predicts every case above without memorising a table.