JavaScript分支结构语句知识点梳理

数据类型转换 - 转数值
1. parseInt()
2. parseFloat()
3. Number()
4. 非 加法 的数学运算
+ parseInt 和 parseFloat 方法在转换的时候时一位一位的看
=> 第一位就不能转换的时候, 直接给出 NaN
=> 第一位可以转换, 那么保留第一位, 继续看第二位, 以此类推
=> parseInt() 不认识小数点, parseFloat() 认识小数点
+ Number 和 非加法 是把要转换的数据当成一个整体来看
=> 整体能转换就是一个转换好的数字
=> 整体不能转换, 那么就是 NaN
+ NaN
=> 是一个数值类型的数据, 但是不是一个数字
=> not a number
非 加法 的数学运算
+ 我们常见的数学运算有四个 + - * /
+ 当你使用一个其他数据类型去进行 - * / 的数学运算的时候
+ 会先把数据转换成 数值 类型 再进行数学运算
+ 比如: ‘100’ - 10
=> 先把 ‘100’ 转换成数值 100
=> 再进行 100 - 10 的数学运算
+ 比如: ‘abc’ - 10
=> 先把 ‘abc’ 转换成数值, 但是不能合法转换, 就得到 NaN
=> 再进行 NaN - 10 的数学运算, 得到的结果还是 NaN
+ 比如: ‘100’ - ‘true’
=> 先把 ‘100’ 转换成数值 100
=> 把 ‘true’ 转换成数值, 得到 NaN
=> 最后就是计算 100 - NaN 得到 NaN
+ 比如: ‘100’ - true
=> 先把 ‘100’ 转换成数值 100
=> 把 true 转换成数值 1
=> 最后就是计算 100 - 1 得到 99
+ 比如: ‘100’ - ‘14asd’
=> 先把 ‘100’ 转换成数值 100
=> 把 ‘14asd’ 转换成数值, 得到结果就是 NaN
=> 最后计算 100 - NaN 得到 NaN
数据类型转换 - 转字符串
+ 把其他类型转换成字符串类型
1. String()
=> 语法: String(要转换的数据)
=> 返回值: 一个字符串, 被转换好的字符串
=> 任何数据类型都能转换
2. toString()
=> 语法: 要转换的数据.toString()
-> 括号里面啥也不用写, 但是括号你得写上
=> 返回值: 一个字符串, 被转换好的字符串
=> undefined 和 null 转换不了, 别的都可以
3. 进行 加法 运算
=> 再 js 里面, 加号有两个含义, 一个叫做 字符串拼接, 一个叫做 数学运算
=> 只要运算符两边有 任意一边 是 字符串, 就会进行字符串拼接
=> 只有运算符两边都是 数字 或者 布尔 的时候, 才会进行数学运算
报错信息: Cannot read property ‘toString’ of null
=> 前提: 再 JS 里面, 点(.) 除了再数字中, 其他的地方翻译成 的
=> cannot 不能
=> read 读取
=> property 属性
=> toString()
=> of 从
=> null
// 小练习
// 1 + 2 得到 3
// 3 + ‘3’ 得到 ‘33’
// ‘33’ + 4 得到 ‘334’
// console.log(1 + 2 + ‘3’ + 4)
// ‘3’ * 4 得到 12 // 非 加法的数学运算会转换成数值以后再进行运算
// 1 + 2 得到 3
// 3 + 12 得到 15
// console.log(1 + 2 + ‘3’ * 4)
// 3 * 4 得到 12
// 1 + ‘2’ 得到 ‘12’
// ‘12’ + 12 得到 ‘1212’
// console.log(1 + ‘2’ + 3 * 4
// 加法运算
// var n1 = 123.456
// var n2 = ‘’ // 空字符串
// var result = n1 + n2 // 因为 n2 是字符串类型, 就会进行字符串拼接
// console.log(result)
// var n1 = true // 1
// var n2 = false // 0
// var result = n1 + n2 // 计算 1 + 0
// console.log(result)
// var n1 = ‘hello world’
// var n2 = ‘您好 世界’
// var result = n2 + n1
// console.log(result)
// toString()
// var n1 = 123.456
// console.log(n1)
// var result = n1.toString()
// console.log(result)
// var n1
// console.log(n1)
// var result = n1.toString()
// console.log(result)
// String()
// var n1 = 100.234
// console.log(n1)
// // 把 n1 转换成字符串赋值给 result 变量
// var result = String(n1)
// console.log(result)
// var n1 = true
// console.log(n1)
// // 把 n1 转换成字符串赋值给 result 变量
// var result = String(n1)
// console.log(result)
// var n1 = null
// console.log(n1)
// // 把 n1 转换成字符串赋值给 result 变量
// var result = String(n1)
// console.log(result)
// var n1
// console.log(n1)
// // 把 n1 转换成字符串赋值给 result 变量
// var result = String(n1)
// console.log(result)
数据类型转换 - 转布尔
+ 把其他数据类型转换成布尔数据类型
1. Boolean()
=> 语法: Boolean(要转换的数据)
=> 返回值: 一个布尔值, 被转换好的布尔值
=> 因为布尔值只有两个 true 和 false
=> 所以任何数据转换布尔的时候, 要么得到 true 要么得到 false
=> 所有数据转换成布尔的时候, 只有五个会转换成 false, 剩余的都是 true
-> 0
-> NaN
-> ‘’(空字符串)
-> undefined
-> null
运算符 - 数学运算符
+ 进行数学运算的符号
+ 比较常用的有五个 + - * / %(取余)
1. + 加
+ 只要符号任意一边是字符串就会进行字符串拼接
+ 只有符号两边都是数字或者布尔的时候才会进行数学运算
2. - 减
+ 就是进行减法的数学运算
+ 如果不能计算出一个合法数字为结果, 那么就是 NaN
3. * 乘
+ 就是进行乘法的数学运算
+ 如果不能计算出一个合法数字为结果, 那么就是 NaN
4. / 除
+ 就是进行除法的数学运算
+ 如果不能计算出一个合法数字为结果, 那么就是 NaN
5. % 取余 或者叫做 摩
+ 就是进行取余的数学运算
+ 取余: 两个数字做除法, 得到不能被整除的一部分
=> 比如 10 % 3
=> 再小学的时候, 10 / 3 = 3 … 1
被除数 / 除数 = 商 … 余数
=> 结果就是 1
+ 如果不能计算出一个合法数字为结果, 那么就是 NaN
console.log(10 % 3)
// 把 10 拆开, 拆成 9 和 1, 9 能被整除, 1 不能被整除
// 10 / 3 = 3 … 1
运算符 - 赋值运算符
+ 进行赋值操作的运算符号
+ 常用的有六个运算符号
1. = 赋值
+ 把 符号 右边的数据给到 符号 左边的变量
2. += 加等于
+ 是 加法 和 赋值 的合并操作
+ 比如: n1 += 20
=> 等价于 n1 = n1 + 20
=> 先计算 n1 + 20 的结果
=> 然后把 n1 + 20 的结果从新赋值给 n1
3. -= 减等于
+ 是 减法 和 赋值 的合并操作
+ 比如: n1 -= 20
=> 等价于 n1 = n1 - 20
4. *= 乘等于
+ 是 乘法 和 赋值 的合并操作
+ 比如: n1 *= 20
=> 等价于 n1 = n1 * 20
5. /= 除等于
+ 是 除法 和 赋值 的合并操作
+ 比如: n1 /= 20
=> 等价于 n1 = n1 / 20
6. %= 模等于 取余等于
+ 是 取余 和 赋值 的合并操作
+ 比如: n1 %= 20
=> 等价于 n1 = n1 % 20
// -=
// var n1 = ‘hello’
// // 先计算一个 ‘hello’ - 20 的结果, 得到 NaN
// // 把 NaN 从新赋值给 n1
// n1 -= 20
// console.log(n1)
// +=
// var n1 = 20
// // 先计算 n1 + 30 的结果, 得到 50
// // 然后把 n1 + 30 的结果从新赋值给 n1
// n1 += 30
// console.log(n1)
// var n1 = ‘你好’
// // 先计算 n1 + 30 的结果得到字符串 ‘你好30’
// // 把计算结果从新赋值给 n1
// n1 += 30 // 等价于 n1 = n1 + 30
// console.log(n1)
运算符 - 比较运算符
+ 就是对两个数据进行比较
+ 得到的结果一定是布尔值, 要么是 true 要么是 false
1. < 小于
+ 符号左边小于符号右边就是 true
+ 符号左边大于或者等于符号右边就是 false
2. > 大于
+ 符号左边大于符号右边就是 true
+ 符号左边小于或者等于符号右边就是 false
3. <= 小于等于
+ 符号左边小于或者等于符号右边就是 true
+ 符号左边大于符号右边就是 false
4. >= 大于等于
+ 符号左边大于或者等于符号右边就是 true
+ 符号左边小于符号右边就是 false
5. == 等于
+ 符号两遍不考虑数据类型的情况下, 值一样就是 true
+ 符号两遍不考虑数据类型的情况下, 值不一样就是 false
6. === 全等于 恒等于
+ 符号两遍必须数据类型一样, 值也一样才是 true
+ 符号两遍只要数据类型或者值有一个不一样就是 false
7. != 不等
+ 符号两边不考虑数据类型的情况下, 值不一样就是 true
+ 符号两边不考虑数据类型的情况下, 值一样就是 false
8. !== 不等等 不全等
+ 符号两边数据类型不一样, 就会返回 true, 不在考虑值了
+ 只有符号两边数据类型和值都一样的时候才会返回 false
+ 符号两边 数据类型 和 值 都一样的时候我们叫做全等
+ 符号两边 数据类型 或 值 有任意一个不一样就是不全等
// !==
console.log(1 !== 1) // 数字 1 和数字 1 比较是 数据类型也一样, 值也一样
console.log(‘1’ !== 1) // 字符串 ‘1’ 和数字 1 比较, 数据类型不一样, 值一样
console.log(‘a’ !== ‘a’) // 字符串 ‘a’ 和 字符串’a’ 数据类型一样, 值也一样
console.log(‘1’ === ‘2’) // 中文, 字符串 1 和 字符串 2 数据类型一样, 值也一样
// 中文, 数字 1 和 数字 1 数据类型不一样, 值也不一样, 这句话是对的还是错的 false
// 中文, 字符串 1 和 数字 1 数据类型不一样, 这句话是对的还是错的 true
// 中文, 字符串 a 和 字符串 a 数据类型不一样, 值也不一样, 这句话是对的还是错的 false
// !=
// console.log(1 != 2)
// console.log(1 != 1)
// console.log(‘1’ != 1)
// ===
// console.log(1 === 1)
// console.log(‘1’ === 1)
// console.log(undefined === null)
// ==
// console.log(1 == 1)
// console.log(‘1’ == 1)
// console.log(true == 1)
// console.log(undefined == null)
// console.log(true == ‘true’)
// console.log(‘1’ == 0)
// >=
// console.log(10 >= 20)
// console.log(20 >= 20)
// console.log(30 >= 20)
// <=
// console.log(10 <= 20)
// console.log(20 <= 20)
// console.log(30 <= 20)
// >
// console.log(10 > 20)
// console.log(20 > 20)
// console.log(22 > 20)
// <
// console.log(10 < 20)
// console.log(20 < 20)
// console.log(22 < 20)
运算符 - 逻辑运算符
数据之间进行逻辑运算
1. && 与 且
符号两边都是 true 的时候才会得到结果 true
符号两边有任意一边是 false 的时候, 就会得到结果 false
2. || 或
符号两边有任意一边是 true 的时候就会得到结果 true
符号两边都是 false 的时候才会得到结果 false
3. ! 非(取反)
把本来是 true 的变成 false
把本来是 false 的变成 true
// !
console.log(!true)
console.log(!false)
console.log(!0) // 0 本身是 false, false 取反以后就是 true
// ||
// console.log(true || true)
// console.log(false || true)
// console.log(true || false)
// console.log(false || false)
// &&
// console.log(true && true)
// console.log(true && false)
// console.log(false && true)
// console.log(false && false)
// 一个生命不是 猫 && 一个生命不是 狗, 你能不能说他是一个 人
运算符 - 自增自减运算符
对一个变量自己本身进行操作
自增： 就是自己本身增加(1)
自减： 就是自己本身减少(1)
1. 自增运算符 (++)
让自身的值 +1
前置++
就是吧 ++ 符号放在变量的前面 (++num)
后置++
就是把 ++ 符号放在变量的后面 (num++)
共同点:
不管前置 ++ 还是后置 ++ 都会让变量自身的值改变(+1)
区别: 当你需要他们参与运算的时候
前置++ 会先改变自身的值, 然后用改变以后的值参数运算
后置++ 会先用自身的值去参与运算, 然后再改变自身的值
2. 自减运算符 (–)
让自身的值 -1
前置–
就是把 – 符号写在变量的前面 (–num)
后置–
就是把 – 符号写在变量的后面 (num–)
共同点:
不管前置 – 还是后置 – 都会让变量自身的值改变(-1)
区别: 当你需要他们参与运算的时候
前置-- 会先改变自身的值, 然后用改变后的值参与运算
后置-- 会先把变量自身的值拿来参与运算, 然后再改变自身的值
// 综合小练习
// var n = 6
// console.log(n++ + ++n + --n + n-- + ++n + n–) // 42
// console.log(n) // 6
var n = 5
var m = 6
console.log(++n + --m + m++ + n-- + m++ + --n) // 32
console.log(n) // 4
console.log(m) // 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
// console.log(++n + ++n + n++ + ++n) // 53
// console.log(n) // 15
// 后置++
// var n = 5
// // 需要用到 n++ 去参与运算了
// // 因为是后置++, 所以先把 n 本身的值参与运算
// // 也就是 10 和 5 进行加法运算
// // 再来把 n 自身的值 +1
// // 把 n 变成 6
// console.log(10 + n++) // 10 + 5 === 15
// console.log(n) // 6
// ++
// var num = 5 // 定义了一个变量 num 他的值是 5
// console.log(num)
// ++num // 执行了一个后置++ 代码, 让 num 的值再自身的基础上 +1
// // 从此以后 num 的值变成了 6
// console.log(num)
// num++ // 执行了一个前置 ++ 代码, 让 num 的值再自身的基础上 +1
// // 从此以后 num 的值变成了 7
// console.log(num)
// 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++)
// console.log(1 + n)
了解分支结构语句
JS 代码应该是从上到下的执行
分支结构: 当执行到某一个部分的时候, 根据条件来选择是否执行某段代码
翻译插件: comment translate
1. if 分支
有四种书写方式
1. if (条件) { 代码 }
只要条件满足就执行 {} 里面的代码
只要条件不满足, 就不执行 {} 里面的代码
满足: 条件为 true
不满足: 条件为 false
2. if (条件) { 条件成立就执行 } else { 条件不成立就执行 }
条件满足执行 if 后面的 {} 里面的代码
条件不满足就执行 else 后面的 {} 里面的代码
两个 {} 必然会执行一个
3. if (条件) { 条件满足就执行 } else if (条件2) { 条件2满足就执行 } …
从第一个条件开始, 哪一个条件满足了, 就执行哪一个条件后面的 {} 里面的代码
前面的条件满足了, 后面的条件就全部不管了, 直接跳过
4. if (条件) { 成立就执行 } else if (条件2) { 条件2 成立就执行 } else {}
从第一个条件开始, 哪一个条件满足了就执行哪一个条件后面的 {} 里面的代码
所有的条件都不满足的时候, 就执行 else 后面 {} 里面的代码
前面的条件满足了, 后面的条件就全都不管了, 直接跳过
// if … else if … else 语句
var age = 5
if (age >= 23) {
console.log(‘我可以结婚了’)
} else if (age >= 14) {
console.log(‘我可以谈恋爱了’)
} else if (age >= 6) {
console.log(‘可以和女同学坐同桌’)
} else {
console.log(‘只能在家和小姨玩’)
}
// if … else if 语句
// var age = 25
// if (age >= 23) {
// console.log(‘我可以结婚了’)
// } else if (age >= 14) {
// console.log(‘我可以谈恋爱了’)
// } else if (age >= 6) {
// console.log(‘可以和女同学坐同桌’)
// }
用 if 语句判断一个整数数字是不是偶数
当一个数字除以 2 得到的余数为 0 的时候, 表示整除了, 那么表示这个数字是偶数
当一个数字除以 2 得到的余数为 1 的时候, 表示没有整除, 那么表示这个数字是奇数
=: 是赋值
: 是不考虑数据类型的比较
=: 是考虑数据类型的比较
// var num = 13
// if (num % 2 === 0) {
// // 如果这个位置的代码执行了
// // 表示 num % 2 === 0 是一个 true
// // 表示 num % 2 的结果就是 0
// // 表示整除, 表示是一个偶数
// console.log(num + ’ 是偶数’)
// } else {
// // 否则就是没有整除, 那么就不是偶数
// console.log(num + ’ 不是偶数’)
// }
和页面进行一个小小的交互
学习一个小方法叫做 prompt()
方法是在浏览器弹出一个输入框
小括号里面写的是一个提示的文本内容
返回值: 用户在文本框里面输入的内容
注意: 从页面中获取到的内容是一个字符串格式
如果你要进行加法运算, 要先记得转换一下数值类型
// prompt 会弹出一个输入框让用户输入内容
// result 接收的就是用户输入的内容
var result = prompt(‘请输入你的银行存款’)
// 判断如果你的银行存款 > 十万, 咱俩可以聊会天
// 判断如果你的银行存款 < 十万, 那么我还有事不好意思
if (result >= 100000) {
alert(‘hello nice to meet you!’)
} else {
alert(‘我还有事, 先走了, 不好意思’)
}
if 小练习2 - 判断一个数字是不是在某一个范围之间
比如: 判断一个数字是不是在 10 ~ 100 之间的一个数字
不能直接写成 10 < num < 100
必须要拆开成两个条件
1. 10 < num
2. num < 100
要同时满足两个条件
10 < num && num < 100
var num = 203
if (10 < num && num < 100) {
console.log(num + ’ 是在 10 ~ 100 之间’)
} else {
console.log(num + ’ 不是在 10 ~ 100 之间’)
}
// if … else 语句
// var age = 16
// if (age >= 18) {
// console.log(‘去网吧上网’)
// } else {
// console.log(‘在家里上网’)
// }
// if 语句
// var age = 16
// // 因为 age >= 18 得到的结果是 false
// // 所以 {} 里面的代码不会执行
// if (age >= 18) {
// console.log(‘在网吧上网’)
// }
if 小练习 - 判断一个年份是不是闰年
当一整个条件中同时出现 && 和 || 的时候, 先 && 后 ||
闰年:
公历年份是4的倍数的，且不是100的倍数，为普通闰年
公历年份是整百数的，必须是400的倍数才是, 世纪闰年
条件:
第一种: 能被 4 整除 并且 不能被 100 整除
第二种: 能被 400 整除
第一种 或者 第二种 满足一个就行
代码:
能被 4 整除: year % 4 === 0
不能被 100 整除: year % 100 ! 0
能被 400 整除: year % 400 === 0
var year = 2008
if (year % 4 === 0 && year % 100 ! 0 || year % 400 === 0) {
console.log(year + ’ 是闰年’)
} else {
console.log(year + ’ 是平年’)
}