JavaScript 是一种弱类型或者说动态语言。这意味着你不用提前声明变量的类型，在程序运行过程中，类型会被自动确定。
这也意味着你可以使用同一个变量保存不同类型的数据。
最新的 ECMAScript 标准定义了 7 种数据类型：
7种内置类型：Boolean、Null、Undefined、Number、String、Symbol (ECMAScript 6 新定义)和Object，除 Object 以外的所有类型都是不可变的（值本身无法被改变）。
typeof操作符返回一个字符串,表示未经求值的操作数(unevaluated operand)的类型。查看在线代码：
37 === ‘number‘ 3.14 === ‘number‘ Math.LN2 === ‘number‘ Infinity === ‘number‘ NaN === ‘number‘; Number(1) === ‘number‘; "" === ‘string‘ "bla" === ‘string‘ ( 1) === ‘string‘; String("abc") === ‘string‘; === ‘boolean‘ === ‘boolean‘ Boolean() === ‘boolean‘; Symbol() === ‘symbol‘ Symbol(‘foo‘) === ‘symbol‘ Symbol.iterator === ‘symbol‘ undefined === ‘undefined‘ blabla === ‘undefined‘; {a:1} === ‘object‘ [1, 2, 4] === ‘object‘ Date() === ‘object‘ Boolean() === ‘object‘ Number(1) === ‘object‘ String("abc") === ‘object‘ === ‘object‘ /s/ === ‘object‘; /s/ === ‘object‘; (){} === ‘function‘ Math.sin === ‘function‘ /s/ === ‘function‘;
undefined（未赋值）和undeclared（未声明）是有区别的。
检查全局变量的是否声明的安全防范机制：
typeof DEBUG == "undefined"//或window.DEBUG
可以通过使用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);//不同 一个未定义的变量会报错// ObjectstoString.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 运算符可以用来判断某个构造函数的 prototype 属性是否存在另外一个要检测对象的原型链上，返回boolean值。语法如下：
也就比对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：某个构造函数。查看在线代码：
1 // 定义构造函数 2 function C(){}
3 function D(){}
4 5 var o = new C(); 6 o instanceof C; // true，因为 Object.getPrototypeOf(o) === C.prototype 7 //o.__proto__={}; //改变o原型链，o instanceof C将会返回false 8 o instanceof D; // false，因为 D.prototype不在o的原型链上 9 o instanceof Object; // true,因为Object.prototype.isPrototypeOf(o)返回true10 C.prototype instanceof Object // true,同上11 12 C.prototype = {};13 var o2 = new C();14 o2 instanceof C; // true15 o instanceof C; // false,C.prototype指向了一个空对象,这个空对象不在o的原型链上.16 17 D.prototype = new C(); // 继承18 var o3 = new D();19 o3 instanceof D; // true20 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)); // trueconsole.log(socrates instanceof human); // falseconsole.log(socrates.__proto__ == human.prototype);//falseconsole.log(socrates.__proto__ == human);//true上面的Object.create()传递的是human函数，“socrates.__proto__ == human.prototype”不相等，
也就是说human.prototype不在socrates的原型链上，所以instanceof返回的是false。
isPrototypeOf() 是指测试一个对象是否存在于另一个对象的原型链上；现在human这个对象在socrates的原型链上。
constructor返回一个指向创建了该对象原型的函数引用。
需要注意的是，该属性的值是那个函数本身，而不是一个包含函数名称的字符串。对于原始值（如1，true 或 "test"），该属性为只读。
所有对象都会从它的原型上继承一个 constructor 属性。查看在线代码。
1、在JavaScript的继承中，instanceof和constructor表现的是不一样的：
function C(){}
function D(){}
D.prototype = new C(); // 继承var o = new D();
o instanceof D; // trueo instanceof C; // trueo.constructor == D; // falseo.constructor == C; // trueo.constructor == D.prototype.constructor;//trueo.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”的打印结果：
in操作，如果指定的属性在指定的对象中会返回true,语法如下:
1）与hasOwnProperty比较
hasOwnProperty() 方法用来判断某个对象是否含有指定的自身属性。
多了个自身。我的理解就是原型链上的公共属性，判断的时候会返回false。下面所有的代码都可以在线查看到。
function colour() { this.a = 1;
}
colour.prototype.b = function() { return 2;
}var mine = new colour();
console.log("a" in mine);//trueconsole.log("b" in mine);//trueconsole.log(mine.hasOwnProperty("a"));//trueconsole.log(mine.hasOwnProperty("b"));//false
2）用in判断对象属性
in判断的是数组或对象的key属性。数组是一类特殊的对象，数组具有length属性，而对象没有。可参考《对象和数组 (JavaScript)》
var arr = ["a","b","c"];
console.log(0 in arr);//trueconsole.log(3 in arr);//falsevar ob = {0:"a", 1:"b", 2:"c"};
console.log(0 in ob);//trueconsole.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);//falsevar 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);
}将会把上面的一个私有和公有的属性打印出来。这里注意，如果我在对象的公共父级（例如Object）中加个属性，也是会打印出来的。
Object.prototype.z = function() {
};
5）巧用in操作
if (value == "a" || value == "b" || value == "c") { //....}//替换为if (value in {"a":"", "b":"", "c":""}) { //....}
JavaScript中typeof、toString、instanceof、constructor与in
原文地址：http://kiujyhgt.blog.51cto.com/12806908/1916735
