Warum instanceof false zurück für einige Literale?

Primitive sind eine andere Art von Art als Objekte, die aus innerhalb von Javascript. Aus der Mozilla API-docs:

var color1 = new String("green");
color1 instanceof String; //returns true
var color2 = "coral";
color2 instanceof String; //returns false (color2 is not a String object)

Ich finde keine Möglichkeit zum erstellen primitive Typen mit code, vielleicht ist es nicht möglich. Dies ist wahrscheinlich, warum Menschen nutzen typeof "foo" === "string" statt instanceof.

Einen einfachen Weg, sich Dinge zu merken, wie das ist, Fragen sich, "ich Frage mich, was wäre, gesund und leicht zu lernen"? Was auch immer die Antwort ist, Javascript ist die andere Sache.

InformationsquelleAutor John Millikin

In JavaScript ist alles ein Objekt (oder können zumindest so behandelt werden, als ein Objekt), außer primitive (Boolean, null, zahlen, strings und der Wert undefined (und symbol in ES6)):

console.log(typeof true);           //boolean
console.log(typeof 0);              //number
console.log(typeof "");             //string
console.log(typeof undefined);      //undefined
console.log(typeof null);           //object
console.log(typeof []);             //object
console.log(typeof {});             //object
console.log(typeof function () {}); //function

Wie Sie sehen können, Objekte, arrays und der Wert null sind alle betrachteten Objekte (null ist eine Referenz auf ein Objekt, das nicht vorhanden ist). Die Funktionen unterscheiden sich, denn Sie sind eine Besondere Art von callable Objekte. Aber Sie sind immer noch Objekte.

Auf der anderen Seite die Literale true, 0, "" und undefined sind keine Objekte. Sie sind primitive Werte in JavaScript. Allerdings Boolesche Werte, zahlen und Zeichenketten haben auch Konstruktoren Boolean, Number und String bzw. die wickeln Ihre jeweiligen primitive, um bereitzustellen, dass Funktion hinzufügte:

console.log(typeof new Boolean(true)); //object
console.log(typeof new Number(0));     //object
console.log(typeof new String(""));    //object

Wie Sie sehen können, wenn die Grundwerte sind, eingehüllt in die Boolean, Number und String Konstruktoren bzw. Sie werden zu Objekten. Die instanceof - operator funktioniert nur für Objekte, (die ist, warum gibt es false für primitive Werte):

console.log(true instanceof Boolean);              //false
console.log(0 instanceof Number);                  //false
console.log("" instanceof String);                 //false
console.log(new Boolean(true) instanceof Boolean); //true
console.log(new Number(0) instanceof Number);      //true
console.log(new String("") instanceof String);     //true

Wie Sie sehen können beide typeof und instanceof sind nicht ausreichend, um zu testen, ob ein Wert ein boolean, eine Zahl oder ein string - typeof funktioniert nur für primitive Boolesche Werte, zahlen und Zeichenketten; und instanceof funktioniert nicht für primitive Boolesche Werte, zahlen und Zeichenketten.

Glücklicherweise gibt es eine einfache Lösung für dieses problem. Die default-Implementierung von toString (D. H., wie es systemintern definiert Object.prototype.toString) liefert die interne [[Class]] Eigenschaft der beiden primitive Werte und Objekte:

function classOf(value) {
    return Object.prototype.toString.call(value);
}

console.log(classOf(true));              //[object Boolean]
console.log(classOf(0));                 //[object Number]
console.log(classOf(""));                //[object String]
console.log(classOf(new Boolean(true))); //[object Boolean]
console.log(classOf(new Number(0)));     //[object Number]
console.log(classOf(new String("")));    //[object String]

Den internen [[Class]] - Eigenschaft der Wert ist viel nützlicher als die typeof den Wert. Wir können Object.prototype.toString erstellen unsere eigene (weitere nützliche) version von der typeof - operator wie folgt:

function typeOf(value) {
    return Object.prototype.toString.call(value).slice(8, -1);
}

console.log(typeOf(true));              //Boolean
console.log(typeOf(0));                 //Number
console.log(typeOf(""));                //String
console.log(typeOf(new Boolean(true))); //Boolean
console.log(typeOf(new Number(0)));     //Number
console.log(typeOf(new String("")));    //String

Hoffe, dieser Artikel geholfen. Erfahren Sie mehr über die Unterschiede zwischen primitiven und verpackten Objekten Lesen Sie die folgenden blog-post: Das Geheime Leben der JavaScript Primitive

InformationsquelleAutor Aadit M Shah

 typeof(text) === 'string' || text instanceof String; 

können Sie diese verwenden, wird es funktionieren, sowohl für den Fall, als

1. var text="foo"; //typeof funktioniert

2. String text= new String("foo"); //instanceof funktioniert

InformationsquelleAutor saurabhgoyal795

https://www.npmjs.com/package/typeof

Gibt eine string-Darstellung des instanceof (die Konstruktoren name)

function instanceOf(object) {
  var type = typeof object

  if (type === 'undefined') {
    return 'undefined'
  }

  if (object) {
    type = object.constructor.name
  } else if (type === 'object') {
    type = Object.prototype.toString.call(object).slice(8, -1)
  }

  return type.toLowerCase()
}

instanceOf(false)                  //"boolean"
instanceOf(new Promise(() => {}))  //"promise"
instanceOf(null)                   //"null"
instanceOf(undefined)              //"undefined"
instanceOf(1)                      //"number"
instanceOf(() => {})               //"function"
instanceOf([])                     //"array"

InformationsquelleAutor samdd

Oder können Sie nur Ihre eigene Funktion, etwa so:

function isInstanceOf(obj, clazz){
  return (obj instanceof eval("("+clazz+")")) || (typeof obj == clazz.toLowerCase());
};

Verwendung:

isInstanceOf('','String');
isInstanceOf(new String(), 'String');

Diese sollten beide true zurück.

InformationsquelleAutor