Closures VS Classes in modern Javascript

Question

For closures which main goal it's to create another functions, I was wondering if in modern javascript, it's better to just use classes in modern javascript.

// Closure way private counter
const countPlusOne = () => {
    let count = 0;
    return () =>{
        count++;
        console.log(count);
    }
}
let demoAdd = countPlusOne();
demoAdd(); // 1
demoAdd(); // 2
demoAdd(); // 3

To be honest, I never liked the use of closures in that way (but I think they're great for things like middlewares) as are hard to read.

So, should I refactor closures like the one up, to classes? Their behavior seem more analogous to typical Objects from other languages.

// Class way private counter
class countPlusClass{
    count = 0;
    add(){
        this.count++;
        console.log(this.count)
    }
}
const demo = new countPlusClass();
demo.add(); // 1
demo.add(); // 2
demo.add(); // 3

Answer 1

A closure has a significant advantage over a class the way you're imagining: with a class, if you use a public class field like you are, any code with access to the instance can modify its value. This is usually undesirable - scope should generally be constrained as possible and you don't want the correctness of your class to depend on consumers of the class not modifying it (whether accidentally or deliberately).

class countPlusClass{
    count = 0;
    add(){
        this.count++;
        console.log(this.count)
    }
}
const demo = new countPlusClass();
demo.add(); // 1
demo.add(); // 2


// some code elsewhere in the codebase that has access to the demo instance:
demo.count = 55555;


demo.add(); // not 3...

Closures, in contrast, are completely private (barring strange, exceptional circumstances).

If you were to use a class, and you wanted to emulate the privacy of closures, make sure to use private class fields instead, so they can't be modified outside the class.

class countPlusClass{
    #count = 0;
    add(){
        this.#count++;
        console.log(this.#count)
    }
}
const demo = new countPlusClass();
demo.add(); // 1
demo.add(); // 2


// some code elsewhere in the codebase that has access to the demo instance
// cannot modify the private field
demo.count = 55555;


demo.add(); // 3...

As for which is better, a closure-based object or a class? That's up to each individual developer.