JavaScript数据类型和类型检测

JavaScript数据类型

JavaScript数据类型主要分为两大类：

1.基本数据类型：字符串(String)，数字(Number)，布尔(Boolean)，空(Null)，未定义(Undefined)，(Symbol)

注:Symbol 是 ES6 引入的一种新的原始数据类型，表示独一无二的值。

2.复杂数据类型 (引用数据类型)：对象(Object)

基本类型

String&Number

var x;               // x 为 undefined
var x = 1;           // x 为 number
var x = "hi";      // x 为 string

Boolean

布尔（逻辑）只能有两个值：true 或 false。

Null&Undefined

1.Undefined 表示变量声明了但是没有赋值(未初始化)。

2.可以通过将变量的值设置为 null 来清空变量。

 var person = null;
 console.log(typeof person); // "object"

引用类型

除了基本数据类型的数据其他数据都是对象（对象，函数，数组…）。

函数（Function）,数组（Array）都可以归为对象。

对象的基本信息：属性，行为（方法）

对象的类型：

1. 内置对象（原生对象）=>RegExp，Date，Math…(js语言本身预定义的对象)
2. 宿主对象

• BOM对象：History，Location，Window，Navigate，Screen
• DOM对象：Body，Style，Meta，Frame，Frameset…

常用的Math内置对象：（Math对象中的属性和方法都是静态的，可以通过构造器名称访问，无需创建对象）

Math.pow(n,m)  n的m次方
Math.sqrt  开根号
Math.abs()  取绝对值
Math.PI  
Math.random()  在[0,1）区间内取随机数
exp:取10到20之间的随机数=>parseInt(Math.random()*10)+10;
Math.cei()   向上取整
Math.floor()   向下取整
Math.round()   四舍五入

可以通过两种方式访问对象的属性

1. obj.key
2. obj[“key”]

给对象添加属性

1. obj[‘key’]=‘value’
2. obj.key=‘value’

创建对象的方式

1.字面量的方式

var obj = {
    name:"John",
    age:50,
    eyeColor:"blue",
    eat:function(){},
    sleep:function(){}
};

2.通过new object创建对象

var obj = new Object();
obj.name = "Jhon";
obj.age = 50;
obj.eat = function(){};

缺点：如果要创建多个对象，需要写很多重复代码。

3.工厂模式创建对象（用函数对第二种方式进行封装，使得相似对象的创建不需要重复代码）

function CreateObject(name,age){
    var obj = new Object();
        obj.name = "Jhon";
        obj.age = 50;
    return obj;
}

缺点：无法判断出所创建出对象的具体类型。

4.构造函数创建对象

function Person(name,age){
    this.name = name;
    this.age = age;
}
var p1 = new Person("Jhon",50);  //实例化

拓展：遍历数组的方式=>for循环 for(var i=0;i<arr.length;i++){}

       遍历对象的方式=>for...in

var Person ={
    name: "Jhon",
    age: 50
}
for(var key in Person){
    console.log(key + ":" + Person.key);
}

函数的原型

原型的作用：可以将对象所有公共的信息（属性和方法）放到原型对象中去。

如果函数和函数原型中有同名的信息，优先使用对象中的信息。

函数的原型prototype，_ proto _,以及函数本身的关系

var foo = function(){}; => Function.prototype._ proto _
				        => Object.prototype._ proto _
				        => NULL

函数本身有一个prototype属性——函数原型（对象所有公共的属性和方法，constructor=>指向函数本身）

函数对象里有一个属性_ proto _=>指向函数原型prototype

console.log(对象._proto_ === 函数.prototype)  //true
console.log(对象._proto_.constructor == 函数)  //true
console.log(函数.prototype.constructor == 函数)  //true

JavaScript数据类型检测

typeof=>string

无法判断具体的引用类型数据，如数组

检测的不管是数组还是正则都返回的是"object",所以typeof不能判断一个值是否为数组

console.log(typeof "");   //string
console.log(typeof 1);  //number
console.log(typeof true);  //boolean
console.log(typeof null);  //object
console.log(typeof undefined);  //undefined
console.log(typeof []);   //object
console.log(typeof function(){});   //function
console.log(typeof {});   //object

instanceof=>boolean

能够判断具体的引用类型（不能用于判断null和undefined）

基本数据类型的值是不能用instanceof来检测的

console.log("1" instanceof String);   //flase
console.log(new String("1") instanceof String);  //true
console.log(1 instanceof Number);   //false
console.log(new Number(1) instanceof Number); //true
console.log(true instanceof Boolean);   //false
console.log(new Boolean(true) instanceof Boolean); //true
console.log([] instanceof Array);  //true
console.log(function(){} instanceof Function);  //true
console.log({} instanceof Object);  //true

constructor

console.log(("1").constructor === String);  //true
console.log((1).constructor === Number);   //true
console.log((true).constructor === Boolean);    //true
console.log(([]).constructor === Array);    //true
console.log((function() {}).constructor === Function);    //true
console.log(({}).constructor === Object);    //true

constructor不适用情况

function Fn(){};

Fn.prototype=new Array();   //函数的原型指向数组

var f=new Fn();   //实例化

console.log(f.constructor===Fn);   //false
console.log(f.constructor===Array);   //true

Object.prototype.toString.call()

var a = Object.prototype.toString;

console.log(a.call("aaa"));    //[object String]
console.log(a.call(1));        //[object Number]
console.log(a.call(true));       //[object Boolean]
console.log(a.call(null));       //[object Null]
console.log(a.call(undefined));   //[object Undefined]
console.log(a.call([]));         //[object Array]
console.log(a.call(function() {}));    //[object Function]
console.log(a.call({}));     //[object Object]

isNaN,isBoolean…

console.log(isObject({}));     //true
console.log(isDate(new Date()));    //true
console.log(isBoolean(false));   //true
console.log(isString(1));     //false
console.log(isError(1));      //false
console.log(isError(new Error()));   //true
console.log(isArray([]));     //true
console.log(isArray(1));  //false