Pourquoi instanceof renvoie false pour certains littéraux?

"foo" instanceof String //=> false
"foo" instanceof Object //=> false
true instanceof Boolean //=> false
true instanceof Object //=> false
false instanceof Boolean //=> false
false instanceof Object //=> false

// the tests against Object really don't make sense

Les littéraux de tableau et les littéraux d'objet correspondent ...

[0,1] instanceof Array //=> true
{0:1} instanceof Object //=> true

Pourquoi pas tous? Ou, pourquoi ne pas tous pas ?
Et de quoi sont-ils un exemple, alors?

C'est la même chose dans FF3, IE7, Opera et Chrome. Donc, au moins, c'est cohérent.

En a manqué quelques-uns.

12.21 instanceof Number //=> false
/foo/ instanceof RegExp //=> true

Les primitives sont d'un type différent de celui des objets créés à partir de Javascript. À partir des documents de l'API Mozilla :

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

Je ne trouve aucun moyen de construire des types primitifs avec du code, ce n'est peut-être pas possible. C'est probablement pourquoi les gens utilisent typeof "foo" === "string"au lieu de instanceof.

Un moyen facile de se souvenir de choses comme celle-ci est de se demander "Je me demande ce qui serait sain et facile à apprendre"? Quelle que soit la réponse, Javascript fait l'autre chose.

J'utilise:

function isString(s) {
    return typeof(s) === 'string' || s instanceof String;
}

Parce qu'en JavaScript, les chaînes peuvent être des littéraux ou des objets.

En JavaScript, tout est un objet (ou peut au moins être traité comme un objet), à l'exception des primitives (booléens, null, nombres, chaînes et la valeur undefined(et le symbole dans 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

Comme vous pouvez le voir, les tableaux et la valeur nullsont tous considérés comme des objets ( nullc'est une référence à un objet qui n'existe pas). Les fonctions se distinguent parce qu'elles sont un type spécial d' objets appelables . Mais ce sont toujours des objets.

D'autre part , les littéraux true, 0, ""et undefinedne sont pas des objets. Ce sont des valeurs primitives en JavaScript. Cependant, les booléens, les nombres et les chaînes ont également des constructeurs Boolean, Numberet Stringrespectivement qui enveloppent leurs primitives respectives pour fournir des fonctionnalités supplémentaires:

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

Comme vous pouvez le voir lorsque les valeurs primitives sont enveloppées respectivement dans les constructeurs et Boolean, elles deviennent des objets. L' opérateur ne fonctionne que pour les objets (c'est pourquoi il retourne pour les valeurs primitives):NumberStringinstanceoffalse

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

Comme vous pouvez voir les deux typeofet instanceofsont insuffisants pour tester si une valeur est un booléen, un nombre ou une chaîne - typeofne fonctionne que pour les booléens primitifs, les nombres et les chaînes; et instanceofne fonctionne pas pour les booléens primitifs, les nombres et les chaînes.

Heureusement, il existe une solution simple à ce problème. L'implémentation par défaut de toString(c'est-à-dire telle qu'elle est définie de manière native sur Object.prototype.toString) renvoie la [[Class]]propriété interne des valeurs primitives et des objets:

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]

La [[Class]]propriété interne d'une valeur est beaucoup plus utile que typeofla valeur. Nous pouvons utiliser Object.prototype.toStringpour créer notre propre version (plus utile) de l' typeofopérateur comme suit:

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

J'espère que cet article vous a aidé. Pour en savoir plus sur les différences entre les primitives et les objets encapsulés, lisez le billet de blog suivant: La vie secrète des primitives JavaScript

Vous pouvez utiliser la propriété constructeur:

'foo'.constructor == String // returns true
true.constructor == Boolean // returns true

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

vous pouvez l'utiliser, cela fonctionnera dans les deux cas comme

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

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

Ceci est défini dans la spécification ECMAScript Section 7.3.19 Étape 3 :If Type(O) is not Object, return false.

En d'autres termes, si l' Objentrée Obj instanceof Callablen'est pas un objet, la instanceofvolonté court-circuitera falsedirectement.

Je pense avoir trouvé une solution viable:

Object.getPrototypeOf('test') === String.prototype    //true
Object.getPrototypeOf(1) === String.prototype         //false

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

Renvoie une représentation sous forme de chaîne de instanceof(le nom du constructeur)

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"

Pour moi, la confusion causée par

"str".__proto__ // #1
=> String

Donc "str" istanceof Stringdevrait revenir trueparce que comment fonctionne istanceof comme ci-dessous:

"str".__proto__ == String.prototype // #2
=> true

Les résultats des expressions # 1 et # 2 sont en conflit, donc l'un d'eux devrait être faux.

# 1 est faux

Je pense que cela est dû à la __proto__propriété non standard, alors utilisez celle standard:Object.getPrototypeOf

Object.getPrototypeOf("str") // #3
=> TypeError: Object.getPrototypeOf called on non-object

Maintenant, il n'y a plus de confusion entre l'expression # 2 et # 3

Ou vous pouvez simplement créer votre propre fonction comme ceci:

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

usage:

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

Celles-ci devraient toutes les deux retourner vrai.