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

Other Questions Notion
1

I’m trying to make a JavaScript function that knows how many times it’s been called. Here’s what I want it to do:

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

How can I write countCalls() to work like this? I tried something like this:

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

But it doesn’t quite work right. When I do console.log(countCalls()()()), it doesn’t print the correct number.

Any ideas on how to fix this or a better way to do it? I’m pretty new to JavaScript and could use some help figuring this out. Thanks!

2

I’ve tackled a similar challenge before, and here’s an approach that worked well for me:

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

This solution uses a closure to maintain the count across multiple calls. The outer function countCalls creates a local variable count, and the inner function has access to this variable even after countCalls has finished executing.

Each time you call the returned function, it increments and returns the count. This way, you can chain calls like countCalls()()() and get the expected result.

One thing to note: the first call to the returned function will give you 1, and subsequent calls will increment from there. If you want to start from 2, just initialize count to 2 instead of 1.

Hope this helps! Let me know if you need any clarification on how closures work in this context.

3

hey, i tried smthing like this and it worked for me:

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

its a bit shorter and does the same thing. the arrow functions make it look cleaner too. hope this helps!

4

An alternative approach to this problem is using an Immediately Invoked Function Expression (IIFE) combined with closure. Here’s how you could implement it:

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

This method encapsulates the count variable within the IIFE’s scope, preventing external access or modification. The outer function returns another function, which in turn returns a function that increments and returns the count. This structure allows for the chained calls you’re looking for while maintaining the count accurately across multiple invocations.

The benefit of this approach is that it’s more concise and doesn’t rely on attaching properties to the function itself, which can sometimes lead to unexpected behavior in certain contexts. It also ensures that the count variable is truly private and can only be accessed through the intended interface.