【JS逆向】【5.JavaScript 基础语法】运算符,算术运算符,比较运算符,逻辑运算符,赋值运算符,位运算符

2024-01-02 19:41:04

运算符

运算符(operator)也被称为操作符,是用于实现赋值、比较和执行算术术运算等功能的符号。
JavaScript中常用的运算符有:

  • 算术运算符
  • 递增和递减运算符
  • 比较运算符
  • 逻辑运算符
  • 赋值运算符

1. 算术运算符

概念:算术运算使用的符号,用于执行两个变量或值的算术运算

运算符描述实例
+10 + 20 = 30
-10 - 20 = -10
*10 * 20 = 100
/10 / 20 = 0.5
%取余数(取模)返回除法的余数9 % 2 = 1
**次幂求次方 10 ** 2 = 100
# 加法运算符
console.log(1 + 2)                 // 等于3
console.log(1 + NaN)               // NaN,只要有一个NaN就为NaN
console.log(Infinity + Infinity)     // Infinity
console.log(-Infinity + -Infinity)    // -Infinity
console.log( Infinity + -Infinity)   // NaN,正无穷和负无穷相加等NaN
console.log(100 + '100')           // 100100,字符串连接符,有字符串就不是加法
console.log('您的年龄是:' + 10 + 20)   // 您的年龄是:1020,被转换成字符串
consolelot(10 + 20 + '是您的年龄')       // 30是您的年龄,没有被转成字符串
console.log('您的年龄是:' + (10 + 20)) // 您的年龄是:30,没有被转成字符串
console.log(10 + {})             // 10[object Object]类型是string
console.log(10 + 对象)             // 10[object Object],如果有toString()或valueOf(),则返回10+返回数的值

# 减法运算符
var a, b;
a = 2;
b = 1;
var sub = a - b;
console.log(sub);  // 1
console.log(2 - 1);  // 1
console.log(100 - 70)                //等于30
console.log(-100 - 70)                //等于-170
console.log(-100 - -70)               //-30,一般写成-100 - (-70)比较清晰
console.log(1 - NaN)               //NaN,只要有一个NaN就为NaN
console.log(Infinity - Infinity)         //NaN
console.log(-Infinity - -Infinity)        //NaN
console.log(Infinity - -Infinity)         //Infinity
console.log(-Infinity - Infinity)         //-Infinity
console.log(100 - true)             //99,true转成数值为1
console.log(100 - '')                 //100''转成了0
console.log(100 - '70')              //30'70'转成了数值70
console.log(100 - null)              //100,null转成了0
console.log(100 - 'Lee')              //NaN,Lee转成了NaN
console.log(100 - 对象 )             //NaN,如果有toString()或valueOf()
 则返回10-返回数的值


# 乘法运算符
console.log(100 * 70)               //7000          
console.log(100 * NaN)             //NaN,只要有一个NaN即为NaN
console.log(Infinity * Infinity)         //Infinity
console.log(-Infinity * Infinity )       //-Infinity
console.log(-Infinity * -Infinity)       //Infinity
console.log(100 * true)            //100,true转成数值为1
console.log(100 * '')                 //0''转成了0
console.log(100 * null)             //0,null转成了0
console.log(100 * 'Lee')           //NaN,Lee转成了NaN
console.log(100 * 对象)            //NaN,如果有toString()或valueOf()
 则返回10 - 返回数的值


# 除法运算符
var a, b;
a = 2;
b = 1;
var div = a / b;
console.log(div); // 2
console.log(3 / 2); // 1.5
console.log(100 / 70)                //1.42....
console.log(100 / NaN)              //NaN
console.log(Infinity / Infinity)          //NaN
console.log(-Infinity / Infinity)        //NaN
console.log(-Infinity / -Infinity)        //NaN
console.log(100 / true)              //100,true转成1
console.log(100 / '')              //Infinity,
console.log(100 / null)            //Infinity,
console.log(100 / 'Lee')             //NaN
console.log(100 / 对象)           //NaN,如果有toString()或valueOf(),则返回10 / 返回数的值



# 取余运算符
var a, b;
a = 9;
b = 6;
var div = a % b;
console.log(div);  // 3
console.log(-3 / 2);  // -1.5
console.log(-3 % 2);  // -1
console.log(10 % 3)                   //1,余数为1            
console.log(100 % NaN)               //NaN
console.log(Infinity % Infinity)       //NaN           
console.log(-Infinity %  Infinity)       //NaN
console.log(-Infinity %  -Infinity)       //NaN
console.log(100 %  true)           //0
console.log(100 %  '')              //NaN
console.log(100 %  null)            //NaN
console.log(100 %  'Lee')          //NaN
console.log(100 %  对象)             //NaN,如果有toString()或valueOf(),则返回10 % 返回数的值

# 求次幂(次方、指数)
console.log(2 ** 3);    // 8
console.log(2 ** 0.5);  // 1.414...2
console.log(0.3 ** 2);  // 0.09

2. 递增和递减运算符

  • 如果需要反复给数字变量添加或减去1,可以使用递增(++)和递减( - - )运算符来完成。
  • 在 JavaScript 中,递增(++)和递减( - - )既可以放在变量前面,也可以放在变量后面。放在变量前面时,我们可以称为前置递增(递减)运算符,放在变量后面时,我们可以称为后置递增(递减)运算符。
  • 注意:递增和递减运算符必须和变量配合使用

前置递增运算符

++num 前置递增,就是自加1,类似于 num = num + 1,但是 ++num 写起来更简单。
使用口诀:先自加,后返回值

// 前置递增运算符 ++ 写在变量的前面
var num1 = 10;
++num1;    // 类似于 num1 = num1 + 1
console.log(num1);
var num2 = 10;
console.log(++num2 + 10);   // 先加1,后返回值

后置递增运算符

num++ 后置递增,就是自加1,类似于 num = num + 1 ,但是 num++ 写起来更简单。
使用口诀:先返回原值,后自加

var num1 = 10;
num1++;    // num1 = num2 + 1     ++num1;
console.log(num1);
// 前置自增和后置自增如果单独使用,效果是一样的
// 后置自增 口诀:先返回原值,后自加1
var num2 = 10;
console.log(num2++ + 10);
console.log(num2);

前置递增和后置递增小结

  • 前置递增和后置递增运算符可以简化代码的编写,让变量的值 + 1 比以前写法更简单
  • 单独使用时,运行结果相同
  • 与其他代码联用时,执行结果会不同
  • 后置:先原值运算,后自加(先人后己)
  • 前置:先自加,后运算(先己后人)
  • 开发时,大多使用后置递增/减,并且代码独占一行,例如:num++; 或者 num- -;

3. 比较(关系)运算符

比较运算符用于比较两个值的大小,然后返回一个布尔值,表示是否满足指定的条件。
注意,比较运算符可以比较各种类型的值,不仅仅是数值。

符号描述案例结果
>大于1 < 2true
<小于1 > 2false
<=小于或等于2 >= 2true
>=大于或等于3 <= 2false
==相等(会转型)6 == 6true
===严格相等9 === “9”false
!=不相等8!=8false
!==严格不相等8!==“8”true

这八个比较运算符分成两类:相等比较和非相等比较。两者的规则是不一样的,对于非相等的比较,算法是先看两个运算子是否都是字符串,如果是的,就按照字典顺序比较(实际上是比较 Unicode 码点);否则,将两个运算子都转成数值,再比较数值的大小。

console.log(3 >= 5);  # false
console.log(2 <= 6);  # true
// 程序里面的等号符号是 ==
console.log(5 == 6);  # false
console.log('香蕉' == '卟NaNa');
console.log(88 == 88);  # true
// == 会默认转换数据类型,会把字符串型的数据类型转换为数字型的,只要求值相等就可以 true
console.log(88 == '88');   # true
console.log(66 != 66);  # false
// 全等 ===
console.log(22 === 22);  # true
// 全等 ===  要求两侧的值和数据类型完全一致才可以 true
 console.log(22 === '22');  # false

4. 逻辑运算符

概念:逻辑运算符是用来进行布尔值运算的运算符,其返回值也是布尔值。后面开发中经常用于多个条件的判断

符号说明案例
&&“逻辑与”,简称 “与” andtrue && false
!“逻辑非”,简称 “非” not!true

逻辑与 &&

两边都是 true才返回 true,否则返回 false
在这里插入图片描述

// 逻辑与 &&  and  两边都是true,结果才是true,只要有一侧是false,结果就是false
console.log(3 > 2 && 3 > 5);  # false
console.log(3 > 2 && 3 < 5);  # true

逻辑或 ||

两边都为 false 才返回 false,否则都为true
在这里插入图片描述

// 逻辑或 ||  or  两侧都为false时,结果才是false,只要有一侧时true,结果就是true
console.log(3 > 2 || 3 > 5);  # true
console.log(3 < 2 || 3 > 5);  # false

逻辑非 !

逻辑非(!)也叫作取反符,用来取一个布尔值相反的值,如 true 的相反值是 false

// 逻辑非 ! not
console.log(!true);  # false

短路运算(逻辑中断)

短路运算的原理:当有多个表达式(值)时,左边的表达式值可以确定结果时,就不再继续运算右边的表达式的值

逻辑与
  • 语法: 表达式1 && 表达式2
  • 如果第一个表达式的值为真,则返回表达式2
  • 如果第一个表达式的值为假,则返回表达式1
// 逻辑与短路运算 如果表达式为真,则返回表达式2,如果表达式1为假,则返回表达式1
console.log(123 && 456);  # 456
console.log(123 && 456 && 789);  # 789
console.log(1 && 2 + 3 && 8 - 6);  # 2
// 如果有如果有空的或者是否定的为假的,其余是真的,0''、null、undefined、NaN为假
console.log(0 && 456);  # 0
console.log('' && 456);  # 空值
console.log(0 && 1+2 && 345);  # 0

逻辑或

  • 语法: 表达式1 || 表达式2
  • 如果第一个表达式的值为真,则返回表达式1
  • 如果第一个表达式的值为假,则返回表达式2
// 逻辑或短路运算 如果表达式1结果为真,则返回表达式1,如果表达式1结果为假,则返回表达式2
console.log(123 || 456);  # 123
console.log(123 || 456 || 789);  # 123
console.log(0 || 456 || 789);  # 456
// 逻辑中断会影响程序的运行结果
var num = 0;
console.log(123 || num++);
console.log(num); # 123

5. 赋值运算符

概念:用来把数据赋值给变量的运算符

符号说明案例
=直接赋值var usrName = “我爱JS”
+=、-=加、减一个数后再赋值var age = 10; age += 5; // 15
*=、/=、%=乘、除、取模 后再赋值var age = 2; age *= 5; // 10
// 赋值运算符 =+=-=*=/=%=
var num = 10;
num += 5;           // 相当于 num = num + 5; 此处num运算前的值是10,运算后是15
console.log(num);
num -= 3;           // 相当于 num = num - 3; 此处num运算前的值是15,运算后是12
console.log(num);
num *= 2;           // 相当于 num = num * 2; 此处num运算前的值是12,运算后是24
console.log(num);
num /= 2;           // 相当于 num = num / 2; 此处num运算前的值是24,运算后是12
console.log(num);
num %= 7;           // 相当于 num = num % 7; 此处num运算前的值是12,运算后是5
console.log(num);

6. 位运算符

按位运算符是JavaScript中的一组二进制运算符,用于对数字的二进制表示进行操作。按位运算符会将操作数转换成二进制形式,然后对它们的每一位进行比较和计算,最终得出运算结果。

位运算符有七种,分别是:位非NOT(~)、位与AND(&)、位或OR(|)、位异或XOR(^)、左移(<<)、有符号右移(>>)、无符号右移(>>>)
在这里插入图片描述

console.log(~25)                //-26
console.log(25 & 3)               //1
console.log(25 | 3)               //27
console.log(25 << 3)         //200
console.log(25 >> 2)              //6
console.log(25 >>> 2)            //6

文章来源:https://blog.csdn.net/weixin_43612602/article/details/135294861
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。