1.什么是算术运算符?
+ - * / %
2.算术运算符的优先级和结合性
* / % 优先级要高于 + -
无论是+ - * / %都是左结合性(从左至右计算)
*/
/*
// let result = 1 + 1;
let num1, num2;
num1 = 3;
num2 = 5;
// let result = num1 + num2;
let result = num1 + 3;
console.log(result);
*/
/*
// let result = 2 - 1;
// let result = 2 * 5;
let result = 10 / 5;
console.log(result);
*/
/*
let result = 1 + 2 * 5;
console.log(result);
*/
/*
被除数 除数 商 余数
10 ÷ 3 = 3 1
*/
// let result = 10 % 3;
let result = 10 % 4;
console.log(result);
1.加法运算的注意点
1.1任何非数值类型的数据在参与加法运算之前, 都会被自动的转换成数值类型之后, 再参与运算
1.2任何数据和NaN进行运算, 结果都是NaN
1.3任何数据和字符串相加, 都会被先转换成字符串之后再运算
2.减法运算的注意点
1.1任何非数值类型的数据在参与加法运算之前, 都会被自动的转换成数值类型之后, 再参与运算
1.2任何数据和NaN进行运算, 结果都是NaN
1.3任何数据和字符串相减, 都会先把字符串转换成数值类型之后再运算
3.乘法和除法运算的注意点
和减法运算的注意点一模一样
4.取模(取余)运算注意点
格式: m%n = 余数
4.1如果m>n的, 那么就正常取余
4.2如果m<n的, 那么结果就是m
4.3如果n是0, 那么结果就是NaN
4.4取余运算结果的正负性, 取决于m而不是n
*/
/*
// let res = 1 + true; // let res = 1 + 1;
// let res = 1 + null; // let res = 1 + 0;
// let res = 1 + NaN;
let res = 1 + "123"; // let res = "1" + "123"; 字符串相加的本质就是字符串拼接 "1123"
console.log(res);
*/
/*
// let res = 1 - true; // let res = 1 - 1;
// let res = 1 - NaN;
let res = 1 - "123"; // let res = 1 - 123; -122
console.log(res);
*/
// let res = 10 % 3;
// let res = 3 % 10;
// let res = 3 % 0;
// let res = 10 % -3; // 1
let res = -10 % 3; // -1
console.log(res);
1.什么是赋值运算符?
赋值运算符就是将等号右边的值存储到等号左边的变量中
1.1简单类型的赋值运算符
=
1.2复杂类型的赋值运算符
+= -= *= /= %=
2.赋值运算符的优先级和结合性
赋值运算符的优先级低于算数运算符
赋值运算符的结合性是右结合性(从右至左的计算)
赋值运算符的左边只能放变量, 不能放常量
*/
/*
// 由于算数运算符的优先级高于赋值运算符所以会先计算1 + 1, 然后再赋值给res
// let res = 1 + 1;
// 由于赋值运算符的结合性是右结合性, 所以会先将3赋值给num2, 然后再将Num2中的值赋值给num1
let num1, num2;
num1 = num2 = 3;
*/
let res = 5;
// 会将等号左边存储的值取出来和右边进行指定的运算, 运算完毕之后再将运算的结果存储到左边
// res += 5; // 相当于 res = res + 5;
res -= 5; // 相当于 res = res - 5;
console.log(res);
1.什么是自增自减运算符?
自增运算符: ++
自减运算符: --
2.自增自减运算符的作用
自增运算符: 可以快速的对一个变量中保存的数据进行+1操作
自减运算符: 可以快速的对一个变量中保存的数据进行-1操作
3.自增和自减写在变量的前面和后面的区别?
写在变量的后面, 表示变量先参与其它的运算, 然后再自增或者自减
写在变量的前面, 表示变量先自增或者自减, 然后再参与其它的运算
*/
/*
let num = 5;
// num = num + 1;
// num += 1; // num = num + 1;
// num++; // num = num + 1;
++num;
console.log(num);
*/
/*
let num = 5;
// num = num - 1;
// num -= 1;
// num--;
--num;
console.log(num);
*/
let num = 1;
// let res = num++ + 1; // let res = num + 1; num++;
let res = ++num + 1; // num++; let res = num + 1;
console.log(res); // 2 3
1.自增自减运算符只能出现在变量的前面或者后面, 不能出现在常量或者表达式的前面或者后面
2.什么是表达式?
表达式就是用运算符连接在一起有意义有结果的语句, 我们就称之为表达式
1 + 1; 表达式
a * 5; 表达式
3.在企业开发中自增自减运算符最好单独出现, 不要出现在表达式中
*/
// let num = 1;
// ++num;
// num--;
// --666; 错误的写法
// 666++;
// (1 + 1)++; 错误的写法
// --(1 + 1);
let a, b;
a = 10;
b = 5;
// 不推荐的写法
// let res = a++ + b; // let res = a + b; a++;
let res = a + b;
a++;
console.log(res);
console.log(a);
1.什么是关系运算符?
> < >= <= == != === !==
2.关系运算符的返回值
只有两个, 要么是true, 要么是false
如果关系成立, 就返回true
如果关系不成立, 就返回false
3.关系运算符的注意点
3.1对于非数值类型的数据, 会先转换成数值类型, 再进行判断
3.2对于关系运算符来说, 任何数据和NaN进行比较, 返回值都是false
3.3如果参与比较的都是字符串类型, 那么不会转换成数值类型再比较, 而是直接比较字符对应的Unicode编码
3.4特殊比较的结果
*/
// let res = 10 != 5;
// console.log(res);
// let res = 1 > true; // let res = 1 > 1;
// let res = 1 > false; // let res = 1 > 0;
// let res = 1 > null; // let res = 1 > 0;
// let res = 1 > "10"; // let res = 1 > 10;
// let res = 666 > NaN;
// let res = 666 > undefined; // let res = 666 > NaN;
// let res = "a" > "b"; // let res = 0061 > 0062;
// let res = "b" > "a"; // let res = 0062 > 0061;
// 如果字符串中有多个字符, 那么会从左至右的依次比较, 直到条件不满足为止
// let res = "ab" > "ac";
// let res = null == 0; // false
// let res = undefined == 0; // false
// let res = null == undefined; // true
// 在企业开发中千万不要通过==来判断某一个数据是否是NaN
// 如果想判断某一个数据是否是NaN那么可以通过isNaN来进行判断
// let res = NaN == NaN; // false
let num = NaN;
let res = isNaN(num);
console.log(res);
1. === !==
会同时判断取值和数据类型
== !=
只会判断取值
2.关系运算符的结合性和优先级
关系运算符都是左结合性(从左至右的运算)
关系运算符中 > < >= <= 的优先级高于 == != === !==
*/
/*
// == 只会判断取值是否相等, 不会判断数据类型是否相等
// let res = 123 == "123"; // let res = 123 == 123; true
// === 不仅会判断取值是否相等, 并且还会判断数据类型是否相等
// 只有取值和数据类型都相等, 才会返回true
let res = 123 === "123"; // let res = 123 == 123; false
console.log(res);
*/
/*
// let res = 123 != "123"; // let res = 123 != 123; false
let res = 123 !== "123"; // let res = 123 != 123; false
console.log(res);
*/
/*
// 注意点: 正式因为关系运算符是左结合性, 所以不能利用关系运算符来判断区间
// let res = 10 > 5 > 3; // let res = true > 3; let res = 1 > 3;
let res = 10 <= 25 <= 20; // let res = true <= 20; let res = 1 <= 20;
console.log(res);
*/
let res = 10 == 10 > 0; // let res = 10 == true; let res = 10 == 1;
console.log(res);
1.什么是逻辑运算符?
名称?格式?返回值?特点?
1.1逻辑与 &&
格式: 条件表达式A && 条件表达式B
返回值: true false
特点: 一假则假
1.2逻辑或 ||
格式: 条件表达式A || 条件表达式B
返回值: true false
特点: 一真则真
1.3逻辑非 !
格式: !条件表达式
返回值: true false
特点: 真变假, 假变真
*/
/*
// 1.1逻辑与 &&
// true && true
// let res = (10 > 5) && (20 > 10);
// let res = true && true; // true;
// let res = false && true; // false;
// let res = true && false; // false;
let res = false && false; // false;
console.log(res);
*/
/*
// 1.2逻辑或 ||
// let res = true || true; // true
// let res = false || true; // true
// let res = true || false; // true
let res = false || false; // false
console.log(res);
*/
// 1.3逻辑非 !
// let res = !true; // false
let res = !false; // true
console.log(res);
1.逻辑运算符的优先级和结合性
逻辑运算符的结合性是左结合性(从左至右的运算)
在逻辑运算中&&的优先级高于||
2.逻辑运算符的注意点
2.1在逻辑运算中如果不是布尔类型, 那么会先转换成布尔类型, 再参与其它的运算
2.2在逻辑与运算中, 如果参与运算的不是布尔类型, 返回值有一个特点
格式: 条件A && 条件B
如果条件A不成立, 那么就返回条件A
如果条件A成立, 无论条件B是否成立, 都会返回条件B
2.3在逻辑或运算中, 如果参与运算的不是布尔类型, 返回值有一个特点
格式: 条件A || 条件B
如果条件A成立, 那么就返回条件A
如果条件A不成立, 无论条件B是否成立, 都会返回条件B
2.4在逻辑与运算中,有一个逻辑短路现象
格式: 条件A && 条件B
由于逻辑与运算的规则是一假则假, 所以只要条件A是假, 那么条件B就不会运算
2.5在逻辑或运算中,有一个逻辑短路现象
格式: 条件A || 条件B
由于逻辑或运算的规则是一真则真, 所以只要条件A是真, 那么条件B就不会运算
*/
/*
// let res = true && false;
// let res = false;
// let res = true || false;
// let res = true;
let res = true || false && false;
console.log(res);
*/
/*
// let res = !0; // let res = !false;
let res = !1; // let res = !true;
console.log(res);
*/
/*
// 如果条件A不成立, 那么就返回条件A
// let res = 0 && 123;
// let res = null && 123;
// 如果条件A成立, 无论条件B是否成立, 都会返回条件B
// let res = 1 && 123;
let res = 1 && null;
console.log(res);
*/
/*
// 如果条件A成立, 那么就返回条件A
// let res = 666 || 0;
// 如果条件A不成立, 无论条件B是否成立, 都会返回条件B
// let res = 0 || 123;
let res = 0 || null;
console.log(res);
*/
let num = 1;
// false
// let res = (10 > 20) && (++num > 0);
// true
let res = (10 < 20) || (++num > 0);
console.log(num);
console.log(res);
1.逗号运算符 ,
在JavaScript中逗号运算符一般用于简化代码
2.逗号运算符优先级和结合性
逗号运算符的结合性是左结合性(从左至右的运算)
逗号运算符的优先级是所有运算符中最低的
3.逗号运算符也是一个运算符, 所以也有运算符结果
逗号运算符的运算符结果就是最后一个表达式的结果
表达式1, 表达式2, 表达式3, ....;
*/
// 利用逗号运算符同时定义多个变量
let a, b;
// 利用逗号运算符同时给多个变量赋值
a = 10, b = 5;
let res = ((1 + 1), (2 + 2), (3 + 3));
console.log(res);
1.什么是三目运算符
三目运算符又称之为条件运算符
2.三目运算符格式
条件表达式 ? 结果A : 结果B;
在三目运算符中当条件为真的时候, 就会返回结果A
在三目运算符中当条件为假的时候, 就会返回结果B
3.三目运算符注意点
在三目运算符中?:不能单独出现, 要么一起出现, 要么一起不出现
*/
// let res = true ? 123 : 456;
// let res = false ? 123 : 456;
let res = (10 > 5) ? 10 : 5;
console.log(res);
网友评论