Parasitic inheritance of JS inheritance
It is easy to feel intimidated when hearing the term "parasitic inheritance". What is this? Don't worry, this article will try to explain this inheritance method in JS in an easy-to-understand way, and I hope it can help everyone.
1. An example
We first define an empty function, the formal parameter is original, like the following:
function createAnother(original){}
Create a new object clone in this function:
function createAnother(original){ var clone=Object.create(original); }
Add the attribute sayHi to the clone object. The sayHi attribute is a function:
function createAnother(original){ var clone=Object.create(original); clone.sayHi=function(){ alert('hi'); }; }
Finally, return the clone object:
function createAnother(original){ var clone=Object.create(original); clone.sayHi=function(){ alert('hi'); }; return clone; }
Suppose we have such an object:
var person={ name:'Nicholas', friends:['Shelby','Court','Van'] };
Pass the above objects as actual parameters into our function to run:
var anotherPerson=createAnother(person); anotherPerson.sayHi();
The result of the operation is: the 'Hi' window will pop up.
2. Doubtful point: What is the difference between this method and prototype inheritance Object.create(o)?
We see that the function createAnother has this sentence:
var clone=Object.create(original);
Isn’t this prototypal inheritance?
Indeed, the prototypal inheritance method is indeed used internally, and the final return is the clone object. However, it is still a little different from prototypal inheritance:
Prototypal inheritance inherits the properties of the original object, and the new object does not have new additional properties; parasitic inheritance can add properties to the new object internally, and the new object has the original object in addition to properties, and also has internally added properties.
In the above example, compared to prototypal inheritance, there are additional key statements:
clone.sayHi=function(){ alert('hi'); };
After creating an instance, the instance will have this attribute.
Related recommendations:
Sharing of several js inheritance styles
js inheritance Base class source code analysis_js oriented Object
js inheritance implementation code_javascript skills
The above is the detailed content of Parasitic inheritance of JS inheritance. For more information, please follow other related articles on the PHP Chinese website!

Hot AI Tools

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Undress AI Tool
Undress images for free

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

Hot Topics

In function inheritance, use "base class pointer" and "derived class pointer" to understand the inheritance mechanism: when the base class pointer points to the derived class object, upward transformation is performed and only the base class members are accessed. When a derived class pointer points to a base class object, a downward cast is performed (unsafe) and must be used with caution.

Inheritance error debugging tips: Ensure correct inheritance relationships. Use the debugger to step through the code and examine variable values. Make sure to use the virtual modifier correctly. Examine the inheritance diamond problem caused by hidden inheritance. Check for unimplemented pure virtual functions in abstract classes.

JavaScript tutorial: How to get HTTP status code, specific code examples are required. Preface: In web development, data interaction with the server is often involved. When communicating with the server, we often need to obtain the returned HTTP status code to determine whether the operation is successful, and perform corresponding processing based on different status codes. This article will teach you how to use JavaScript to obtain HTTP status codes and provide some practical code examples. Using XMLHttpRequest

Detailed explanation of C++ function inheritance: Master the relationship between "is-a" and "has-a" What is function inheritance? Function inheritance is a technique in C++ that associates methods defined in a derived class with methods defined in a base class. It allows derived classes to access and override methods of the base class, thereby extending the functionality of the base class. "is-a" and "has-a" relationships In function inheritance, the "is-a" relationship means that the derived class is a subtype of the base class, that is, the derived class "inherits" the characteristics and behavior of the base class. The "has-a" relationship means that the derived class contains a reference or pointer to the base class object, that is, the derived class "owns" the base class object. SyntaxThe following is the syntax for how to implement function inheritance: classDerivedClass:pu

Introduction to the method of obtaining HTTP status code in JavaScript: In front-end development, we often need to deal with the interaction with the back-end interface, and HTTP status code is a very important part of it. Understanding and obtaining HTTP status codes helps us better handle the data returned by the interface. This article will introduce how to use JavaScript to obtain HTTP status codes and provide specific code examples. 1. What is HTTP status code? HTTP status code means that when the browser initiates a request to the server, the service

Inheritance and polymorphism affect the coupling of classes: Inheritance increases coupling because the derived class depends on the base class. Polymorphism reduces coupling because objects can respond to messages in a consistent manner through virtual functions and base class pointers. Best practices include using inheritance sparingly, defining public interfaces, avoiding adding data members to base classes, and decoupling classes through dependency injection. A practical example showing how to use polymorphism and dependency injection to reduce coupling in a bank account application.

What is object-oriented programming? Object-oriented programming (OOP) is a programming paradigm that abstracts real-world entities into classes and uses objects to represent these entities. Classes define the properties and behavior of objects, and objects instantiate classes. The main advantage of OOP is that it makes code easier to understand, maintain and reuse. Basic Concepts of OOP The main concepts of OOP include classes, objects, properties and methods. A class is the blueprint of an object, which defines its properties and behavior. An object is an instance of a class and has all the properties and behaviors of the class. Properties are characteristics of an object that can store data. Methods are functions of an object that can operate on the object's data. Advantages of OOP The main advantages of OOP include: Reusability: OOP can make the code more

Interface: An implementationless contract interface defines a set of method signatures in Java but does not provide any concrete implementation. It acts as a contract that forces classes that implement the interface to implement its specified methods. The methods in the interface are abstract methods and have no method body. Code example: publicinterfaceAnimal{voideat();voidsleep();} Abstract class: Partially implemented blueprint An abstract class is a parent class that provides a partial implementation that can be inherited by its subclasses. Unlike interfaces, abstract classes can contain concrete implementations and abstract methods. Abstract methods are declared with the abstract keyword and must be overridden by subclasses. Code example: publicabstractcla
