JavaScript summary 6.0—Detailed Explanation of Prototype Chain and Handwritten Inheritance

    Basic Concept

    Prototype

    Prototypes are properties of JavaScript functions. Every time a function is created in JavaScript, the JavaScript engine adds an extra property called prototype to the created function.
    _proto__ and constructor properties are unique to objects
    The prototype attribute is unique to function, because function is also a kind of object, so the function also has proto_ and constructor attributes
    The proto attribute of the object is equal to the prototype of the new constructor

    function foo() {
}
console.log(foo.prototype)  //foo {}

var f1 = new foo()
console.log(f1.__proto__ === foo.prototype) //true

    constructor property: a property added by default on the prototype object prototype, pointing to the object's constructor, all functions (the final constructor points to Function

    Prototypes allow objects to share properties and methods, simplifying the amount of code


    prototype chain

    A prototype chain is a chain that connects prototypes in sequence
    Each instance object (object) has a private attribute (called proto) pointing to the prototype object of its constructor (prototype). The prototype object also has a prototype object (proto) of its own, layering up until an object's prototype object is null. By definition, null has no prototype and acts as the last link in this prototype chain

    var obj = {}
obj.__proto__ = {
}
// prototype chain
obj.__proto__.__proto__ = { 
}
obj.__proto__.__proto__.__proto__ = {
 value: "3"
}
console.log(obj.value) //3

    Order when looking up object properties or methods: Search for the object itself --> search in the constructor of the object --> the prototype of the object (_proto_) --> the prototype of the constructor (prototype) ---> search in the prototype of the current prototype and so on until the prototype The top of the chain (Object.prototype), if it has not been found and the property to be searched for is undefined, and the method to be searched for is an error

    The prototype chain is searched up layer by layer, and the prototype of all objects can be traced back to Object in the end. At this time, there is no proto pointing to Object.prototype (top layer), so the prototype object at the top of the prototype chain is Object.prototype ( His proto value is null), there are many default properties and methods on this object

    var obj = {  }   
console.log(obj.__proto__) //{}
console.log(Object.prototype)//{}

console.log(obj.__proto__.__proto__) //null
console.log(Object.prototype.__proto__)//null


    Handwritten prototype chain inheritance

    1. Inheritance through the prototype chain

    Prototype chain inheritance is to directly let the prototype of the Child constructor directly point to the Parent object, so that the Parent's property Child object can be found directly from its prototype chain. Core: Child.prototype = new Parent(); //use prototype chain inheritance

    Parent class:

    // parent class: public properties and methods

function Parent(name, age, friends) {
   //Attributes
   this.name = name || 'A';
   this.friends = friends || [];
   this.age = age || 18;
   //instance method
   this. say = function () {
 console.log(this.name + 'say hi');
   };
}
//prototype method
Parent.prototype.eating = function() {
   console.log(this.name + "eating")
}

    Subclass:

    // subclass: specific properties and methods
function Child() {
   this.sno = 111
}

Child.prototype = new Parent(); //prototype chain inheritance
Child.prototype.studying = function() {
   console.log(this.sno + 'studying');
}

var stu = new Child()
console.log(stu.name) //'A'
stu. eating() //A eating
stu.studying()//111 studying
//The subclass successfully inherits the properties and methods of the parent class, and successfully uses its own unique properties and methods

    shortcoming:

    //Create two stu objects
var stu1 = new Child()
var stu2 = new Child() 
// Modify the value in the reference, different subcases will affect each other
stu1. friends. push("B")

console.log(stu1.friends) //B
console.log(stu2.friends) //also B, not []

// cannot pass parameters
var stu3 = new Child("lilei", 112)
    • When creating a subclass instance, parameters cannot be passed to the parent class constructor
    • The reference properties from the prototype object are shared by all instances, so when multiple instances are created, if the modified object is a reference type, different instances will affect each other, because the two instances use the same prototype object


    2. Use constructor inheritance

    The principle is to use call in the Child constructor to change the point of this, which can realize passing parameters to the parent class, and there is no problem of mutual influence of reference attributes (no prototype is used) function Child(age) { Parent.call(this, age) }

    Parent class: the same as the parent class of the prototype chain

    Subclass:

    // can pass parameters
function Child( name, age, friends) {
   Parent. call(this, name, age, friends);
}

var stu = new Child('AB', 20, ['lilei']);
var stu1 = new Child('C', 18, ['li']);
  console.log(stu.name)//AB
// Subclass instances will not affect each other
stu.friends.push('lucy');
console.log(stu.friends);//[ 'lilei', 'lucy' ]
console.log(stu1.friends);//['li']
//stu.eating() reports an error, the properties and methods on the prototype chain of the parent function cannot be inherited

    shortcoming:

    • Only the instance properties and methods of the parent class can be inherited, and the properties/methods on the prototype chain of the parent class cannot be inherited


    3. Composition inheritance

    Combined inheritance: You can inherit the properties/methods on the prototype chain of the parent class, which is to add the operation of the prototype of the subclass on the basis of inheritance using the constructor, and the constructor of the Parent will be executed once more function Child(age) { Parent.call(this, age) } Child.prototype = new Parent();

    Parent class: the same as the parent class of the prototype chain

    Subclass:

    function Child(name, age, friends) {
  Parent.call(this, name, age, friends);
}
Child.prototype = new Parent();

var stu = new Child('AB', 20, ['lilei']);
 console.log(stu.name)//AB
stu.eating() //AB eating

    shortcoming:

    • The parent class constructor (new Parent() and Parent.call()) is called twice, which consumes a little more memory (it feels negligible)
    • There will be two copies of properties in the supertype: one in the prototype object and one in the subtype instance (When we call the supertype.call(this, parameter) in the constructor of the subtype, the properties and methods in the supertype will be copied to the subtype. So **the supertype itself inside, we no longer need **)


    4. Inheritance through parasitic composition (most recommended)

    Parent class: the same as the parent class of the prototype chain

    Subclass:

    function Child(name, age, friends) {
   Parent. call(this, name, age, friends)
}
Child.prototype = Object.create(Parent.prototype)
Child.prototype.constructor = Child
//If you modify the prototype object in the form of an object, you need to use the constructor to point back to the original constructor, that is, repair the constructor

var stu = new Child("F", 18, ["FX"])
console.log(stu) //Parent { name: 'F', friends: [ 'FX' ], age: 18, say: [Function] }
stu. eating()//F eating
console.log(stu.constructor.name) //Child
//If you don't point Child.prototype.constructor back to Child, the value here will be Parent


/*Object.create() actually does two actions to create a new object, using the existing object as the prototype of the newly created object (prototype)*/
/*
Handwritten Object.create()
Object.prototype.create = function (o) {
   function F() {}
   F.prototype = o;
   return new F();
};
*/


    Summarize

    Each of these four handwriting inheritance methods appears to solve the shortcomings of the previous method. It is recommended to connect the four methods to think about learning when writing by hand.

    Popular posts from this blog

    大学资料分享——广工计院各个科目实验报告、课设及期末复习资料！！

    各位师弟师妹，我今年即将从广工毕业，因工作毕设都已差不多完成，整理资料时最终还是决定分享自己大学期间积累的各科资料。本人是广工计院一名本科生，在校绩点四年综合4.0左右，我相信这些资料对你们的学习和实验有非常大的实用性和价值。也真心希望大家能做好时间效率管理，一些不必要的课程不用浪费很多时间，把时间多留给自己所走的方向，希望各位师弟师妹好好利用我的资料，提升自己。如果本篇文章对你有帮助，请多来网站阅览并点击下页面的谷歌广告支持一下，十分感谢~~ 本博客除资源分享外还会 定期发布前端相关的行业动态、前端面试题系列等，后续也会逐步将自己的秋招总结发到谷歌博客上，同方向的师弟师妹们可以关注下，毕竟我也是在最寒冬秋招中获得好几个知名厂offer的，相信对你们将来的工作和面试也会非常实用 。 University special design: Specialised design IPV6 Experiment Report: GDUT IPV6 GDUT matlab digital signal processing experiment report: Matlab Experiment Report The latest operating system experiment and course design report: OS Experiment Report Virtualization and Cloud Computing-Hadoop Deployment Experiment Report: Hadoop Report GDUT C language programming experiment report 1-4: C language programming experiment report Summary of Physics Data of GDUT ： Physics GDUT DEA experiment + big assessment (source code, waveform diagram) + test paper information： EDA Data summary of GDUT Electrician： University Ele
    Read more

    Win10 远程计算机或设备将不接受连接

    Image
    Table Of Contents 错误详情 当晚如平常一样开着clash，但谷歌浏览器显示此网站无法提供安全连接，按网上说的方法改https为http、清除SSL状态缓存、还原浏览器默认设置三个方法后还是没能解决，想起重启能解决99%的问题后果断重启电脑，这也是后面悲剧的开始。 电脑重启后，发现打开浏览器依然无法上网，且火狐浏览器等都出现了一样的问题，通过网络诊断得出原因：远程计算机或设备将不接受连接 百度后发现网上的解决方法千篇一律，都是通过Internet——属性——连接——局域网设置——为LAN使用代理服务器的选项去掉勾选就可恢复（也有说将所有复选框都取消勾选） 我满怀希望的尝试后发现然并卵，虽然提示网络状态已连接Internet但是上不了网。。。后来想了想，可能是因为自己用了翻墙上网然后没有退出就重启的关系（如果没用梯子的兄弟姐妹们可以先尝试我上述的方法，行不通的话再试试我后面的方法） 解决方法 可先尝试重新连接关机时使用的翻墙软件 并正常退出，即可访问网络，如果不行再按以下方法 。 非校园网 重置网络：Internet属性——高级——重置 用了科学上网的同学可能I nternet属性 的常规里主页地址会被篡改，可以手动输入成百度地址 设置完成后点确定，然后重启电脑，此时就能恢复访问了。但出错时如果是用着校园网没有退出科学上网就重启的话，此时用校园网还是上不了网，只能用手机开热点的网络上网，于是进一步摸索 校园网 1.先按非校园网方法重置网络 2.删除电脑科学上网的软件 3.重新认证校园网（可以改个密码重新登录） 呜呜，孩子终于又通网了 总结 科学上网时一定要正常进出网络，不能直接关电脑或者断网，否则IP地址还挂在外面网络回不来，所以记得科学上网时 正常退出后再重启电脑 。
    Read more

    JAVA Traffic Signal Light Course Design (Source Code + Report + Video Demonstration)

    Image
    Table Of Contents topic details Simulate the logic of the traffic light management system at the intersection. 1. Randomly generate vehicles traveling along each route 2. Signal lights ignore yellow lights and only consider red and green lights. 3. It should be considered that vehicles turning left are controlled by signal lights, and vehicles turning right are not controlled by signal lights. 4. The specific signal light control logic is the same as that of ordinary traffic light control logic in real life, regardless of the control logic in special cases: North-south vehicles and east-west vehicles are released alternately. Vehicles waiting in the same direction should pass through vehicles first, and then vehicles turning left. 5. The time for each vehicle to pass through the intersection is 1 second (reminder: it can be simulated by thread sleep). 6. The time interval for randomly generating vehicles and the time interval for exchanging traffic lights i
    Read more