JavaScript's object-oriented behavior is built on the **prototype chain**. When an object is created via a constructor function, all instances inherit shared methods and properties from the constructor’s **.prototype**.

```js
function Animal(name) {
  this.name = name;
}

Animal.prototype.speak = function () {
  console.log(`${this.name} makes a noise.`);
};

const dog = new Animal("Rex");
dog.speak(); // Rex makes a noise.

```

Behind the scenes:
- dog. __ proto __ points to Animal.prototype
- That’s how dog can access speak() even though it’s not directly on the dog object

When you use the new keyword, JavaScript performs these steps:

1. Creates a new empty object
2. Sets its internal [[Prototype]] (i.e., __proto__) to the constructor's .prototype
3. Calls the constructor function with this bound to the new object
4. Returns the new object

```js
const rex = new Animal("Rex");

//equivalent to:

const rex = {};
rex.__proto__ = Animal.prototype;
Animal.call(rex, "Rex");
```

The class syntax introduced in ES6 provides a cleaner, more familiar structure for OOP, but it's just syntactic sugar—the underlying prototype-based inheritance model remains unchanged.

```js
class Animal {
  constructor(name) {
    this.name = name;
  }

  speak() {
    console.log(`${this.name} makes a noise.`);
  }
}
```

This modern syntax feels more like traditional OOP, but under the hood:

- It still creates a constructor function
- Methods are still placed on the prototype
- Inheritance still uses the prototype chain


OOP in Javascript: Classes, prototypes and constructors

JavaScript’s object-oriented model. How class syntax simplifies, but doesn't replace, prototype-based inheritance. What happens under the hood with prototype, __proto__, and new.