JavaScript数据类型

JS数据类型总结

JavaScript有7种原始数据类型

• 1.String: 任意字符串
• 2.Number: 任意的数字
• 3.Boolean: true/false
• 4.Undefined: undefined
• 5.Null: null
• 6.Object: 任意对象
• 7.Symbol(ES6新增): 独一无二的值

1. 基本数据类型：Undefined、Null、Boolean、Number、String、Symbol（新增）

   （1）基本数据类型保存在栈内存中，是按值传递的，因为可以直接操作保存在变量中的实际值；

   （2）引用数据类型是保存在堆内存中的对象；与其他语言不同的是，JavaScript没有按引用传递，而是传递引用类型的参数（是按值传递，按引用访问），你不可以直接访问堆内存空间中的位置和操作堆内存空间，只能操作对象在栈内存中的引用地址；

   （3）typeof操作符适合确定除Null以外的简单数据类型；

   // javascript
       var a = "zzwi";
       var b = 123;
       var c = true;
       var d = null;
       var e = new Object();
   
       console.log(typeof a); // string
       console.log(typeof b); // number
       console.log(typeof c); // boolean
       console.log(typeof d); // object
       console.log(typeof e); // object
   

   （4）instanceof 操作符可以用来判断new 出来的基本数据类型；

   // javascript
       var a = "zzwi";
   
       var f = new String("zzwi");
       console.log(f instanceof String); // true
       console.log(a instanceof String); // false
   

2. 引用数据类型：Object、Array、Function、Date、RegExp、基本包装类型、单体内置对象（特殊引用类型）；

   （1）引用类型是一种数据结构，用以将数据和功能组合在一起；

   （2）使用 new 创建的均为 Object 类型，所有引用类型默认都继承自 Object ；

   （3）使用 typeof 操作符无法有效区分引用类型，只能知道他是对象，而不能知道是什么类型的对象，此时使用 instanceof 操作符；

   // javascript
       var g = new Object();
       var h = new Array();
       var i = new RegExp();
       console.log(g instanceof Object); // true
       console.log(h instanceof Object); // true
       console.log(i instanceof Object); // true
   
       console.log(h instanceof Array); // true
       console.log(i instanceof RegExp); // true
   

3. 基本包装类型：Boolean、Number、String；

   （1）基本包装类型首先是基本类型，同时也是特殊引用类型；

   （2）自动创建的基本包装类型的对象，只存在于一行代码执行瞬间，而使用 new 运算符创建的引用类型的实例，在执行流离开当前作用域之前一直保存在内存中；

   PS：typeof 检测函数返回"function";

   Safair 5 及 Chrome 7 之前，typeof检测正则表达式返回"function";

   ECMA-262规定：内部实现 [[call]] 方法的对象都应该在typeof 操作符时候返回“function”！

   IE 与 Firefox 中，typeof 检测正则表达式返回"object";

Undefined类型

在声明变量但未对其加以初始化时，这个变量的值就是undefined。也就是说undefined是变量的默认值。

// javascript
let j;
console.log(j); // undefined

对未初始化和未声明的变量执行typeof操作符（检测变量数据类型）返回的值都是undefined。所以建议定义（声明）变量时要自己初始化一下，这样当typeof操作符返回的值为undefined时，我们就可以清楚的知道该值没有定义（声明）。

Null类型

null值表示一个空对象指针。

• 由于null是一个空对象指针，所以（typeof null）的返回值是"object"
• 由于undefined值派生于null值，所以（undefined==null）返回的是true
• 只要意在保存对象的变量还没真正保存对象，就应该明确的让该变量保存null值

Boolean类型

该类型只有两个字面值true和false。

true和false是区分大小写的，所以True和False以及其它混合大小写形式都不是Boolean值，只是标识符。

可以对任何数据类型的值调用Boolean()函数，而且总会返回一个Boolean值。至于返回的这个值是true还是false，取决于要转换值的数据类型及其实际值。下表给出了各种数据类型及其对应的转换规则。

数据类型	转换为true的值	转换为false的值
Boolean	true	false
String	任何非空字符串	“”(空字符串)
Number	任何非零数字值(包括无穷大)	0和NAN
Object	任何对象	null
Undefined	/	undefined

Number类型

该类型表示整数和浮点数值。

最基本的数值字面量格式是十进制整数，如果要表示八进制的话，第一位必须是0，后跟八进制序列（0_{7）。如果要表示十六进制的话，前两位必须是0x，后跟十六进制数字（0}9和A~F）。

• 八进制字面量在严格模式下是无效的。
• 如果八进制字面值中的数据超出了范围，则前面的零会被忽略，后面的数字当做十进制处理。
• 在进行算术计算时，八进制和十六进制最终都会被转换成十进制进行计算。

// javascript
    const k = 0x86; // 16进制
    const l = 076; // 8进制
    const m = 088;
    console.log(k); // 134
    console.log(l); // 62
    console.log(l+1); // 自动转成十进制进行数值运算 63
    console.log(m); // 超出八进制范围则忽略前导零 88

1. 浮点数值

浮点数值就是该数值中必须包含一个小数点，并且小数点后至少有一位数字，最高精度是17位小数。例如2. ,或者浮点型本身就是一个整数，例如：2.0，都会被自动转换成整数。

极大和极小的数值，可以用科学计数法表示的浮点数值表示。

在默认情况下，ECMAScript会将那些小数点后面带有6个零以上的浮点数值转换成以科学计数法表示的数值。

// javascript
    const n = 8.625e7; // 科学计数法
    console.log(n); // 86250000    const n = 8.625e7; // 科学计数法
    const o = 0.0000003;
    console.log(n); // 86250000
    console.log(o); // 3e-7

同时，浮点计算存在精度问题，例如0.1+0.2==0.3的判断结果为false。

2）数值范围

在JavaScript中Number类型实质是一个64位的浮点数，这与Java中double类型的浮点数是一致的。

JavaScript所能表示的两个边界值分别可以通过访问Number对象的MAX_VALUE属性和MIN_VALUE属性来获取。

// javascript
    console.log(Number.MAX_VALUE); // 1.7976931348623157e+308
    console.log(Number.MIN_VALUE); // 5e-324

对于整数，JavaScript能表示并进行精确算术运算的整数范围为：正负2的53次方；对于超过这个范围的整数，JavaScript依旧可以进行运算，但却不保证运算结果的精度。

实验：

// javascript
    const p = 2e53;
    console.log(p); // 2e+53
    console.log(p+2); // 2e+53

对于位运算，JavaScript仅支持32位整数

// javascript
    const q = 256;
    const r = 2200000000;
    console.log(q / 2); // 128
    console.log(q >> 1); // 128
    console.log(r / 2); // 1100000000
    console.log(r >> 1); // -1047483648

可以看到，对于32位以内的整数(256)，JavaScript可以进行正确的位运算，所得结果与除法运算的结果一致(128)。而对于32位以外的整数，JavaScript可以进行正确的除法运算(1100000000)，但进行位运算后所得结果却与正确结果相去甚远(-1047483648)。

3）NaN

NaN，即非数值（Not a Number），是一个特殊的数值，这个数值用于表示一个本来要返回数值的操作数未返回数值的情况。

NaN有两个特点：

• 任何与NaN相关的操作都会返回NaN
• NaN与任何的值都不相等，包括NaN本身。

isNaN()函数：

• 作用：可以接收一个参数，来确定该参数是否“不是数值”。不是数值就会返回true，是数值就会返回false。
• 流程：当其接收一个参数后，会尝试把这个参数转换为数值，某些不是数值的值也会转换为数值，任何不能被转换为数值的值都会导致这个函数返回true
• 该函数也适用于对象，但是在对象调用该函数的时候，会先调用该对象的valueOf()函数，然后确定该方法的返回值是否可以转为数值，如果不可以，则基于这个返回值再调用toString()方法，再次测试返回值。

实验

// javascript
    console.log(NaN === NaN); // false
    console.log(isNaN(NaN)); // true
    console.log(isNaN(12)); // false
    console.log(isNaN("13")); // false
    console.log(isNaN("black")); // true
    console.log(isNaN(false)); // false

4. 数值转换

有三个函数可以把非数值转成数值：Number()、parseInt()、parseFloat()。Number()可以用于任何数据类型，其余两个专门把字符串转换成数值。

Number()转换规则如下：

• 如果是Boolean值，true和false将分别被转换成1和0；
• 如果是数值，只是简单的传入和返回；
• 如果是null值，返回0；
• 如果是undefined，返回NaN；
• 如果是字符串，遵循下列规则：
  • 如果字符串中只包含数字（包括前面带正号或负号的情况），则将其转换为十进制数值，即“123”会变成123，而“011”会变成11（注意：前导的零被忽略了）；
  • 如果字符串中包含有效的浮点格式，如“1.1”,则将其转换为对应的浮点数值（同样，也会忽略前导零）；
  • 如果字符串中包含有效的十六进制格式，例如“oxf”，则将其转换为相同大小的十进制整数值；
  • 如果字符串是空的（不包含任何字符），则将其转换为0；
  • 如果字符串中包含除上述格式之外的字符，则将其转换为NaN；
• 如果是对象，则调用对象的valueOf()方法，然后依据前面的规则转换返回的值。如果转换的结果是NaN，则调用对象的toString()方法，然后再次依前面的规律转换返回的字符串值

parseInt()的转换规则：

• parseInt()是专门处理将字符串转换成整数的，该函数在转换字符串时，更多的是看其是否符合数值模型。
• 忽略字符串前面的空格，直至找到第一个非空格字符。
• 如果第一个字符不是数字字符或者负号，parseInt()就会返回NaN；也就是说，用parseInt()转换空字符串会返回NaN（Number()对空字符返回0）。
• 如果第一个字符是数字字符，parseInt()会继续解析第二个字符，直到解析完所有后续字符或者遇到了一个非数字字符。例如，“1234blue123”会被转换成1234，“22.5”会被转换成22。
• 如果字符串中第一个字符是数字字符，parseInt()也能够识别出各种整数格式（即前面讨论的十进制，八进制和十六进制）

// javascript
    const num1 = parseInt("1234blue123");
    const num2 = parseInt("22.5");
    const num3 = parseInt("0xA");
    const num4 = parseInt("070");
    const num5 = parseInt("70");
    const num6 = parseInt("");
    const num7 = parseInt("-10");
    console.log(num1); // 1234
    console.log(num2); // 22
    console.log(num3); // 10
    console.log(num4); // 70
    console.log(num5); // 70
    console.log(num6); // NaN
    console.log(num7); // -10

• parseInt()还有另外一种用法，使用两个参数，第二个参数表示转换时使用的基数（即多少进制）。最终都转为10进制。如果指定了16作为第二个参数，字符串可以不带前面的“0x”

// javascript
    const num8 = parseInt("A",16);
    const num9 = parseInt("A");
    const num10 = parseInt("70",8);
    const num11 = parseInt("70",10);
    const num12 = parseInt("10",2);
    console.log(num8); // 10
    console.log(num9); // NaN
    console.log(num10); // 56
    console.log(num11); // 70
    console.log(num12); // 2

parseFloat()的转换规则：

• parseFloat()与parseInt()类似，从头解析，到字符串末尾停止，或者当解析遇到一个无效的浮点数字字符为止。
• 在parseFloat()的解析中，字符串的第一个小数点是有效的，而第二个小数点就是无效的，因此它后面的字符串将被忽略。例如，“12.34.5”将会被转换为12.34。
• parseFloat()只解析十进制，没有使用第二个参数指定基数的用法；
• parseFloat()会始终忽略前导的零。十六进制的字符串都会被转换为零。
• 如果字符串包含的是一个可解析为整数的数（没有小数点，或者小数点后都是零），parseFloat()会返回整数。

// javascript
    const num13 = parseFloat("0xAF");
    const num14 = parseFloat("1234happy5");
    const num15 = parseFloat("12.34");
    const num16 = parseFloat("12.34.5");
    const num17 = parseFloat("0100");
    const num18 = parseFloat("100");
    console.log(num13); // 0
    console.log(num14); // 1234
    console.log(num15); // 12.34
    console.log(num16); // 12.34
    console.log(num17); // 100
    console.log(num18); // 100

String类型

表示字符串。

该类型也包含一些特殊的字符字面量，即转义序列，用于表示非打印字符，或者具有其他用途的字符。比如下表：

转义字符	含义
\b	退格
\f	换页
\r	回车
\n	换行
\"	双引号
\’	单引号
\t	制表符
\\	反斜杠

把一个值转换成字符串有三种方式。

第一种是除null和undefined之外都有的**toString()**方法，toString()一般不用传递参数，在调用数值的toString()方法时，默认是以十进制输出，如果想输出二进制的话，则可以用toString(2)输出，其他进制同理。

第二种是转型函数String()，在不知道转换值是不是null或者undefined的情况下，可以使用String()来转换。

第三种是使用加号操作符+,要把某个值转换成字符串，可以使用+把它和一个空字符串("")加在一起。

// javascript
    const s = 10;
    const t = true;
    const t1 = t.toString();
    const u = undefined;
    const u1 = String(u);
    const u2 = u + "";
    const v = null;
    const v1 = String(v);
    const v2 = v + "";
    console.log(s.toString()); // 10
    console.log(s.toString(2)); // 1010
    console.log(typeof(t)); // boolean
    console.log(typeof(t1)); // string
    console.log(typeof(u)); // undefined
    console.log(typeof(v)); // object
    console.log(typeof(u1)); // string
    console.log(typeof(v1)); // string
    console.log(typeof(u2)); // string
    console.log(typeof(v2)); // string

Object类型

Object对象就是一组数据和功能的集合。

当创建一个对象时，这个对象的数据类型就是Object，并且拥有Object的属性和方法。

每个Object类型的实例共有的属性和方法：

• constructor：保存着用于创建当前对象的函数。
• hasOwnProperty：用于检测给定的属性在当前对象的实例中是否存在。
• isPrototypeOf：用于检查传入的对象是否是当前对象的原型。
• propertyIsEnumerble：用于检查给定属性能否使用for-in来枚举。
• toLocalString：返回对象的字符串表示。
• toString()：返回对象的字符串表示。
• valueOf()：返回对象的字符串，数值，或布尔表示。通常和toString()返回的值相同。

Symbol类型

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

详见阮一峰老师的博客：

https://es6.ruanyifeng.com/#docs/symbol