运算符
- 运算符也被称为操作符，是用于实现赋值，比较和执行算数功能的符号
算数运算符
概述
- 算数运算符使用的符号，用于执行两个变量或值的算数运算
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 | 1+1=2 |
| - | 减 | 2-1=1 |
| * | 乘 | 1*2=2 |
| / | 除 | 2/1=2 |
| % | 取余（取模） | 返回除法中的余数9%2=1 |
| ++ | 递增 | |
| – | 递减 | |
| delete | 删除 | 删除数组或对象中特定的索引值 |
| typeof | 类型 | 判断对象的类型 |
| void | void运算对任何值的返回都是undefined |
console.log(1 + 1); // 2
console.log(1 - 1); // 0
console.log(1 * 1); // 1
console.log(1 / 1); // 1
// 1. % 取余 （取模）
console.log(4 % 2); // 0
console.log(5 % 3); // 2
console.log(3 % 5); // 3
+加号
- 进行数据相加
var num1 = 3;
var num2 = 5;
var sum = num1 + num2; //8
- 取正数
var num = 6;
console.log(+num); // 6
- 与字符串运算时，就是字符串拼接符（字符串的隐式转换）
var a = 'hello';
var b = 'world';
console.log(a + b); // helloworld
var num=10;
var string='sintop'
console.log(num + string,typeof(num + string));//10sintop string
- 可以将数字字符串或布尔类型等隐式转换成number类型
var a = '123';
var b = true;
console.log(+a, +b); // 123 1
-（减号）
- 正、负可以对数字进行取正或取负，其他运算不能转换
var num1 = 6;
var num2 = -6;
console.log(-num1); //-6
console.log(+num1); //6
console.log(-num2); //6
console.log(+num2); //-6
- 正、负号可以将字符串数字隐式转换成数字
var num1 = '20';
var num2 = '-20';
console.log(-num1); //-20
console.log(+num1, typeof +num1); //20 number
console.log(-num2); //20
console.log(+num2, typeof +num2); //-20 number
- ！(取反）
- 经常被用作条件判断时的取反操作，类型判断等，还可以用‘！’将变量转换成Boolean类型
var a;
if (!a) {}
console.log(!null); //true
console.log(!undefined); //true
console.log(!''); //true
console.log(!100); //false
console.log(!'abc'); //false
delete
- 删除数组或对象中特定索引的值
var obj = {
name:'zhangsan',
age: 17
};
delete obj.name;
console.log(obj); // {age: 17}
var arr = [1,2,3,4,5];
delete arr[2];
console.log(arr); //[ 1, 2, <1 empty item>, 4, 5 ]
浮点数的精度问题
- 浮点数的最高精度是17位小数，但在进行算数计算时其精度远远不如整数
// 2. 浮点数 算数运算里面会有问题
console.log(0.1 + 0.2); // 0.30000000000000004
console.log(0.07 * 100); // 7.000000000000001
所以不要直接判断两个浮点数是否相等
var num = 0.1 + 0.2;
console.log(num == 0.3); // false
表达式和返回值
- 表达式：是由数字、运算符、变量等以能求得数值的有意义排列方法所得的组合
- 简单来说：是由数字、运算符、变量组成的式子
console.log(1 + 1); // 2 就是返回值
// 1 + 1 = 2
// 在我们程序里面 2 = 1 + 1 把我们的右边表达式计算完毕把返回值给左边
var num = 1 + 1;
- 表达式最终都会有一个结果，返回给我们
递增和递减运算符
- 给数字变量进行加1或减1操作，可以使用递增（++）和递减（–）运算符完成
前置递增运算符（递减）
- ++num前置递增，就是自加1，类似于 num = num + 1
// 2. 前置递增运算符 ++ 写在变量的前面
var age = 10;
++age; // 类似于 age = age + 1
console.log(age);//11
- 使用口诀：先自加，后返回值
//先自加1，后返回值
var p = 10;
console.log(++p + 10);//21
后置递增运算符（递减）
- num++ 后置递增，就是自加1，类似于num=num+1
var num = 10;
num++; // num = num + 1 ++num;
console.log(num);
- 使用口诀：先返回值，后自加
var age = 10;
console.log(age++ + 10);//20
console.log(age);//11
小结
注意：
- 前置递增和后置递增运算符可以简化代码的编写，让变量的值 +1 比以前写法更简单
- 单独使用时，运算结果相同
- 与其他代码联用时，运行结果会不同
- 后置：先原值运算，后自加
- 前置：先自加，后运算
- 开发时，大多使用后置递增/减，并且代码独占一行，例如：num++；或者num–；
var a = 10;
++a; // ++a 11 a = 11
var b = ++a + 2; // a = 12 ++a = 12
console.log(b); // 14
var c = 10;
c++; // c++ 11 c = 11
var d = c++ + 2; // c++ = 11 c = 12
console.log(d); // 13
var e = 10;
var f = e++ + ++e; // 1. e++ = 10 e = 11 2. e = 12 ++e = 12
console.log(f); // 22
// 后置自增 先表达式返回原值 后面变量再自加1
比较运算符
概述
- 比较运算符（关系运算法）是两个数据进行比较时所使用的运算符，比较运算后，会返回一个布尔值（true/false）作为比较的运算的结果
| 运算符名称 | 说明 | 案例 | 结果 |
|---|---|---|---|
| < | 小于号 | 1<2 | true |
| > | 大于号 | 1>2 | false |
| >= | 大于等于号 | 2>=2 | true |
| <= | 小于等于号 | 3<=2 | false |
| == | 判等号（会转型） | 37==37 | false |
| ！= | 不等号 | 37！=37 | false |
| === | 全等号（值和类型都一致） | 37 === '37 | false |
console.log(3 >= 5); // false
console.log(2 <= 4); // true
//1. 我们程序里面的等于符号 是 == 默认转换数据类型 会把字符串型的数据转换为数字型 只要求值相等就可以
console.log(3 == 5); // false
console.log('张学友' == '刘德华'); // flase
console.log(18 == 18); // true
console.log(18 == '18'); // true
console.log(18 != 18); // false
// 2. 我们程序里面有全等 一模一样 要求 两侧的值 还有 数据类型完全一致才可以 true
console.log(18 === 18);//true
console.log(18 === '18'); // false
= 小结
| 符号 | 作用 | 用法 |
|---|---|---|
| = | 赋值 | 把右边的给左边 |
| == | 判断 | 判断两边的值是否相等（此时有隐式转换） |
| === | 全等 | 判断两边的值和类型是否完全相等 |
var num1 = 10;
var num2 = 100;
var res1;
console.log(res1 = num1 > num2 ); //false
var res2;
console.log(res2=num1==11);//false
var res3;
console.log(res3 = num1 != num2);///true
逻辑运算符
概述
- 逻辑运算符是用来进行布尔值运算的运算符，其返回值也是布尔值，后面开发中经常用于多个条件的判断
| 逻辑运算符 | 说明 | 案例 |
|---|---|---|
| && | “逻辑与”，简称 “与” and | true&&false |
| ! | "逻辑非“，简称”非“ not | ！true |
逻辑与 &&
- 两边都是true才返回true 否则返回false
console.log(3 > 5 && 3 > 2); // false
console.log(3 < 5 && 3 > 2); // true
逻辑或 ||
- 两边都为false才返回 false，否则都是true
console.log(3 > 5 || 3 > 2); // true
console.log(3 > 5 || 3 < 2); // false
逻辑非 not ！
- 逻辑非（！）也叫做取反符，用来取一个布尔值相反的值，如true的相反值是false
console.log(!true); // false
短路运算（逻辑中断）
- 短路运算的原理：当有多个表达式（值）时，左边的表达式值可以确定结果时，就不再继续运算右边的表达式的值：
1、逻辑与
- 语法：表达式1 && 表达式2
- 如果第一个表达式的值为真，则返回表达式2
- 如果第一个表达式值为假，返回表达式1
console.log(123 && 456); // 456
console.log(0 && 456); // 0
console.log(0 && 1 + 2 && 456 * 56789); // 0
console.log('' && 1 + 2 && 456 * 56789); // ''
2、逻辑或
- 语法：表达式1 || 表达式2
- 如果第一个表达式的值为真，则返回表达式1
- 如果第一个的表达式为假，则返回表达式2
console.log(123 || 456); // 123
console.log(123 || 456 || 456 + 123); // 123
console.log(0 || 456 || 456 + 123); // 456
3、逻辑中断
var num = 0;
console.log(123 || num++);//123
console.log(num); // 0 （！！！）
赋值运算符
- 用来把数据赋值给变量的运算符
| 赋值运算符 | 说明 |
|---|---|
| = | 直接赋值 |
| +=、-= | 加、减一个数后再赋值 |
| *=、/=、%= | 乘、除、取余后在赋值 |
var num = 10;
// num = num + 1; num++
// num = num + 2; // num += 2;
// num += 2;
num += 5;
console.log(num);//15
var age = 2;
age *= 3;
运算符优先级
| 优先级 | 运算符 | 顺序 |
|---|---|---|
| 1 | 小括号 | （） |
| 2 | 一元运算符 | ++ – ！ |
| 3 | 算数运算符 | 先* / 后 + - |
| 4 | 关系运算符 | > >= < <= |
| 5 | 相等运算符 | == != === !== |
| 6 | 逻辑运算符 | 先&&后 |
| 7 | 赋值运算符 | = |
| 8 | 逗号运算符 | ， |
// ++num !num 2 + 3
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('-------------------');
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
类型转换
* => 字符串
- toString 函数
var a = true;
var b = 123;
console.log(a.toString(), b.toString());// 'true' '123'
console.log(typeof a.toString(), typeof b.toString());//string string
- 通过传递参数，可将十进制数字转化成二、八、十六进制的数字字符串
var num = 10;
console.log(num.toString()); //"10"
console.log(num.toString(2)) //"1010"
console.log(num.toString(8)) //"12"
console.log(num.toString(16)) //"a"
- 通过 + 来隐式转化成字符串
console.log(typeof (true + '')); //string
* => 布尔类型
- Boolean（）包装器
Boolean('hello') //true
- 使用！！转换任意其他数据类型变成布尔类型
console.log(!!'hello');//true
* => 数字类型
- Number() 包装器
Number(true); //1
Number(false); //0
Number(null); //0
Number(undefined); //NaN
Number(10); //10 如果是数字值,原样输出
Number("123"); //123 如果仅包含数值，转换为对应的数值
Number("234.1"); //234.1 解析为对应的小数
Number("+12.1"); //12.1 首位为符号位，其余为为数值，转换为对应的数值
Number("1+2.3"); // NaN 符号位出现在其他位置，解析为NaN
Number("0xa"); //10 如果仅包含十六进制格式，转为为对应的十进制的值
Number("010"); //10【注意】不会当做八进制被解析，结果为10。
Number(""); // 0 空字符串被转换为0
Number("123ac"); // NaN 包含其他字符： NaN
Number(12); //12
- parseInt()函数
将数字转换成整数
parseInt(10); //10 如果是整数值，原样输出 parseInt(10.3); //10 如果是小数，舍去小数点一级后面的内容
parseInt("123"); //123；如果仅包含数值，转换为对应的数值
parseInt("234.1"); //234；小数点后面的数值省略
parseInt("+12.1"); //12； 首位为符号位，其余为为数值，转换为整数
parseInt("1+2.7"); //1； 符号位出现在其他位置，保留符号位前面的数值
parseInt("0xa"); //10； 如果仅包含十六进制格式，转为为对应的十进制的值
parseInt("010"); //10； 【注意】不会当做八进制被解析，结果为10
parseInt(""); //NaN；空字符串被转换为NaN
parseInt("123ac"); //123;如果首位为数值，依次向后解析，找到连续的数值，直到遇到第一个非数值的，将之前获取的数值转换为Number返回 parseInt("123ac"); //123;
- parseFloat() 函数
将数字转化成浮点数
parseFloat(10); //10 如果是整数值，原样输出 parseFloat(10.1); //10.1 如果是小数，保留小数点，但是如果是10.0结果为10
parseFloat("123"); //123；如果仅包含数值，转换为对应的数值
parseFloat("234.1"); //234.1；保留小数点后面的数值
parseFloat("+12.1"); //12.1； 首位为符号位，其余为为数值，转换为整数
parseFloat("1+2.6"); //1；符号位出现在其他位置，保留符号位前的数值
parseFloat("0xa"); //0； 【注意】不会当做十六进制来解析。
parseFloat("010"); //10； 【注意】不会当做八进制被解析，结果为10
parseFloat(""); //NaN；空字符串被转换为NaN
parseFloat("123.3ac"); //123.3;如果首位为数值，依次向后解析，找到连续的数值，直到遇到第一个非数值的，将之前获取的数值转换为Number返回 parseFloat("123.3ac");//123.3;
- +加号
+"23" //23
+null //0
+undefined //NaN
流程控制
顺序流程控制
- 程序会按照代码的先后顺序，依次执行
分支流程控制 if语句
- 由上到下，根据不同的条件选择不同的路径代码
if语句
- 语法解构
//条件成立执行代码，否则什么也不做
if(条件表达式) {
//条件成立执行的代码语句
}
- 执行流程
- 案例：进入网吧
<script>
// 弹出 prompt 输入框，用户输入年龄， 程序把这个值取过来保存到变量中
// 使用 if 语句来判断年龄，如果年龄大于18 就执行 if 大括号里面的输出语句
var age = prompt('请输入您的年龄:');
if (age >= 18) {
alert('我想带你去网吧偷耳机');
}
</script>
if-else语句（双分支语句）
- 代码结构
// 1. 语法结构 if 如果 else 否则 条件表达式为真 执行语句1 否则 执行语句2
if (条件表达式) {
// 执行语句1
} else {
// 执行语句2
}
- 执行流程
- 案例：判断闰年
// 算法：能被4整除且不能整除100的为闰年（如2004年就是闰年，1901年不是闰年）或者能够被 400 整除的就是闰年
// 弹出prompt 输入框，让用户输入年份，把这个值取过来保存到变量中
// 使用 if 语句来判断是否是闰年，如果是闰年，就执行 if 大括号里面的输出语句，否则就执行 else里面的输出语句
// 一定要注意里面的且 && 还有或者 || 的写法，同时注意判断整除的方法是取余为 0
var year = prompt('请您输入年份：');
if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
alert('您输入的年份是闰年');
} else {
alert('您输入的年份是平年');
}
if-else-if（多分支语句）
- 语法结构
if (条件表达式1) {
// 语句1;
} else if (条件表达式2) {
// 语句2;
} else if (条件表达式3) {
// 语句3;
} else {
// 最后的语句;
}
- 执行流程
- 案例：判断成绩
<script>
// 伪代码 按照从大到小判断的思路
// 弹出prompt输入框，让用户输入分数（score），把这个值取过来保存到变量中
// 使用多分支 if else if 语句来分别判断输出不同的值
var score = prompt('请您输入分数:');
if (score >= 90) {
alert('宝贝，你是我的骄傲');
} else if (score >= 80) {
alert('宝贝，你已经很出色了');
} else if (score >= 70) {
alert('你要继续加油喽');
} else if (score >= 60) {
alert('孩子，你很危险');
} else {
alert('熊孩子，我不想和你说话，我只想用鞭子和你说话');
}
</script>
-注意点：
(1) 多分支语句还是多选1 最后只能有一个语句执行
(2) else if 里面的条件理论上是可以任意多个的
(3) else if 中间有个空格
分支流程控制 switch 语句
- 语法结构
switch (表达式) {
case value1:
执行语句1;
break;
case value2:
执行语句2;
break;
...
default:
执行最后的语句;
}
- 语法结构说明：
1、关键字switch后面小括号可以是表达式或值，通常是一个变量
2、关键字case，后跟一个选项的表达式的值，后面是一个冒号
3、switch表达式的值会与结构中case的值做比较
4、如果存在匹配全等（===），则于=与该case关联的代码会被执行，并在遇到break时停止，真个switch语句代码执行结束
5、如果所有的case的值都和表达式的值不匹配，则执行default的代码
注意：执行case里面的语句时，如果没有break，则继续执行下一个case里面的语句
- 案例：查询水果
<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>
396
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
