JavaScript之数据类型

JavaScript有哪些数据类型

共有八种数据类型：undefined、null、boolean、string、number、object、symbol、bigint

简单数据类型

又称为原始数据类型，直接存储在栈（stack）中的简单数据段，占据空间小、大小固定、属于被频繁使用的数据

string——字符串

由一系列的字符构成的数据，对某个东西进行描述。在使用字符串类型数据的使用，需要使用双引号：""或单引号：'',一单一双或者不加引号都会报错。

字符串有length属性，可以使用length方法获取自身长度

number——数字

用来表示数字的 ，任何数字都可以使用数值类型。比如商品价格、年份、年龄等，包含整数和浮点数（数值必须包含一个小数点，且小数点后面至少有一位数字,需要大于0）两种值以及特殊的非数字类型NaN

var n = NaN;
var a = 1; 
// NaN表示一个本来要返回数字，但是由于某种原因，没有返回成功，就用NaN表示。
console.log(typeof(n));    // NaN
// NaN与任何值都不等，包括其本身; 
console.log(n == NaN)    // NaN 
// NaN与其他任意值进行运算，都为NaN；
console.log(n + a);    // NaN

isNaN()函数用于检查其参数是否是’非数字值’，如果是数值返回false，如果是非数值返回true

var a = 1; 
var b = '我是字符串';
console.log(isNaN(a));    // false
console.log(isNaN(b));    // true 

boolean——布尔值

该类型只有两个值：true和false，一般会在条件判断和循环等语句中来使用。

null——空值

null类型被看做空对象指针，null类型也是空的对象引用，当将来需要存储一个对象的时候，可以给其初始值赋为null。

// 初始赋值
var name = null,
    obj = null
// 赋值
name = '张三'
obj = {
    'key'：'value'
}

undefined——未定义

如果一个变量通过var声明了，但是没有赋值，那么它的值就是undefined，表示变量在声明的时候没有初始值。

var name;
console.log(name);    // undefined 
// undefined 的数据类型是 ‘undefined’； 
console.log(typeof name);    // undefined 

symbol——独一无二的值

创建后独一无二且不可变的数据类型，主要是为了解决可能出现的全局变量冲突问题

bigint——大数

因为js中的Number.MAX_SAFE_INTEGER表示最大安全数字，在数值范围内整数不会出现精度丢失，但是一旦超过这个范围，就会出现计算不准确的情况，这种时候就不得不依赖一些第三方库进行解决，因此官方提出bigint解决此问题。

复杂数据类型

又称为引用数据类型，存储在堆（heap）中的对象，占据空间大，大小不固定。通过存储在栈中的指向堆中实体地址的指针获取使用

数组、对象、函数，本质上都是object。

// 创建方式
// 对象字面量方式定义：
var a = {
    name:"张三", 
    age:18, 
    sex:'男'
}
// 构造函数的方式定义：
var b = new Object();
b.name = '李四';
b.age = 28;
b.sex = '女'
console.log(b);    // {name:"兔子",m:"吃草",age:14}

// 通过点语法和[中括号语法]获取对象里面的数据
console.log(a.age);
console.log(b['name']);;

类型转换

JavaScript 是弱类型语言，而且JavaScript声明变量的时候并没有预先确定的类型，变量的类型就是其值的类型，也就是说变量当前的类型由其值所决定,在进行加减乘除等操作运算中可能就发生了强制类型转换。虽然弱类型的这种不需要预先确定类型的特性给我们带来了便利，同时也会给我们带来困扰。

Boolean()：可以将任意类型的数据转为布尔类型

// 等于false有且仅有：null、0、’‘、undefined、NaN
console.log(Boolean(null));     // false
console.log(Boolean(0));     // false
console.log(Boolean(''));     // false
console.log(Boolean(undefined));     // false
console.log(Boolean(NaN));     // false
// 其余统一为true
console.log(Boolean(123));//ture
console.log(Boolean(’123‘));//ture
console.log(Boolean({}));//ture
console.log(Boolean([]));//ture

String():可以将任意类型的数据转为字符型

// 数字
var a = 123;
console.log(typeof(a));    // number
console.log(typeof(String(a)));    // string

// NaN
var b = NaN;
console.log(typeof(b));    // number
console.log(typeof(String(b)));     // string

// null
var c = null;
console.log(typeof(c));     // objcet
console.log(typeof(String(c)));     // string

// 未定义类型的
var d = undefined;
console.log(typeof(d));     // undefined
console.log(typeof(String(d)));     // string

// 布尔值
var e = true;
console.log(typeof(e));     // Boolean
console.log(typeof(String(e)));     // string

// toString():除了null和undefined之外的数据都可用toString转换
var num = 123 ;
num.toString()     // '123';
var str = true;
str.toString();    // 'ture';

// 隐式转换
console.log(123 + '');    // '123'
console.log(null + '');    // 'null'
console.log('' + undefined);    // 'undefined'

Number();可以将任意类型数据转为数值型

// null 转 number:  结果为 0  
console.log(Number(null))    // 0

// Undefined转number:结果为NaN
console.log(Number(undefined))     // NaN
var a;
console.log(Number(a))    // NaN

// 布尔 转 number 结果:true = 1,false = 0
console.log(Number(true))     // 1
console.log(Number(false))     // 0

// 空字符串 转 number 结果为 0
console.log(Number(' '))     // 0

// 非空字符串 转 number ,如果字符串里 的内容全部是有效数字，那么就转成对应的有效数字，否则，转number后就是NaN.数字前面有零的就默认隐藏0
console.log(Number('123'));     // 123
console.log(Number('12.34'));     // 12.34
console.log(Number('12.31.54'));     // NaN
console.log(Number('123nx'));     // NaN
console.log(Number('你好'));     // NaN
console.log(Number('012138'));     // 12138

JavaScript数据类型检测

typeof

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

其中数组、对象、null都会返回object

instanceof

instanceof只能正确判断引用数据类型，不能判断基本数据类型，原理是判断能否在变量原型链中找到该类型的原型，可以用来测试一个对象在其原型链中是否存在一个构造函数的prototype属性。

console.log(2 instanceof Number);                           // false
console.log(true instanceof Boolean);                       // false
console.log('str' instanceof String);                       // false
console.log(undefined instanceof undefined);                // 报错
console.log(null instanceof Object);                        // false
console.log({} instanceof Object);                          // true
console.log([] instanceof Object);                          // true
console.log(function(){} instanceof Function);              // true

constructor

constructor有两个作用，判断数据类型和实例对象通过constructor访问构造函数，但是如果创建一个对象改变它的原型，判断就不再准确

console.log((2).constructor === Number);                    // true
console.log(true.constructor === Boolean);                  // true
console.log('str'.constructor === String);                  // true
console.log({}.constructor === Object);                     // true  
console.log([].constructor === Array);                      // true
console.log((function(){}).constructor === Function);       // true
// 改变原型之后
function fn(){}
fn.prototype = new Array()
let f = new fn()
console.log(f.constructor === Function);                    // false
console.log(f.constructor === Array);                       // true

Object.prototype.toString

Object.prototype.toString.call()使用Object对象的原型方法toString来判断数据类型

let to = Object.prototype.toString
console.log(to.call(2));                // [object Number]
console.log(to.call(true));             // [object Boolean]
console.log(to.call('str'));            // [object String]
console.log(to.call(undefined));        // [object Undefined]
console.log(to.call(null));             // [object Null]
console.log(to.call([]));               // [object Array]
console.log(to.call({}));               // [object Object]
console.log(to.call(function(){}));     // [object Function]

判断

Object.is()与比较操作符’==‘、’===‘的区别

双等号（==）进行相等判断时，如果两边的类型不一致，则会进行强制类型转换后比较

console.log(2 == '2');          // true
console.log(0 == false);        // true
console.log('1' == true);       // true
console.log(NaN == NaN);        // false
console.log(-0 == +0);          // true
console.log(null == null);      // true

三等号（===）进行判断不会做强制类型转换

console.log(2 === '2');          // false
console.log(0 === false);        // false
console.log('1' === true);       // false
console.log(NaN === NaN);        // false
console.log(-0 === +0);          // true
console.log(null === null);      // true

Object.is()一般情况下与三等号相同，但也处理了一些特殊情况

console.log(Object.is(2,'2'));          // false
console.log(Object.is(0,false));        // false
console.log(Object.is('1',true));       // false
console.log(Object.is(NaN,NaN));        // true
console.log(Object.is(-0,+0));          // false
console.log(Object.is(null,null));      // true

如何判断一个空对象

// 使用JSON自带的stringify方法判断
if(JSON.stringify(obj) == '{}'){
    console.log('这是一个空对象');
}
// 使用ES6新增的方法object.keys()判断
if(Object.keys(obj).length < 1){
    console.log('这是一个空对象');
}