Was ist der Unterschied zwischen isPrototypeOf und instanceof in Javascript?

In einige meiner eigenen älteren code verwende ich das folgende:

Object.prototype.instanceOf = function( iface )
{
 return iface.prototype.isPrototypeOf( this );
};

Dann mache ich (zum Beispiel)

[].instanceOf( Array )

Dies funktioniert, aber es scheint, das folgende würde das gleiche tun:

[] instanceof Array

Nun, sicherlich ist dies nur ein sehr einfaches Beispiel. Meine Frage ist daher:

Ist a instanceof b IMMER das gleiche wie b.prototype.isPrototypeOf(a) ?

Während Sie können immer instanceof (mit Konstruktoren auf die Rechte Seite), nicht alle Objekte, die möglicherweise Erben von Object.prototype. Object.create(null) instanceof Something und ({}).instanceOf({prototype:Something.prototype}) arbeiten (und Ertrag false), wo das Gegenteil würde scheitern.

InformationsquelleAutor Steffen Heil | 2010-03-17

27

Ja, Sie tun das gleiche, beide Durchlaufen bis der Prototyp-Kette suchen nach einem bestimmten Objekt.

Den Unterschied zwischen den beiden ist , was Sie, und wie Sie Sie nutzen können, z.B. die isPrototypeOf ist eine Funktion verfügbar auf der Object.prototype Objekt ist, können Sie testen, ob ein bestimmtes Objekt ist in der Prototyp-Kette von dem anderen, da diese Methode definiert Object.prototype es ist für alle Objekte verfügbar.

instanceof ist ein operator und Sie erwartet zwei Operanden, ein Objekt und eine Konstruktor-Funktion, es zu testen, ob die übergebene Funktion prototype Eigenschaft vorhanden ist, an der Kette des Objekts (über die [[HasInstance]](V) interne operation, die nur in Funktions-Objekte).

Beispiel:
```
function A () {
  this.a = 1;
}
function B () {
  this.b = 2;
}
B.prototype = new A();
B.prototype.constructor = B;

function C () {
  this.c = 3;
}
C.prototype = new B();
C.prototype.constructor = C;

var c = new C();

//instanceof expects a constructor function

c instanceof A; //true
c instanceof B; //true
c instanceof C; //true

//isPrototypeOf, can be used on any object
A.prototype.isPrototypeOf(c); //true
B.prototype.isPrototypeOf(c); //true
C.prototype.isPrototypeOf(c); //true
```
- So, der einzige Unterschied ist, dass ich verwenden können, isPrototypeOf, wenn ich nur den Prototyp, obwohl ich den Konstruktor für ein? (Meine Funktion wirklich identisch mit instanceof?)
- Ihren text Antwort, die nützlich ist, dein code-Beispiel ist weniger. (Es wird nur zeigen die gleichen Aspekte aber keine Unterschiede.) Aber es wirft eine weitere Frage an mich: Das ist ".Konstruktor" für? Ich habe gesehen, wie der code an einigen stellen, aber nie geschrieben, dass mich-und ich scheine nicht zu haben brauchte. (Ich hatte in der Regel so etwas wie C.prototype.clazz = C; hart.) Warum machen die Leute das set-Konstruktor?
- Heil: den code geschrieben, die von CMS, ist klar genug, denke ich, verwendet es die meisten einfach und bekannt (obwohl es nicht die effektivste) Weg, um Erben in JavaScript zwischen Konstruktoren. Versuchen Sie, um die Zeile zu löschen B.prototype.constructor = B und prüfen der Konstruktor einer Instanz von B: alert((new B).constructor) und du wirst sehen, das Eine Konstruktor-Funktion. Indem er das tut, er versichert sich selbst zu finden, wie ein Konstruktor, der alle Instanzen von B, nur B.
- Kann man auch sagen, instanceof ist vor allem für die pseudo-klassische Vererbung, wie es stützt sich auf B.prototype, und B, das ist ein "Konstruktor". Was also, wenn B.prototype und B nicht verwendet werden, so gibt es keinen Konstruktor, wenn das JavaScript-Programm geschrieben wird, streng in einer prototypal inheritance Weg? In diesem Fall, dann animal.isPrototypeOf(woofie) verwendet werden kann
- AFAIK instanceof funktioniert nicht, wenn Sie nicht über eine Konstruktor-Funktion, z.B. Object.create. Scheint mit allerlei anderen Problemen: tobyho.com/2011/01/28/checking-types-in-javascript
- Einige interessante zusätzliche info über die Geschwindigkeit der beiden Funktionen: lh5.googleusercontent.com/... Für mehr info: v8project.blogspot.fr/2017/08/v8-release-61.html?m=1
InformationsquelleAutor CMS
2

Ist a instanceof b IMMER das gleiche wie b.prototype.isPrototypeOf(a) ?

Nein, a instanceof b wird nicht immer Verhalten sich genauso wie b.prototype.isPrototypeOf(a).

CMS' Antwort wies darauf hin, dass Sie unterscheiden sich in , was Sie (ist ein operator und das andere ist eine integrierte Methode zur Verfügung, die auf die Object.prototype Objekt). Das ist richtig, allerdings gibt es auch einige spezielle Fälle, für die a instanceof b wird in einem TypeError während b.prototype.isPrototypeOf(a) gut funktionieren und Umgekehrt.

Unterschied #1

Der rechten Seite der instanceof wird erwartet, dass eine Konstruktor-Funktion.

Wenn b ist nicht eine Funktion:
- a instanceof b wird in einem TypeError.
- b.prototype.isPrototypeOf(a) gut funktionieren wird.
JS:
```
const b = {
    prototype: {}
};
const a = Object.create( b.prototype );

console.log( b.prototype.isPrototypeOf(a) );    //true
console.log( a instanceof b );                  //TypeError: Right-hand side of 'instanceof' is not callable
```
Unterschied #2

Bei der Verwendung b.prototype.isPrototypeOf(a), b.prototype werden sollen Erben von Object.prototype:

Wenn b.prototype hat keinen Zugriff auf die Object.prototype.isPrototypeOf() Methode:
- b.prototype.isPrototypeOf(a) wird in einem TypeError.
- a instanceof b gut funktionieren wird.
JS:
```
function B() {};
B.prototype = Object.create( null );

const a = new B();

console.log( a instanceof B );              //true
console.log( B.prototype.isPrototypeOf(a) ) //TypeError: B.prototype.isPrototypeOf is not a function
```
Unterschied #3

Wenn die Rechte Seite von instanceof ist eine Funktion gebunden, es ist äquivalent behandelt, um seine Ziel-Funktion.

Wenn b eine gebundene Funktion:
- a instanceof b gut funktionieren wird.
- b.prototype.isPrototypeOf(a) wird in einem TypeError (bound-Funktion nicht über eine prototype Eigenschaft).
JS:
```
function B() {};
const BoundB = B.bind( null );
const a = new B();

console.log( a instanceof BoundB );              //true
console.log( BoundB.prototype.isPrototypeOf(a) ) //TypeError: Cannot read property 'isPrototypeOf' of undefined
```
Abschluss
- Wenn Sie Umgang mit prototypal inheritance durch Object.create(), ohne die Verwendung von Konstruktoren, sollten Sie wahrscheinlich die Object.prototype.isPrototypeOf() Methode (denn in der Tat Fälle von instanceof sind mehr beschränkt, dass instanceof erwartet der rechten Seite parameter einen Konstruktor-Funktion).
- Wenn Sie sind den Umgang mit Konstruktoren werden Sie etwas sicherer durch die Verwendung der instanceof Betreiber (Sie werden in der Lage, Einband Funktionen, sowie die Fälle, in denen Object.prototype liegt nicht in der Prototyp-Kette von Constructor.prototype).
- Beachten Sie, dass das Problem in Difference #2 könnte auch vermieden werden, indem Object.prototype.isPrototypeOf.call(B.prototype, a)
- siehe quora.com/...
InformationsquelleAutor Oliver Sieweke

Rangfolge und truthiness abweichen, da ist ein Ausdruck und die andere ist eine Methode aufrufen. Eine Sache zu betonen ist, dass sowohl traverse der Prototyp-Kette, so dass Sie können nicht davon ausgehen, dass es eine eins-zu-eins-Zuordnung zwischen ein-matching-Prototyp und Objekt in Frage:

JS:

var i = 0;

function foo()
{
console.log("foo");
console.log(i++ + ": " + Object.prototype.isPrototypeOf(Object) ) //true
console.log(i++ + ": " + Function.prototype.isPrototypeOf(Function) ) //true

console.log(i++ + ": " + Function.prototype.isPrototypeOf(Function) ) //true
console.log(i++ + ": " + Function.prototype.isPrototypeOf(Object) ) //true

console.log(i++ + ": " + RegExp.prototype.isPrototypeOf( RegExp(/foo/) ) ) //true
console.log(i++ + ": " + Object.prototype.isPrototypeOf( RegExp(/foo/) ) ) //true
console.log(i++ + ": " + Function.prototype.isPrototypeOf( RegExp(/foo/) ) ) //false
console.log(i++ + ": " + Object.prototype.isPrototypeOf(Math) ) //true
console.log(i++ + ": " + Math.isPrototypeOf(Math) ) //false
}

function bar()
{
console.log("bar");
console.log(i++ + ": " + (Object instanceof Object) ) //true

console.log(i++ + ": " + (Function instanceof Function) ) //true
console.log(i++ + ": " + (Function instanceof Object) ) //true

console.log(i++ + ": " + (RegExp(/foo/) instanceof RegExp) ) //true
console.log(i++ + ": " + (RegExp(/foo/) instanceof Object)  ) //true
console.log(i++ + ": " + (RegExp(/foo/) instanceof Function) ) //false
console.log(i++ + ": " + (Math instanceof Object) ) //true
console.log(i++ + ": " + (Math instanceof Math) ) //error
}
try
  {
  foo()
  }
catch(e)
  {
  console.log(JSON.stringify(e));
  }
finally
  {
  try
    {
    bar();
    }
  catch(e)
    {
    console.log(JSON.stringify(e));
    }
  }

Unterschied #1

Unterschied #2

Unterschied #3

Abschluss