oop - What does it mean that Javascript is a prototype based language? - Stack Overflow

admin管理员组

文章数量:1128669

One of the major advantages with Javascript is said to be that it is a prototype based language.

But what does it mean that Javascript is prototype based, and why is that an advantage?

One of the major advantages with Javascript is said to be that it is a prototype based language.

But what does it mean that Javascript is prototype based, and why is that an advantage?

• javascript
• oop
• inheritance
• prototype-programming

Share Improve this question Follow edited Dec 28, 2011 at 15:28 Tom van der Woerdt 30k77 gold badges7474 silver badges105105 bronze badges asked Oct 9, 2008 at 7:22 Jonas PegerfalkJonas Pegerfalk 9,20699 gold badges3030 silver badges2929 bronze badges 1

• 3 This answer explains everything you need to know about prototypal inheritance: stackoverflow.com/a/16872315/783743 – Aadit M Shah Commented Jun 2, 2013 at 3:20

Add a comment  | 

9 Answers 9

Sorted by: Reset to default 325

Prototypal inheritance is a form of object-oriented code reuse. Javascript is one of the only [mainstream] object-oriented languages to use prototypal inheritance. Almost all other object-oriented languages are classical.

In classical inheritance, the programmer writes a class, which defines an object. Multiple objects can be instantiated from the same class, so you have code in one place which describes several objects in your program. Classes can then be organized into a hierarchy, furthering code reuse. More general code is stored in a higher-level class, from which lower level classes inherit. This means that an object is sharing code with other objects of the same class, as well as with its parent classes.

In the prototypal inheritance form, objects inherit directly from other objects. All of the business about classes goes away. If you want an object, you just write an object. But code reuse is still a valuable thing, so objects are allowed to be linked together in a hierarchy. In javascript, every object has a secret link to the object which created it, forming a chain. When an object is asked for a property that it does not have, its parent object will be asked... continually up the chain until the property is found or until the root object is reached.

Each function in JavaScript (which are objects themselves) actually has a member called "prototype", which is responsible for providing values when an object is asked for them. Having this member allows the constructor mechanism (by which objects are constructed from functions) to work. Adding a property to the prototype of a function object will make it available to the constructed object, as well as to all of the objects which inherit from it.

Advantages

There may not be a hard and fast rule as to why prototypal inheritance is an advantageous form of code-reuse. Code reuse itself is advantageous, and prototypal inheritance is a sensible way of going about it. You might argue that prototypal inheritance is a fairly simple model of code reuse, and that code can be heavily reused in direct ways. But classical languages are certainly able to accomplish this as well.

Sidenote: @Andrew Hedges makes a good point, that there are actually many prototypal languages. It's worth noting that these others exist, but also worth noting that none of them are anything close to mainstream. NewtonScript seemed to have some traction for a while, but died with its platform. It's also possible to extend some modern languages in ways which add prototypal capabilities.

A prototype-based language, does not make the distinction of classes vs objects: it simply has objects. A prototype-based language has the notion of a prototypical object, an object used as a template from which to get the initial properties for a new object. Any object can specify its own properties, either when you create it or at run time. In addition, any object can be associated as the prototype for another object, allowing the second object to share the first object's properties.

Prototype-based programming is a style of object-oriented programming where classes are not present, and behavior reuse (or inheritance in class-based languages) is performed by cloning existing objects that serve as prototypes.

The advantage/disadvantage is that, we can create new kinds of objects at run time without need for defining classes (static code). Like most features it is upto the developer to turn it to a advantage/disadvantage.

Above is possible because objects are essentially functions in java script (closures too).

After reading all the answers this is the conclusion

1) Inheritance in which objects are inherited directly from other objects

2) That does not use classes

3) Also called instance based programming or classless prototype oriented programming

4) Behaviour reuse is performed by cloning existing objects that serve as prototypes

5) Object used as template from the new object get initial properties

Instead of declaring a class structure, you can create objects of the same type, and add to their definition any time you like using the object's prototype. It's more flexible than the normal way of doing things.

If you just use objects at runtime instead of a class at compile to build new objects, this opens up the possibility of extending an object without knowing any details about it. Of course, it may become a disadvantage pretty quickly depending on usage. I make no assumptions about the language here, so it is applicable to languages other than javascript which are not as dynamic.

myobject.prototype=unkownobject;
myobject.newproperty=1;

You may get the object from just about anywhere; your own code, from the network, from the database, from external linkage and so on.

Note that, a language don't have to implement prototype inheritance like javascript. In javascript, a prototype object is merely shared, so is its properties, among the inheritors. The alternative is copying over all the properties of the prototype to the new object. Each approach has its strengths in different situations. I like the second more but it isn't what javascript does.

JavaScript is known as a prototype-based language, and understanding what this means can be simpler than it seems.

In prototype-based programming, objects are the central concept and directly inherit from other objects. This differs from the class-based inheritance in many different languages like Java or C++.

Unlike class-based languages, there are no "classes" in JavaScript. Instead, objects inherit from other objects directly. Every object can serve as a prototype for another object. This prototype object provides a template of properties and methods that other objects can reuse. When you create a new object, it can inherit properties and methods from another object, its prototype. If the new object needs a property or method that it doesn't have, it can look up the prototype chain to find it.

How this works:

You can create a new object using an existing object as a prototype. Here's a simple example:

let animal = {
    eats: true
};

let rabbit = Object.create(animal);
rabbit.jumps = true;

console.log(rabbit.eats); // true, inherited from animal

If you try to access a property or method that doesn't exist on the object itself, JavaScript will look up the prototype chain until it finds it or reaches the end of the chain.

console.log(rabbit.eats); // true (inherited from animal)
console.log(rabbit.jumps); // true (defined on rabbit)

You can add properties or methods to the prototype even after objects have been created. These changes will be reflected in all objects that inherit from that prototype.

animal.walks = true;
console.log(rabbit.walks); // true (inherited from animal)

Memory conservation is one of the benefits of prototypal inheritance in JS. In a language like Java, objects generate their own copies of the superclass' instance variables and methods, while in JS, the "super"-object offers get-access to its variables and methods to each "sub"-object that inherits from it without the need to recreate them.

本文标签： oopWhat does it mean that Javascript is a prototype based languageStack Overflow