转换为字符串类型
1. 变量.toString() 方法 注意: S 是大写的
注意: undefined 类型 和 null 不能使用 toString 方法
(因为 JS 没有给我们提供, 或者说 JS 不允许)
2. String(变量) 注意 S 也是大写
什么类型都可以转换为字符串类型的, 包括undefined 和 null 类型
3. 扩展: 开发时常用的一个方法!
变量 + ''
转换结果于 String 类似, 写法上更简单一些, 所以推荐使用
// var str1 = 100
// console.log(typeof(str1), str1) // number 100
// console.log(typeof(str1.toString()), str1.toString()) // string 100
// 1. 变量.toString()
// var str1 = 100
// console.log(typeof(str1.toString()), str1.toString()) // string 100
// var str2 = true
// console.log(typeof(str2.toString()), str2.toString()) // string true
// var str3 = false
// console.log(typeof(str3.toString()), str3.toString()) // string false
// var str4 = undefined
// // console.log(typeof(str4.toString()), str4.toString()) // 这里会报错, 因为 undefined 不能使用 toString
// var str5 = null
// // console.log(typeof(str5.toString()), str5.toString()) // 这里会报错, 因为 null 不能使用 toString
// 2. String(变量)
// var str1 = 100
// console.log(typeof(String(str1)), String(str1)) // string 100
// var str2 = true
// console.log(typeof(String(str2)), String(str2)) // string true
// var str3 = false
// console.log(typeof(String(str3)), String(str3)) // string false
// var str4 = undefined
// console.log(typeof(String(str4)), String(str4)) // string undefined
// var str5 = null
// console.log(typeof(String(str5)), String(str5)) // string null
// 3. 变量 + ''
var str1 = 100
var str2 = true
var str3 = false
var str4 = undefined
var str5 = null
console.log(typeof(str1 + ''), str1 + '') // string 100
console.log(typeof(str2 + ''), str2 + '') // string true
console.log(typeof(str3 + ''), str3 + '') // string false
console.log(typeof(str4 + ''), str4 + '') // string undefined
console.log(typeof(str5 + ''), str5 + '') // string null
转换为布尔类型
Boolean(变量) 将其他数据类型, 转换为 布尔值(也就是转换为 true 或者 false)
// 1. 数字转换布尔值, 只有0会转换为 false 其他的数字都会转换为 true, (非0即为真)
var num1 = 100
var num2 = 0
var num3 = -1
// console.log(num1, '-->', Boolean(num1)) // 100
// console.log(num2, '-->', Boolean(num2)) // 0
// console.log(num3, '-->', Boolean(num3)) // -1
// 2. 字符串转换布尔值, 只有 空字符串 会转换为 false 其他的字符串都会转换为 true
var str1 = ''
var str2 = ' '
var str3 = 'abc'
var str4 = '0'
// console.log(str1, '-->', Boolean(str1)) // ''
// console.log(str2, '-->', Boolean(str2)) // ' '
// console.log(str3, '-->', Boolean(str3)) // 'abc'
// console.log(str4, '-->', Boolean(str4)) // '0'
// 3. undefined 和 null 转换为 布尔值的时候 就是 false (重点, 以后会常用!!!)
var und = undefined
var nul = null
console.log(und, '-->', Boolean(und)) // undefined
console.log(nul, '-->', Boolean(nul)) // null
JS 的运算符
1. 算术运算符
加减乘除 取余(求余数)
+ - * / %
注意: + 运算符, 相加时如果两边都是数字, 那么会运算数字的相加操作
相加时如果两边有一个不是数字的, 比如出现一个字符串, 那么运行的不是在相加, 而是拼接操作
拼接操作只有 + 运算时会出现, 其他符号不出现
其他运算符在遇到两边有非数字类型时, 会将其转换为 数字(这一步就叫做隐式转换), 然后在运算
2. 赋值运算符
3. 比较运算符
4. 逻辑运算符
5. 自增自减运算符
console.log(1 + 1)
console.log(1 + 1)
console.log(3 + 4)
console.log(5 + 0)
console.log(5 + '0')
console.log(1 - 1)
console.log(3 - 4)
console.log(5 - 0)
console.log(5 - '0')
- 两边出现了一个 字符串类型的 0, JS 会帮助我们将他的类型先转换为 数字 然后在运算减法
也就是会计算 数字5 - 数字0 ---> 5
console.log(1 * 1)
console.log(3 * 4)
console.log(5 * 0)
console.log(5 * '0')
* 两边出现了一个 字符串类型的 0, JS 会帮助我们将他的类型先转为 数字, 然后在运算减法
也就是会 计算 数字5 * 数字0 ---> 0
console.log(5 / 1)
console.log(12 / 3)
console.log(6 / 2)
console.log(6 / '2')
/ 两边出现了 一个 字符串类型的 '2', JS 会帮助我们将他的类型先转为 数字, 然后在运算除法
也就是会计算 数字6 / 数字2 --> 3
console.log(5 % 1)
console.log(10 % 3)
console.log(6 % 2)
console.log(6 % '2')
% 两边出现了 一个 字符串类型的 '2', JS 会帮助我们将他的类型先转为数字, 然后在运算取余
也就是 计算 数字6 % 数字2 --> 0
console.log(5 / 0)
console.log(5 % 0)
0.1 + 0.2 不等于 0.3
JS 的赋值运算符
=
+= 相当于是 "我自身" 加上一个新值, 就可以用这个 += 来优化, 例子: a = a + 10 优化后: a += 10
-= *= /= %= 运算逻辑与 += 是完全相同的
var a = 1
console.log(a)
var b = 2
console.log(b)
+=
var a = 1
a = a + 10
console.log(a)
var a = 1
a += 10
console.log(a)
-=
var a = 5
a -= 5
console.log(a)
*=
var a = 2
a *= 5
console.log(a)
/=
var a = 4
a /= 2
console.log(a)
%=
var a = 10
a %= 3
console.log(a)
比较运算符
比较运算符 比较运算符两边的值之后, 返回一个 布尔值, 也就是返回一个true或者false
判断 大于 小于 大于等于 小于等于
> < >= <=
判断相等
注意: = 赋值号
== === 在JS中 等号出现两次或者三次时代表 等于的意思
两个等号与 三个等号的区别 (面试可能会问)
== 在JS中判断时会做隐式转换, 也就是说 只会对比值是否相等, 不会对比数据类型
=== 在 JS 中也叫做全等, 在判断的时候不会做隐式转换, 也就是说, 在对比时除了会对比值是否相等, 还会判断数据类型
判断不相等
!= !==
共同点: 判断符号两边的值是否不相等, 不相等时返回 true 相等时返回 false
不同点
!= 不会对比数据类型
!== 会对比数据类型
console.log(1 + 1)
比较两边的值, 然后返回一个 布尔值, 也就是返回一个 true 或者 false
console.log(3 > 4)
console.log(4 > 3)
console.log(5 < 6)
console.log(6 < 5)
console.log(1 > 1)
console.log(1 >= 1)
console.log(1 < 1)
console.log(1 <= 1)
console.log(1 == 1)
console.log(99 === 99)
console.log(1 == '1')
console.log(1 === '1')
console.log(3 != 4)
console.log(9 !== 20)
console.log(3 != '3')
console.log(3 !== '3')
逻辑运算符
&& 逻辑与(相当于并且的意思)
|| 逻辑或(相当于或者的意思)
! 逻辑非(取反, 反义词)
逻辑与运算符的特性!!!
符号左边的值 如果为真(也就是转为布尔值后为true), 那么会返回 符号右边的值
如果为 假(也就是转为布尔值后为 false), 那么会将自身返回出去
逻辑或运算符的特性!!!
符号左边的值 如果为真, 那么会将自身返回出去
如果为假, 那么会将符号右侧的值返回出去
逻辑非运算符的特性!!!
语法: !值
返回值: 将值转换为布尔值之后, 做一个取反的操作, 也就是 true 改变false, false改变为 true
&&
console.log(1 && 100)
console.log(0 && 99)
console.log(true && 'qwer')
console.log(false && 'qwer')
|| shift + 回车键上边的 |
console.log(1 || 100)
console.log(0 || 99)
!
console.log(!99)
console.log(!0)
console.log(!true)
自增自减运算符
++ --
语法:(自增自减都是相同的语法, 这里就拿 自增为例)
1. ++值
2. 值++
自增运算符的能力就是将自身的值 +1
自减运算符的能力就是将自身的值 -1
自增自减运算符 写法不同, 运行结果也不同
1. ++值(++在前)
如果 ++ 在前, 那么会先将自身的值 +1 然后参与其他的
2. 值++(++在后)
如果 ++ 在后, 那么会先参与周围的运算, 然后将自身的值 +1
自减运算符在前与在后的作用与 自增运算符完全相同, 只不过是 -1
var a = 1
var b = 1
console.log(++a)
console.log(b++)
console.log(a, b)
if 分支语句的基本写法
var a = 3
if (条件) {要执行的代码}
if (a === 1) {
console.log(1)
}
if (a === 2) {
console.log(2)
}
if...else... 的嵌套写法
var a = 2
if (a === 1) {
console.log(1)
} else if (a === 2) {
console.log(2)
} else {
console.log('a 不等于 1或者2')
}
运行流程:
首先判断 a 是否等于 1, 如果满足条件, 直接打印1 ,并结束这个分支
如果不满足, 会进入下一个分支的判断, 判断a 是否等于 2, 如果满足条件, 直接打印 2, 并结束这个分支
最后结尾的 else 分支 只会在 前边所有的条件都不满足的时候 才会执行, 前边如果有一个条件成立, 那么 else 就不会执行
