Summary  
This chapter explains how JavaScript implements prototype-based object-oriented programming by using constructor functions and the prototype chain to share methods and properties efficiently across object instances.

General domain of usage  
Web development

JavaScript uses a **prototype-based** approach to object-oriented programming, which means that objects can inherit properties and methods directly from other objects. Every JavaScript object has an internal link to another object called its **prototype**. When you try to access a property or method on an object, JavaScript first looks for that property on the object itself. If it does not find it, it looks up the **prototype chain**, searching each prototype in turn until it finds the property or reaches the end of the chain.

This system allows you to share methods and properties efficiently between objects. Rather than duplicating functions for every object instance, you can attach methods to a constructor function's prototype. All objects created by that constructor will then have access to those shared methods via the prototype chain.

// Constructor function for creating Person objects
function Person(name) {
  this.name = name;
}

// Add a method to the prototype
Person.prototype.greet = function() {
  return "Hello, my name is " + this.name;
};

// Create two instances
const alice = new Person("Alice");
const bob = new Person("Bob");

console.log(alice.greet()); // Output: Hello, my name is Alice
console.log(bob.greet());   // Output: Hello, my name is Bob

Which statement best describes how prototype-based inheritance works in JavaScript?

Explore how modern JavaScript uses classes to organize logic, model real-world objects, and build reusable, maintainable code. Work with constructors, methods, inheritance, and encapsulation to understand how object-oriented patterns shape application structure. Apply advanced class features and build practical class designs that strengthen your ability to write clean, scalable JavaScript.

Build a clear understanding of how modern JavaScript implements object-oriented programming. Explore the shift from prototype-based design to ES6 classes, create your first class structures, and learn how constructors, methods, and this work together inside class definitions.

Extend class functionality with inheritance patterns that model real-world relationships. Override behavior, call parent constructors, and apply encapsulation techniques using getters, setters, and private fields to protect internal state and enforce clean APIs.

Strengthen your OOP skills with advanced class capabilities and compare class-based and prototype-based approaches. Apply everything by designing practical User and Account classes, reinforcing how object-oriented design translates into real applications.

Prototype-Based OOP in JavaScript