为什么的instanceof一段文字返回false？为什么的instanceof一段文字返回fals

"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

数组常量和对象文本匹配...

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

为什么不是所有的人？ 或者说，为什么不用他们都没有 ？
而且，什么是他们的一个实例，然后呢？

它在FF3，IE7，Opera和Chrome的相同。 所以，至少是一致的。

---

错过了一些。

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

Answer 1:

元是不同的类型不是在JavaScript中创建的对象。 从Mozilla的API文档 ：

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

我找不到任何方法来构建基本类型与代码，也许这是不可能的。 这大概就是为什么人们使用typeof "foo" === "string"来代替instanceof 。

一个简单的方法来记住这样的事情是问自己，“我不知道会是明智的，简单易学”？ 无论答案是，JavaScript并其他的事情。

Answer 2:

我用：

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

因为在JavaScript字符串可以是文字或对象。

Answer 3:

在JavaScript一切都是一个对象（或可以至少被当作一个对象），除了原语 （布尔型，空值，数字，字符串和值undefined （和在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

正如可以看到的物体，阵列和值null都被认为是对象（ null是一个对象，该对象不存在的参考）。 因为他们是一个特殊类型的可调用对象的功能区分。 但是他们仍然对象。

在另一方面的文字true ， 0 ， ""和undefined不是对象。 他们是在JavaScript中的原始值。 但是布尔，数字和字符串也有构造Boolean ， Number和String分别缠绕其各自的原语来提供额外的功能：

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

正如你可以看到当原始值的内包装Boolean ， Number和String构造它们分别成为目标。 该instanceof运算符仅适用于对象（这就是为什么它返回false的原始值）：

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

正如你可以同时看到typeof和instanceof不足以测试值是否是一个布尔值，数字或字符串- typeof只适用于原始的布尔，数字和字符串; 和instanceof没有为原始布尔，数字和字符串工作。

幸运的是有一个简单的解决这个问题。 的默认实现toString （即，因为它是天然上定义Object.prototype.toString ）返回内部[[Class]]两者的原始值和对象的属性：

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]

内部[[Class]]的值的性能比的更加有用typeof的值。 我们可以使用Object.prototype.toString来创建我们自己的（更多有用）版本typeof符，如下所示：

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

希望这篇文章帮助。 要了解更多关于原语和包裹对象之间的差异阅读下面的博客文章： JavaScript的原语的秘密生活

Answer 4:

您可以使用constructor属性：

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

Answer 5:

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

你可以利用这一点，它会为这两个情况下工作

1. var text="foo"; // typeof运算将工作

2. String text= new String("foo"); //的instanceof将工作

Answer 6:

我相信我已经想出了一个可行的解决方案：

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

Answer 7:

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

返回一个字符串表示instanceof （构造函数名称）

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"

Answer 8:

对我来说，混乱造成的

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

所以， "str" istanceof String应该返回true ，因为istanceof是如何工作的，如下：

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

表达式＃1和＃2冲突的结果彼此，所以应该是他们中的一个错误。

＃1是错误的

我弄清楚，它造成的__proto__是非标准的属性，因此使用标准之一： Object.getPrototypeOf

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

现在有表达＃2，＃3之间没有混淆

Answer 9:

或者你也可以让自己的功能，如下所示：

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

用法：

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

这些都应该返回true。

文章来源: Why does instanceof return false for some literals?