JavaScript中typeof、toString、instanceof、constructor与in

JavaScript 是一种弱类型或者说动态语言。这意味着你不用提前声明变量的类型，在程序运行过程中，类型会被自动确定。

这也意味着你可以使用同一个变量保存不同类型的数据。

最新的 ECMAScript 标准定义了 7 种数据类型：

7种内置类型：Boolean、Null、Undefined、Number、String、Symbol (ECMAScript 6 新定义)和Object，除 Object 以外的所有类型都是不可变的（值本身无法被改变）。

一、typeof

typeof操作符返回一个字符串,表示未经求值的操作数(unevaluated operand)的类型。查看在线代码：

// Numbers
typeof 37 === 'number';
typeof 3.14 === 'number';
typeof Math.LN2 === 'number';
typeof Infinity === 'number';
typeof NaN === 'number'; // 尽管NaN是"Not-A-Number"的缩写,意思是"不是一个数字"
typeof Number(1) === 'number'; // 不要这样使用!

// Strings
typeof "" === 'string';
typeof "bla" === 'string';
typeof (typeof 1) === 'string'; // typeof返回的肯定是一个字符串
typeof String("abc") === 'string'; // 不要这样使用!

// Booleans
typeof true === 'boolean';
typeof false === 'boolean';
typeof Boolean(true) === 'boolean'; // 不要这样使用!

// Symbols
typeof Symbol() === 'symbol';
typeof Symbol('foo') === 'symbol';
typeof Symbol.iterator === 'symbol';

// Undefined
typeof undefined === 'undefined';
typeof blabla === 'undefined'; // 一个未定义的变量,或者一个定义了却未赋初值的变量

// Objects
typeof {a:1} === 'object';
// 使用Array.isArray或者Object.prototype.toString.call方法可以从基本的对象中区分出数组类型
typeof [1, 2, 4] === 'object';
typeof new Date() === 'object';
// 下面的容易令人迷惑，不要这样使用！
typeof new Boolean(true) === 'object';
typeof new Number(1) === 'object';
typeof new String("abc") === 'object';
// 从JavaScript一开始出现就是这样的
typeof null === 'object';
// 正则表达式
typeof /s/ === 'object'; // Chrome 12+ , 符合 ECMAScript 5.1
typeof /s/ === 'object'; // Firefox 5+ , 符合 ECMAScript 5.1

// 函数
typeof function(){} === 'function';
typeof Math.sin === 'function';
typeof /s/ === 'function'; // Chrome 1-12 , 不符合 ECMAScript 5.1

undefined（未赋值）和undeclared（未声明）是有区别的。

检查全局变量的是否声明的安全防范机制：

typeof DEBUG == "undefined"
//或
window.DEBUG

二、toString

可以通过使用toString.call(obj)来检测对象类型。

可以用来检测Object、Number、Array、Date、Function、String、Boolean、Error和RegExp。

下面的代码与上面的代码做了一一比较，其中在注释中有标红的“不同”，说明有区别。查看在线代码：

var toString = Object.prototype.toString;
// Numbers 都返回[object Number]
toString.call(37);
toString.call(3.14);
toString.call(Math.LN2);
toString.call(Infinity);
toString.call(Number(1));

// Strings 都返回[object String]
toString.call("");
toString.call("bla");
toString.call(String("abc"));

// Booleans 都返回[object Boolean]
toString.call(true);
toString.call(false);
toString.call(Boolean(true));

// Symbols 都返回[object Symbol]
toString.call(Symbol());
toString.call(Symbol('foo'));
toString.call(Symbol.iterator);

// Undefined 都返回[object Undefined]
toString.call(undefined);
//toString.call(blabla);//不同 一个未定义的变量会报错

// Objects
toString.call({a:1});//[object Object]
toString.call([1, 2, 4]);//[object Array] 不同
toString.call(new Date());//[object Date] 不同
toString.call(new Boolean(true));//[object Boolean] 不同
toString.call(new Number(1));//[object Number] 不同
toString.call(new String("abc"));//[object String] 不同
toString.call(null);//[object Null] 不同
toString.call(/s/);//[object RegExp] 不同
toString.call(new TypeError());//[object Error] 不同

// 函数 都返回[object Function]
toString.call(function(){});
toString.call(Math.sin);

三、instanceof

instanceof 运算符可以用来判断某个构造函数的 prototype 属性是否存在另外一个要检测对象的原型链上，返回boolean值。语法如下：

aaarticlea/png;base64,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" alt="" />

也就比对object.__proto__与constructor.prototype是否对应。

JavaScript instanceof 运算符代码，参考自《JavaScript instanceof 运算符深入剖析》

function instance_of(L, R) {//L 表示左表达式，R 表示右表达式
  var O = R.prototype;// 取 R 的显示原型
  L = L.__proto__;// 取 L 的隐式原型
  while (true) {
    if (L === null)
      return false;
    if (O === L)// 这里重点：当 O 严格等于 L 时，返回 true
      return true;
    L = L.__proto__;
  }
 }

object：要检测的对象，constructor：某个构造函数。查看在线代码：

 // 定义构造函数
 function C(){}
 function D(){} 

 var o = new C();
 o instanceof C; // true，因为 Object.getPrototypeOf(o) === C.prototype
 //o.__proto__={}; //改变o原型链，o instanceof C将会返回false
 o instanceof D; // false，因为 D.prototype不在o的原型链上
 o instanceof Object; // true,因为Object.prototype.isPrototypeOf(o)返回true
 C.prototype instanceof Object // true,同上

 C.prototype = {};
 var o2 = new C();
 o2 instanceof C; // true
 o instanceof C; // false,C.prototype指向了一个空对象,这个空对象不在o的原型链上.

 D.prototype = new C(); // 继承
 var o3 = new D();
 o3 instanceof D; // true
 o3 instanceof C; // true

有两种方式可以将"o instanceof C"返回“false”：

1、注意上面代码的第12行，改变了函数C.prototype属性，改变之后导致这个对象不在o的原型链上。

2、改变对象o的原型链，借助于非标准的__proto__魔法属性可以实现。比如代码的第7行执行o.__proto__ = {}。

这里需要注意一个地方，就是Object.prototype.isPrototypeOf()与instanceof的区别。请看下面的代码：

var human = function() {}
var socrates = Object.create(human);
console.log(human.isPrototypeOf(socrates)); // true
console.log(socrates instanceof human); // false
console.log(socrates.__proto__ == human.prototype);//false
console.log(socrates.__proto__ == human);//true

上面的Object.create()传递的是human函数，“socrates.__proto__ == human.prototype”不相等，

也就是说human.prototype不在socrates的原型链上，所以instanceof返回的是false。

isPrototypeOf() 是指测试一个对象是否存在于另一个对象的原型链上；现在human这个对象在socrates的原型链上。

四、constructor

constructor返回一个指向创建了该对象原型的函数引用。

需要注意的是，该属性的值是那个函数本身，而不是一个包含函数名称的字符串。对于原始值（如1，true 或 "test"），该属性为只读。

所有对象都会从它的原型上继承一个 constructor 属性。查看在线代码。

1、在JavaScript的继承中，instanceof和constructor表现的是不一样的：

function C(){}
function D(){}
D.prototype = new C(); // 继承
var o = new D();
o instanceof D; // true
o instanceof C; // true
o.constructor == D; // false
o.constructor == C; // true
o.constructor == D.prototype.constructor;//true
o.constructor == Object.prototype.constructor;// false

对象的constructor属性是根据函数的prototype.constructor来的。

2、改变这个对象的constructor属性的值，只有 true, 1 和 "test" 的不受影响，其他的都变成了"function type(){}"

function Type() { };
var    types = [
    new Array,
    [],
    new Boolean,
    true,        // remains unchanged
    new Date,
    new Error,
    new Function,
    function(){},
    Math,
    new Number,
    1,           // remains unchanged
    new Object,
    {},
    new RegExp,
    /(?:)/,
    new String,
    "test"       // remains unchanged
];
for(var i = 0; i < types.length; i++) {
    types[i].constructor = Type;
    types[i] = [ types[i].constructor, types[i] instanceof Type, types[i].toString() ];
    console.log(types[i]);
};

下图分别是“new Boolean” 和 “true”的打印结果：

aaarticlea/png;base64,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" alt="" />

五、in

in操作，如果指定的属性在指定的对象中会返回true,语法如下:

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAiEAAAAyCAIAAAAFqJzMAAAMaElEQVR4nO2dX0/bWBrG+STzTfYj2Bf2Bb7AN6m06QWVFkfClQa0S6tt0DbVDEFN2KXVVHNTloJKss0WFRgKI6aISchCu4LuhGWSTSdkJmSaRM6xr2Yvju3Y+eOQkIChT3Q0mtjnPP6d1855/B4fl4FSuYKCgoKCgtKPMkBUjRalSsz/tiqlcsVhr3Nb697GmlS5lUIrNjCDGcxgBrObmQccjtS4q7EPzmRn72GvogNmMIMZzGB2D3MHHtO/6EAZylCGMpSvpXJfPKapiMujA2YwgxnMYO45c3OPadXm0qPjsBfMYAYzmMHsNuaBOu4LiI61mvn/nSqDGcxgBjOY3c/cxzzG+evZleu67RAdMIMZzGAGs6uYz7uu7OyU/XZgMIMZzGAGs9uYL+f9mF4pgxnMYAYzmN3MPEAznTOWUrnSUX0oQxnKUIbyp6zsivdjFHuW11iza2UwgxnMYAbzJTK39JimzXrYh7oDtVJWzpAhghnMYAYzmN3JfMl5jLnRbTOJYAYzmMEM5vMrX7THtKrj5riDGcxgBjOYu1M+q8c4Z0y9ik5jnY7yRzCDGcxgBrOrmM+Vx5iVzxOdpsod9QTMYAYzmMHsTuYez5U5NO9OuZG+lZeCGcxgBjOY3cbsirXLUIYylKEM5WupjH9LpgfM6ajMTCf7yfxD8O78Z+F4rsdxTgZZOZJp3Xb/iYf3BBMVl8S5t8pgBjOYL4D5Mt7zT78YYfnB8Fv9a/whI71I9fAN1Z+2Q5LIsTzDD489ffuTk3JmSeIZ4W//0r/uTrGjS+mOo/FjZJQJ7vaMv0mc/zN1Z/6z0Pcfeqzcrr97X3l4z1S81BUzUaq5f97xhOLnDXhvrjooQxnKl6Hcx7myxq/6lkxMYsfk8cBGWSOqRhIhxhdLtVi30LEDnyaDose/liWqRk52gqLwh+fHrdtmlyRevj3h36T9Sk6xo3X39Q6HNtda9DaP6VmcHZlpf9vkMedlzkZ8fDBhbZuN+Hj59sS9jZIVoBPmc1wblxZnMIP502Vu6THpqCwtJt/MyIM8z/DSo/0iPVJ8mpei7w+i9zw8zwky3U5ULbU2NSIIDMtzNyeeGhvtIiN65UxMYkMvl8fk5TxRbR5DTnYejQ9zLM/wHvnxu4KqETUb8cmzkYceXvA8TsZnvBzvDeuzN9nVyeFBnmd4UZrZyRlHZCa3SmaPEiHOM5cyDvrmZCd8S2BYwTu5nlY16jHB5Vfy7Vc5VbOMufrgSKNhWEg24pMfRUONJOmozDx4ZXRzOJwoGpFsQkjFp77LvZmROJbnbgZWM/VnxXqtHK9EBuT5AXl+4Ku3lnP09q68Evlhc+jz+QF5/nfhncM257sYn5vw8jzDCoO+qQ39iMkgKz9ai/lvCgwrDI7HfqRtEyGG5c1CTYIqp9cCXkFgWGHQN/vmpKaf254dFQVaX4pmiarFp3mriLE9G/E1CbhSJeT0/csHNICicXa0dFSWHse+8AjcjSfxxKyHFzwzSXpyC/tPZJFeb/cjh8UL+E1CGcpQ7qKtk8cwrCAvvi+oWmF7alCY3TM8ZlD0eKZ3CqqWi44xvlha1UqJ0KAYWEkTomq57dAQP7F6Ui/y83dfUhE63MfLW/5bSynV5jHxxdDqYZ6oGjnZCghCMKERNbskCZz0PH34zMMLw3PHqUWJmU4StRKf9gxN7xRUTfl4tOATpGiWqJWNSX2M08vp+ufsn1ZP6UE9QzfkhSONqMlgTZwPJiobk5K+vY3HCJxvySQ5mB+h6QvtpjRHYxUa4gOvPxKlWjIJSfnYINTFh0SvtHhMVC0+LXINOVDjGT1eiTR4zPxnd1de/1Ilv771/XH+brLqcL7TUZnzPTs41UrlYmpR5sTZPZX2l2dEanLHzyTBu3Bkb5gMWjzm1/jDITH05lQjaiW1KHO+GHWCwvbUoHjvH00G+uZ5TGPAlSpJrz1ZSGRLeqz0k5iOyhwv//3o309vCNytZ6mjpWE2FKeXEC8vHGlKlXz47uGQEIqXr8xv0vmGEcxgvmbMjh7zYMfYngyy0kJG9xhzcNHdQi2ujvPyct5oSwf6fJ2IUt2lIkYrbW9mOLxvz2MsJT5du/O9t1EimdgIe3+jbIz45S0/q8+2KVVCtqcYXyxnGdRM8i/o9FcmJrGeYKJYJ74k8cGERvZnvTPvzuAxvH+zQjIxiQ1slLXU89Gax9Ri9S4siOF9Tfn4rZ8NvP5oRF8n1MWHgrsFuj0RYsx4tj6jzTwm8vX/6N7q66/mmZUPra8VHclQPn56g1qsflpptcLaBDP+TcGmYPWYyms/b0wqakTdCbBy5EQjaj7i4+Xl/NnnyhoDXsdszj3SrPSX8rEl8qG4qqXmvJ65Y6O/mYVbwlS8myz+cu/7upt5ADOYrxazo8fU7q/1scaYK8va69tGZFIbwW0iSnVXH7CMkYIcLQ1PbpUsHpPbnpWNKRfr7MpUnJitfoyMMtNJkolJ9qkYxhdLN89j/rJRthzUFgvDY9TjhVuBjXJ7j7Hy2zymFiujbfpFM0Kt1qNOzuh/Xzl4jNbOY2rPXUrlimXotz+PSYQY6YXpdkqV2D0muyTVTX/Rtskgr18bDddSpqXH2AOuVEnhMOa/KXKmuCWwpfJxXeQbJ+LsR+n+l2OtfzF3lGAG8/VmPpvHlLf8rBw5aeIxRNWIWlwd58fWikZb/WudiPLxWypiGe7zL2+PvVw2POZ0fYwVA5t5Wt+ax1g9Rtc8XR+z5jEGTGrOy1mex5Q2A5x30XweE6+PjukxWm55TF5+1dRjDh57O/GYZJD3Pj3SlF++MQnrDtqFxzjmMW09pi6PMb/aPCYdlRn/tyVbQ6vHFFfGrXmMrTv+zUpneYw94Er1bVjgpcXjkv3aa+UxezOiJY+5YnMLUIbyJ6U8ULfb5jH6YJ2Pzwxz4+sfqoR6zEgkU6eSW5vgxIdbPxGiP48JbJxqCl1wZYh8Hx7mxtdzqm24L20GJJ+se0wmJrHeR4caUSvp7dAw39pjgrtEza+OC96ZZK5s72EmJvGe4HaeqBrJrN8ThT9/kycqzSrqPYYupdXH0PKW3yeP6OvKiqvjvPfxe6VK0muBIf222tFjJtdLqkbU4sGc/qBCqeZMQvtpaOMxirHO3dov02OM2c+axyhV0s5jtL0ZD+dbSpWN5zE3n6VUjc6VPT2s0Fj5Rc9UvGQn2bU+j/mwOsHdnI2f1F9t6ajMiPeXj4qNR49PC4MPdn6uzdhazLu85ffJku4xu0GWv7NWJKqW24/dEdvkMWR/dkiYiBw2Wevi/LVtnK17u1bu9DcJZjBfY2bnZ/48w9J1PrGDU/1IzfIYjajFg2jAXLa0eqQ1EfG/oCL2lOJdWOCNubLi3mNzZVHs0V3HPEbVyOn7CF21ZVnORFStcEgXSvGcIIe3jecE7fIYomp7MyJj3tdnYmMCXYH26s1im7myQmJWvkHfyKnFSqmSFoQd5TEfvr4/r68rM1aXdZ7HaETN68veWME7/iyuEx69HJeGeJ5heU4cC2/nG9ranvkr1cJBlK4rs0796Wf/94JQdyKIqpGTrYAxA1ZbV9YQcOrl9PoZuj27MC218pgR9iE9ifZp1cYz2/tfTtfKnc54gBnM14m5uccoxjsfdY3b9sFsTrfoz04uJDpmnXMyW5t/8sy2ybQrwnwV4wxmMF9b5oFSudK0pJ6PMl9+32rvGUtPRFAuqxzMj3LiXxOXjYGCgnJ1yxnXlXXpZvZ1ZZef5UH5LMrGqi3r25puZ4YylKHsTuUmHuPQoFSuOOzteR/MzK6tMpjBDGYwg9mFzL3598rqpvmaSrnNgcEMZjCDGcz9Zj6Tx5gbrUdqrOlsaNZdjdV6HncwgxnMYAbzpTMP1NVz5uj6SA6ydHujsnOfwQxmMIMZzO5nvui/g9mqjjufVoEZzGAGM5j7Pld2JaIDZShDGcpQdpsyPAbKUIYylKF8XTym1SyeO6MDZjCDGcxgPpfHKBf1V52hDGUoQxnKn5pyf/MYpYUr9sOBwQxmMIMZzG5j7v79mD5Fh1pfXZMulMEMZjCDGcyXztyX9/ydA+GgXKfT2+iAGcxgBjOYL5i5yTuYXfShf9FxbgtmMIMZzGB2M3Nfnsd07ZMOyg7NwQxmMIMZzO5kbvm3ls/Thz5Fp1WMwAxmMIMZzO5k7n0e45w3uTw6YAYzmMEM5h4yX5m5sr7GHcxgBjOYwdwP5oHf8MEHH3zwwac/n/8DV+pWoZqcUoMAAAAASUVORK5CYII=" alt="" />

1）与hasOwnProperty比较

hasOwnProperty() 方法用来判断某个对象是否含有指定的自身属性。

多了个自身。我的理解就是原型链上的公共属性，判断的时候会返回false。下面所有的代码都可以在线查看到。

function colour() {
  this.a = 1;
}
colour.prototype.b = function() {
  return 2;
}
var mine = new colour();
console.log("a" in mine);//true
console.log("b" in mine);//true
console.log(mine.hasOwnProperty("a"));//true
console.log(mine.hasOwnProperty("b"));//false

2）用in判断对象属性

in判断的是数组或对象的key属性。数组是一类特殊的对象，数组具有length属性，而对象没有。可参考《对象和数组 (JavaScript)》

var arr = ["a","b","c"];
console.log(0 in arr);//true
console.log(3 in arr);//false
var ob = {0:"a", 1:"b", 2:"c"};
console.log(0 in ob);//true
console.log(3 in ob);//false

上面的代码中数组的key是“0，1，2”与对象的key是一样的。

3）（delete）删除对象的属性

在使用delete后，属性判断都变成了“false”。

var arr = ["a","b","c"];
delete arr[0];
console.log(0 in arr);//false
var ob = {0:"a", 1:"b", 2:"c"};
delete ob[0];
console.log(0 in ob);//false

4）for...in循环

这里用上面示例中的对象mine。

for(property in mine) {
  console.log(property);
}

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAARgAAAAlCAIAAAAWf2EcAAABhklEQVR4nO3bMarCQBRGYdeSasqsIZ2NjYWNkBUoARvBXghYBYOl4BosxBW4ARsLi0BQhBBJLAzC5BUP7Efv8JjH+VbwN4drEuy0AL7W+esBwH9ASIAAQgIEEBIggJAAAWYhxXHseZ7neWEY5nluaRPgnE8uktZ6t9ulaSq+BnCUQUha6+12GwTB71GK49jeLMAtBiFlWTYYDI7HY9u2h8OBkIA3g5DO5/NwOMzz/Hq9TiYTQgLeDEJ6vV7L5VIp1e12F4sFIQFvvP4GBBASIICQAAGEBAjo3AF8jYsECCAkQAAhAQIICRBASIAAQgIEGIRUFEUURUVR2FsDOIqQAAFmIY1GoyRJfN/v9Xqn08neLMAtZiH1+/3NZvN8Pvf7/Ww2a5rG3jLAIR/+tLtcLuPxuCxLa8MAl3wYUpZl0+m0rmtrwwCXGD8j3W63pmnW6/VqtdJa21sGOMQgpKqqoihSSiml5vP54/GwNwtwCx9kAQGEBAggJEAAIQEC+Ks5IICLBAj4Ac7/Q7SuVAQoAAAAAElFTkSuQmCC" alt="" />

将会把上面的一个私有和公有的属性打印出来。这里注意，如果我在对象的公共父级（例如Object）中加个属性，也是会打印出来的。

Object.prototype.z = function() {
};

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAOkAAAA3CAIAAABmYfrrAAACCElEQVR4nO3dO6rqUBiGYceSQlI6BjsbQSxsBGsLJWAj2AsBm4hiJYITsLEI9oITsNDCIhC8QPCgQQyB5Sk2pzXLDYvjD+8zgq94WYRcSO4FyJT73wOAX6JdSKXbruu6lmVZltVoNMIwNLoJ0PHZuauU8n1/PB4bWgPo02pXKbVcLovF4s/R67qu6VlAJq12gyCo1Wrb7fb1em02G9rFN9Bq93A41Ov1MAxPp1On06FdfAOtdtM0HY1Gtm2XSqXBYEC7+AbcI4NUtAupaBdS0S6kyv0BZOLchVS0C6loF1LRLqSiXUhFu5BKq90oihzHiaLI9BpAH+1CKt12W63WcDgsFArlcnm/35ueBWTSbbdarc7n8+fzuVqter1ekiSmlwHvfXzNcDwe2+329Xo1PAzI8HG7QRB0u937/W54GJDhg+vdy+WSJMlsNptMJkop08uA97Tavd1ujuPYtm3bdr/fj+PY9CwgE88mIBXtQirahVS0C6n45gdSce5CKtqFVLQLqWgXUtEupKJdSEW7kIp2IZXuO5CVSuXnZxP5fN73fdOzgEyfnbvn89nzPN6BxDf4oN0kSTzP4+dq+BK67SqlFovFer02ugbQp9vubrebTqdpmhpdA+jTajeO42azaf3jOM7j8TC9DHiPe2SQinYhFe1CKtqFVHzzA6k4dyEV7UIq2oVUfwFmPrhKXN38qwAAAABJRU5ErkJggg==" alt="" />

5）巧用in操作

if (value == "a" || value == "b" || value == "c") {
     //....
}
//替换为
if (value in {"a":"", "b":"", "c":""}) {
    //....
}

参考资料：

http://www.cnblogs.com/ecalf/archive/2012/12/03/2799968.html   JavaScript对象及原型继承有关的属性

http://anykoro.sinaapp.com/2012/01/31/javascript%E4%B8%ADfunctionobjectprototypes__proto__%E7%AD%89%E6%A6%82%E5%BF%B5%E8%AF%A6%E8%A7%A3/    Javascript中Function,Object,Prototypes,__proto__等概念详解

http://rockyuse.iteye.com/blog/1426510   理解js中的原型链，prototype与__proto__的关系

http://www.cnblogs.com/snandy/archive/2012/09/01/2664134.html   JavaScript中__proto__与prototype的关系

http://www.ruanyifeng.com/blog/2011/06/designing_ideas_of_inheritance_mechanism_in_javascript.html   Javascript继承机制的设计思想

http://www.linuxfly.org/post/524/     JavaScript 的in 操作符