JavaScript笔记（2）

-aw_aw-

已于 2022-01-23 20:20:52 修改

阅读量720

点赞数

文章标签： javascript 前端

于 2022-01-23 20:20:06 首次发布

本文链接：https://blog.csdn.net/aw_cs/article/details/122647177

版权

1. 数据类型

确定一个值是什么类型

（1）typeof

function f(){}
typeof f;       //"funtion"
typeof undefined;     //"undefined"

typedef 可检查一个没有声明的变量，而不报错

v;    //直接使用将会报错
typeof v;   //"undefined"(不报错)

// 错误的写法
if (v) {
  // ...
}
// ReferenceError: v is not defined

// 正确的写法
if (typeof v === "undefined") {
  // ...
}

对象返回object（包括null）

typeof windows;    //"object"
typeof {};    //"object"
typeof [];    //"object"
typeof null;  //"object"

（2）instanceof

instanceof可以区分数组和对象

const o = {};
const a = [];

o instanceof Array; // false
a instanceof Array; // true

（3）Object.prototype.toString

1.1 数值（Number）

1.1.1 数值精度

$-2^{53}$ 到 $2^{53}$

1.1.2 数值范围

$2^{-1023}$ 到 $2^{1024}$ （开区间）

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

数值大于等于 $2^{1024}$ 则正向溢出，返回Infinity，小于等于 $2^{-1075}$ （指数部分-1023，小数部分的52位），则负向溢出，返回0

Math.pow(2, 1024); // Infinity
Math.pow(2, -1075); // 0

1.1.3 数值的表示法

科学计数法

12e3；    //12000

当（1）小数点前的数字多于 21 位，（2）小数点后的零多于 5 个，自动转换为科学计数法表示

1.1.4 数值的进制

二进制: 有前缀 0b 或 0B 的数值

十进制: 没有前导 0 的数值

八进制: 有前缀 0o 或 0O 的数值，或者有前导 0、且只用到 0-7 的八个阿拉伯数字的数值

十六进制: 有前缀 0x 或 0X 的数值

1.1.5 特殊数值

（1）正零和负零

两者是等价的

-0 === +0; // true
0 === -0; // true
0 === +0; // true

但在做分母时，除以正零得到 +Infinity，除以负零得到 -Infinity

1 / +0 === 1 / -0;     //false

（2）NaN（非数字）

例如：

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

NaN仍属于Number

typeof NaN; // 'number'

NaN与任何数(包括它自己)的运算，得到的都是 NaN。

NaN === NaN; // false
NaN + 32; // NaN

因为数组的 indexOf 方法内部使用的是严格相等运算符，所以该方法对 NaN 不成立。

[NaN].indexOf(NaN); // -1
//NaN跟它自己也不相等

（3） Infinity

Infinity 大于一切数值 (除了 NaN)，-Infinity 小于一切数值 (除了 NaN)。

四则运算：

5 * Infinity; // Infinity
5 - Infinity; // -Infinity
Infinity / 5; // Infinity
5 / Infinity; // 0

与0的运算：

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

Infinity 加上或乘上 Infinity, 仍返回 Infinity

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

Infinity 减去或除以 Infinity, 返回0

Infinity - Infinity; // NaN
Infinity / Infinity; // NaN

Infinity 与 null 计算，则null 转为0，相当于与0计算

undefined + Infinity; // NaN
undefined - Infinity; // NaN
undefined * Infinity; // NaN
undefined / Infinity; // NaN
Infinity / undefined; // NaN

1.1.6 与数值相关的全局方法

（1）parseInt（）

将字符串转换为整数，只返回一个十进制整数或者NaN

会将参数转换为字符串再转换，若字符串头部有空格，自动去除空格，字符串转换为整数时，是一个个字符依次转换，若遇到不能转为数字的字符，则不再进行下去，返回已经转好的部分

//去除头部空格
parseInt("   81"); // 81
//转到不能转为数字的字符停止
parseInt(1.23); // 1
parseInt("8a"); // 8

若字符串以 0x 或 0X 开头，parseInt 会将其按照十六进制数解析；若字符串以 0 开头，将其按照 10 进制解析，但对于科学计数法，则结果可能会出错（因为e无法转为数字，则后面的部分被直接舍弃。

//十六进制
parseInt("0x10"); // 16
//十进制
parseInt("011"); // 11
//科学计数法
parseInt(0.0000008); // 8
// 等同于
parseInt("8e-7"); // 8

parseInt()还可接受第二个参数(2 到 36 之间)，表示被解析的值的进制，返回该值对应的十进制数。默认情况下，parseInt 的第二个参数为 10，即默认是十进制转十进制。

parseInt("1000", 2); // 8

若第二个参数不是数值，会被自动转为一个整数。这个整数只有在 2 到 36 之间，才能得到有意义的结果，超出这个范围，则返回 NaN。如果第二个参数是 0、undefined 和 null，则直接忽略。

parseInt("10", 37); // NaN
parseInt("10", 1); // NaN
parseInt("10", 0); // 10
parseInt("10", null); // 10
parseInt("10", undefined); // 10

如果字符串包含对于指定进制无意义的字符，则从最高位开始，只返回可以转换的数值。如果最高位无法转换，则直接返回 NaN。

parseInt("1546", 2); // 1
parseInt("546", 2); // NaN

如果 parseInt 的第一个参数不是字符串，会被先转为字符串

parseInt(0x11, 36); // 43
parseInt(0x11, 2); // 1

// 等同于
parseInt(String(0x11), 36);
parseInt(String(0x11), 2);

// 等同于
parseInt("17", 36);
parseInt("17", 2);

特别注意八进制的前缀0

parseInt(011, 2); // NaN

// 等同于
parseInt(String(011), 2);

// 等同于
parseInt(String(9), 2);
//9不是二进制的有效字符
parseInt('011', 2);   //3

（2）parseFloat（）

将字符串转换为浮点数，只返回一个浮点数或者NaN

parseFloat([]); // NaN
parseFloat("FF2"); // NaN
parseFloat(""); // NaN

字符串符合科学计数法，则进行相应的转换

parseFloat("314e-2"); // 3.14
parseFloat("0.0314E+2"); // 3.14

若字符串头部有空格，自动去除空格，字符串转换为整数时，是一个个字符依次转换，若遇到不能转为数字的字符，则不再进行下去，返回已经转好的部分

parseFloat("\t\v\r12.34\n "); // 12.34
parseFloat("3.14more non-digit characters"); // 3.14

parseFloat() 与 Number() 的不同：

parseFloat(true); // NaN
Number(true); // 1

parseFloat(null); // NaN
Number(null); // 0

parseFloat(""); // NaN
Number(""); // 0

parseFloat("123.45#"); // 123.45
Number("123.45#"); // NaN

（3）isNaN（）

isNaN 只对数值有效，如果传入其他值，则会先转成数值。例如，传入字符串，字符串则先转成NaN，最后返回true。

isNaN("Hello"); // true
// 相当于
isNaN(Number("Hello")); // true

同理，对于对象和数组，isNaN也返回true。

isNaN({}); // true
// 等同于
isNaN(Number({})); // true

isNaN(["xzy"]); // true
// 等同于
isNaN(Number(["xzy"])); // true

但对于空数组和只有一个数值成员的数组，它们能被Number() 转换为数值，isNaN返回false

isNaN([]); // false
isNaN([123]); // false
isNaN(["123"]); // false

因此使用isNaN之前最好判断一下数据类型。

function myIsNaN(value) {
  return typeof value === "number" && isNaN(value);
}

我们可以利用NaN为唯一一个不等于自身的值这个特点来判断NaN（更加推荐）

function myIsNaN(value) {
  return value !== value;
}

1.2 字符串

1.3 布尔值

undefined, null, false, 0, Nbi比较aN, " ", ' '（空字符串）会被转为false，其他均为true

1.3.1 比较运算符

== 比较，将自动转换数据类型再比较

===比较，不会转换数据类型，数据类型和值都要相等（更推荐使用）

注意：NaN与任何值都不相等，包括它自己

NaN === NaN;     // false

只能通过isNaN()函数来判断NaN

isNaN(NaN); // true

浮点数不能直接比较，只能计算它们的差的绝对值是否小于某个阈值

Math.abs(1 / 3 - (1 - 2 / 3)) < 0.0000001;     //true

1.3.2 布尔运算符

（1）与运算符 &&

从左至右运行时，检测到有任一表达式为 false 时，即停止执行输出该表达式的值(后面的表达式不会执行），否则输出最后一个表达式的值。

（2）或运算符 ||

从左至右运行时，检测到有任一表达式为 true 时，即停止执行输出该表达式的值(后面的表达式不会执行），否则输出最后一个表达式的值。

（3）非运算符！

1.4 undefined

1.5 null

1.6 对象

1.6.1 狭义的对象

1.6.2 数值

1.6.3 函数