本文详细介绍了JavaScript中的数据类型分类，包括基本数据类型如Number、String、Boolean，以及复杂数据类型如Array、Object、Function。同时，深入探讨了各种数据类型之间的转换方法和规则，并全面覆盖了JS中的数学、赋值、比较、逻辑和自增自减运算符的使用及优先级。
JavaScript 数据类型
JS数据类型的分类
-
一个变量可以存储一个什么样的数据，一类叫做基本数据类型（简单数据类型），一类叫做复杂数据类型（引用数据类型 / 地址数据类型）
-
基本数据类型（简单数据类型）
- Number 数值
- String 字符串
- Boolean 布尔
- Undefined 空
- Null 空
-
复杂数据类型(引用数据类型 / 地址数据类型)
- Array 数组
- Object 对象
- Function 函数
一、Number 数值类型
- 包含我们认知的十进制数字（整数和小数）
- 10 20 100.234 -300.5678
var n1 = 100 // n1 这个变量存储的就是一个数值类型的数据
var n2 = -200.345 // n2 这个变量存储的就是一个数值类型的数据
- 科学计数法（一般不用，了解）
- 15e2 表示 15 * 10 的二次方
// n3 这个变量存储的也是一个数值类型的数据
var n3 = 15e2
console.log(n3)
- 其他进制表示的数字（一般不用，了解）
- 0b 开头的, 表示一个二进制数字
- 0 开头, 表示一个八进制数字
- 0x 开头, 表示一个十六进制数字
// n4 这个变量存储的就是一个 二进制的 10, 二进制的 10 转换成 十进制就是 2
// n4 存储的就是数字 2
var n4 = 0b10
console.log(n4)
-
NaN
- not a number 一个非数字
- 是一个数值类型, 但是不是一个合法数字
-
普及一下进制关系
- 十进制(逢10进1): 0 1 2 3 4 5 6 7 8 9 10 11 12
- 二进制(逢2进1): 0 1 10 11 100 101
- 八进制(逢8进1): 0 1 2 3 4 5 6 7 10 11 12 13
- 十六进制(逢16进1): 0 1 2 3 4 5 6 7 8 9 a b c d e f 10 11 12
二、String 字符串类型
- 在 js 里面所有被单引号或者双引号包裹的内容都叫做字符串
- 就是表示一段普通的文本内容
- 单引号和双引号没有任何区别
// s1 变量存储的是一个字符串数据类型, 文本内容就是 hello world
var s1 = 'hello world'
// s2 变量存储的是一个字符串数据类型, 文本内容就是 你好 世界
var s2 = "你好 世界"
// s3 变量存储的是一个字符串数据类型, 文本内容就是 李雷说: '你好韩梅梅!'
var s3 = "李雷说: '你好韩梅梅!'"
// s4 变量存储的不是一个数字 一百, 而是一段普通文本 一零零
var s4 = '100'
三、Boolean 布尔类型
- 只有两个值
- true 表示真 在计算机里面存储的就是1
- false 表示假 在计算机里面存储的就是0
var b1 = true
var b2 = false
四、Undefined 类型（叫做空）
- undefined 表示本该有一个值, 但是没有, 就是 undefined
- 举例：我告诉有你桌子上应该有一杯水，但是当我的桌子上什么都没有的时候, 就是 undefined
- Undefined 类型, 只有一个值，就是 undefined，即：当一个变量声明不赋值的时候, 他的值就是 undefined
var un // 声明了一个变量叫做 un, 但是没有进行赋值
console.log(un) // 控制台的输出结果为 undefined
五、Null 类型（叫做空）
- null 赋值为一个空
- 举例：我告诉有你桌子上应该有一杯水，当我的桌子上有一个空杯子的时候, 就是 null
- Null 类型, 只有一个值，就是 null，当一个变量只有被赋值为 null 的时候, 你才能得到 null
var n = null // 声明了一个变量叫做 n, 我给他赋值为 null(空)
console.log(n) // 控制台的输出结果为 null
JS数据类型的检测
var n1 = 100 // 定义了一个叫做 n1 的变量, 值存储的是一个 100
var result = typeof(n1) // 把检测 n1 变量的结果赋值给了 result 这个变量
console.log(result) // 检测 n1 这个变量, 控制台输出的结果为 number
var s1 = '100' // 定义了一个叫做 s1 的变量, 值存储的是一个 '100'
var result2 = typeof s1 // 把检测 s1 变量的结果赋值给了 result2 这个变量
console.log(result2) // 检测 s1 这个变量, 控制台输出的结果为 strng
-
只要是多个 typeof 连用, 那么你得到的结果一定是一个 string
- 一个字符串是被引号包裹的, 但是当你把一个字符串打印在控制台的时候
- 浏览器的控制台回把引号去掉, 只显示文本内容给你看
- 你的 typeof(n1) 得到的是 ‘number’, 但是当你打印在控制台的时候
- 浏览器把引号去掉给你看, 你看到的结果就是 number
var n1 = 100 // 定义了一个叫做 n1 的变量, 值存储的是一个 100
var result = typeof(n1) // 检测 n1 变量的数据类型
console.log(result) // result 得到的内容是 'number',控制台输出的结果为number
var result2 = typeof(result) // 检测 result 变量的数据类型
console.log(result2) // result2, 控制台输出的结果为 string
var b1 = true // 定义了一个叫做 b1 的变量, 存储的值是一个 true
var result3 = typeof(b1) // 把检测 b1 变量的结果赋值给了 result3 这个变量
console.log(result3) // 检测 b1 这个变量, 控制台输出的结果为 boolean
var un // 定义一个变量没有赋值, 那么 un 的值就是 undefined
var result4 = typeof un // 把检测 un 变量的结果赋值给了 result4 这个变量
console.log(result4) // 控制台输出的结果为undefined
var n = null // 定义一个变量, 赋值为 null
var result5 = typeof(n) // 把检测 n 变量的结果赋值给了 result5 这个变量
console.log(result5) // 检测 n 这个变量, 控制台输出的结果为 object
-
检测变量的数据类型
-
定义一个变量
-
var num = 100 -
我计算机里面存储的这个 num 变量是一个什么数据类型
-
我们就可以检测一下，使用 typeof 来检测
- typeof num
- typeof(num)
-
只要你 typeof 一下, 他会给你一个结果
- 只要给你的结果是一个 number, 表示这个变量存储的是一个数值类型
- 只要给你的结果是一个 string, 表示这个变量存储的是一个字符串类型
- 只要给你的结果是一个 boolean, 表示这个变量存储的是一个布尔类型
-
typeof 会给你返回一个结果
- 这个被返回的结果又是一个什么数据类型呢 ?
- 我们就要再次检测一下 typeof 的返回值
-
结论: 当你有多个 typeof 连用的时候, 得到的结果一定是 string
-
var n1 = 100 // 定义一个变量
var result = typeof n1 // 把检测 n1 变量的结果赋值给了 result 这个变量
console.log(result) // 控制台的输出结果为 number
var result2 = typeof result // 检测的是 typeof 的返回值的数据类型
console.log(result2) // 控制台的输出结果为 string
JS数据类型的转换
一、数据类型的转换 - 转数值
-
就是把其他数据类型转换成数值类型，有四种方法进行转换
-
Number()
- 语法: Number(你要转换的数据)
- 返回值(结果)： 一个被转换成数值类型以后的数据
- 能转什么, 不能转什么
- 转换一个纯数字的字符串, 那么很明显得到一个合法数字
- 转换一个不能转换成合法数字的字符串, 我们得到的就是 NaN
- 你非得让我给你转成数值, 但是你又成为不了一个合法数值
- 我就只能给你转换成数值类型, 但是告诉你是一个 (not a number)非数字
- 如果你转换布尔值 true, 得到的结果就是 1
- 如果你转换布尔值 false, 得到的结果就是 0
// Number 方法
// 转换合法数字
var s1 = '-100.3456'
console.log(typeof s1) // string
// 把 s1 转换一下, 转换以后的结果赋值给 result 这个变量
var result = Number(s1)
console.log(result) // -100.3456
// 转换一个不合法的字符串
var s1 = 'abc'
console.log(typeof s1) // string
// 把 s1 转换一下, 转换以后的结果赋值给 result 这个变量
var result = Number(s1)
console.log(result) // NaN
// 转换一个布尔值
var s1 = true
console.log(typeof s1) // boolean
// 把 s1 转换一下, 转换以后的结果赋值给 result 这个变量
var result = Number(s1)
console.log(result) // 1
- 小练习
var s1 = 'true' // 布尔值 true 会转换成 1, 但是现在是 字符串 true
var result = Number(s1)
console.log(result) // => 结果是 NaN
var s1 = true // 布尔值 true 会转换成 1
var result = Number(s1)
console.log(result) // => 结果是 1
-
parseInt()
- 语法: parseInt(你要转换的数据)
- 返回值(结果): 一个被转换成数值类型以后的数据
- 转换规则
- 把你要转换的数据从左到右一位一位的看
- 如果第一位就不是一个合法的数字, 那么直接给你 NaN
- 如果第一位是一个合法的数字, 那么就看第二位, 以此类推
- 能解析多少位就解析多少位
- 不认识小数点
var s1 = '100.3456'
var result = parseInt(s1)
console.log(result) // 100
var s1 = true
var result = parseInt(s1) // parseInt 是一位一位的看, 不管你是什么玩意
console.log(result) // NaN
var s1 = '100.345'
var result = parseFloat(s1)
console.log(result) // 100.345
var s1 = false
var result = parseFloat(s1)
console.log(result) // NaN
- 非加法的数学运算都可以转为数值类型(- * / %)
- 加法不行，在 js 里面, 加号有两个含义, 一个叫做 字符串拼接, 一个叫做 数学运算
var s1 = '123.456'
var result = s1 - 0
console.log(result) // 123.456
console.log(typeof result) // number
var s1 = '123.456'
var result = s1 * 1
console.log(result) // 123.456
console.log(typeof result) // number
var s1 = '123.456'
var result = s1 / 1
console.log(result) // 123.456
console.log(typeof result) // number
var s1 = '100'
var res = s1 % 1
console.log(res) // 0
console.log(typeof res) // number
var s1 = '123.456'
var result = s1 + 0
console.log(result) // 123.4560
console.log(typeof result) // string
- 思路拓展：非加法的数学运算
- 我们常见的数学运算有四个：+ - * /
- 当你使用一个其他数据类型去进行 - * / 的数学运算的时候，会先把数据转换成数值类型，再进行数学运算
// 先把'100'转换成数值100
// 再进行100 - 10 的数学运算
console.log('100' - 10) // 90
// 先把'abc'转换成数值，但不能合法转换，就得到NaN
// 再进行NaN - 10的数学运算，得到的结果还是NaN
console.log('abc' - 10) // NaN
// 先把'100'转换成数值100，再把'true'转换成数值，得到NaN
// 最后就是计算100 - NaN 得到 NaN
console.log('100' - 'true') // NaN
// 先把'100'转换成数值100，再把true转换成数值1，
// 最后就是计算100 - 1得到99
console.log('100' - true) // 99
// 先把'100'转换成100，再把 '14asd' 转换成数值, 得到结果就是 NaN
// 最后计算100 - NaN 得到 NaN
console.log( '100' - '14asd') // NaN
-
非加法 和 Number 是把要转换的数据当成一个整体来看
- 整体能转换就是一个转换好的数字
- 整体不能转换，那么就是 NaN
-
精确度拓展 - 即：保留小数点后几位
- 语法：.toFixed(保留几位小数)
var num = 123.456789
console.log(num.toFixed(2)) //保留两位小数，结果为 123.46
二、数据类型转换 - 转字符串
var n1 = 100.234
console.log(n1) // 100.234
var result = String(n1) // 把 n1 转换成字符串赋值给 result 变量
console.log(result) // 100.234
var n1 = true
console.log(n1) // true
var result = String(n1) // 把 n1 转换成字符串赋值给 result 变量
console.log(result) // true
var n1 = null
console.log(n1) // null
var result = String(n1) // 把 n1 转换成字符串赋值给 result 变量
console.log(result) // null
var n1
console.log(n1) // undefined
var result = String(n1) // 把 n1 转换成字符串赋值给 result 变量
console.log(result) // undefined
var n1 = 123.456
console.log(n1) // 123.456
var result = n1.toString()
console.log(result) // 123.456
var n2
console.log(n2) // undefined
var result = n2.toString()
console.log(result) // 控制台报错
var n3 = null
console.log(n3) // null
var result = n3.toString()
console.log(result) // 控制台报错
-
控制台报错信息: Cannot read property ‘toString’ of null
- 前提: 在 JS 里面, 点(.) 除了在数字中, 其他的地方翻译成的
- cannot 不能
- read 读取
- property 属性
- toString()
- of 从
- null
-
进行加法运算
- 再在js 里面, 加号有两个含义, 一个叫做 字符串拼接, 一个叫做 数学运算
- 只要运算符两边有 任意一边 是 字符串, 就会进行字符串拼接
- 只有运算符两边都是 数字 或者 布尔 的时候, 才会进行数学运算
var n1 = 123.456
var n2 = '' // 空字符串
var result = n1 + n2 // 因为 n2 是字符串类型, 就会进行字符串拼接
console.log(result) // 123.456
console.log(typeof result) // string
var n1 = true // 1
var n2 = false // 0
var result = n1 + n2 // 计算 1 + 0
console.log(result) // 1
console.log(typeof result) // number
var n1 = 'hello world'
var n2 = '您好 世界'
var result = n2 + n1
console.log(result) // 您好 世界hello world
console.log(typeof result) // string
- 小练习
// 1 + 2 得到 3
// 3 + '3' 得到 '33'
// '33' + 4 得到 '334'
console.log(1 + 2 + '3' + 4) // 334
// 非 加法的数学运算会转换成数值以后再进行运算
// '3' * 4 得到 12
// 1 + 2 得到 3
// 3 + 12 得到 15
console.log(1 + 2 + '3' * 4) // 15
// 3 * 4 得到 12
// 1 + '2' 得到 '12'
// '12' + 12 得到 '1212'
console.log(1 + '2' + 3 * 4) // 1212
三、数据类型转换 - 转布尔
-
把其他数据类型转换成布尔数据类型
-
Boolean()
- 语法: Boolean(要转换的数据)
- 返回值: 一个布尔值, 被转换好的布尔值
- 因为布尔值只有两个 true 和 false
- 所以任何数据转换布尔的时候, 要么得到 true 要么得到 false
- 所有数据转换成布尔的时候, 只有五个会转换成 false, 剩余的都是 true
- 0
- NaN
- 空字符串
- undefined
- null
var s1 = ''
var result = Boolean(s1)
console.log(result) // false
var s2 = 0
var result2 = Boolean(s2)
console.log(result2) // false
var s3 = NaN
var result3 = Boolean(s3)
console.log(result3) // false
var s4 = null
var result4 = Boolean(s4)
console.log(result4) // false
var s5 = undefined
var result5 = Boolean(s5)
console.log(result5) // false
var s6 = -1231231
var result6 = Boolean(s6)
console.log(result6) // true
JS运算符 - 数学运算符
- 进行数学运算的符号，比较常用的有5个：+ - * / %(取余)
一、+ 加
- 只要符号任意一边是字符串就会进行字符串拼接
- 只有符号两边都是数字或者布尔的时候才会进行数学运算
二、 - 减
- 就是进行减法的数学运算
- 如果不能计算出一个合法数字为结果, 那么就是 NaN
三、* 乘
- 就是进行乘法的数学运算
- 如果不能计算出一个合法数字为结果, 那么就是 NaN
四、/ 除
- 就是进行除法的数学运算
- 如果不能计算出一个合法数字为结果, 那么就是 NaN
五、% 取余 或者叫做 摩
- 就是进行取余的数学运算
- 取余: 两个数字做除法, 得到不能被整除的一部分
- 比如 10 % 3
- 在小学的时候, 10 / 3 = 3 … 1
- 被除数 / 除数 = 商 … 余数
- 结果就是 1
- 如果不能计算出一个合法数字为结果, 那么就是 NaN
console.log(10 % 3) // 1
// 把 10 拆开, 拆成 9 和 1, 9 能被整除, 1 不能被整除
// 10 / 3 = 3 ... 1
JS运算符 - 赋值运算符
- 进行赋值操作的运算符，常用的有六个运算符号
一、= 赋值
- 把符号右边的数据给到符号左边的变量
二、+= 加等于
- 是加法和赋值的合并操作
- 比如：n1 += 20
- 等价于 n1 = n1 + 20
- 先计算 n1 +20 的结果，然后把 n1 + 20 的结果重新赋值给 n1
var n1 = 20
// 先计算 n1 + 30 的结果, 得到 50
// 然后把 n1 + 30 的结果从新赋值给 n1
n1 += 30
console.log(n1) // 50
var n1 = '你好'
// 先计算 n1 + 30 的结果得到字符串 '你好30'
// 把计算结果从新赋值给 n1
n1 += 30 // 等价于 n1 = n1 + 30
console.log(n1) // 你好30
三、-= 减等于
- 是减法和赋值的合并操作
- 比如：n1 -= 20
- 等价于 n1 = n1 - 20
var n1 = 20
// 先计算一个 20 - 10 的结果, 得到 10
// 把 10 从新赋值给 n1
n1 -= 10
console.log(n1) // 10
var n1 = 'hello'
// 先计算一个 'hello' - 20 的结果, 得到 NaN
// 把 NaN 从新赋值给 n1
n1 -= 20
console.log(n1) // NaN
四、*= 乘等于
- 是乘法和赋值的合并操作
- 比如：n1 *= 20
- 等价于 n1 = n1 * 20
五、/= 除等于
- 是除法和赋值的合并操作
- 比如：n1 /= 20
- 等价于 n1 = n1 / 20
六、%= 模等于（取余等于）
- 是取余和赋值的合并操作
- 比如：n1 %= 20
- 等价于 n1 = n1 % 20
JS运算符 - 比较运算符
- 就是对两个数据进行比较，得到的结果一定时布尔值，要么是true，要么是false
一、< 小于
- 符号左边小于符号右边就是 true
- 符号左边大于或者等于符号右边就是 false
console.log(10 < 20) // true
console.log(20 < 20) // false
console.log(22 < 20) // false
二、> 大于
- 符号左边大于符号右边就是 true
- 符号左边小于或者等于符号右边就是 false
console.log(10 > 20) // false
console.log(20 > 20) // false
console.log(22 > 20) // true
三、<= 小于等于
- 符号左边小于或者等于符号右边就是 true
- 符号左边大于符号右边就是 false
console.log(10 <= 20) // true
console.log(20 <= 20) // true
console.log(30 <= 20) // false
四、>= 大于等于
- 符号左边大于或者等于符号右边就是 true
- 符号左边小于符号右边就是 false
console.log(10 >= 20) // false
console.log(20 >= 20) // true
console.log(30 >= 20) // true
五、== 等于
- 符号两遍不考虑数据类型的情况下, 值一样就是 true
- 符号两遍不考虑数据类型的情况下, 值不一样就是 false
console.log(1 == 1) // true
console.log('1' == 1) // true
console.log(true == 1) // true
console.log(undefined == null) // true
console.log(true == 'true') // false
console.log('1' == 0) // false
六、=== 全等于（恒等于）
- 符号两遍必须数据类型一样, 值也一样才是 true
- 符号两遍只要数据类型或者值有一个不一样就是 false
console.log(1 === 1) // true
console.log('1' === 1) // false
console.log(undefined === null) // false
七、!= 不等
- 符号两边不考虑数据类型的情况下, 值不一样就是 true
- 符号两边不考虑数据类型的情况下, 值一样就是 false
console.log(1 != 2) // true
console.log(1 != 1) // false
console.log('1' != 1) // false
八、!== 不等等（不全等）
- 符号两边数据类型不一样, 就会返回 true, 不在考虑值了
- 只有符号两边数据类型和值都一样的时候才会返回 false
// 数字 1 和数字 1 比较是 数据类型也一样, 值也一样
console.log(1 !== 1) // false
// 字符串 '1' 和数字 1 比较, 数据类型不一样, 值一样
console.log('1' !== 1) // true
// 字符串 'a' 和 字符串'a' 数据类型一样, 值也一样
console.log('a' !== 'a') // false
// 中文, 字符串 1 和 字符串 2 数据类型一样, 值不一样
console.log('1' === '2') // false
// 中文, 字符串 1 和 字符串 1 数据类型一样, 值也一样
console.log('1' === '1') // true
九、拓展
- 符号两边 数据类型 和 值 都一样的时候我们叫做全等
- 符号两边 数据类型 或 值 有任意一个不一样就是不全等
JS运算符 - 逻辑运算符
- 数据之间进行逻辑运算
一、&& 与（且）
-
符号两边都是 true 的时候才会得到结果 true
-
符号两边有任意一边是 false 的时候, 就会得到结果 false
-
见假即假
console.log(true && true) // true
console.log(true && false) // false
console.log(false && true) // false
console.log(false && false) // false
// 一个生命不是 猫 && 一个生命不是 狗, 你能不能说他是一个 人？不能
二、|| 或
-
符号两边有任意一边是 true 的时候就会得到结果 true
-
符号两边都是 false 的时候才会得到结果 false
-
见真即真
console.log(true || true) // true
console.log(false || true) // true
console.log(true || false) // true
console.log(false || false) // false
三、! 非(取反)
- 把本来是 true 的变成 false
- 把本来是 false 的变成 true
console.log(!true) // false
console.log(!false) // true
console.log(!0) // 0 本身是 false, false 取反以后就是 true
JS运算符 - 自增自减运算符
- 对一个变量自己本身进行操作
- 自增： 就是自己本身增加1
- 自减： 就是自己本身减少1
一、自增运算符 (++) — 让自身的值 +1
| 分类 | 前置++ | 后置++ |
|---|---|---|
| 概念 | 就是吧 ++ 符号放在变量的前面 (++num) | 就是把 ++ 符号放在变量的后面 (num++) |
| 共同点 | 会让变量自身的值改变(+1) | 会让变量自身的值改变(+1) |
| 区别（当你需要他们参与运算的时候） | 会先改变自身的值, 然后用改变以后的值参数运算 | 会先用自身的值去参与运算, 然后再改变自身的值 |
// 前置 ++
var n = 5
console.log(1 + ++n) // 1 + 6 === 7
// 并且把 n 的值也变成了 6
console.log(n) // 6
// 后置 ++
var n = 5
// 后置++ 先把 n 本身的值拿过来参与运算, 然后再改变 n 本身的值
// 目前 n 本身的值 5, 当我计算 1 + n++ 的时候
// 就是计算 1 + n本身的值, 也就是 1 + 5
console.log(1 + n++) // 1 + 5 === 6
// 后置++ 也会把 n 的值改变了
console.log(n) // 6
var n = 5
// 执行 1 + n++ 和 执行 1 + n 有什么区别, 因为得到的都是 6
// 上面两个运算结果没有区别, 区别在于运算结束以后, n 的值
// 因为不管前置++ 还是后置++ 只要运行了, 就会改变 n 的值
// 1 + n++, 这个代码运行完毕以后, n 会变成 6
// 1 + n, 这个代码运行完毕以后, n 还是 5
console.log(1 + n++) // 6, 此时 n === 6
console.log(1 + n) //7
var n = 5
// 5 + ++n + ++n + n++, 此时 n === 6
// 5 + 7 + ++n + n++, 此时 n === 7
// 5 + 7 + 8 + n++, 此时 n === 8
// 5 + 7 + 8 + 8, 此时 n === 9
console.log(n++ + ++n + ++n + n++) // 28
console.log(n) // 9
var n = 11
// 12 + ++n + n++ + ++n, 此时 n === 12
// 12 + 13 + n++ + ++n, 此时 n === 13
// 12 + 13 + 13 + ++n, 此时 n ===14
// 12 + 13 + 13 + 15, 此时 n ===15
console.log(++n + ++n + n++ + ++n) // 53
console.log(n) // 15
二、自减运算符 (–) — 让自身的值 -1
| 分类 | 前置– | 后置– |
|---|---|---|
| 概念 | 就是把 – 符号写在变量的前面 (–num) | 就是把 – 符号写在变量的后面 (num–) |
| 共同点 | 会让变量自身的值改变(-1) | 会让变量自身的值改变(-1) |
| 区别（当你需要他们参与运算的时候） | 前置-- 会先改变自身的值, 然后用改变后的值参与运算 | 后置-- 会先把变量自身的值拿来参与运算, 然后再改变自身的值 |
var n = 6
// 6 + ++n + --n + n-- + ++n + n--, 此时 n === 7
// 6 + 8 + --n + n-- + ++n + n--, 此时 n === 8
// 6 + 8 + 7 + n-- + ++n + n--, 此时 n === 7
// 6 + 8 + 7 + 7 + ++n + n--, 此时 n === 6
// 6 + 8 + 7 + 7 + 7 + n--, 此时 n === 7
// 6 + 8 + 7 + 7 + 7 + 7, 此时 n === 6
console.log(n++ + ++n + --n + n-- + ++n + n--) // 42
console.log(n) // 6
var n = 5
var m = 6
// 6 + --m + m++ + n-- + m++ + --n, 此时 n === 6, m === 6
// 6 + 5 + m++ + n-- + m++ + --n, 此时 n === 6, m === 5
// 6 + 5 + 5 + n-- + m++ + --n, 此时 n === 6, m === 6
// 6 + 5 + 5 + 6 + m++ + --n, 此时 n === 5, m === 6
// 6 + 5 + 5 + 6 + 6 + --n, 此时 n === 5, m === 7
// 6 + 5 + 5 + 6 + 6 + 5, 此时 n === 4, m === 7
console.log(++n + --m + m++ + n-- + m++ + --n) // 32
console.log(n) // 4
console.log(m) // 7
扫一扫
1793
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
