Classes let you make similar and related objects.
Javascript didn't support classes until ECMAScript 6.
Of course, it was possible to use constructor functions, but classes are more simple.

// Here is pre-ES6 class-like function
// This is the constructor function
function Person(name, age) {
    this.name = name;
    this.age = age;
}

// Create a class method
Person.prototype.sayName = function() {
    console.log(this.name);
};

// Create the instance
let person = new Person("Lary", 23);

console.log(person.age); // 23
person.sayName(); // "Lary"

However, the new class syntax is much simpler:

class Person {
    // Constructor function
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
    // Class method
    sayName() {
        console.log(this.name);
    }
}

// Creating instances stays the same

let person = new Person("Máté", 14);

console.log(person.age); // 14
person.sayName(); // "Máté"

But there is the big question:
How exactly are classes different from plain constructor functions?
There are a few differences:

You can't call the class constructor without new {1}
Class declarations are not hoisted, unlike with functions (they act like let declarations) {2}
Code inside classes is automatically in strict mode {3}
Class methods are not enumerable (yay)
You can't call any of the class methods with new (yay) {4}
You can't overwrite the class name within class methods (yay) {5}

// {2}
try {
    let newClass = new MyClass();
} catch (e) {
    console.error(e);
}

class MyClass {
    constructor(why, _do, people, call, stuff, like, _this) {
        this.kitten = "kitten"
    }
    sayHi() {
        console.log("Hi.");
    }
    thisMethodThrowsAnError() {
        MyClass = "YourClass"; // Error
    }
    thisMethodWillAlsoThrowAnError() {
        // Illegal in strict mode
        four = 4;
    }
}

let temp = new MyClass("Hello", "World");

// {1}
try {
    let newClassWithoutNew = MyClass();
} catch (e) {
    console.error(e);
}

// {5}
try {
    temp.thisMethodThrowsAnError();
} catch (e) {
    console.error(e);
}

// {3}
try {
    temp.thisMethodWillAlsoThrowAnError();
} catch (e) {
    console.error(e);
}

// {4}
try {
    let newMyClassDotSayHi = new MyClass.sayHi();
} catch (e) {
    console.error(e);
}

// You can overwrite the class name here without a problem {5}
MyClass = "Kittens";

Now, there are a few things that might be confusing about classes.

Classes are functions.
Classes have prototypes.
Classes are first-class citizens (Can be passed to a function, returned from a function, or be assigned to variables)
Class instances are still instances of objects
There are anonymous classes, like with functions, so you can get confused.

class Square {
    constructor(size) {
        this.size = size;
    }
    area() {
        return this.size ** 2;
    }
}

// Classes are functions
console.log(typeof Square); // "function"
console.log(typeof Square.prototype.area) // "function"

let square = new Square(4);

console.log(square instanceof Square); // "true"
console.log(square instanceof Object); // "true"

class Circle {
    constructor(r) {
        this.radius = r;
    }
    area() {
        return this.radius ** 2 * Math.PI;
    }
}

// Classes passed to functions
function makeObject(className) {
    return new className();
}

let sq = makeObject(Square), circ = makeObject(Circle);

// Anonymous classes
let MyClass = class {
    constructor() {
        this.name = "No";
    }
    sayHi() {
        console.log("Hi.");
    }
}

console.log(MyClass); // A class.

// You can also use anonymous classes instantly:
let why = new class {
    constructor() {
        this.dont = "don't";
    }
    really() {
        console.log("Don't do it");
    }
}
// This is to be avoided, though

Classes, like objects have accessor properties.

class HasAccessorProperties {
    constructor(value) {
        this._value = value;
    }
    get value() {
        return this._value;
    }
    set gotcha(value) {
        this._value = value;
    }
}

let yes = new HasAccessorProperties(100);

console.log(yes.value); // 100
yes.gotcha = 1000;
console.log(yes.value); // 1000

Classes, like objects can have computed member names. It is the same syntax:

let i = 5;

class HasComputedMemberNames {
    constructor(value) {
        this.value = value;
    }
    ["Number" + ++i]() {
        console.log(this.value);
    }
}

let no  = new HasComputedMemberNames(50);
no.Number6(); // 50

Classes can also have static members.
That means, they belong to the class rather than the instances of the class.

class HasStaticMembers {
    constructor(value) {
        this.value = value;
    }
    static sayHi() {
        console.log("Hi.");
    }
}

let hmm = new HasStaticMembers(5);

HasStaticMembers.sayHi(); // "Hi."

try {
    hmm.sayHi();
} catch (e) {
    console.error(e);
}

Of course, you can inherit with classes, you can't leave out one of the four buzzwords of OOP.
Before ES6, it was pretty hard to inherit with constructor functions.
But it is much simpler with classes:

class Rectangle {
    constructor(width, height) {
        this.width = width;
        this.height = height;
    }
    getArea() {
        return this.width * this.height;
    }
}

class Square extends Rectangle {
    constructor(size) {
        super(size, size);
    }
}

let square = new Square(3);

console.log(square.getArea()); // 9

There are quite a few things to unpack here.
You can inherit from one class with the extends keyword.
In the constructor, calling super() calls the super class' constructor.
You can only use the super keyword inside derived classes, or otherwise it will throw an error.
Thou are to use the super function before using the this keyword, because the super function constructs this.
If you see, the derived class now also inherited the base class' methods too.
You can override the base class' methods, too:

class Rectangle {
    constructor(width, height) {
        this.width = width;
        this.height = height;
    }
    getArea() {
        return this.width * this.height;
    }
}

class Square extends Rectangle {
    constructor(size) {
        super(size, size);
        this.height = size;
    }
    getArea() {
        return this.width ** 2;
    }
    sayHi() {
        // You can access the super class' methods like this:
        console.log(`Hello sidelength ${super.getArea()}!`);
    }
}

let square = new Square(3);

console.log(square.getArea()); // 9
square.sayHi(); // "Hello sidelength 9"

The cool thing is, that anything can be on the right side of extends, as long as it is a function that can be a constructor:

function ThisIsActuallyAClassButNotReally() {
    this.name = "name";
}

class ThisIsACTUALLYAClass extends ThisIsActuallyAClassButNotReally {}

let longName = new ThisIsACTUALLYAClass();
console.log(longName.name); // "name"

function returnAClass() {
    return class {
        constructor() {
            this.name = "eman";
        }
    }
}

class anotherClass extends returnAClass() {}

longName = new anotherClass();
console.log(longName.name); // "eman"

Classes

Thank you for reading!0

ES6 - Classes and why they need a 400+ line code