Named Function Expressions and Recursion in JavaScript

Named Function Expressions and Recursion in JavaScript

A named function expression is a function expression with an internal name. The name is only visible inside the function, which is useful for recursion and produces better stack traces.

Basic Named Function Expression

const greet = function sayHi(name) {
  return `Hello, ${name}`;
};
greet("Kunal"); // "Hello, Kunal"
sayHi("Kunal"); // ReferenceError: sayHi is not defined (not visible outside)
``
The internal name `sayHi` is only accessible inside the function body. Outside, you must use the variable name `greet`.

### Recursion With a Named Function Expression

```js
const factorial = function compute(n) {
  if (n <= 1) return 1;
  return n * compute(n - 1); // use the internal name for recursion
};
factorial(5); // 120
``
`compute` is available inside the function, so it can call itself. This is more robust than using the outer variable:

```js
// less robust: if factorial is reassigned, recursion breaks
const factorial = function (n) {
  if (n <= 1) return 1;
  return n * factorial(n - 1); // uses the outer variable
};
``
If someone reassigns `factorial` to something else, the inner `factorial(n - 1)` still refers to the original (because of closure), but it is fragile.

### Better Stack Traces

```js
// anonymous: stack trace shows <anonymous>
const foo = function () { throw new Error("oops"); };

// named: stack trace shows sayHi
const foo = function sayHi() { throw new Error("oops"); };
``
Named function expressions produce clearer stack traces, which makes debugging easier.

### IIFE With a Name

```js
const counter = (function count() {
  let c = 0;
  return function () { return ++c; };
})();
``
The IIFE has an internal name `count`, useful if it needs to recurse.

### Arrow Functions Cannot Have a Name

Arrow functions are always anonymous. For recursion with arrows, use the outer variable:

```js
const factorial = (n) => (n <= 1 ? 1 : n * factorial(n - 1));
``
This works but is fragile if `factorial` is reassigned.

### The Takeaway

Named function expressions give an internal name that is only visible inside the function. This is useful for recursion (more robust than using the outer variable) and produces better stack traces. Arrow functions are always anonymous, so they must use the outer variable for recursion.