JavaScript First (vi)--------inheritance history, namespaces

Source: Internet
Author: User

History of succession

  There are four forms in the history of succession, let's take a look.

1. Traditional forms   
     Fir.prototype.lastName = "STG";             function Fir () {                 this.age =;             }             var fir = new Fir ();             Foo.prototype = Fir;             function foo () {}             var foo = new Foo ();             Person.prototype = foo;             function person () {}

  

  From the code we can see that the code looks cumbersome, not beautiful, and inherited very cumbersome, so this form is out from the beginning.

Cons: Excessive inheritance of useless attributes.

  

   2. With the help of constructors

      

             function Person1 (name,age) {                     this.name = name;                    This.age = age;                }                function Person2 (name,age) {                    var pObj = object.create (person2.prototype);                    Person1.call (pobj,name,age);                    return pObj;                }                var person = new Person2 (' STG ', 23);

  

    This approach is not inherently inherited, because he is borrowing call and constructors to change the constructor person's this point to himself, and not to access the prototype prototype.

  

      Disadvantage: You cannot inherit the prototype of a borrowed constructor, and each constructor takes one more function.

3. Sharing prototypes

    

function inherit (origin,target) {                    target.prototype = Origin.prototype;                }                Person.prototype.lastName = "Xiaoming";                function person () {};                function Son () {}                inherit (Person,son);

     Cons: You can't change your prototype at will.

4. Grail mode   

      Due to the lack of a third way, I will add an intermediate layer in the middle as a transition, there is a fourth form of inheritance-------the Holy Grail pattern.

function inherit (origin,target) {        function Func () {};        Func.prototype = Origin.prototype;        Target.prototype = new Func ();    }    Person.prototype.lastName = "HHH";    function person () {}    function Son () {}    Inhert (person, Son);

    Because the third form of the person and son prototype is pointing to the same prototype, so changing the person's prototype will be the son's prototype changes, here we add a middle-tier function func transition, let its prototype point to the origin of the

Prototype, then Target's prototype inherits its prototype, which is equivalent to the prototype of the target prototype inheriting origin, so that when son changes, the person's prototype will not change. One more drawback is that we know that the constructor attribute points to the

It is the function that constructs this object, but at this time son's constructor points to person, because the Func function does not have the constructor attribute, then will look up with the prototype chain, then found the person inside, this time we need

To manually add a constructor attribute to son.

In development, we need something called super-Class (Uber) to find out who the function is inheriting from. The final grail pattern is this:

function inherit (origin,target) {        function Func () {};        Func.prototype = Origin.prototype;        Target.prototype = new Func ();        Target.prototype.constructor = Target;        Target.prototype.uber = Origin.prototype;    }

  

  With the privatization variables of closures, we can write the Grail pattern a bit more advanced

var inherit = (function () {        var Func = function () {};        return function (origin,target) {        func.prototype = Origin.prototype;        Target.prototype = new Func ();        Target.prototype.constructor = Target;        Target.prototype.uber = Origin.prototype;    }} ())//**********function and function Func generate closures

name Space

      function: manage variables to prevent contamination globally, for modular development

      In the development, often each person uses the variable, the team development will have the variable conflict, we can use the object to solve, because each object inside the thing is independent, does not interfere with each other.

org = {Person    : {        xiaoming: {        age:20,        sex: "Male"        },        Xiaozhang: {        age:22,        sex: "Fe Male "        }    }}var per1 = Org.person.xiaoming.age;var Per2 = org.person.xiaozhang.age;

using objects to resolve variable conflicts is a previously used method, and now we can use closures to solve the problem.

var add = (function () {                var count1 = 1;                var count2 = 0;                function Myadd (NUM1, num2) {                    count1 = NUM1;                    Count2 = num2;                    Console.log (count1 + count2);                }                Return Myadd (Count1,count2);            } ())

similar to privatization variables to resolve naming conflicts, only the variables that generate closures can be accessed.

JavaScript First (vi)--------inheritance history, namespaces

Related Article

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.