关于javascript:js学习笔记3数据类型

数据类型概述

js 的数据类型共有 6 种：

• 数值（number）：整数和小数（比方 1 和3.14）
• 字符串（string）：文本（比方Hello World）。
• 布尔值（boolean）：示意真伪的两个非凡值，即true（真）和false（假）
• undefined：示意“未定义”或不存在，即因为目前没有定义，所以此处临时没有任何值
• null：示意空值，即此处的值为空。
• 对象（object）：各种值组成的汇合。

通常，数值、字符串、布尔值三种类型称为原始类型（即最根本的数据类型，不能再细分）；对象称为合成类型（对象能够看做寄存着多种原始类型的容器）；undefined、null 个别看做两个非凡值

对象又能够细分为三种子类型：

• 广义的对象（object）
• 数组（array）
• 函数（function）

通常，咱们平时所指的对象就是特指广义的对象；函数是解决数据的办法，js 把它当成一种数据类型，能够赋值给变量，这为编程带来了很大的灵活性，也为 JavaScript 的“函数式编程”奠定了根底。

typeof 运算符

JavaScript 有三种办法，能够确定一个值到底是什么类型。

• typeof运算符
• instanceof运算符
• Object.prototype.toString办法

下边咱们次要介绍 typeof 运算符，它能够返回一个值的数据类型

typeof 123 // "number"
typeof '123' // "string"
typeof false // "boolean"


function f() {}
typeof f
// "function"


typeof undefined
// "undefined"

typeof window // "object"
typeof {} // "object"
typeof [] // "object"

由上可见，空数组的类型也是对象，这表明在 js 中，数组实质上是一种非凡的对象

布尔值

下列逻辑运算会返回布尔值：

• 前置逻辑运算符：! (Not)
• 相等运算符：===，!==，==，!=
• 比拟运算符：>，>=，<，<=

布尔值转换规则：除了下边 6 个值被转为 false，其余为 true

• undefined
• null
• false
• 0
• NaN
• ""或''（空字符串）

if ('') {console.log('true');
}
// 没有任何输入

这里要留神的是，空数组（[]）和空对象（{}）对应的布尔值，都是true

if ([]) {console.log('true');
}
// true

if ({}) {console.log('true');
}
// true

数值

js 数据存储模式

js 外部，所有数字都是以 64 位浮点数存储，即便整数也是如此。所以 1 和 1.0 是雷同的

1 === 1.0 // true

也就是说，js 语言底部基本没有整数，都有数字都是小数（64 位浮点数）。

若要进行某些只有整数能力实现的运算时，js 会主动把 64 位浮点数转换成 32 位整数，而后再进行运算

js 数值精度

js 浮点数的 64 个二进制位，从最右边开始，是这样组成的。

• 第 1 位：符号位，0示意负数，1示意正数
• 第 2 位到第 12 位（共 11 位）：指数局部
• 第 13 位到第 64 位（共 52 位）：小数局部（即有效数字）

符号位决定了一个数的正负，指数局部决定了数值的大小，小数局部决定了数值的精度。

指数局部一共有 11 个二进制位，因而大小范畴就是 0 到 2047。若指数局部的值在 0 到 2047 之间（不含两个端点），那么有效数字的第一位默认总是 1，不保留在 64 位浮点数之中。也就是说，有效数字这时总是 1.xx...xx 的模式，其中 xx..xx 的局部保留在 64 位浮点数之中，最长可能为 52 位。因而，js 提供的有效数字最长为 53 个二进制位。

精度最多只能到 53 个二进制位，这意味着，绝对值小于 2 的 53 次方的整数，即 -253 到 253，都能够准确示意。

大于 2 的 53 次方当前，整数运算的后果开始呈现谬误。所以，大于 2 的 53 次方的数值，都无奈放弃精度。因为 2 的 53 次方是一个 16 位的十进制数值，所以简略的法令就是，JavaScript 对 15 位的十进制数都能够准确解决。

数值范畴

依据规范，64 位浮点数的指数局部的长度是 11 个二进制位，意味着指数局部的最大值是 2047（2 的 11 次方减 1）。也就是说，64 位浮点数的指数局部的值最大为 2047，分出一半示意正数，则 JavaScript 可能示意的数值范畴为 21024 到 2 -1023（开区间），超出这个范畴的数无奈示意。

如果一个数大于等于 2 的 1024 次方，那么就会产生“正向溢出”，即 JavaScript 无奈示意这么大的数，这时就会返回Infinity。

Math.pow(2, 1024) // Infinity

如果一个数小于等于 2 的 -1075 次方（指数局部最小值 -1023，再加上小数局部的 52 位），那么就会产生为“负向溢出”，即 JavaScript 无奈示意这么小的数，这时会间接返回 0。

Math.pow(2, -1075) // 0

上面是一个理论的例子。

var x = 0.5;

for(var i = 0; i < 25; i++) {x = x * x;}

x // 0

下面代码中，对 0.5 间断做 25 次平方，因为最初后果太靠近 0，超出了可示意的范畴，JavaScript 就间接将其转为 0。

JavaScript 提供 Number 对象的 MAX_VALUE 和MIN_VALUE属性，返回能够示意的具体的最大值和最小值。

Number.MAX_VALUE // 1.7976931348623157e+308
Number.MIN_VALUE // 5e-324

数值的进制

应用字面量（literal）间接示意一个数值时，JavaScript 对整数提供四种进制的示意办法：十进制、十六进制、八进制、二进制。

• 十进制：没有前导 0 的数值。
• 八进制：有前缀 0o 或0O的数值，或者有前导 0、且只用到 0 - 7 的八个阿拉伯数字的数值。
• 十六进制：有前缀 0x 或0X的数值。
• 二进制：有前缀 0b 或0B的数值。

非凡数值

• + 0 和 -0。两者区别就是符号位不同，简直所有场合两者都会了解为失常的 0，惟一有区别的场合是，+0或 -0 当作分母，返回的值是不相等的。

(1 / +0) === (1 / -0) // false

下面的代码之所以呈现这样后果，是因为除以正零失去 `+Infinity`，除以负零失去 `-Infinity`，这两者是不相等的
* NaN 示意非数字。可能呈现在将字符串解析成数字出错的场合（5 - 'x' // NaN），或者一些非法运算后果

Math.acos(2) // NaN
Math.log(-1) // NaN
Math.sqrt(-1) // NaN
0/0

须要留神的是，NaN 数据类型依然属于 Number

typeof NaN // ‘number’

##### 运算规定
* `NaN` 不等于任何值，包含它自身。

NaN === NaN // false

* 数组的 `indexOf` 办法外部应用的是严格相等运算符，所以该办法对 `NaN` 不成立。

[NaN].indexOf(NaN) // -1

* `NaN` 在布尔运算时被当作 `false`。

Boolean(NaN) // false

* `NaN` 与任何数（包含它本人）的运算，失去的都是 `NaN`。

NaN + 32 // NaN
NaN – 32 // NaN
NaN * 32 // NaN
NaN / 32 // NaN

* infinity 示意无穷。可能因为负数太大或者正数太小呈现，也可能是非 0 数值除以 0.

// 场景一
Math.pow(2, 1024)
// Infinity

// 场景二
0 / 0 // NaN
1 / 0 // Infinity

因为数值正向溢出（overflow）、负向溢出（underflow）和被 `0` 除，JavaScript 都不报错，所以单纯的数学运算简直没有可能抛出谬误。`Infinity` 大于所有数值（除了 `NaN`），`-Infinity` 小于所有数值（除了 `NaN`）。

Infinity > 1000 // true
-Infinity < -1000 // true

`Infinity` 与 `NaN` 比拟，总是返回 `false`。##### 运算规定
`Infinity` 的四则运算，合乎无穷的数学计算规定。

5 * Infinity // Infinity
5 – Infinity // -Infinity
Infinity / 5 // Infinity
5 / Infinity // 0

0 乘以 `Infinity`，返回 `NaN`；0 除以 `Infinity`，返回 `0`；`Infinity` 除以 0，返回 `Infinity`。

0 * Infinity // NaN
0 / Infinity // 0
Infinity / 0 // Infinity

`Infinity` 加上或乘以 `Infinity`，返回的还是 `Infinity`。

Infinity + Infinity // Infinity
Infinity * Infinity // Infinity

`Infinity` 减去或除以 `Infinity`，失去 `NaN`。

Infinity – Infinity // NaN
Infinity / Infinity // NaN

`Infinity` 与 `null` 计算时，`null` 会转成 0，等同于与 `0` 的计算。

null * Infinity // NaN
null / Infinity // 0
Infinity / null // Infinity

`Infinity` 与 `undefined` 计算，返回的都是 `NaN`。

undefined + Infinity // NaN
undefined – Infinity // NaN
undefined * Infinity // NaN
undefined / Infinity // NaN
Infinity / undefined // NaN