JavaScript数据类型和类型检测

JavaScript数据类型

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

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

注:Symbol 是 ES6 引入的一种新的原始数据类型，表示独一无二的值，在此不作详细详情。

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

基本类型

String&Number

var x;               // x 为 undefinedvar x = 1;           // x 为 numbervar 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)  //trueconsole.log(对象._proto_.constructor == 函数)  //trueconsole.log(函数.prototype.constructor == 函数)  //true

JavaScript数据类型检测

typeof=>string

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

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

console.log(typeof "");   //stringconsole.log(typeof 1);  //numberconsole.log(typeof true);  //booleanconsole.log(typeof null);  //objectconsole.log(typeof undefined);  //undefinedconsole.log(typeof []);   //objectconsole.log(typeof function(){});   //functionconsole.log(typeof {});   //object

instanceof=>boolean

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

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

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

constructor

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

constructor不适用情况

function Fn(){};Fn.prototype=new Array();   //函数的原型指向数组var f=new Fn();   //实例化console.log(f.constructor===Fn);   //falseconsole.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({}));     //trueconsole.log(isDate(new Date()));    //trueconsole.log(isBoolean(false));   //trueconsole.log(isString(1));     //falseconsole.log(isError(1));      //falseconsole.log(isError(new Error()));   //trueconsole.log(isArray([]));     //trueconsole.log(isArray(1));  //false