javascript - opérateur instanceof

Question

https://www.ibm.com/developer...

Basé sur cet article

instaceof peut être simulé avec le code suivant

function instance_of(L, R) {//L 表示左表达式，R 表示右表达式
  var O = R.prototype;// 取 R 的显示原型
  L = L.__proto__;// 取 L 的隐式原型
  while (true) { 
    if (L === null) 
      return false; 
    if (O === L)// 这里重点：当 O 严格等于 L 时，返回 true 
      return true; 
    L = L.__proto__; 
  } 
 }
     

Mais
var a=1;
instance_of(a,Object) est true
une instanceof Object renvoie false, pourquoi est-ce ?

Answer 1

Propriétaire, vous pouvez essayer vos instance_of 是代替不了 instanceof

Tout d'abord, assurez-vous que votre échantillon a est de type Numéro

Cependant, le résultat de l'exécution est le suivant
instance_of(a, Object) // true
instance_of(a, Number) // true

Modifier la méthode instance_of :

function instance_of(L, R) {
  try {
    var O = R.prototype;// 取 R 的显示原型
    L = Object.getPrototypeOf(L);// 取 L 的隐式原型
    while (true) { 
      if (L === null) 
        return false; 
      if (O === L)// 这里重点：当 O 严格等于 L 时，返回 true 
        return true; 
      L = L.Object.getPrototypeOf(L); 
    }
  } catch (e) {
    return false
  }
}

Expérimentez à nouveau :

var a = 1

instance_of(a, Object) // false 
instance_of(a, Number) // true

var parent = function () {}  
var child = new parent()

instance_of(child, parent) // true

Answer 2

Le standard utilisé dans cet article est ES3

ES6 instanceof标准更长一点, 规定了当type(L)不是Object时L instanceof R devrait renvoyer false. Ce code fictif ne s'applique pas

.

Answer 3

Une partie est le contenu de la chaîne de prototypes, dans votre code de simulation :

    function instance_of(L, R) {//L 表示左表达式，R 表示右表达式
      var O = R.prototype;// 取 R 的显示原型
      L = L.__proto__;// 取 L 的隐式原型
      while (true) { 
        if (L === null) 
          return false; 
        if (O === L)// 这里重点：当 O 严格等于 L 时，返回 true 
          return true; 
          L = L.__proto__; 
       } 
     }

L = L._proto_ signifie que L recherchera le prototype tout au long de la chaîne de prototypes, et dans cet exemple, il encapsule finalement l'objet de l'objet Number ==> Object, et R est Objet, après avoir passé l'opérateur de congruence, il renvoie vrai, donc instance_of(a,Object) est vrai. L = L._proto_ 代表着L会沿着原型链一直向上查找原型,而在本例中,最后是从Number包装对象==>Object对象,而R就是Object,再经过全等运算符之后就返回true,所以instance_of(a,Object)为true。

a instanceof Object

une instance d'Objet renvoie false car elle ne passe pas par la recherche en chaîne du prototype et est directement jugée entre l'instance de l'objet Number et l'Objet, donc le résultat est faux🎜