Por que o instanceof retorna falso para alguns literais?

"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 

Literais de matriz e literais de object correspondem …

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

Por que não todos eles? Ou, porque não todos eles não ?
E, como eles são um exemplo?

É o mesmo em FF3, IE7, Opera e Chrome. Então, pelo menos é consistente.


Perdeu alguns.

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

    Primitivos são um tipo diferente de tipo de objects criados dentro do Javascript. Dos documentos da API do 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) 

    Não consigo encontrar nenhuma maneira de construir tipos primitivos com código, talvez não seja possível. Provavelmente é por isso que as pessoas usam typeof "foo" === "string" vez de instanceof .

    Uma maneira fácil de lembrar coisas como esta é se perguntando “Eu me pergunto o que seria sensato e fácil de aprender”? Seja qual for a resposta, o Javascript faz a outra coisa.

    Eu uso:

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

    Porque em JavaScript strings podem ser literais ou objects.

    Em JavaScript, tudo é um object (ou pelo menos pode ser tratado como um object), exceto primitivos (booleanos, nulos, números, cadeias e o valor undefined (e símbolo em 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 

    Como você pode ver objects, arrays e o valor null são todos objects considerados ( null é uma referência a um object que não existe). As funções são diferenciadas porque são um tipo especial de objects que podem ser chamados . No entanto, eles ainda são objects.

    Por outro lado, os literais true , 0 , "" e undefined não são objects. Eles são valores primitivos em JavaScript. No entanto booleanos, números e cadeias de caracteres também têm construtores Boolean , Number e String respectivamente, que envolvem seus respectivos primitivos para fornecer funcionalidade adicional:

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

    Como você pode ver quando os valores primitivos são agrupados nos construtores Boolean , Number e String respectivamente, eles se tornam objects. O operador instanceof só funciona para objects (é por isso que retorna false para valores primitivos):

     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 

    Como você pode ver, typeof e instanceof são insuficientes para testar se um valor é um booleano, um número ou uma string – typeof funciona apenas para primitivos booleanos, números e strings; e instanceof não funciona para primitivos booleanos, números e strings.

    Felizmente, há uma solução simples para esse problema. A implementação padrão de toString (isto é, como é definida nativamente em Object.prototype.toString ) retorna a propriedade [[Class]] interna de valores e objects primitivos:

     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] 

    A propriedade interna [[Class]] de um valor é muito mais útil que o typeof do valor. Podemos usar o Object.prototype.toString para criar nossa própria versão (mais útil) do operador typeof seguinte maneira:

     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 

    Espero que este artigo tenha ajudado. Para saber mais sobre as diferenças entre primitivos e objects encapsulados, leia a seguinte postagem no blog: A vida secreta de primitivos JavaScript

    Você pode usar a propriedade constructor:

     'foo'.constructor == String // returns true true.constructor == Boolean // returns true 
      typeof(text) === 'string' || text instanceof String; 

    você pode usar isso, ele vai funcionar para ambos os casos

    1. var text="foo"; // typeof funcionará

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

    Eu acredito que encontrei uma solução viável:

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

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

    Retorna uma representação de string de instanceof (o nome dos construtores)

     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" 

    Para mim a confusão causada por

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

    Então, "str" istanceof String deve retornar true porque é como funciona abaixo:

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

    Os resultados da expressão # 1 e # 2 entram em conflito uns com os outros, portanto deve haver um deles errado.

    # 1 está errado

    Eu entendo que isso é causado pelo __proto__ não é uma propriedade padrão, então use o padrão: Object.getPrototypeOf

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

    Agora não há confusão entre as expressões # 2 e # 3

    Eu uso isso para resolver:

     function typeOf(value) { var ret = typeof value; // adjusting type based on object instanceof if (ret === 'object') { if (value instanceof Date) { ret = 'date'; } else if (value instanceof Number) { ret = 'number'; } else if (value instanceof String) { ret = 'string'; } else if (value instanceof Boolean) { ret = 'boolean'; } } return ret; } 

    Ou você pode apenas fazer sua própria function da seguinte forma:

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

    uso:

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

    Estes devem retornar verdadeiros.