JavaScript 运算符和表达式

console.log(parseInt(5 / 2));

// ++ 递,当前数值+1， – 递减，当前数字-1

var a = 1;

a++; // a=a+1

console.log(a); // 2

a++; // a=a-1

console.log(a) // 1

++a;

console.log(a); // 2

–a;

console.log(a); // 1

// ++ 和 – 都可以在变量前或变量后，都为变量+1或-1.

// 但是，表达式的返回值不同。

// a++ ，a增一，表达式返回+1前的旧值。

// ++a ，a增一，表达式返回+1后的新值。

a = 0;

var n = a++;

console.log(a,n); // 1,0

a = 0;

var m = ++a ;

console.log(a,m); // 1,1

var b = 1;

console.log(b++); // 1 输出 +1 的新值

console.log(++b); // 3

/*

• 1. 所有表达式都是从左往右执行

• 2.如果前一个表达式修改了变量，则会影响后续的表达式。

*/

var n =5;

console.log(n++ + ++n + n++); // 19

// n 的的值： 6 7 8

// 表达式的值： 5 7 7

console.log(++n + n++ + ++n); // 29

// n的值 9 10 11

// 表达式的值 9 9 11

赋值运算

---

赋值运算符包括：　　=　　+=　　-=　　*=　　/=　　%=

= ：用于为变量赋值，变量名=变量值；

+=： n+=3 相当于 n=n+3。

-=： n-=3 相当于 n=n-3。

*=： n*=3 相当于 n=n*3。

/=： n/=3 相当于 n=n/3。

%=： n%=3 相当于 n=n%3。

案例代码

var a = 1, b = 2;

// a=a+b

a+=b; //3

console.log(a);

var c = 3 ,d = 4;

c*=d; // c = c*d;

console.log©

var e = 5 , f = 6;

// e = e%f

e%=f;

console.log(e) // 5

var g= 7;

// g = g+1;

// g+=1;

g++;

console.log(g);

var str =“abc”;

str =str +“def”; // “abcdef”

console.log(str);

str += “def” // “abcdefdef”

console.log(str);

关系运算

---

关系运算用于比较数据之间的大小关系。

关系运算符主要有一下八个：>　　<　　>=　　<=　　==　　!=　　===　　!==

关系表达式的返回值为 Boolean 类型：true / false 。

代码案例

// 关系运算

var n1 = 10, n2 = 20, n3 = 20;

console.log(

n1 < n2, // true

n2 >= n3, // true

n2 == n3, // true

n2 != n3, // false

);

在关系运算中存在隐式转换，默认一切转为数字在参与运算

// 在关系运算中存在隐式转换，默认一切转为数字在参与运算。

var n = 2, s = “3”, b = true;

console.log(

s > n, // true

b < s, // true

s - n == b, // true

s >= b, // true

s - n >= b, // true

);

特殊情况一 ：两个字符串作比较 。不在转换为数字，而是依次比较每一个字符的 Unicode编号大小。

console.log(

“12” > “3”, // “1” VS “3” --> false

“eric” < “jerry”, // “e” VS “j” --> true

“scott” > “smith” , // “c” VS “m” --> false

“123” > “12” // 当前面字符一样大，比个数。 true

)

特殊情况二 ：null 和 undefined

var n; // undefined

var m = null;

console.log(

n == null, // false

m == undefined, // true

null == undefined // true

);

=== 全等，先比较数据类型是都相同，再比较值是否相同，相当于不带隐式转换的 ==。

接上边例子

var n; // undefined

var m = null;

console.log(

n === null, // false

m === undefined, // false

null === undefined, // false

“3” == 3, // true

“3” === 3, // false

“1” == true, // true

“1” === true, // false

);

特殊情况三 NaN 不大于，不小于，不等于任何值。

- NaN的意思是“不是一个数字”，两个不是一个数字的值没法比较，就是false

var a = NaN;

console.log(

a == NaN, // false

a > NaN, // false

a < NaN, // false

a != NaN,// true

2 != NaN, // true

“abc” != NaN // true

);

使用方法 isNaN(num) 来判断num是否是一个数字

-  如果 num 不是数字或者无法转换为数值，就返回 true。

• 如果 num 是数字或者可以用个隐式转换为数值，就返回 false。

console.log(

isNaN(“abc”), // true

isNaN(3), // false

isNaN(“3”), // false

);

• 习惯上，我们反着用 !isNaN(num)

• 如果为 true 是数字，不过为 false 就不是数字。

console.log(

!isNaN(“abc”), // false

!isNaN(3), // true

!isNaN(“3”), // true

);

逻辑运算

---

逻辑运算是将多个表达式的结果综合得出最终结论。

逻辑运算符有三个：

- &&（与/并且）

- || （或/或者）

- ！（非/不）

逻辑与  &&

逻辑与，当所有条件都满足是返回true，否则为false。

价格便宜  &&  销量高   &&  评价好

true                true               true      ==>   true

true                true              false    ==>   false

逻辑或  ||

逻辑或，只要一个条件满足就返回true，所有条件都不满足返回false。

距离 　 || 　 价格

true 　　　   true 　 ==>　true

true 　　　  false　 ==>    true

false　　　  false     ==>    false

逻辑非 ！

逻辑非，颠倒结果 如果是true返回false ，如果是false就返回true。

!true==> false

!false ==> true

!isNaN() ==> isNaN()

案例代码

var n = 10, m = 20;

console.log(

// 逻辑与

n > 5 && n < 20,// true

n > 5 && n < 8, // false

n > 5 && n < m && n < 10, // true && ture && false ==> false

// 逻辑或

n < m || n > 20, // true || false ==> true

n > 5 || n < 8, // true || false ==> true

n > 5 || n < m || n < 10, // true

// 逻辑非

!(n + m) == 30, // !true ==> false

);

运算符的优先级

下面的表将所有运算符按照优先级的不同从高到低排列。

短路逻辑

---

如果前一个条件已经可以得出最终总结，则后续的条件不再执行。

-  && 如果前一个条件为 true ，则后续的条件才会继续执行。

- 　　如果前一个条件为 false，则后续的条件不在执行，直接返回结果 false。

-   ||   如果前一个条件为 true，则后续的条件不在执行，直接返回 true。

-    　 如果前一个条件为 false ，则后续的条件继续执行。

短路逻辑 案例代码

var n = 10;

console.log(

n >= 10 && m == 2 // true && 未声明报错 ==> 未声明报错

);

console.log(

n >= 10 || m == 2 // true && 未声明报错 (但未执行) ==> true

);

console.log(

n < 10 && m == 2 // false && 未声明报错（但未执行） ==> false

);

console.log(

n < 10 || m == 2 // false && 未声明报错 ==> 未声明报错

);

利用逻辑与的短路实现简单的分支，只有满足了某个条件，才会做某事

案例代码

// 利用逻辑与的短路实现简单的分支，只有满足了某个条件，才会做某事。

// 请用户输入自己的薪水，如果薪水小于6000，则涨薪20%。

var salary = parseFloat(prompt(“请输入您的薪水”));

// 判断用户的薪水是否小于6000，小于则涨薪20%。

(salary<6000) && (salary = salary*(1.2));

console.log(“您张新后的薪水为：”+salary);

假设我们在弹框填入3000

假设我们在弹框填入8000

利用逻辑或的短路实现默认值效果。

如果第一个值有效，则优先使用值1，如果第一个值无效，则使用值2。

案例代码

// 利用逻辑或的短路实现默认值效果，如果第一个值有效，则优先使用值1，如果第一个值无效，则使用值2.

//请用户输入自己的座右铭，如果用户输入了，就用用户自己输入的，如果游湖没输入，就输出“用户很懒，什么都没留下。”

var input = prompt(“请输入您的座右铭”);

var msg = input || “用户很懒，什么也没留下。”; // 存储个人说明的内容。

console.log(msg);

假设在弹框输入“向死而生”，点击确定

假设在弹框不输入内容，点击确定

条件运算

---

条件运算，也叫做 三目运算、三元运算

条件运算可以实现简单的分支

条件运算符 ： ？

-  条件 ? 表达式1 : 表达式2

• 若条件为 true ，则执行表达式1

• 若条件为 false，则执行表达式2

案例代码

// 条件运算符

// 长出两个数中的最大值.

var a = 10, b = 20;

var max;

a>b ? max = a:max =b;

console.log(max); // 20

var a = 50, b = 20;

var max;

a>b ? max = a:max =b;

// max = a>b?a:b; // 简写

console.log(max); // 50