目录
- 1. 运算符(操作符)
- 1.1 算数运算符
- 1.2 递增和递减运算符
- 1.3 比较运算符
- 1.4 逻辑运算符
- 1.5 赋值运算符
- 1.6 运算符优先级
- 2. 流程控制
- 2.1 if 的语法结构
- 2.2 if else双分支语句
- 2.3 if else if语句（多选1）
- 2.4 三元表达式
- 2.5 switch分支流程控制
- 总结
1. 运算符(操作符)
「运算符」是用于实现赋值、比较和执行算数运算等功能的符号。常用运算符分类如下
- 算数运算符
- 递增和递减运算符
- 比较运算符
- 逻辑运算符
- 赋值运算符
1.1 算数运算符
| 运算符 | 描述 | 案例 |
|---|---|---|
| + | 加 | 10+20=30 |
| – | 减 | 10-20=-10 |
| * | 乘 | 10*20=200 |
| / | 除 | 10/20=0.5 |
| % | 取余(取模) | 返回除法的余数9%2=1 |
//alert(1 + 1);
console.log(1 + 1); //运算符的左右两侧都要敲空格
//alert(1 - 1); //0
//alert(1 * 1); //1
//alert(1 / 1); //1
1. % 取余（取模）
//alert(4 % 2); //0 //alert(5 % 3); //2 //alert(3 % 5); //3 注意！！！！！！！！！！
2.浮点数 算数运算里面会有问题
var result = 0.1 + 0.2; // 结果不是 0.3，而是：0.30000000000000004 console.log(0.07 * 100); // 结果不是 7， 而是：7.000000000000001
浮点数值的最高精度是17位小数，但是在进行算数运算时其精确度远远不如整数,所以不要直接判断两个浮点数是否相等!
3. 我们不能直接拿浮点数来进行相比较 是否相等
var num = 0.1 + 0.2; alert(num == 0.3); //false 要转化为2进制，精确度会有误差
- 表达式与返回值
- 表达式：由数字、运算符和变量组成的式子。
- 返回值：每一个表达式经过相应的运算之后，会有一个最终结果，称为表达式的返回值
// 是由数字、运算符、变量等组成的式子 我们称为表达式 1+1 // alert(1 + 1); //2 就是返回值 //写法 //1 + 1=2 // 在我们程序里面 2 = 1 + 1 把我们右边表达式计算完毕把返回值给左边 var num = 1 + 1; // alert(num); //2
1.2 递增和递减运算符
如果需要反复给数字变量添加或减去1，可以使用递增（ + + ）和递减（ – – ）运算符来完成。
在javascript 中，递增（ + + ）和递减（ – – ）运算符既可以放在变量前面，也可以放在变量后面。放在变量前面时，称为前置递增（ 递减 ）运算符，放在后面是后置递增（ 递减 ）运算符
注意：递增和递减运算符必须配合变量使用。
前置递增运算符使用口诀：先自加，后返回值
<script>
//1. 想要一个变量自己加1 num=num+1 比较麻烦
var num = 1;
num = num + 1; // ++num
num = num + 1;
//alert(num); //3
//2. 前置递增运算符 ++写在变量前面
var age = 20;
++age; //类似于 age = age + 1
//alert(age); //21
// 3. 先加1 后返回值
var p = 10;
alert(++p + 10); //21
</script>
前置递增运算符使用口诀：先返回值原值 后自加1
<script>
var num = 10;
num++; // num = num + 1 ++num
// alert(num); //11
//1. 前置自增和后置自增如果单独使用 效果是一样的
//2. 后置自增 口诀：先返回值原值 后自加1
var age = 10;
//alert(age++ + 10); //20
//alert(age); //11
//alert(age + 10); //21
</script>
案例：
<script>
var a = 10;
++a; //++a = 11 a=11 ++a 是表达式
var b = ++a + 2; // a=12 a++ = 12 前置：先自加，后返回值
//alert(b); //14
var c = 10;
c++; //c++ = 11 c = 11
var d = c++ + 2; //c++ = 11 c = 12 后置：先原值返回，后自加
//alert(d); //13
var e = 10;
var f = e++ + ++e; // e++ =10 e=11 ++e=12
console.log(f); //22
// 后置自增 先表达式返回原值 后面变量再自加1
// 前置自增 先自加，后运算
// 单独使用 ，运行结果相同
// 开发时，大多数使用后置递增/减，并且代码独占一行，例如：num++;或者num--
</script>
1.3 比较运算符
比较运算符是两个数据进行比较时所使用的运算符，比较运算符，会返回一个布尔值（true/false）作为比较运算的结果。
| 运算符 | 描述 | 案例 |
|---|---|---|
| + | 加 | 10+20=30 |
| – | 减 | 10-20=-10 |
| * | 乘 | 10*20=200 |
| / | 除 | 10/20=0.5 |
| % | 取余(取模) | 返回除法的余数9%2=1 |
<script>
// alert(3 >= 5); //false
// alert(2 <= 5); //true
//1. 我们程序员里面的等于符号是 == 默认转换数据类型 会把字符串型的数据转换为数字型
// 只要求值相对
//alert(3 == 5); //false
//alert('pink老师' == '刘德华'); //false
//alert(18 == 18); //true
//alert(18 == '18'); //true
//alert(18 != 18); //false != 不等于
//2. 我们程序员里面有全等 一模一样 要求两侧的值，还有数据类型完全一致才可以 true
//alert(18 === 18); //true
//alert(18 === '18'); //false
</script>
| 符号 | 作用 | 用法 |
| = | 赋值 | 把右边给左边 |
| == | 判断 | 判断两边值是否相等（注意此时有隐式转换） |
| === | 全等 | 判断两边的值和数据类型是否完全相等 |
1.4 逻辑运算符
概念：逻辑运算符是用来进行布尔值运算的运算符，其返回值也是布尔值。后面开发中经常用于多个条件的判断
<script>
// 1. 逻辑 与&&(and) 两侧都为true 结果才是true 只要一侧结果为false 结果就为false
//alert(3 > 5 && 3 > 2); //false
//alert(3 < 5 && 3 > 2); //true
// 2. 逻辑或|| （or） 两侧都为 false 结果才是假 false ,只要一侧为true ,结果就是true
//alert(3 > 5 || 3 > 2); //true
//alert(3 > 5 || 3 < 2); //false
//3. 逻辑非 ! (not)
alert(!true); //false
</script>
练习：
<script>
var num = 7;
var str = "我爱你~中国~";
alert(num > 5 && str.length >= num); //true
alert(num < 5 && str.length >= num); //false
alert(!(num < 10)); //false
alert(!(num < 10 || str.length == num)); //false
</script>
短路运算（逻辑中断）:（js API）
当有多个表达式（值）时,左边的表达式值可以确定结果时,就不再继续运算右边的表达式的值;
3. 逻辑与短路运算 如果表达式1 结果为真 则返回表达式2 如果表达式1为假 那么返回表达式1
alert(123 && 456); //456 除了0之外，所有的数字都为真
alert(0 && 456); // 0
alert(0 && 1 + 2 && 456 * 56789); // 0
alert('' && 1 + 2 && 456 * 56789); // ''
如果有空的或者否定的为假 其余是真的 : 0 '' null undefined NaN
4. 逻辑或短路运算 如果表达式1 结果为真 则返回的是表达式1 如果表达式1 结果为假 则返回表达式2
alert(123 || 456); // 123
alert(123 || 456 || 456 + 123); // 123
alert(0 || 456 || 456 + 123); // 456
逻辑中断很重要 它会影响我们程序运行结果
var num = 0;
//alert(123 || num++); //123 num++不会运行
//alert(num); // 0
1.5 赋值运算符
| 运算符 | 描述 | 案例 |
|---|---|---|
| = | 直接赋值 | var userName = ‘fan’ |
| += -= | 加减一个数后 再赋值 | var age=5; age+=5 |
| *= /= %= | 乘、除、取模后再赋值 | var age=5; age*=5 |
<script>
var num = 10;
// num = num + 1; //num++
// num = num + 2 //num+=2;
var num = 10;
num += 5;
// alert(num); //15
var num = 10;
num -= 5;
// alert(num); //5
var age = 2;
age *= 3;
// alert(age); //6
var age = 6;
age /= 3;
// alert(age); //2
var age = 4;
age %= 2;
// alert(age); //0
</script>
1.6 运算符优先级
| 优先级 | 运算符 | 顺序 |
|---|---|---|
| 1 | 小括号 | () |
| 2 | 一元运算符 | ! ++ — |
| 3 | 算数运算符 | 先* / % 后+ – |
| 4 | 关系运算符 | > >= < <= |
| 5 | 相等运算符 | == != === !== |
| 6 | 逻辑运算符 | 先&& 后|| |
| 7 | 赋值运算符 | = |
| 8 | 逗号运算符 | , |
<script>
// 一元运算符：++num !num 二元运算符： 2 + 3
// 练习1
console.log(4 >= 6 || '人' != '阿凡达' && !(12 * 2 == 144) && true) //true
var num = 10;
console.log(5 == num / 2 && (2 + 2 * num).toString() === '22'); //true
console.log('-------------------');
// 练习2
var a = 3 > 5 && 2 < 7 && 3 == 4;
console.log(a); //false
var b = 3 <= 4 || 3 > 1 || 3 != 2;
console.log(b); //true
var c = 2 === "2";
console.log(c); //false
var d = !c || b && a;
console.log(d); //true
</script>
2. 流程控制
「流程控制」在一个程序执行的过程中，各条代码的执行顺序对程序的结果是有直接影响的。很多时候我们要通过控制代码的执行顺序来实现我们要完成的功能。流程控制主要有三种结构，分别是顺序结构、分支结构和循环结构，代表三种代码执行的顺序。
分支流程控制:
2.1 if 的语法结构
if (条件表达式) {
//执行语句
}
2. 执行思路 如果
if 里面的条件表达式结果为真 true 则执行大括号里面的 执行语句
如果if 条件表达式结果为假 则不执行大括号里面的语句 则执行if 语句后面的代码
3. 体验代码：
if (3 < 5) {
alert('沙漠骆驼');
}
案例：
<script>
// 弹出 prompt 输入框，用户输入年龄， 程序把这个值取过来保存到变量中
// 使用 if 语句来判断年龄，如果年龄大于18 就执行 if 大括号里面的输出语句
var age = prompt('请输入年龄');
if (age >= 18) {
alert('可以进入网吧')
}
</script>
2.2 if else双分支语句
<script>
// 1. 语法结构 if 如果 else 否则
// if (条件表达式) {
// // 执行语句1
// } else {
// // 执行语句2
// }
// 2. 执行思路 如果表达式结果为真 那么执行语句1 否则 执行语句2
// 3. 代码验证
var age = prompt('请输入您的年龄:');
if (age >= 18) {
alert('我想带你去网吧偷耳机');
} else {
alert('滚， 回家做作业去');
}
// 5. if里面的语句1 和 else 里面的语句2 最终只能有一个语句执行 2选1
// 6. else 后面直接跟大括号
</script>
案例：闰年
// 算法：能被4整除且不能整除100的为闰年（如2004年就是闰年，1901年不是闰年）或者能够被 400 整除的就是闰年
// 弹出prompt 输入框，让用户输入年份，把这个值取过来保存到变量中
// 使用 if 语句来判断是否是闰年，如果是闰年，就执行 if 大括号里面的输出语句，否则就执行 else里面的输出语句
// 一定要注意里面的且 && 还有或者 || 的写法，同时注意判断整除的方法是取余为 0
var year = prompt("请输入要检测的年份：")
if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
alert(year + '是闰年')
} else {
alert(year + '是平年')
}
2.3 if else if语句（多选1）
<script>
// 1. 多分支语句 就是利用多个条件来选择不同的语句执行 得到不同的结果 多选1 的过程
// 2. 是多分支语句
// 3. 语法规范if else if语句
if (条件表达式1) {
//语句1;
} else if (条件表达式2) {
//语句2;
} else if (条件表达式3) {
//语句3;
} else {
//最后语句;
}
// 4. 执行思路
// 如果条件表达式1 满足就执行 语句1 执行完毕后，退出整个if 分支语句
// 如果条件表达式1 不满足，则判断条件表达式2 满足的话，执行语句2 以此类推
// 如果上面的所有条件表达式都不成立，则执行else 里面的语句
// 5. 注意点
// (1) 多分支语句还是多选1 最后只能有一个语句执行
// (2) else if 里面的条件理论上是可以任意多个的
// (3) else if 中间有个空格了
</script>
案例：成绩
<script>
// 伪代码 按照从大到小判断的思路
// 弹出prompt输入框，让用户输入分数（score），把这个值取过来保存到变量中
// 使用多分支 if else if 语句来分别判断输出不同的值
var score = prompt('请输入分数：');
if (score >= 90) {
alert('A');
} else if (score >= 80) { //不用写:90>score>=80 能运行下面，一定是小于90的
alert('B');
} else if (score >= 70) {
alert('C');
} else if (score >= 60) {
alert('D');
} else {
alert('E'); //要带引号，不然以为是一个变量，就要声明了
}
</script>
2.4 三元表达式
<script>
// 1. 有三元运算符组成的式子我们称为三元表达式
// 2. 一元运算符：++num 二元运算符： 3 + 5 三元运算符： ? :
// 3. 语法结构
// 条件表达式 ？ 表达式1 ： 表达式2
// 4. 执行思路
// 如果条件表达式结果为真 则 返回 表达式1 的值 如果条件表达式结果为假 则返回 表达式2 的值
// 5. 代码体验
var num = 10;
var result = num > 8 ? '是的' : '不是' // 我们知道表达式是有返回值的,赋值给result
console.log(result); //是的
//等价于：
var num = 10;
if (num > 5) {
alert('是的');
} else {
alert('不是的');
}
// 三元表达式是简化版的if else
</script>
案例 : 数字补0
<script>
// 用户输入0~59之间的一个数字
// 如果数字小于10，则在这个数字前面补0,（加0 拼接） 否则 不做操作
// 用一个变量接受这个返回值，输出
var num = prompt('请输入0~59之间的一个数字？')
//三元表达式： 表达式？ 表达式1： 表达式2；
var result = num < 10 ? '0' + num : num; //字符型的0 把返回值赋值给一个变量
alert(result);
</script>
2.5 switch分支流程控制
switch 语句也是多分支语句，它用于基于不同的条件来执行不同的代码。当要针对变量设置一系列的特定值的选项时，就可以使用 switch。
<script>
//1. switch 语句也是多分支语句 也可以实现多选1
// 2. 语法结构 switch 转换、开关 case小例子或者选项的意思 break 退出
/* switch (表达式) {
case value1: 执行语句1; break;
case value2: 执行语句2; break;
case value3: 执行语句3; break;
default: 执行最后的语句;
} */
// 3. 执行思路 利用我们的表达式的值 和 case 后面的选项值相匹配 如果匹配上，就执行该case 里面的语句 如果都没有匹配上，那么执行 default里面的语句
switch (2) {
case 1: alert('这是1'); break;
case 2: alert('这是2'); break; //这是2
case 3: alert('这是3'); break;
default: alert('没有匹配结果');
}
</script>
注意事项：
var num=1;
switch(num){
case 1: console.log(1);break; //1
case 2: console.log(2);break;
case 3: console.log(3);break;
}
// 1. 我们开发里面 表达式我们经常写成变量
// 2. 我们num 的值 和 case 里面的值相匹配的时候是 全等 必须是值和数据类型一致才可以 num === 1
break 如果当前的case里面没有break 则不会退出switch 是继续执行下一个case
var num=1;
switch(num){
case 1: console.log(1);//1
case 2: console.log(2);//2
case 3: console.log(3);//3
}
案例：查询水果案例
<script>
// 弹出 prompt 输入框，让用户输入水果名称，把这个值取过来保存到变量中。
// 将这个变量作为 switch 括号里面的表达式。
// case 后面的值写几个不同的水果名称，注意一定要加引号 ，因为必须是全等匹配。
// 弹出不同价格即可。同样注意每个 case 之后加上 break ，以便退出 switch 语句。
// 将 default 设置为没有此水果。
var fruit = prompt('请输入水果名称')
switch (fruit) {
case '苹果':
alert('苹果的价格是 3.5/斤');
break;
case '榴莲':
alert('榴莲的价格是 35/斤');
break;
default:
alert('没有此水果');
}
</script>
switch 语句和 if else if区别：
1. 一般情况下，它们两个语句可以相互替换
2. switch…case 语句通常处理case为比较确定值的情况，而if…else…语句更加灵活，常用于范围判断(大于、等于某个范围)
3. switch 语句进行条件判断后直接执行到程序的条件语句，效率更高。而if..else 语句有几种条件，就得判断多少次。
4. 当分支比较少时，if…else语句的执行效率比switch语句高。
5. 当分支比较多时，switch语句的执行效率比较高，而且结构更清晰。
总结
本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注NICE源码的更多内容！
