JavaScript 数据类型与类型判断详解

1、JavaScript 数据类型

JavaScript 数据类型有两种，分别是基本数据类型和引用数据类型。

• 基本数据类型

  • Number
  • String
  • Boolean
  • Undefined
  • Null
  • Symbol (ES6 新增，表示独一无二的值)

• 引用数据类型

  • Object
  • Function
  • Array

咱们来详细了解一下这两种数据类型的特色

1.基本数据类型

值不可变

基本类型的值是不可变的

var name = 'javascript';
name.toUpperCase(); //  'JAVASCRIPT'
console.log(name); //  'javascript'

可是咱们不是常常有 ++a 这种操做吗？好比

let a = 1
console.log(++a) // '2'

其实这个时候并非 a 指向的 1 直接加了 1，而是 新建了一个 1+1 = 2 的值，再将 a 指向这个新建出来的 2，原来的那个 1 并无发生改变，留由垃圾回收机制处理。也就是说不是 a 指向的值发生了改变，而是 a 变量指针指向了一个新的值，这和「基本类型的值是不可变的」这句话并不矛盾。

数据存放在栈区

原始数据类型直接存储在栈(stack)中的简单数据段，占据空间小、大小固定，属于被频繁使用数据，因此放入栈中存储。

2.引用数据类型

值是可变的

let a = { age : 20 }；
a.age = 21；
console.log(a.age)    //21

同时保存在栈内存和堆内存

引用数据类型占据空间大，大小不固定，储存在堆内存，可是指向该引用数据类型的变量指针「a」是储存在栈内存中。当解释器寻找引用值时，会首先检索其在栈中的地址，取得地址后从堆中得到实体。

2、数据的赋值

基本数据类型的赋值为复制了一个新的值，对新变量的修改不会影响原变量

let a = 1;
let b = a;
b++
console.log(a)   // 1
console.log(b)   // 2

在内存中的变化如图：

可是引用数据类型就不同，由于引用数据内型占用空间大，因此赋值操做是将新变量指针指向了原对象，修改其一都会影响到另外一个。

let a={id=1234}
let b=a
b.id=1222
console.log(a.id) // 1222
console.log(b.id) // 1222

在内存中的变化如图：

关于引用对象的拷贝又分为深拷贝和浅拷贝，限于篇幅就留给下篇文章了

3、检验数据类型

typeof

这应该初学者首次接触的类型判断方法了，它返回一个表示数据类型的字符串，返回结果包括：

• number
• boolean
• string
• symbol
• object
• undefined
• function

可是不能判断 array 和 null

typeof Symbol();  
// symbol  正确
typeof '';   
// string 正确
typeof 1;     
// number正确
typeof true;    
//boolean 正确
typeof undefined; 
//undefined 正确
typeof new Function(); 
// function 正确
typeof null; 
//object 无效
typeof [] ;
//object 无效
typeof new Date(); 
//object 无效
typeof new RegExp(); 
//object 无效

typeof 缺点

能够看到 Date 和 RegExp 对象都只是被是被成了 object 对象，也就是说除 function 之外的对象都会被识别成 object ，这样显然是不合理的，这时就须要 instanceof 来进行判断。

instanceof

instanceof 运算符用于检测构造函数的 prototype 属性是否出如今某个实例对象的原型链上。 简单来讲就是 instanceof 是用来判断 A 是否为 B 的实例，表达式为

A (object) instanceof B (constructor)

若是A是B的实例，则返回true,不然返回 false。

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

var o = new C();


o instanceof C; // true，由于 Object.getPrototypeOf(o) === C.prototype


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 由于 C.prototype 如今在 o3 的原型链上

如今就能够判断不一样类别的对象了

[] instanceof Array; //true
{} instanceof Object;//true
new Date() instanceof Date;//true
new RegExp() instanceof RegExp//true

instanceof 的缺点

1.是否处于原型链上的判断方法不严谨

instanceof 方法判断的是是否处于原型链上，而不是是否是处于原型链最后一位，因此会出现下面这种状况：

var arr = [1, 2, 3];
console.log(arr instanceof Array) // true
console.log(arr instanceof Object);  // true
function fn(){}
console.log(fn instanceof Function)// true
console.log(fn instanceof Object)// true

由于全部原型链的尽头都是 object，因此就形成了这种情况。当你自定义了一个类A，而且继承了一个原生类B，这个时候检测结果未必准确：

A instanceof A // true
A instanceof B // true
A instanceof Object true

2.没法判断字面量方式建立的基本数据类型

对于基本数据类型来讲，字面量方式建立出来的结果和实例方式建立的是有必定区别的

console.log(1 instanceof Number)//false
console.log(new Number(1) instanceof Number)//true

从严格意义上来说，只有实例建立出来的结果才是标准的对象数据类型值，也是标准的Number这个类的一个实例；对于字面量方式建立出来的结果是基本的数据类型值，不是严谨的实例，可是因为JS的松散特色，致使了可使用Number.prototype上提供的方法。

3. 没法检测 null 和 undefined

对于特殊的数据类型null和undefined，他们的所属类是Null和Undefined，可是浏览器把这两个类保护起来了，不容许咱们在外面访问使用。

constructor

constructor 做用和 instanceof 很是类似。但 constructor 检测 Object 与 instanceof 不同，还能够处理基本数据类型的检测。

var aa=[1,2];
console.log(aa.constructor===Array);//true
console.log(aa.constructor===RegExp);//false
console.log((1).constructor===Number);//true
var reg=/^$/;
console.log(reg.constructor===RegExp);//true
console.log(reg.constructor===Object);//false

constructor的缺点

1.没法检测 null 和 undefined

null 和 undefined 是无效的对象，所以是不会有 constructor 存在的，这两种类型的数据须要经过其余方式来判断。

2.不稳定

函数的 constructor 是不稳定的，这个主要体如今把类的原型进行重写，在重写的过程当中颇有可能出现把以前的 constructor 给覆盖了，这样检测出来的结果就是不许确的，由此可知 instanceof 一样也存在这个问题。

function Fn(){}
Fn.prototype = new Array()
var f = new Fn
console.log(f.constructor)//Array

Object.prototype.toString.call()

这就是大名鼎鼎的全能方法，最准确最经常使用，据 MDN 描述

每一个对象都有一个 toString() 方法，当该对象被表示为一个文本值时，或者一个对象以预期的字符串方式引用时自动调用。默认状况下，toString() 方法被每一个 Object 对象继承。若是此方法在自定义对象中未被覆盖，toString() 返回 "[object type]"，其中 type 是对象的类型。

在 Number、String，Boolean，Array，RegExp、Date、Function 等对象上 toString() 方法都是被重写过了的，会按照必定的规则返回字符串。可是在 object 对象上，这个方式是返回当前方法执行的主体（方法中的this）所属类的详细信息即"[object Object]",其中第一个object表明当前实例是对象数据类型的(这个是固定的 onject)，第二个Object表明的是this所属的类型。

为了每一个对象都能经过 Object.prototype.toString() 来检测，须要以 Function.prototype.call() 或者 Function.prototype.apply() 的形式来调用，传递要检查的对象做为第一个参数，称为 thisArg。

Object.prototype.toString.call('') ;   // [object String]
Object.prototype.toString.call(1) ;    // [object Number]
Object.prototype.toString.call(true) ; // [object Boolean]
Object.prototype.toString.call(undefined) ; // [object Undefined]
Object.prototype.toString.call(null) ; // [object Null]
Object.prototype.toString.call(new Function()) ; // [object Function]
Object.prototype.toString.call(new Date()) ; // [object Date]
Object.prototype.toString.call([]) ; // [object Array]
Object.prototype.toString.call(new RegExp()) ; // [object RegExp]
Object.prototype.toString.call(new Error()) ; // [object Error]
Object.prototype.toString.call(document) ; // [object HTMLDocument]
Object.prototype.toString.call(window) ; //[object global] window是全局对象global的引用

总结

判断方法	缺点
typeof	不能判断 null 和区分 array/Date/RegExp 等
instanceof	没法检测 null 和 undefined，未必准确，没法判断字面量方式建立的基本数据类型
constructor	没法检测 null 和 undefined，未必准确
Object.prototype.toString.call()	无

参考文章

• JavaScript的数据类型及其检测
• Object.prototype.toString()--MDN
• instanceof---MDN
• [[ JS 进阶 ] 基本类型 引用类型 简单赋值 对象引用](https://segmentfault.com/a/11...
• JS判断数据类型的三种方法