Supplementary inheritance and strict mode

Define how inheritance works

 1.  Prototype chain inheritance

function Father(){

        this.color=["red","blue"]

   }

    function Son(){ }

Son.prototype=new Father()

advantage ： You can reuse the properties and methods under the parent class

shortcoming ： Cannot pass a value to a variable under a parent class , Attributes are shared by children , One change, all change

 2.  Constructor inheritance

function Father(name){

        this.color=["red","blue"]

        this.name=name

    }

    function Son(name){

        Father.call(this,name)

    }

advantage ： The data under the parent class is not shared , Subclasses can be assigned with the help of the parent constructor

shortcoming ： Code reuse cannot be realized , Each child assigns a copy of the parent class

3. Combination inheritance

function Father(name){
       
        this.name=name// Borrowed 

    }

    function Son(name){

        Father.call(this,name)

    }

    Father.prototype.color=["red","blue"]// Shared 

Son.prototype=new Father()

advantage ： You can find the property and method inheritance on the prototype , You can also pass parameters to the parent class

shortcoming : Every time you create a new object , Call the parent object constructor multiple times , Multiple... Will be generated in memory , Waste resources

4. Prototype pattern inheritance

var Father={color:["red","blue"]}

function person(obj){

     function F(){}

     F.prototype=obj

     return new F()

}

var s1=person(Father)

advantage ： You can reuse the properties and methods under the parent class

shortcoming ： Cannot pass value to parent variable , Properties are shared by child objects , Every change changes

5. Parasitic inheritance patterns

var Father={color:["red","blue"]}

function person(obj){

     function F(){}

    F.prototype=obj

     var f= new F()

     f.say=function(){

        console.log(this.color)

     }

    return f

}

advantage ： You can reuse the properties and methods under the parent class , It's an enhanced version of the prototype pattern , You can add properties and methods by yourself

shortcoming ： Cannot pass value to parent variable , Properties are shared by child objects , Every change changes

6. Parasitic combination inheritance

  function Father(name){

        this.name=name

    }

    Father.prototype.color=["red","blue"]

    function Son(name){

        Father.call(this,name)

    }

    function fun(son,father){

        son.prototype=Object.create(Father.prototype)

        son.prototype.constructor=son

    }

fun(Son,Father)

var s1=new Son("asd")

advantage ： You can use the parent constructor , Prototype data can be shared , You can create different instance objects , Can achieve deep copy , Solve the waste of resources

Strict mode

To eliminate js Unreasonable and lax code in grammar , Make code run safer , Improve compilation efficiency

Definition ：

"use strict"

Limited content

1. The variable must use var Statement
2. The top level of the function is no longer pointing to window, It's pointing to undefined
3. Cannot define and eval A variable or function with the same name
4. No use delete Keyword deletion
5. No use argument, and calee and caller Method
6. No use width sentence
7. Duplicate function names are prohibited
8. Object property name duplication is prohibited
9. The use of octal numbers is prohibited
10. It is not allowed to declare a function in a non functional code block

for example ：

"use strict"

a=12

console.log(a)// no need var Declaration error 

// Out-of-service with sentence 

 with(location){

        console.log(href)

        console.log(location.pathname)

        console.log(location.port)// Port number 

    }