What's the best way to create a JavaScript function that tracks its own call count?

Other Questions Notion
1

I’m trying to build a function that can tell how many times it has been invoked. Here is the behavior I need:

console.log(countCalls()()); // should print '2'
console.log(countCalls()()()); // should print '3'
console.log(countCalls()()()()); // should print '4'

How can I implement countCalls() to achieve this? I attempted something like the code below:

countCalls.count = 1;
function countCalls() {
  countCalls.count++;
  return function() {
    return countCalls.count;
  };
}

However, when I run console.log(countCalls()()()()), it doesn’t print the number I expect. Can anyone suggest how to modify this code or propose a better method to meet this requirement?

2

I’ve implemented a similar functionality using a generator function. It’s a bit different from the other approaches mentioned, but it’s elegant and maintains state effectively:

function* countCallsGenerator() {
  let count = 1;
  while (true) {
    yield ++count;
  }
}

const countCalls = (() => {
  const generator = countCallsGenerator();
  return () => () => generator.next().value;
})();

This solution leverages JavaScript’s generator functions to create an infinite sequence of incrementing numbers. The outer IIFE initializes the generator, and each call to the returned function advances the sequence. It’s efficient and doesn’t rely on global variables or function properties. In my experience, this approach scales well in complex applications and is less prone to unexpected behavior in edge cases.

3

hey Harry, u could use a closure to keep track of the count. something like:

function countCalls() {
  let count = 1;
  return () => {
    return ++count;
  };
}

this way, the count variable is preserved between calls. hope it helps!

4

I’ve encountered a similar challenge in my own projects. One approach that worked well for me was using an Immediately Invoked Function Expression (IIFE) combined with closures. Here’s how I tackled it:

const countCalls = (function() {
  let count = 1;
  return function() {
    return function() {
      return count++;
    };
  };
})();

This method creates a private scope for the count variable, ensuring it persists across function calls without polluting the global namespace. It’s a bit more complex than a simple closure, but I found it to be more robust for long-term use, especially in larger codebases where function naming conflicts can become an issue.

Just remember, this approach returns a function that needs to be called twice to get the count, matching your desired behavior. It’s been quite reliable in my experience.