天津11选5助手安卓版:JavaScript運算符-算數-比較-邏輯-字符串-三元-特殊運算符

作者: 魯智深 分類: JAVASCRIPT 發布時間: 2015-12-03 23:58

運算符

天津11选5中奖结果 www.ebzvaz.com.cn 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. 嵌套結構本身的性能不夠好
 */

運算符的優先級

運算符的優先級

運算符的優先級

如果覺得我的文章對您有用,請隨意打賞。您的支持將鼓勵我繼續創作!

發表評論

電子郵件地址不會被公開。 必填項已用*標注