JavaScript Counter Function

Let's build a fundamental JavaScript function that acts as a counter. This is a common pattern used in various applications, such as tracking user interactions, managing game scores, or implementing throttling mechanisms. Your task is to create a function that can be called repeatedly to increment a value.

Problem Description

You need to create a JavaScript function that returns another function. The returned function, when called, should increment an internal counter and return the new value.

Key Requirements:

• The outer function should not take any arguments.
• The returned inner function should also not take any arguments.
• Each time the inner function is called, it should increment a private counter.
• The inner function must return the current value of the counter after it has been incremented.

Expected Behavior:

When you call the outer function, you get a new counter function. Each subsequent call to this returned counter function will produce an increasing sequence of numbers, starting from 1.

Edge Cases:

• Calling the outer function multiple times should create independent counters. Each counter should maintain its own state.

Examples

Example 1:

let counter1 = createCounter();
console.log(counter1()); // Output: 1
console.log(counter1()); // Output: 2

Explanation: createCounter() is called, returning a new counter function. The first call to counter1() increments its internal count to 1 and returns 1. The second call increments the count to 2 and returns 2.

Example 2:

let counter2 = createCounter();
console.log(counter2()); // Output: 1
let counter3 = createCounter();
console.log(counter3()); // Output: 1
console.log(counter2()); // Output: 2

Explanation: Two independent counter functions, counter2 and counter3, are created. They each start their count from 1 independently. counter2's count continues to increment as expected.

Constraints

• The createCounter function must not take any arguments.
• The returned counter function must not take any arguments.
• The solution should be written purely in JavaScript.
• The counter should start at 0 internally and increment to 1 on the first call.

Notes

Consider using closures to maintain the private state of the counter. This is a classic example of how closures can be used to create private variables in JavaScript. Think about how you can initialize the counter and ensure it increments correctly with each call.