JavaScript classes provide a structured way to create objects with shared properties and methods, introduced in ES6 as syntactic sugar over JavaScript’s prototype-based model. 1. Classes simplify object creation and inheritance for developers familiar with class-based languages. 2. They use constructors for initialization, methods for functionality, and support static methods and inheritance via extends and super. 3. Inheritance allows reusing code by building new classes based on existing ones. 4. Classes can be defined using declarations or expressions, with declarations being hoisted and expressions not.

JavaScript classes are a way to create objects with shared properties and methods, making it easier to organize code that’s based on object-oriented principles. They were introduced in ES6 (2015) as a cleaner, more familiar syntax for developers coming from other class-based languages like Java or Python.

How JavaScript Classes Work

Before classes were added, JavaScript used constructor functions and prototypes to handle object creation and inheritance. Classes in JavaScript are essentially syntactic sugar over this prototype-based model.

Here's a basic example:

class Car {
  constructor(brand) {
    this.brand = brand;
  }

  present() {
    return 'I have a '   this.brand;
  }
}

const myCar = new Car('Toyota');
console.log(myCar.present()); // I have a Toyota

This creates a Car class with a constructor and a method. You can then make instances of the class using new.

Key Features of Classes

• Constructor method – This is automatically called when a new instance is created.
• Methods – You can define any number of methods inside a class.
• Static methods – These belong to the class itself, not instances.
• Inheritance – You can extend one class from another using extends.

Using Inheritance with extends and super

One of the main benefits of classes is being able to reuse code through inheritance. For example:

class Model extends Car {
  constructor(brand, model) {
    super(brand);
    this.model = model;
  }

  show() {
    return this.present()   ', it’s a '   this.model;
  }
}

• extends lets you build a new class based on an existing one
• super() calls the parent class’s constructor
• The child class can add or override methods

This makes it easy to build complex object hierarchies while keeping your code DRY.

Class Expressions vs Class Declarations

You can define classes in two main ways:

• Class declarations

  class Dog { /* ... */ }

• Class expressions

  const Dog = class { /* ... */ };

  They behave similarly, but declarations are hoisted (you can use them before they’re defined in code), while expressions are not.

  Also, unlike functions, even if you declare a class with a name, its identifier is only available inside the class body.

  ---

  That’s the core idea behind JavaScript classes — they provide a more structured and readable way to work with objects and inheritance. Not too different from how things work under the hood, but definitely easier to write and understand once you get the hang of it.

  The above is the detailed content of What are JavaScript classes?. For more information, please follow other related articles on the PHP Chinese website!