Javascript 为什么instanceof对于某些文本返回false？

数组文字和对象文字匹配

"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

为什么不是所有人？或者，为什么他们都不呢？
那么，它们是什么样的例子呢

---

在FF3、IE7、Opera和Chrome中也是如此。所以，至少它是一致的。

原语是一种不同于Javascript中创建的对象的类型。从：

我找不到用代码构造基元类型的任何方法，也许这是不可能的。这可能就是为什么人们使用

类型的“foo”==“string”

而不是

实例的原因

记住这类事情的一个简单方法是问自己“我想知道什么是理智的、容易学的”？不管答案是什么，Javascript做的是另一件事。
原语是一种不同于Javascript中创建的对象的类型。从：

我找不到用代码构造基元类型的任何方法，也许这是不可能的。这可能就是为什么人们使用
类型的“foo”==“string”
而不是
实例的原因

记住这类事情的一个简单方法是问自己“我想知道什么是理智的、容易学的”？不管答案是什么，Javascript做的是另一件事。
您可以使用构造函数属性：

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

您可以使用构造函数属性：

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

或者，您可以像这样创建自己的函数：

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

用法：

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

这两个函数都应该返回true。
或者您可以这样创建自己的函数：

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

用法：

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

这两者都应返回true。
我使用：

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

因为在JavaScript中，字符串可以是文字或对象。
我使用：

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

因为在JavaScript中，字符串可以是文本或对象。
在JavaScript中，所有内容都是对象（或者至少可以被视为对象），除了（布尔值、null、数字、字符串和未定义的值（以及ES6中的符号））：

如您所见，对象、数组和值
null
都被视为对象（
null
是对不存在的对象的引用）。函数之所以与众不同，是因为它们是一种特殊类型的可调用对象。然而，它们仍然是对象

另一方面，文本
true
、
0
、
“
和
未定义的
不是对象。它们是JavaScript中的基本值。但是布尔、数字和字符串也分别具有构造函数
Boolean
、
Number
和
String
，它们包装各自的原语以提供附加功能：

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

正如您所看到的，当基本值分别包装在
布尔
、
数字
和
字符串
构造函数中时，它们将成为对象。
instanceof
运算符仅适用于对象（这就是它返回
false
基本值的原因）：

正如您所见，
typeof
和
instanceof
都不足以测试值是布尔值、数字还是字符串-
typeof
仅适用于原始布尔值、数字和字符串；而
instanceof
不适用于原始布尔、数字和字符串

幸运的是，这个问题有一个简单的解决方案。
toString
的默认实现（即在
Object.prototype.toString
上本机定义的）返回基本值和对象的内部
[[Class]]
属性：

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

值的内部
[[Class]]
属性比值的
类型有用得多。我们可以使用
Object.prototype.toString
创建自己（更有用）的
typeof
操作符，如下所示：

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]

希望这篇文章有帮助。要了解原语和包装对象之间的差异，请阅读以下博文：
在JavaScript中，除了（布尔、null、数字、字符串和未定义的值
（以及ES6中的符号）），一切都是对象（或者至少可以被视为对象）：

如您所见，对象、数组和值
null
都被视为对象（
null
是对不存在的对象的引用）。函数之所以与众不同，是因为它们是一种特殊类型的可调用对象。然而，它们仍然是对象

另一方面，文本
true
、
0
、
“
和
未定义的
不是对象。它们是JavaScript中的基本值。但是布尔、数字和字符串也分别具有构造函数
Boolean
、
Number
和
String
，它们包装各自的原语以提供附加功能：

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

正如您所看到的，当基本值分别包装在
布尔
、
数字
和
字符串
构造函数中时，它们将成为对象。
instanceof
运算符仅适用于对象（这就是它返回
false
基本值的原因）：

正如您所见，
typeof
和
instanceof
都不足以测试值是布尔值、数字还是字符串-
typeof
仅适用于原始布尔值、数字和字符串；而
instanceof
不适用于原始布尔、数字和字符串

幸运的是，这个问题有一个简单的解决方案。
toString
的默认实现（即在
Object.prototype.toString
上本机定义的）返回基本值和对象的内部
[[Class]]
属性：

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

值的内部
[[Class]]
属性比值的
类型有用得多。我们可以使用
Object.prototype.toString
创建自己（更有用）的
typeof
操作符，如下所示：

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]

希望这篇文章有帮助。要了解原语和包装对象之间的差异，请阅读以下博文：
<
Object.getPrototypeOf('test') === String.prototype    //true
Object.getPrototypeOf(1) === String.prototype         //false

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

var name = "foo";
var firstChar = name.charAt(0);
console.log(firstChar);

// what the JavaScript engine does
var name = "foo";
var temp = new String(name);
var firstChar = temp.charAt(0);
temp = null;
console.log(firstChar);