What are prototypes in JavaScript? Explain their role in object-oriented programming.

In JavaScript, prototypes are a fundamental part of the language's object-oriented programming (OOP) model. They are a mechanism that allows objects to inherit properties and methods from other objects. Understanding prototypes is crucial for grasping the essence of JavaScript's unique approach to OOP.

In JavaScript, every object has an internal property called `[[Prototype]]`, which can be accessed using the `__proto__` property (although it is recommended to use the `Object.getPrototypeOf()` method instead). This `[[Prototype]]` property refers to another object, called the prototype object. When you access a property or method on an object, if that property or method is not found on the object itself, JavaScript automatically looks for it in the object's prototype, and then in the prototype's prototype, forming a chain known as the prototype chain.

Prototypes allow for the concept of inheritance in JavaScript. When a property or method is accessed on an object, JavaScript checks the object itself first, and if not found, it continues up the prototype chain until it either finds the desired property/method or reaches the end of the chain (where the last object in the chain has a null prototype).

Here's an example to illustrate the role of prototypes in JavaScript:

```
javascript`// Parent object constructor
function Person(name) {
this.name = name;
}

// Adding a method to the prototype
Person.prototype.greet = function() {
console.log('Hello, my name is ' + this.name);
};

// Creating instances of the Person object
var person1 = new Person('Alice');
var person2 = new Person('Bob');

person1.greet(); // Outputs: "Hello, my name is Alice"
person2.greet(); // Outputs: "Hello, my name is Bob"`
```
In this example, the `Person` function serves as a constructor for creating objects representing people. The `Person` function has a prototype object (`Person.prototype`), which is shared among all instances of `Person`. We add a `greet` method to the prototype, which allows all instances to access and use it.

When we create `person1` and `person2` using the `new` keyword, each instance gets its own set of properties defined within the constructor function (`this.name`). However, when we call the `greet` method on each instance, JavaScript first looks for that method in the instance itself. Since it's not found, JavaScript then follows the prototype chain and finds the `greet` method in the `Person.prototype`, allowing both instances to access and execute it.

Prototypes in JavaScript offer several advantages in object-oriented programming:

1. Code Reusability: By defining properties and methods on prototypes, you can share them across multiple objects. This promotes code reuse and helps keep memory usage efficient.
2. Inheritance: Prototypes enable object inheritance, allowing you to create a hierarchy of objects. Subsequent objects can inherit properties and methods from their prototypes, simplifying code organization and reducing redundancy.
3. Dynamic Nature: Since prototypes can be modified at runtime, you can add, remove, or modify properties and methods dynamically. This flexibility allows for dynamic object behavior and opens up possibilities for advanced programming techniques.
4. Memory Efficiency: Prototypes allow multiple objects to share the same set of properties and methods, reducing memory consumption compared to creating separate copies of the same properties/methods for each object.
5. Efficient Method Lookup: With prototypes, JavaScript performs method lookup in the prototype chain, reducing the need to search for properties/methods in each object individually. This lookup mechanism contributes to the performance efficiency of JavaScript.

It's worth noting that ES6 introduced the `class` syntax, which provides a more familiar syntax for creating classes and defining methods. Under the hood, the `class` syntax still