Javascriptの継承原理をしっかり理解しましょう！

この記事の内容は、JavaScript 継承の原則を徹底的に理解するのに役立ちます。困っている友人は参考にしていただければ幸いです。

継承を理解する前に、js について 3 つのことを知っておく必要があります。

1. JS プロトタイプ チェーンとは

2. これ値とは何ですか。

3. JS の新機能は何ですか。

1. JS プロトタイプ チェーンとは何ですか?

JS には

    var obj = { name: 'obj' }

などのオブジェクトがあることがわかっています。

コンソールから obj を出力します。

obj にはすでにいくつかのプロパティ (メソッド) があることがわかります。 次に疑問が生じます: valueOf / toString / constructionor はどこから来たのでしょうか? obj.valueOf には値を割り当てませんでした。

上の図は少し分かりにくいですが、模式図を手書きで描きました。結果は次のようになります。

obj 自体には属性名があります (これは私たちが追加したものです)

obj にも属性名があります__proto__ という属性 (オブジェクトです)

1. obj には、valueOf、toString、コンストラクターなどの属性もあります。

2. obj .__proto__ には、実際には __proto__ という属性もあります (console.log は表示されません)、値は null

3. さて、質問に戻ります。なぜ obj には valueOf / toString という属性があるのですか。 /コンストラクター?

4. 回答: これは __proto__ に関連しています。

obj.toString を「読み取る」とき、JS エンジンは次の処理を実行します:

obj オブジェクト自体に toString 属性があるかどうかを確認します。そうでない場合は、次のステップに進みます。

obj.__proto__ オブジェクトに toString 属性があるかどうかを見て、obj.__proto__ に toString 属性があることがわかったので、obj.toString が実際の obj です。 __proto__ は手順 2 で見つかりました。.toString。

1. obj.__proto__ が存在しない場合、ブラウザは引き続き obj.__proto__.__proto__

2. obj.__proto__.__proto__ も存在する場合、ブラウザは引き続き obj.__proto__.__proto を表示します。そうでない場合、ブラウザは toString が見つかるか
proto
3. が null になるまで、obj.__proto__.__proto__.__proto__

##5 をチェックし続けます。

4. 以上の処理が「読み取り」属性の「検索処理」です。そして、この「検索プロセス」は

   proto
から構成されるチェーンに接続されます。

このチェーンは「プロトタイプ チェーン」と呼ばれます。

#共有プロトタイプ チェーン

これで別のオブジェクトができました

var obj2 = { name: 'obj2' }

次のように:

この場合、obj.toString と obj2.toString は実際には同じもの、つまり obj2.__proto__.toString です。

率直に言うと、一方を __proto__.toString に変更すると、もう一方も実際に変更されます!

Differentiation

obj.toString と obj2.toString が必要な場合は、何あなたの行動が違う場合はどうすればよいですか？ 値を直接割り当ててください:

obj.toString = function(){ return '新的 toString 方法' }

##概要

[ Read] 属性が検索される場合、プロトタイプ チェーンに沿って検索されます

#[New] 属性が追加される場合、プロトタイプ チェーンは参照されません

# 2. これ

の値は何ですか? JS インタビューの質問に遭遇したことがあるかもしれません:

1. var obj = {
     foo: function(){
       console.log(this)
     }
   }
   
   var bar = obj.foo
   obj.foo() // 打印出的 this 是 obj
   bar() // 打印出的 this 是 window

   最後の 2 行に関数の値が含まれている理由を説明してください異なっています。

関数呼び出し

2. JS (ES5) には 3 つの関数呼び出し形式があります:

   func(p1, p2) 
   obj.child.method(p1, p2)
   func.call(context, p1, p2) // 先不讲 apply

一般に、初心者は最初の 2 つの形式を知っており、最初の 2 つの形式は「第三形態よりは良い。

私たちの教師 Fang Fang のおばあちゃんは、3 番目の呼び出し形式は通常の呼び出し形式であることを覚えておく必要があると言いました:

    func.call(context, p1, p2)

他の 2 つは構文シュガーであり、同等に変更できます。これは呼び出しの形式です。

func(p1, p2) は func.call(unknown, p1, p2) と同等です;

obj.child.method(p1, p2) は obj .child.method と同等です。 .call(obj.child, p1, p2);

これまでのところ、関数呼び出しの形式は 1 つだけです:

func.call(context, p1, p2)

このようにすると、これは簡単に説明できます
これが上記の文脈です。

これは、関数呼び出しの呼び出し形式を使用することがないため、関数を呼び出すときに渡されるコンテキストです。

まず、func(p1, p2) でこれを決定する方法を見てみましょう:

当你写下面代码时

function func(){
  console.log(this)
}

func()
等价于

function func(){
  console.log(this)
}

func.call(undefined) // 可以简写为 func.call()

論理的に言えば、出力された this は未定義である必要がありますが、ブラウザーにはルールがあります:

如果你传的 context 就 null 或者 undefined，那么 window 对象就是默认的 context（严格模式下默认 context 是 undefined）

因此上面的打印结果是 window。如果你希望这里的 this 不是 window，很简单：

func.call(obj) // 那么里面的 this 就是 obj 对象了

回到题目：

var obj = {
  foo: function(){
    console.log(this)
  }
}

var bar = obj.foo
obj.foo() // 转换为 obj.foo.call(obj)，this 就是 obj
bar() 
// 转换为 bar.call()
// 由于没有传 context
// 所以 this 就是 undefined
// 最后浏览器给你一个默认的 this —— window 对象

[ ] 语法

function fn (){ console.log(this) }
var arr = [fn, fn2]
arr[0]() // 这里面的 this 又是什么呢？

我们可以把 arr0 想象为arr.0( )，虽然后者的语法错了，但是形式与转换代码里的 obj.child.method(p1, p2) 对应上了，于是就可以愉快的转换了：

    arr[0]()

假想为    arr.0()
然后转换为 arr.0.call(arr)
那么里面的 this 就是 arr 了 :)

小结：

1. this 就是你 call 一个函数时，传入的第一个参数。

2. 如果你的函数调用不是 call 形式， 请将其转换为 call 形式

三、JS 的 new 到底是干什么的？

我们声明一个士兵，具有如下属性：

var 士兵 = {
  ID: 1, // 用于区分每个士兵
  兵种:"美国大兵",
  攻击力:5,
  生命值:42, 
  行走:function(){ /*走俩步的代码*/},
  奔跑:function(){ /*狂奔的代码*/  },
  死亡:function(){ /*Go die*/    },
  攻击:function(){ /*糊他熊脸*/   },
  防御:function(){ /*护脸*/       }
}

我们制造一个士兵， 只需要这样：

兵营.制造(士兵)

如果需要制造 100 个士兵怎么办呢？

循环 100 次吧：

var 士兵们 = []
var 士兵
for(var i=0; i<p>哎呀，看起来好简单</p><h4 id="质疑">质疑</h4><p>上面的代码存在一个问题：浪费了很多内存</p><ol class=" list-paddingleft-2">
<li><p>行走、奔跑、死亡、攻击、防御这五个动作对于每个士兵其实是一样的，只需要各自引用同一个函数就可以了，没必要重复创建 100 个行走、100个奔跑……</p></li>
<li><p>这些士兵的兵种和攻击力都是一样的，没必要创建 100 次。</p></li>
<li><p>只有 ID 和生命值需要创建 100 次，因为每个士兵有自己的 ID 和生命值。</p></li>
</ol><h4 id="改进">改进</h4><p>通过第一节可以知道 ，我们可以通过原型链来解决重复创建的问题：我们先创建一个「士兵原型」，然后让「士兵」的 <strong>proto</strong> 指向「士兵原型」。</p><pre class="brush:php;toolbar:false">var 士兵原型 = {
  兵种:"美国大兵",
  攻击力:5,
  行走:function(){ /*走俩步的代码*/}，
  奔跑:function(){ /*狂奔的代码*/  },
  死亡:function(){ /*Go die*/    },
  攻击:function(){ /*糊他熊脸*/   },
  防御:function(){ /*护脸*/       }
}

var 士兵们 = []
var 士兵
for(var i=0; i<h4 id="优雅">优雅？</h4><p>有人指出创建一个士兵的代码分散在两个地方很不优雅，于是我们用一个函数把这两部分联系起来：</p><pre class="brush:php;toolbar:false">function 士兵(ID){
  var 临时对象 = {};
  临时对象.__proto__ = 士兵.原型;
  临时对象.ID = ID;
  临时对象.生命值 = 42;
  
  return 临时对象;
}  

士兵.原型 = {
  兵种:"美国大兵",
  攻击力:5,
  行走:function(){ /*走俩步的代码*/}，
  奔跑:function(){ /*狂奔的代码*/  },
  死亡:function(){ /*Go die*/    },
  攻击:function(){ /*糊他熊脸*/   },
  防御:function(){ /*护脸*/       }
}

// 保存为文件：士兵.js

 然后就可以愉快地引用「士兵」来创建士兵了：

var 士兵们 = []
for(var i=0; i<p>JS 之父看到大家都这么搞，觉得何必呢，我给你们个糖吃，于是 JS 之父创建了 new 关键字，可以让我们少写几行代码：</p><p style="text-align: center;"><span class="img-wrap"><img src="/static/imghwm/default1.png" data-src="https://img.php.cn//upload/image/223/671/797/1538126235427481.png?x-oss-process=image/resize,p_40" class="lazy" title="1538126235427481.png" alt="Javascriptの継承原理をしっかり理解しましょう！"></span></p><p><strong>只要你在士兵前面使用 new 关键字，那么可以少做四件事情：</strong></p><ol class=" list-paddingleft-2">
<li><p>不用创建临时对象，因为 new 会帮你做（你使用「this」就可以访问到临时对象）；</p></li>
<li><p>不用绑定原型，因为new 会帮你做(new 为了知道原型在哪，所以指定原型的名字 prototype);</p></li>
<li><p>不用 return 临时对象，因为 new 会帮你做；</p></li>
<li><p>不要给原型想名字了，因为 new 指定名字为 prototype。</p></li>
</ol><h4 id="这一次用-new-来写">这一次用 new 来写</h4><pre class="brush:php;toolbar:false">function 士兵(ID){
  this.ID = ID
  this.生命值 = 42
}

士兵.prototype = {
  兵种:"美国大兵",
  攻击力:5,
  行走:function(){ /*走俩步的代码*/},
  奔跑:function(){ /*狂奔的代码*/  },
  死亡:function(){ /*Go die*/    },
  攻击:function(){ /*糊他熊脸*/   },
  防御:function(){ /*护脸*/       }
}

// 保存为文件：士兵.js
然后是创建士兵（加了一个 new 关键字）：

var 士兵们 = []
for(var i=0; i<p><strong>new 的作用，就是省那么几行代码。（也就是所谓的语法糖）</strong></p><h4 id="注意-constructor-属性">注意 constructor 属性</h4><p>new 操作为了记录「临时对象是由哪个函数创建的」，所以预先给「士兵.prototype」加了一个 constructor 属性：</p><pre class="brush:php;toolbar:false">士兵.prototype = {
  constructor: 士兵
}

如果你重新对「士兵.prototype」赋值，那么这个 constructor 属性就没了，所以你应该这么写：

士兵.prototype.兵种 = "美国大兵"
士兵.prototype.攻击力 = 5
士兵.prototype.行走 = function(){ /*走俩步的代码*/}
士兵.prototype.奔跑 = function(){ /*狂奔的代码*/  }
士兵.prototype.死亡 = function(){ /*Go die*/    }
士兵.prototype.攻击 = function(){ /*糊他熊脸*/   }
士兵.prototype.防御 = function(){ /*护脸*/       }

或者你也可以自己给 constructor 重新赋值：

士兵.prototype = {
  constructor: 士兵,
  兵种:"美国大兵",
  攻击力:5,
  行走:function(){ /*走俩步的代码*/},
  奔跑:function(){ /*狂奔的代码*/  },
  死亡:function(){ /*Go die*/    },
  攻击:function(){ /*糊他熊脸*/   },
  防御:function(){ /*护脸*/       }
}

四、继承

继承的本质就是上面的讲的原型链

1)借助构造函数实现继承

 function Parent1() {
   this.name = 'parent1';
 }
 
 Parent1.prototype.say = function () {}
 
 function Child1() {
   Parent1.call(this);
   this.type = 'child';
 }

 console.log(new Child1);

打印结果：

这个主要是借用call 来改变this的指向，通过 call 调用 Parent ，此时 Parent 中的 this 是指 Child1。有个缺点，从打印结果看出 Child1并没有say方法，所以这种只能继承父类的实例属性和方法，不能继承原型属性/方法。

2)借助原型链实现继承

/**
 * 借助原型链实现继承
 */
function Parent2() {
  this.name = 'parent2';
  this.play = [1, 2, 3];
}

function Child2() {
  this.type = 'child2';
}
Child2.prototype = new Parent2();

console.log(new Child2);

var s1 = new Child2();
var s2 = new Child2();

打印：

通过一讲的，我们知道要共享莫些属性，需要 对象.__proto__ = 父亲对象的.prototype,但实际上我们是不能直接 操作__proto__，这时我们可以借用 new 来做，所以
Child2.prototype = new Parent2(); Child2.prototype.__proto__ = Parent2.prototype; 这样我们借助  new 这个语法糖，就可以实现原型链继承。但这里有个总是，如打印结果，我们给 s1.play新增一个值 ，s2 也跟着改了。所以这个是原型链继承的缺点，原因是 s1.__pro__ 和 s2.__pro__指向同一个地址即 父类的prototype。

3)组合方式实现继承

/**
 * 组合方式
 */

function Parent3() {
  this.name = 'parent3';
  this.play = [1, 2, 3];
}

Parent3.prototype.say = function () { }

function Child3 () {
  Parent3.call(this);
  this.type = 'child3';
}

Child3.prototype = new Parent3();

var s3 = new Child3();
var s4 = new Child3();
s3.play.push(4);
console.log(new Child3);
console.log(s3.play, s4.play)

打印:

将 1 和 2 两种方式组合起来，就可以解决1和2存在问题，这种方式为组合继承。这种方式有点缺点就是我实例一个对象的时， 父类 new 了两次，一次是var s3 = new Child3()对应  Child3.prototype = new Parent3()还要new 一次。

4)组合继承的优化1

function Parent4() {
  this.name = 'parent4';
  this.play = [1, 2, 3];
}

Parent4.prototype.say = function () { }

function Child4() {
  Parent4.call(this);
  this.type = 'child4';
}

Child4.prototype = Parent4.prototype;

var s5 = new Child4();
var s6 = new Child4();

这边主要为 Child4.prototype = Parent4.prototype， 因为我们通过构造函数就可以拿到所有属性和实例的方法，那么现在我想继承父类的原型对象，所以你直接赋值给我就行，不用在去 new 一次父类。其实这种方法还是有问题的，如果我在控制台打印以下两句:

从打印可以看出，此时我是没有办法区分一个对象 是直接 由它的子类实例化还是父类呢？我们还有一个方法判断来判断对象是否是类的实例，那就是用 constructor,我在控制台打印以下内容：

咦，你会发现它指向的是父类 ，这显然不是我们想要的结果， 上面讲过我们 prototype里面有一个 constructor, 而我们此时子类的 prototype 指向是 父类的 prototye ,而父类prototype里面的contructor当然是父类自己的，这个就是产生该问题的原因。

组合继承的优化2

/**
 * 组合继承的优化2
 */

function Parent5() {
  this.name = 'parent4';
  this.play = [1, 2, 3];
}

Parent5.prototype.say = function () { }

function Child5() {
  Parent5.call(this);
  this.type = 'child4';
}

Child5.prototype = Object.create(Parent5.prototype);

这里主要使用Object.create()，它的作用是将对象继承到__proto__属性上。举个例子：

var test = Object.create({x:123,y:345});
console.log(test);//{}
console.log(test.x);//123
console.log(test.__proto__.x);//3
console.log(test.__proto__.x === test.x);//true

那大家可能说这样解决了吗，其实没有解决,因为这时 Child5.prototype 还是没有自己的 constructor,它要找的话还是向自己的原型对象上找最后还是找到  Parent5.prototype, constructor还是 Parent5 ,所以要给 Child5.prototype 写自己的 constructor:

Child5.prototype = Object.create(Parent5.prototype);
Child5.prototype.constructor = Child5;

以上がJavascriptの継承原理をしっかり理解しましょう！の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。