JavaScript运算符-算数-比较-逻辑-字符串-三元-特殊运算符

作者: 鲁智深 分类: JAVASCRIPT 发布时间: 2015-12-03 23:58

运算符

JavaScript 提供了一组用于操作数据值的运算符。

  • 算数运算符(+ – * / % ++ –)
  • 比较运算符(> >= < <= == != === !==)
  • 逻辑运算符(&& || !)
  • 赋值运算符(= += -= *= /= %= )
  • 字符串连接运算符(+)
  • 三元运算符(? :)(条件运算符)
  • 特殊运算符(typeof instanceof delete)

算数运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
var num = 60;
var num1 = 50;

//加法
console.log(num + num1);//输出80

//减法
console.log(num - num1);//输出-20

//乘法
console.log(num * num1);//输出1500

//除法
console.log(num / num1);//输出0.6

//求余
console.log(num % num1);//余数10

//数字和boolean类型以前计算时,true是1,false
console.log(100 + true);//输出101

console.log(100 + false);//输出100

//当字符串和加法在一起的时候是连接符并且类型转成字符串
console.log(100 + '3213');//输出1003213
console.log(typeof (100 + '3213'));

//除了加法遇到字符串会成拼接符,其他的都会出现将字符串转化为数字,并且类型是number
console.log(100 - '232');
console.log(typeof (100- '232'));

console.log(100 / '232');//number类型
console.log(typeof (100 / '232'));//number类型

//判断数据类型
//typeof判断原始数据类型
//instanceof判断引用数据类型

自增自减

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
var num = 100;
console.log(num++);//先赋值在运算
console.log(++num);//先运算在赋值

//前置自增,也就是说这是先运算在赋值
var num2 = 200;
var result = ++num2;
console.log(result);//输出是201
console.log(num2);//输出是201

//后置自增,证明是先赋值后,在运算
var num1 = 100;
var result1 = num1++;
console.log(result1);//输出的值还是100
console.log(num1);//这里的num1值是101

//前置自减,先运算后赋值
var num3 = 200;
var result2 = --num3;
console.log(result3);//输出199
console.log(num2);//输出199

//后置自减,先赋值后运算
var num4 = 200;
var result3 = num3--;
console.log(result3);//输出200
console.log(num3);//输出199

//总结如果自增自减运算符在变量前面,那先进行运算在赋值,如果自增自减运算符在后面,那么先赋值在运算。

比较运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
//boolean类型的比较
var num = 100;
var num1 = 100;
console.log(num == num1);//为true,==检查两个运算数的值是否相等
console.log(num != num1);//为false !=检查两个运算数的值是否不等
console.log(num > num1);//为false >检查左边运算数是否大于右边运算数
console.log(num >= num1);//为true >=检查左边运算数是否大于或等于右边运算数
console.log(num < num1);//为false <检查左边运算数是否大于右边运算数
console.log(num <= num1);//为true 检查左边运算数是否小于或等于右边运算数

//string类型比较
var str = '我符串';
var str1 = '字符串';
console.log(str == str1);//false
console.log(str > str1);//true

var str2 = 'this is string';
var str3 = 'string';
console.log(str2  == str3 );//false
console.log(str2  <= str3);//false
console.log(str2  >= str3);//true
console.log(str2 > str3);//true
//字符串之间的大小关系是按首字母排序定,中文是按拼音的首字母

var str2 = '100';
console.log(100 == str2);//true
//==和!=只是比较值,和类型无关

//boolean类型比较
var boo = true;
var boo1 = false;
console.log(boo > boo1);//true是1,false是0

全等与不全等

1
2
3
4
5
6
7
8
9
//全等===和相等==的区别
console.log(100 === '100');//false
console.log(100 == '100');//true
//总结是===类型不同也会返回false ,==类型不同,值相同返回true

//不等!=和不全等!==
console.log(100 !== '100');//true,只要有值和类型都不相等,就是不全等,返回true
console.log(100 != '100');//虽然类型不等,但是这个值是相等的,所有返回false
console.log(1 != 1);//false,只是相同的自然是个false

isNaN 函数

1
2
3
4
5
6
7
8
9
10
11
//NaN,不是一个数字,not a numberr
//自身不相等于自己,并且和任何人比较都是false
console.log(NaN == NaN);//false
console.log(NaN == true);//false

//我们可以通过构造函数进行比较is_NaN
console.log(isNaN(NaN));//true,判断是否是NaN
console.log(isNaN(parseInt('32131a')));//输出为false,parseInt取整数了
console.log(parseInt('32131a'));//输出32131
console.log(typeof Number('32131a'));//number类型
console.log(isNaN(Number('32131a')));//true,虽然是数字类型但其不是一个数字

逻辑运算符

逻辑与&&

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//boolean之间的
console.log(true && true);  //true
console.log(true && false);//false
console.log(false && false);//false
console.log(false && true);//false

//string之间的
console.log('string' && '等等');//等等
console.log('' && '得到');//''
console.log('' && 121334);//''

//boolean之间
console.log(3231 && 23131);//23131
console.log('' && 21312);//''
console.log('dwsad' &&  213);//213
console.log('DSDA' && '');//''

//逻辑短路原则:
// 逻辑与&&,先将要比较的2个值转化为boolean类型(ps:true或者false)
//如果是前面的值是true,取后面的值输出
//如果前面的的值是fals,取前面的值输出

逻辑或||

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//逻辑短路原则:
// 逻辑或|| 先将要比较的值转化为Boolean类型
//如果前面的值是true直接取前面的值为输出
//如果前面的值为false直接取后面的值为输出

//boolean之间的
console.log(true || true);  //true
console.log(true || false);//true
console.log(false || false);//false
console.log(false || true);//true

//string之间的
console.log('string' || '等等');//string
console.log('' || '得到');//得到
console.log('' || 121334);//121334

//boolean之间
console.log(3231 || 23131);//3231
console.log('' || 21312);//21312
console.log('dwsad' ||  213);//dwsad
console.log('DSDA' || '');//DSDA

逻辑非

1
2
3
4
5
var num = 123;
console.log(!num);//false,原本是true,逻辑非就是取反
console.log(!NaN);//true
console.log(!'打');//false
//值得注意的是: 能被转换为 false 的值有null, 0, NaN, 空字符串("") 和 undefined。

赋值运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//直接量赋值
var num = 100 +100;
console.log(num);//200,赋值运算就是将右的值赋给左边的变量

//运算符简写的方法
//参考 :C += A转换为C = C + A
// C += A由于运行时可以进行优化,执行效率都要优于C = C + A。
var num1 = 100;
num1 += 100;//num1 = num1 +100
console.log(num1);  //200

var num2 = 100;
num2 -= 100;//num2 = 100-100
console.log(num2);//输出0

var num3 = 100;
num3 *= 100;//num3 = 100*100
console.log(num3);//10000

var num4 = 1000;
num4 /= 200;//num4 = 1000/200
console.log(num4);//5

var num5 = 6000;
num5 %= 13;//num5 = 6000/13
console.log(num5);

字符串连接运算符

1
2
3
4
5
6
var num1 = 1;
var num2 = 2;
var num3 = num1 + num2; // 加法计算

var num4 = "4";
var num5 = num1 + num4; //字符串拼接计算

条件运算符

1
2
3
//条件运算符又称为三元运算符  ?:
var mi = true && true ? "真的":"加的";
console.log(mi);

嵌套

1
2
3
4
5
6
7
8
9
10
var score = 55;
var result = score > 90 ? '优秀' : (score > 80 ? '良好' : (score > 60 ? '及格' : '不及格'));
console.log(result);

/*
    条件运算符的嵌套情况
    1. 嵌套的层级有没有要求?语法结构没有任何要求,实际上建议最多不要超过 3 层
    2. 嵌套结构本身的代码可读性不高
    3. 嵌套结构本身的性能不够好
 */

运算符的优先级

运算符的优先级

运算符的优先级

如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!

发表评论

电子邮件地址不会被公开。 必填项已用*标注