javascript prototypal inheritance example

Create a custom object with the prototype prototype person:functionPerson (name,sex) { This. Name =name; This. Sex =sex;} Person.prototype={getName:function(){return This. Name}, Getsex:function(){return This. Sex}}varLiu =NewPerson ("LCY", "female");//Create a blank object//Copy the attributes in Person.prototype to an empty object (internally implemented as a hidden link)//pass the object through the This keyword to the constructor and execute the constructor//assign this object to the obje

unnecessary attributes. At the same time, the prototype chain can remain unchanged, so instanceof and isPrototypeof () can be used normally (). This is also the most ideal inheritance method currently, and is also transforming to this mode. (YUI also uses this mode .) This blog reference JavaScript advanced programming version 3rd, the code is rewritten, more specific, and added annotations to make everyon

inheritance is that it only calls the parent Type constructor once, avoiding unnecessary or unnecessary attributes. At the same time, the prototype chain can remain unchanged, so instanceof and isPrototypeof () can be used normally (). This is also the most ideal inheritance method currently, and is also transforming to this mode. (YUI also uses this mode .) This blog reference

.getsuerpervalue ()); Truealert (instance1.test); H1,H2,H3,H4,H5 alert (Instance1.getsubvalue ()); False alert (Instance1.color); Pink,yellow,bluevar Instance2 = new Subtype (' WYC '); Instance2.testfun (); Http://www.cnblogs.com/wuyuchang/alert (Instance2.name); WYC alert (Instance2.getsuerpervalue ()); Truealert (instance2.test); H1,h2,h3,h4alert (Instance

Agreed to explain the JavaScript inheritance, but delayed to now explain. No more nonsense, go straight to the point. Since you want to understand the inheritance, prove that you have a certain understanding of JavaScript-oriented objects, such as what you do not understand can refer to the object-oriented JS Basic ex

rough and has many problems: It is not appropriate to instantiate the Person when creating the Employee constructor and prototype (hereinafter referred to as the class. The constructor of the Employee class cannot call the constructor of the parent class Person, causing repeated value assignment to the name and sex attributes in the Employee constructor. The functions in Employee override the functions with the same name in Person, and there is no overload mechanism (which is a type problem

());//truealert (instance2.test);//H1,h2,h3,h4Alert (Instance2.getsubvalue ());//falsealert (Instance2.color);//Pink,yellowThe above code passes through Supertype.call (this, name), inherits the properties of the parent type, through Subtype.prototype = new Supertype (), and inherits the method of the parent type. The above code is very convenient to solve the prototype chain and borrowing the problems encountered by the constructor, JavaScript is th

gave out the following words: I have been writing JavaScript for 8 years now, and I have never once found need to use an uber function. the super idea is fairly important in the classical pattern, but it appears to be unnecessary in the prototypal and functional patterns. I now see my early attempts to support the classical model in JavaScript as a mistake. I

Object-oriented and object-based Almost every developer has development experience in object-oriented languages such as C + +, C #, Java. In traditional object-oriented languages, there are two very important concepts-classes and instances. A class defines a common behavior and method of a class of things, and an instance is a concrete implementation of a category. We also know that object-oriented programming has three important concepts-encapsulation, in