I Don't Use JavaScript Classes At All. Am I Missing Out on Something?

Honestly, I don't really see classes as having any use and kind of go against my principles that I try to use. I like having every data structure being pure or json serializable and classes just kind of mess that up with unnecessary logic with this and that (pun intended). I find it much simpler to just use pure functions to manipulate data structures.

IMO javascript is a great language because you can use it functionally, or in a basic (non-class) manner, pretty effectively.

However, for anyone who needs to write code (libraries, tools, components, etc.) that will be used by multiple programmers, classes become very important. In agile shops, you will find that you might be able to whip out some pretty slick (non-class-based) code, but it's unlikely to survive a thorough code review process.

Classes help to define strict interfaces that are easy to read and use. Using the class based get and set keywords, you can easily validate and sanitize class properties, as well as perform business logic.

Additionally, using a well-thought out class constructor can make it easy to clone an object instance.

Defining the toJSON method on a class also allows you to precisely control the serialization of your class as well.

Here is a contrived example:

class Car {
    constructor(car = null) {
        //can define non-public (implied) properties
        this._licensePlate = '';
        this._speed = 0;
        this._direction = 0;
        this._lightsOn = false;
        //take an instance of a Car as a constructor argument
        if(car) {
            for(let k in car) {
                if(!car.hasOwnProperty(k) || this[k] === undefined) continue;
                this[k] = car[k] || this[k];
            }
        }
    }
    //get & set to control the property values
    set speed(value) {
       let v = +value;
       if(isNaN(v)) {
           console.warn('property speed must typof number');
           return;
       }
       this._speed = v;
    }
    get speed() {
        return this._speed;
    }

    set direction(value) {
        let d = +value;
        if(isNaN(v) || (d < 0 || d > 360)) {
            console.warn('property direction must be typeof number between 0 and 360');
            return;
        }
        this._direction = d;
    }
    get direction() {
        return this._direction;
    }

    set lightsOn(value) {
        this._lightsOn = !(!value || value === "false");
    }
    get lightsOn() {
        return this._lightsOn;
    }

    set licensePlate(value) {
        //sanitize the input to remove illegal characters
        this._licensePlate = (value || '').replace(/[^a-zA-Z0-9]/g,'');
    }
    get licensePlate() {
        //guarantee uniformity in license plates
        return this._licensePlate.toUpperCase();
    }

    //computed property. This is not serialized
    get isSpeeding() {
        return (this.speed > 55);
    }

    toggleLights() {
        this._lightsOn = !this._lightsOn;
    }

    //JSON.stringify will automatically use this function to serialize the class
    toJSON() {
        return {
            licensePlate : this.licensePlate,
            speed : this.speed,
            direction : this.direction,
            lightsOn : this.lightsOn
        };
    }

    //super cheap way to clone an object
    copy() {
        return new Car(this.toJSON);
    }
}

“classes are a poor mans clojure” I think it’s from the tao of programming book. But i agree with it in case of JS, since it doesn’t have classes in the same way C# or Java do, you can just use closures when you need to keep state and have functions work on it.

One of my favourite use cases for a JS class is for building a custom service response wrapper that ensures consistency in the way my APIs return JSON. For example, I might want to send along a success prop and a message with my data whereby I can pass custom messages back to the client from my API.

A very simple example...

class ServiceResponse {
  constructor(data = "", success = true, message = "") {
    this.data = data;
    this.success = success;
    this.message = message;
  }
}

module.exports = ServiceResponse;

This allows me to return a default success value of true and an empty message on each call along with the data unless something goes wrong, in which case, I can return early and set the success and message values appropriately.

I don't use classes at all since several years and don't feel like I will ever need them.

I use classes when it makes sense from a readability point of view. Whenever I find myself writing a bunch of functions that are related, take in similar or same inputs (i.e. a bunch of related functions all depending on similar variables) then I think you can move this to a class.

This allows you to group your functions together, and reduce or eliminate the arguments they take, as they can use properties set by the constructor.

You can achieve exactly the same by not using a class. You can write lots of functions in a module, or simulate a class behaviour with a closure. You can always get the same result by not writing classes, but I would challenge if they are as readable as a simple class.

One particular place I find classes useful is when you want to create your own errors. In that case you can just extend the regular built in Error class and add properties to it. Then you can check for it with MyError instanceof Error.

You may never need it, but I can't see any other solution to better understand business rules than to abstract everything into classes and use good object-oriented practices. Another important point is that functional programming is not simply creating partial applications and using them later, there are several practices that, in my view, are more complex than the design patterns related to OOP.

The thing that’s a bit off with the class syntax is that we can actually create more methods on the class itself without extending it to another class:

class Foo {
    bar() {}
    baz() {}
}

Foo.prototype.qux = function() {};

bigger applications need more encapsulation. If you still are able to do that with functions and modules go for it. But depending on your preferences classes can help you to structure your code which is hard to do only with functions. Sure JS is no OO language but classes and SOLID principles work well with it