"foo" instanceof String //=> false
"foo" instanceof Object //=> false
true instanceof Boolean //=> false
true instanceof Object //=> false
false instanceof Boolean //=> false
false instanceof Object //=> false
12.21 instanceof Number //=> false
/foo/ instanceof RegExp //=> true
// the tests against Object really don't make sense
Array-Literale und Objekt-Literale stimmen überein…
[0,1] instanceof Array //=> true
{0:1} instanceof Object //=> true
Warum nicht alle? Oder warum nicht alle nicht?
Und wovon sind sie dann ein Beispiel?
Dasselbe gilt für FF3, IE7, Opera und Chrome. So ist es zumindest konsequent.
Primitive sind eine andere Art von Typ als Objekte, die in Javascript erstellt wurden. Von dem Mozilla-API-Dokumentation:
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 kann keine Möglichkeit finden, primitive Typen mit Code zu konstruieren, vielleicht ist es nicht möglich. Dies ist wahrscheinlich der Grund, warum die Leute verwenden typeof "foo" === "string" anstatt instanceof.
Eine einfache Möglichkeit, sich an solche Dinge zu erinnern, besteht darin, sich zu fragen: “Ich frage mich, was vernünftig und leicht zu lernen wäre”? Was auch immer die Antwort ist, Javascript macht das andere.
Ich benutze:
function isString(s) {
return typeof(s) === 'string' || s instanceof String;
}
Denn in JavaScript können Strings Literale oder Objekte sein.
In JavaScript ist alles ein Objekt (oder kann zumindest als Objekt behandelt werden), außer Primitive (Booleans, 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 Objekte, Arrays und den Wert sehen können null werden alle als Objekte betrachtet (null ist ein Verweis auf ein Objekt, das nicht existiert). Funktionen werden unterschieden, weil sie eine besondere Art von sind abrufbar Objekte. Sie sind jedoch immer noch Objekte.
Andererseits die Literale true, 0, "" und undefined sind keine Gegenstände. Sie sind primitive Werte in JavaScript. Boolesche Werte, Zahlen und Strings haben jedoch auch Konstruktoren Boolean, Number und String die ihre jeweiligen Grundelemente umschließen, um zusätzliche Funktionalität bereitzustellen:
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, werden primitive Werte in die eingeschlossen Boolean, Number und String Konstruktoren bzw. sie werden zu Objekten. Die instanceof -Operator funktioniert nur für Objekte (weshalb er zurückkehrt 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 man beides sieht typeof und instanceof reichen nicht aus, um zu testen, ob ein Wert ein boolescher Wert, eine Zahl oder ein String ist – typeof funktioniert nur für primitive boolesche Werte, Zahlen und Strings; und instanceof funktioniert nicht für primitive boolesche Werte, Zahlen und Strings.
Glücklicherweise gibt es eine einfache Lösung für dieses Problem. Die Standardimplementierung von toString (dh wie es nativ auf definiert ist Object.prototype.toString) gibt die interne zurück [[Class]] Eigenschaft von primitiven Werten und Objekten:
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]
Das Innere [[Class]] Eigenschaft eines Wertes ist viel nützlicher als die typeof der Wert. Wir können benutzen Object.prototype.toString um unsere eigene (nützlichere) Version von zu erstellen typeof Betreiber 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 hat geholfen. Um mehr über die Unterschiede zwischen Primitiven und umschlossenen Objekten zu erfahren, lesen Sie den folgenden Blogbeitrag: Das geheime Leben von JavaScript-Primitiven
Sie können die Konstruktoreigenschaft verwenden:
'foo'.constructor == String // returns true
true.constructor == Boolean // returns true
typeof(text) === 'string' || text instanceof String;
Sie können dies verwenden, es funktioniert für beide Fälle
-
var text="foo"; // typeof wird funktionieren
-
String text= new String("foo"); // instanceof wird funktionieren
Dies ist in der ECMAScript-Spezifikation definiert Abschnitt 7.3.19 Schritt 3: If Type(O) is not Object, return false.
Mit anderen Worten, wenn die Obj in Obj instanceof Callable ist kein Objekt, das instanceof wird kurzschließen false direkt.
Ich glaube, ich habe eine brauchbare Lösung gefunden:
Object.getPrototypeOf('test') === String.prototype //true
Object.getPrototypeOf(1) === String.prototype //false
