刘流的博客

JavaScript 基础(第一周内容)

JavaScript
Word count: 4.6kReading time: 19 min
2020/12/14 Share

这是学习 JavaScript 的笔记。此为课程第一周的内容。

1. JavaScript的简介

1.1 JavaScript的历史

1995年由 Brendan Eich（布兰登·艾奇）发明，前身是 LiveScript.

1.2 ECMAScript 是 JavaScript 的标准

1997年，欧洲计算机制造商协会（ECMA） 设置了JavaScript的标准，命名为 ECMAScript 。
ECMAScript 规范了 JavaScript，同样 JavaScript 实现了 ECMAScript。

1.3 JavaScript 体系

完整的 JavaScript 包含：

  1. 语言核心（ECMAScript5，6，7，8，9）
  2. DOM
  3. BOM

1.4 JavaScript 的语言风格和特性

  1. 类 C 语言的风格，简单好学。
  2. 弱类型，易编写。

2. JavaScript 的基础使用

2.1 JavaScript 的书写位置

  1. 在 <body> 中的 <script> 标签内部书写 JavaScript 代码。
  2. 将代码单独储存为 .js 格式文件，然后在 HTML 文件中使用 <script src=""></script> 这样的形式将 js 文件引入。

在 HTML4 中使用 <script> 标签时，会有type 属性： <script type="text/javascript"></script> 但在 HTML5 中可以忽略这种写法。

2.2 认识输出语句

  1. alert() –弹出警告框。
  2. console.log() –控制台输出。

2.3 处理报错信息

常见的报错信息有：

  1. Uncaught SyntaxError: Invalid or unexpected token 未捕获的语法错误:不合法或错误的符号
  2. Uncaught ReferenceError: a is not defined 未捕获的引用错误:a 没有被定义.

2.4 REPL 环境

控制台也是一个 REPL 环境，可以使用它临时测试表达式的值。

  1. read 读
  2. eval 执行
  3. print 打印
  4. loop 循环

    3. 变量

    变量是计算机语言中能储存计算结果或能表示值抽象概念。变量不是数值本身，它们仅仅是一个用于存储数值的容器

    3.1 定义变量

    要想使用变量，第一件事就是声明它，并给它赋值: var a = 5; ，使用 var 关键字定义变量，等号表示赋值。
    当变量被赋值后，就可以使用了: console.log(a);

3.2 改变变量的值

变量的值是可以被改变的，这个时候不需要使用 var

1
2
3
var a = 10; // 定义变量a 并赋初始值为10
a = 18; // 更改变量a的值为 18
console.log(a); //18

3.3 变量的合法命名

标识符的命名规则，函数，类名，对象的属性等也要遵守这个规则：

  1. 只能是数字，字母，下划线，$ 组成，并且不能以数字开头。
  2. 不能是关键字或者保留字
  3. 变量名大小写敏感，a 和 A 两个是不同的变量。

3.4 变量的常见错误

不用 var 定义，而直接将值赋予它，虽不会引发错误，但会产生作用域问题

1
2
console.log(a); // 不会输出 10，只会输出 undefined
var a = 10;

3.5 同时输出多个变量

使用逗号同时声明和初始化两个变量: var a = 0, b= 0;

3.6 变量声明提升

变量声明的提升: 你可以提前使用一个稍后才声明的变量，而不会引发异常。在执行所有代码前， JS 有预解析阶段，会预先解读所有的变量。

1
2
3
// 变量声明提升只提升定义，不提升值。
console.log(a); // 先使用变量，输出 undefined
var a = 12; // 后定义变量

注意：

  1. 变量声明的提升是JavaScript的特性， 所以经常出面试题。
  2. 在实际开发时，不要刻意使用变量声明提升特性。一定要先定义并给变量赋初值，然后再使用变量。

4. 基本数据类型

课程简介：

  1. 数据类型简介和检测

基本数据类型

  1. 数字类型
  2. 字符串类型
  3. 布尔类型
  4. undefined类型
  5. null
    数据类型的转换

4.1 JavaScript 中两大数据类型

  1. 基本数据类型
  2. 复杂数据类型

4.2 typeof 运算符

使用 typeof 运算符可以检测值或者变量的类型

1
2
typeof 5; // number
typeof 'javascript'; // string

5钟基本数据类型的 typeof 检测结果

类型名 typeof 检测结果 值举例
数字类型 number 3
字符串类型 string “java”
布尔类型 boolean true
undefined类型 undefined undefined
null类型 Object null

4.3 Number （数字）类型

所有的数字不分大小，不分整浮，不分正负，都是数字类型。

1
2
3
typeof 925; // number
typeof -6; // number
typeof 9.25; // number

4.4 小数中0可以忽略

1
2
.5; // 0.5
typeof .5; // number

4.5 科学计数法

较大数或者较小数（绝对值较小）可以写成科学计数法

1
2
3
4
5
3e8; //300000000
typeof 3e8; // number

3e-4; //0.0003
typeof 3e-4; //number

4.6 不同进制的数字

  1. 二进制数值以 0b 开头

    1
    2
    0b10 //2
    0b1111 // 15

  2. 八进制数值以0开头

    1
    017 //15

  3. 十六进制数字以0x开头

    1
    0xf //15

4.7 一个特殊的数字类型 NaN

  1. NaN是英语“not a number” 的意思，即“不是一个数”，但它是一个数字类型的值

typeof NaN;//number

  1. 0除以0的结果就是NaN，事实上，在数学运算中，如若结果不能得到数字，其结果往往都是 NaN。

    1
    2
    '我' - '你'; //NaN
    '我' * '你'; //NaN

  2. NaN有一个奇怪的性质：不自等。

5. String(字符串) 类型

字符串就是“人类的自然语言”，字符串要用引号包裹，双引号或者单引号均可。

1
2
typeof '好好学习'; // string
typeof "好好学习"; // string

5.1 字符串的拼接

加号可以用来拼接多个字符串

1
'imo'+'oc'; // 'imooc'

5.2 字符串和变量的拼接

将一个变量的值“插入”到字符串中：

1
2
var year = 2020;
var str = '今年是' + year +'年';

5.3 空字符串

一些时候需要使用空字符串，直接书写闭合的引号对即可：var str = '';

5.4 字符串的length 属性

字符串的 length 属性表示字符串的长度

1
2
'学习JS'.length; // 4
''.length //0

5.5 字符串的常用方法

“方法”就是能够通过打点调用的函数，字符串有丰富的方法。

方法 功能
charAt() 得到指定位置字符
substring() 提取子串
substr() 提取子串
slice() 提取子串
toUpperCase() 将字符串变为大写
toLowerCase() 将字符串变为小写
indexOf() 检索字符串 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 // charAt() 方法
 var str = '海上生明月，天涯共此时。';
 // charAt()方法可以得到指定位置的字符
 console.log(str.charAt(0)); //海
 console.log(str.charAt(3)); //明

// substring(a,b) 方法得到从a开始到b结束（不包括b处）的子串
console.log(str.substring(3,5)); // 明月
// substring(a,b) 方法如果省略第二个参数，返回的子串会一直到字符串的结尾
console.log(str.substring(6)); // 天涯共此时。
// subString(a,b) 中，a可以大于 b，数字顺序将自动调整为小数在前
console.log(str.substring(6,2)); //生明月，

// substr(a,b)中，将得到从a开始的长度为b的字串
console.log(str.substr(3,2));//明月
// substr(a,b) 方法如果省略第二个参数，返回的子串会一直到字符串的结尾
console.log(str.substr(6));//天涯共此时。
// substr(a,b) 中，a可以是负数，表示倒数位置
console.log(str.substr(-4,2)); //共此

// slice(a,b) 方法得到从 a 开始到b 结束(不包括b处)的子串
console.log(str.slice(3,6)); //明月，
// slice(a,b) 的参数a可以是负数
console.log(str.slice(-4,-1)); //共此时
// slice(a,b)中，参数a必须小于参数b
console.log(str.slice(5,2)); // ''

5.6 对比总结

substring(), substr(), slice() 对比总结

  1. substring(a,b) 和 slice(a,b) 功能基本一致，都是从a开始到b结束（不包括b）的子串，区别：
    1. substring() 可以自动交换两个参数位置，而 slice() 不行
    2. slice() 的参数a 可以是负数，而 substring() 不行
  2. substr(a,b) 中参数 b 是子串长度，而不是位置编号。

5.7 toUpperCase() 和 toLowerCase()

  1. toUpperCase() 转为大写
  2. toLowerCase() 转为小写
1
'i love you'.toUpperCase(); //I LOVE YOU

5.8 indexOf()

indexOf() 方法返回某个指定的字符串在字符串中首次出现的位置，如果要检索的字符串值没有出现，则该返回 -1

1
2
3
4
var str111 = 'abcdef';
console.log(str111.indexOf('a')); //0
console.log(str111.indexOf('d')); //3
console.log(str111.indexOf('m')); // -1

6. 布尔类型

布尔（Boole·George）英国19世纪数学家及逻辑学家。人们为了纪念他，以他的名字命名布尔值。

布尔值只有两个： true 和 false .分别表示真和假。

1
2
typeof true; // boolean
typeof false;  // boolean

7. undefined 类型

一个没有被赋值的变量的默认值是 undefined ,而 undefined 的类型也是 undefined 。即：undefined 又是值，又是一种数据类型，这种数据类型只有它自己。typeof undefined; //undefined

8. null 类型

null 代表空，它是“空对象”。当我们需要将对象销毁，数组销毁或者删除事件监听时，通常将它们设置为 null

1
box.onclick = null

8.1 用 typeof 检测 null 结果是 object

1
typeof null; // object

9. 类型转换

9.1 Number()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 字符串 -> 数字
// 纯数字字符串能变为数字，不是纯数字的字符串转为 NaN
console.log(Numer('123')); //123
console.log(Numer('123.4')); //123.4
console.log(Numer('123年')); // NaN
console.log(Numer('2e3')); //2000
console.log(Numer('')); //0


// 布尔值 -> 数字
// true 变为 1，false 变为 0
console.log(Number(true)); //1
console.log(Number(false)); //0

// undefined 和 null -> 数字
// undefined 变为 NaN，null 变为 0
console.log(Number(undefined)); // NaN
console.log(Number(null));//0

9.2 parseInt()

1
2
3
4
5
6
// parseInt() 函数
// parseInt() 函数的功能是将字符串转为整数
console.log(parseInt('2.14')); //2 parseInt() 将自动截去第一个非数字字符之后的所有字符
console.log(parseInt('3.14是圆周率')); //3 所有的文字都被去掉
console.log(parseInt('圆周率是3,14')); //NaN 如果第一个字符不是以数字开头，则转为 NaN
console.log(parseInt('9.99')); //9 不会四舍五入

9.3 parseFloat()

1
2
3
4
5
6
// parseFloat() 函数
// parseFloat() 函数的功能是将字符串转为浮点数
console.log(parseFloat('2.14')); //2.14 将小数字符串转换为小数 
console.log(parseFloat('3.14是圆周率')); //3.14 小数后的非数字都被去掉
console.log(parseFloat('圆周率是3,14')); //NaN 如果第一个字符不是以数字开头，则转为 NaN
console.log(parseFloat('9.99')); //9。99 不会四舍五入

9.4 String()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 使用 String() 函数
// 数字 -> 字符串 
// 变为长度相同的字符串，科学计数法和非10进制数字会转为 10 进制的值

console.log(String(123)); //'123'
console.log(String(123.4)); //'123.4'
console.log(String(2e3));// '2000'
console.log(String(NaN));//'NaN'
console.log(String(Infinity)); // 'Infinity'
console.log(String(0xf)); // '15'

// 布尔值 -> 字符串
// 变为“长度相同”的字符串
console.log(String(true)); // '1'
console.log(String(false)); // '0'

// undefined 和 null -> 字符串
// 变为相同长度的字符串
console.log(String(undefined)); // 'undefined'
console.log(String(null)); // 'null'

9.4 Boolean()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Boolean() 
// 数字 -> 布尔值
// 0 和 NaN 转为 false ，其他数字都转为 true
console.log(Boolean(123)); //true
console.log(Boolean(0));//false
console.log(Boolean(NaN));//false
console.log(Boolean(Infinity));//true
console.log(Boolean(-Infinity));//true

// 布尔值 -> 布尔值
// 空字符串变为 false ，其他转为 true
console.log(Boolean(''));//false
console.log(Boolean('abc'));//true
console.log(Boolean('false'));//true

// undefined和null -> 布尔值
// 转为 false
console.log(Boolean(undefined));//false
console.log(Boolean(null)); //false

10. 表达式与操作符

10.1 表达式和操作符

1
2
3
4
5 + 3 // 表达式
// 5 是操作数
// + 是运算符
// 3 是操作数

10.2 表达式种类

  1. 算术
  2. 关系
  3. 逻辑
  4. 赋值
  5. 综合

10.3 算术运算符

意义 运算符
加 +
减 -
乘 *
除 /
取余 %

10.3.1 加减乘除

加减的符号和数学一致，乘法是 * 号，除法是 / 。默认情况下，乘除法的优先级要高于加法和减法；必要时可以使用圆括号来改变运算的顺序。

1
2
3
4
1 + 2 * 3; //7
(1 + 2) * 3; // 9
1 + 2/4 // 1.5
((1 + 2) * 3 + 4 ) / 2 // 6.5

10.3.2 加号的两种作用

加号有 加法 和 连字符 两种作用。如果加号两边的操作数都是数字，则为 加法 ,否则为 连字符

1
2
3
1 + 2 // 3
1 + '2' //'12'
'1' + '2' //'12'

10.3.3 取余运算

取余运算也叫做“”求模运算“，用百分号 ”%” 表示。a % b 表示求 a 除以 b 的余数，它不关心整数部分，只关心余数。

1
2
3
11 % 4; // 3
20 % 6; // 2
12 % 3; // 0

10.4 隐式类型转换

如果参与数学运算的某操作数不是数字型，那么 JavaScript 会自动 将此操作数转为数字型。

1
2 * '3' //6

隐式类型转换的本质是内部调用 Number() 函数

1
2
3
true + true //2
false + 2 // 2
3 * '2天' //NaN

10.5 有关 IEEE754

在 JavaScript 中，有些小数的数学运算不是很精准。JavaScript 使用了 IEEE754 二进制浮点数算术标准，这会使一些个别的小数运算产生“丢失精度”问题。

1
0.1 + 0.2 // 0.30000000000000004

解决办法：在进行小数运算的时候，调用数字的 toFixed() 方法保留指定的小数位数

1
2
0.30000000000000004.toFixed(2)
"0.30"

10.6 幂和开根号

JavaScript 中没有提供幂计算，开根号的运算符。需要使用Math 对象的相关方法进行计算。

1
2
3
4
5
Math.pow(2,3) // 8
Math.pow(3,2) //9

Math.sqrt(81) //9
Math.sqrt(-81) // NaN

10.7 向上取整和向下取整

Math.ceil() 向上取整；Math.floor() 向下取整

1
2
3
4
5
6
7
8
Math.ceil(2.4) // 3
Math.floor(2.4) //2

Math.ceil(-2.4) //-2
Math,floor(-2.4) //-3

Math.ceil(2) //2
Math.flooe(2) //2

10.8 关系运算符

意义 运算符
大于 >
小于 <
大于或等于 >=
小于或等于 <=
等于 ==
不等于 !=
全等于 ===
不全等于 !==

10.8.1 大于和小于

大于 > , 小于 < 两个符号和数学相同。”大于等于”运算符是>=, “小于等于x”运算符是 <=

1
2
3
4
5
8 > 5 //true
7 < 4 // false
8 >= 7 //true
8 <= 8 //true
8 <= 11 // true

10.8.2 判断是否全等

如果想比较两个值是否全等，此时应该使用 == 运算符。JavaScript 中等号 = 表示赋值，而不是相等。判断相等应该使用 == 运算符。

1
2
3
3 == 3 // true
3 === 3 // true
3 = 3 //错误语句

10.8.3 相等和全等

  1. 两个等号 == 运算符 不比较值的类型，它会进行隐式转换后比较值是否相等。

  2. 三个等号 === 运算符，不仅仅比较值是否相同，也比较类型是否相同。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
5 == '5' //true
5 === '5' //false

1 == true // true
1 === true // false

0 == false //true
0 === false // false

0 == undefined // false
0 === undefined // false

undefined == null // true
undefined === null //false

10.8.4 NaN 不自等

NaN 作为一个特殊的数字类型值，它在用 == 比较的时候也有特殊的结果

1
2
NaN == NaN // false
NaN === NaN // false

10.8.5 如何判断某变量值为 NaN

isNaN() 函数可以用来判断变量值是否为 NaN

1
2
isNaN(NaN) // true
isNaN(5) // false

但 isNaN() 也不好用，它的机理是：只要该变量传入 Number() 的执行结果是 NaN, 则 isNaN() 函数都会得到 true

1
2
3
isNaN(undefined) // true
isNaN('3天') //true
isNaN(null) //false

10.8.6 不相等和不全等

!= 表示不相等，!== 表示不全等

1
2
3
4
5
5 != 6 //true
5 !== 6 //true

5 != '5' //false
5 !== '5' //true

10.9 逻辑表达式

逻辑运算符

意义 运算符
非 ！
与 &&
或 ||

10.9.1 非运算

！ 表示 “非”，也可以称为 “置反运算”。! 是一个 “单目运算符”，只要一个操作数，置反运算的结果一定是布尔值。

1
2
3
4
5
6
7
8
9
10
11
12
!true  //false
!false //true

!0 //true
!undefined //true
!'' //true
!'abc' //false

!!true//true
!!0//false
!!'' // false
!!'abc' //true

10.9.2 与运算

&& 表示 并且，称为“与运算”，口诀：都真才真

1
2
3
4
true && true //true
true && false //false
false && true //false
false && false //false

10.9.3 或运算

||表示“或者”，称为 “或运算”，口诀：有真就真。

1
2
3
4
true || true // true
true || false // true
false || true // true
false || false //false

10.9.4 短路计算

1
2
3
a && b //都真才真
// 真 ，b 真总结果才真，b假，总结果就假
// 假 不用看 b了，被“短路”

a && b 运算符中 ：a 真，表达式值为 b； a假，表达式为a。

1
2
3
4
5
6
3 && 6 //6
undefined && 15 //undefined
15 && undefined //undefined
null && 2 //null
'' && 16 // ''
NaN && undefined //NaN
1
2
3
a || b // 有真就真
// 真。 不用看 b了。被”短路“
// 假。b 真，总结过就真，b假 总结过就假。

a || b 运算符中 ：a 真，表达式值为 a； a假，表达式为b。

1
2
3
4
5
3 || 6 //3
0 || 6 // 6
null || undefined // undefined
'a' || 'b' //'a'
NaN || null // null

10.9.5 逻辑运算顺序

逻辑运算的优先级是：非 -> 与->或

1
2
! true || true //true
3 && 4 || 5 && 6 // 4

10.9.6 赋值运算符

意义 运算符
赋值 =
快捷赋值 +=
-=
*=
/=
%=
自增运算 ++
自减运算 –

  1. JS 中，= 表示赋值，==判断是否相等（不判断类型），===判断是否全等。

  2. 赋值运算符会将等号右边的数值，赋予等号左边的变量。var a = 5;

赋值运算也产生值，等号后面的值将作为**”赋值运算的值”**

1
2
var a;
console.log(a = 4); //4

这就意味着，可以连续使用赋值运算符

1
2
3
4
5
var a,b,c;
a = b = c = 15;
console.log(a);
console.log(b);
console.log(c);

10.9.7 快捷赋值

快捷赋值运算符表示在原数值基础上进一步进行运算

1
2
3
4
5
6
7
var a = 3;
a += 5; //等价于 a = a + 5;
console.log(a);  //8

var c = 16;
c %= 3; //等价于 c = c % 3
console.log(c); //1

10.9.8 自增/自减运算符

++ 和 -- 是自增/自减运算符，表示在在自身基础上加1或减1.

1
2
3
var a = 3;
a++;
console.log(a); //4

10.9.9 a++ 和 ++a 的区别

a++ 先用再加；++a 先加再用

1
2
3
4
5
6
7
8
9
var a = 3;
var b = a++;
console.log(b);//3
console.log(a);//4

var c = 3;
var d = a++;
console.log(c);//4
console.log(d);//4

11. 综合表达式

综合运算的运算顺序

运算顺序：非运算-> 数学运算-> 关系运算 -> 逻辑运算

1
2
3
4
5
5 < 3 +3 //true
3 > 2 && 8 > 3+4 // true 
3>2&& 8>3+5 //false
!13 < 5 - 3 //true
!13 < 5-5 //false

11.1 变量的范围表示

验证变量 a 是否介于 5 到 12 之间

1
a >= 5 && a <= 12

11.2 闰年判断

闰年的计算公式：满足下面之间的一个即可

  1. 能被 4 整除并且不能被 100 整除。
  2. 能被 100 整除并且能被 400 整除。
1
2
var year = prompt('请输入年份');
alert(year % 4 == 0 && year % 100 != 0 || year % 100 == 0 && year % 400 == 0)

Author：John Doe

原文链接：http://example.com/2020/12/14/2020-12-14-JS-basic-1/

发表日期：December 14th 2020, 12:00:00 am

更新日期：December 16th 2020, 9:27:40 pm

版权声明：本文采用知识共享署名-非商业性使用 4.0 国际许可协议进行许可

CATALOG
  1. 1. 1. JavaScript的简介
    1. 1.1. 1.1 JavaScript的历史
    2. 1.2. 1.2 ECMAScript 是 JavaScript 的标准
    3. 1.3. 1.3 JavaScript 体系
    4. 1.4. 1.4 JavaScript 的语言风格和特性
  2. 2. 2. JavaScript 的基础使用
    1. 2.1. 2.1 JavaScript 的书写位置
    2. 2.2. 2.2 认识输出语句
    3. 2.3. 2.3 处理报错信息
    4. 2.4. 2.4 REPL 环境
  3. 3. 3. 变量
    1. 3.1. 3.1 定义变量
    2. 3.2. 3.2 改变变量的值
    3. 3.3. 3.3 变量的合法命名
    4. 3.4. 3.4 变量的常见错误
    5. 3.5. 3.5 同时输出多个变量
    6. 3.6. 3.6 变量声明提升
  4. 4. 4. 基本数据类型
    1. 4.1. 4.1 JavaScript 中两大数据类型
    2. 4.2. 4.2 typeof 运算符
    3. 4.3. 4.3 Number （数字）类型
    4. 4.4. 4.4 小数中0可以忽略
    5. 4.5. 4.5 科学计数法
    6. 4.6. 4.6 不同进制的数字
    7. 4.7. 4.7 一个特殊的数字类型 NaN
  5. 5. 5. String(字符串) 类型
    1. 5.1. 5.1 字符串的拼接
    2. 5.2. 5.2 字符串和变量的拼接
    3. 5.3. 5.3 空字符串
    4. 5.4. 5.4 字符串的length 属性
    5. 5.5. 5.5 字符串的常用方法
    6. 5.6. 5.6 对比总结
    7. 5.7. 5.7 toUpperCase() 和 toLowerCase()
    8. 5.8. 5.8 indexOf()
  6. 6. 6. 布尔类型
  7. 7. 7. undefined 类型
  8. 8. 8. null 类型
    1. 8.1. 8.1 用 typeof 检测 null 结果是 object
  9. 9. 9. 类型转换
    1. 9.1. 9.1 Number()
    2. 9.2. 9.2 parseInt()
    3. 9.3. 9.3 parseFloat()
    4. 9.4. 9.4 String()
    5. 9.5. 9.4 Boolean()
  10. 10. 10. 表达式与操作符
    1. 10.1. 10.1 表达式和操作符
    2. 10.2. 10.2 表达式种类
    3. 10.3. 10.3 算术运算符
      1. 10.3.1. 10.3.1 加减乘除
      2. 10.3.2. 10.3.2 加号的两种作用
      3. 10.3.3. 10.3.3 取余运算
    4. 10.4. 10.4 隐式类型转换
    5. 10.5. 10.5 有关 IEEE754
    6. 10.6. 10.6 幂和开根号
    7. 10.7. 10.7 向上取整和向下取整
    8. 10.8. 10.8 关系运算符
      1. 10.8.1. 10.8.1 大于和小于
      2. 10.8.2. 10.8.2 判断是否全等
      3. 10.8.3. 10.8.3 相等和全等
      4. 10.8.4. 10.8.4 NaN 不自等
      5. 10.8.5. 10.8.5 如何判断某变量值为 NaN
      6. 10.8.6. 10.8.6 不相等和不全等
    9. 10.9. 10.9 逻辑表达式
      1. 10.9.1. 10.9.1 非运算
      2. 10.9.2. 10.9.2 与运算
      3. 10.9.3. 10.9.3 或运算
      4. 10.9.4. 10.9.4 短路计算
      5. 10.9.5. 10.9.5 逻辑运算顺序
      6. 10.9.6. 10.9.6 赋值运算符
      7. 10.9.7. 10.9.7 快捷赋值
      8. 10.9.8. 10.9.8 自增/自减运算符
      9. 10.9.9. 10.9.9 a++ 和 ++a 的区别
    10. 10.10. 11. 综合表达式
      1. 10.10.1. 11.1 变量的范围表示
      2. 10.10.2. 11.2 闰年判断
Total : 16
2020
小程序 NodeJS ES6 杂记 HTML CSS JavaScript
CSS 小程序 Node JavaScript 杂记 HTML 前端