js是一门弱语言，它在声明变量时无需确定变量的类型，js在运行时会自动判断。那么如何判断一个变量的类型呢，js提供了typeof运算符，用来检测一个变量的类型。

    typeof是一个运算符，有2种使用方式：typeof(表达式)和typeof 变量名，第一种是对表达式做运算，第二种是对变量做运算。

    typeof运算符的返回类型为字符串，值包括如下几种：

        1. 'undefined'              --未定义的变量或值

        2. 'boolean'                 --布尔类型的变量或值

        3. 'string'                     --字符串类型的变量或值

        4. 'number'                  --数字类型的变量或值

        5. 'object'                    --对象类型的变量或值，或者null(这个是js历史遗留问题，将null作为object类型处理)

        6. 'function'                 --函数类型的变量或值

    console.log(typeof a)    //'undefined'

    console.log(typeof(true))  //'boolean'

    console.log(typeof '123')  //'string'

    console.log(typeof 123)   //'number'

    console.log(typeof NaN)   //'number'

    console.log(typeof null)  //'object'    

    var obj = new String()

    console.log(typeof(obj))    //'object'

    var  fn = function(){}

    console.log(typeof(fn))  //'function'

    console.log(typeof(class c{}))  //'function'

        总结：typeof运算符用于判断对象的类型，但是对于一些创建的对象，它们都会返回'object'，有时我们需要判断该实例是否为某个对象的实例，那么这个时候需要用到instanceof运算符，后续记录instanceof运算符的相关用法。

由于js为弱类型语言拥有动态类型，这意味着相同的变量可用作不同的类型。

js 的七种数据类型，分别为：Number  Array Boolean String  Object  unll    undefine。

typeof 返回类型与以上依次对应为 number  object boolean string  object  object  undefine，其中还有一种返回类型为function。

在javascript中经常会用到数组,如:多个名字相同的checkbox, 若是动态生成的, 提交时就需要判断其是否是数组。

正确的是 if( typeof(document.mylist.length) != "undefined" ) { } 或 if( !isNaN(document.mylist.length) ) { }   typeof的运算数未定义,返回的就是 "undefined"。

运算数为数字 typeof(x) = "number" 字符串 typeof(x) = "string"  布尔值 typeof(x) = "boolean"  对象,数组和null typeof(x) = "object"    函数 typeof(x) = "function"    typeof 运算符返回一个用来表示表达式的数据类型的字符串。可能的字符串有："number"、"string"、"boolean"、"object"、"function" 和 "undefined"。

如：    alert(typeof (123))//typeof(123)返回"number"alert(typeof ("123"))//typeof("123")返回"string"typeof 运算符返回一个用来表示表达式的数据类型的字符串。  

typeof[()expression[ ] expression 参数是需要查找类型信息的任意表达式。说明typeof 运算符把类型信息当作字符串返回。typeof 返回值有六种可能： "number" 。"string"， "boolean"， "object"， "function“， 和 "undefined"。typeof 语法中的圆括号是可选项。

如何判断js中的数据类型：typeof、instanceof、 constructor、 prototype方法比较

如何判断js中的类型呢，先举几个例子：

var a = "iamstring."

var b = 222

var c= [1,2,3]

var d = new Date()

var e = function(){alert(111)}

var f = function(){this.name="22"}

最常见的判断方法：typeof

alert(typeof a) ------------>string

alert(typeof b) ------------>number

alert(typeof c) ------------>object

alert(typeof d) ------------>object

alert(typeof e) ------------>function

alert(typeof f) ------------>function

其中typeof返回的类型都是字符串形式，需注意，例如：

alert(typeof a == "string") ------------->true

alert(typeof a == String) --------------->false

另外typeof 可以判断function的类型；在判断除Object类型的对象时比较方便。

判断已知对象类型的方法： instanceof

alert(c instanceof Array) --------------->true

alert(d instanceof Date)

alert(f instanceof Function) ------------>true

alert(f instanceof function) ------------>false

注意：instanceof 后面一定要是对象类型，并且大小写不能错，该方法适合一些条件选择或分支。

根据对象的constructor判断： constructor

alert(c.constructor === Array) ---------->true

alert(d.constructor === Date) ----------->true

alert(e.constructor === Function) ------->true

注意： constructor 在类继承时会出错

eg,

function A(){}

function B(){}

A.prototype = new B()//A继承自B

var aObj = new A()

alert(aobj.constructor === B) ----------->true

alert(aobj.constructor === A) ----------->false

而instanceof方法不会出现该问题，对象直接继承和间接继承的都会报true：

alert(aobj instanceof B) ---------------->true

alert(aobj instanceof B) ---------------->true

言归正传，解决construtor的问题通常是让对象的constructor手动指向自己：

aobj.constructor = A//将自己的类赋值给对象的constructor属性

alert(aobj.constructor === A) ----------->true

alert(aobj.constructor === B) ----------->false//基类不会报true了

通用但很繁琐的方法： prototype

alert(Object.prototype.toString.call(a) === ‘[object String]’) ------->true

alert(Object.prototype.toString.call(b) === ‘[object Number]’) ------->true

alert(Object.prototype.toString.call(c) === ‘[object Array]’) ------->true

alert(Object.prototype.toString.call(d) === ‘[object Date]’) ------->true

alert(Object.prototype.toString.call(e) === ‘[object Function]’) ------->true

alert(Object.prototype.toString.call(f) === ‘[object Function]’) ------->true

大小写不能写错，比较麻烦，但胜在通用。

通常情况下用typeof 判断就可以了，遇到预知Object类型的情况可以选用instanceof或constructor方法，简单总结下，挖个坑，欢迎补充！

---