Alternative JavaScript approach for counter functionality?

Other Questions JavaScript
1

Hey folks! I’m working on a counter function in JavaScript and I’m stuck. Here’s what I’ve got:

function createTally() {
  let total = 0;

  function tally() {
    return total++;
  }

  // Need help here
  tally.update = (num) => total = num;
  tally.subtract = () => total--;
  // End of tricky part

  return tally;
}

let tally = createTally();

console.log(tally()); // 0
console.log(tally()); // 1

tally.update(10);
console.log(tally()); // 10

tally.subtract();
console.log(tally()); // 10 (not 11)

I’m not happy with how I’m setting the update and subtract methods. Is there a better way to do this? Maybe using prototypes or a different pattern? Any ideas would be awesome! Thanks!

2

hey swiftcoder15, have u thought about using a factory function? it’s pretty neat:

const createTally = () => {
  let total = 0;
  return {
    count: () => total++,
    update: num => total = num,
    subtract: () => total--
  };
};

keeps things simple and modular. whaddya think?

3

An alternative approach you might consider is using a closure with a revealing module pattern. This maintains privacy for the counter variable while exposing only the necessary methods:

function createTally() {
  let total = 0;

  return {
    count: () => total++,
    update: (num) => { total = num; },
    subtract: () => { total--; },
    getTotal: () => total
  };
}

const tally = createTally();

console.log(tally.count()); // 0
console.log(tally.count()); // 1

tally.update(10);
console.log(tally.getTotal()); // 10

tally.subtract();
console.log(tally.getTotal()); // 9

This pattern provides a clean interface, encapsulates the ‘total’ variable, and allows for easy addition of new methods if needed. It’s a flexible solution that maintains good separation of concerns.

4

I’ve encountered similar challenges with counter functions before. One approach I’ve found effective is using a class-based structure. Here’s how you could refactor your code:

class Tally {
  constructor() {
    this.total = 0;
  }

  count() {
    return this.total++;
  }

  update(num) {
    this.total = num;
  }

  subtract() {
    this.total--;
  }
}

const tally = new Tally();

This approach encapsulates all the functionality within a single class, making it more organized and easier to maintain. It also allows for better method naming - ‘count()’ feels more intuitive than using the same name as the class for the main incrementing function.

You could then use it like:

console.log(tally.count()); // 0
console.log(tally.count()); // 1

tally.update(10);
console.log(tally.count()); // 10

tally.subtract();
console.log(tally.count()); // 10

This structure provides a cleaner interface and is more extensible if you need to add more functionality later.