前端第一周，Javascript--算数运算符 、赋值运算符、比较运算符、逻辑运算符、一元运算符

1.算数运算符：   +   -   *   /   %

// + 加：

 举个栗子：

        var n1 = 34;

        var n2 = 83;

        var num1 = n1 + n2;

        console.log(num1);// 117

        var sum2 = n2 + num1 + 100 + 40;

        console.log(sum2);//340

     加号 存在一个问题： 如果字符串和其他类型的数据相加,不会执行加法运算,而是进行 字符串拼接，字符串拼接:将多个数据拼接成为一个完整的字符串。

var n3 = '45'

var sum3 = n1 + n3;

   console.log(sum3);//'3445'

//  - 减：

 举个栗子：

        var n4 = 339;

        var n5 = n4 - n2;

        console.log(n5);//256

        var n6 = 23 - 45 + 13 - 22;

        console.log(n6);

        var n7 = 78 - 'hello';

        console.log(n7);// NaN

  //  * 乘：

 举个栗子：

        console.log(23 * 3);//69

        console.log(100 * 5);//500

        console.log(34 * 'a')// NaN

 

 //  /  除：

 举个栗子：

        console.log(14 / 2);//7

        console.log(15 / 2);//7.5

        console.log('zhagnlele' / 10);// NaN

 

 //  % 模(取余)：

 举个栗子：

        console.log(56 % 5);//1

        console.log(102 % 10);//2

        console.log(34 % 3);//1

        console.log('hello' % 2); // NaN

 

下面大家运用一下算术运算符做几个算术题把~ 

 题目一：

console.log(23 - 10 * 2 / 4 + 15 % 10);//23

        //23-20/4+15%10

        //23-5+15%10

        //23-5+5

        //23

 题目二：   

    console.log((23 - 10) * 2 / (4 + 15) % 10);//1.36..

        //13*2/19%10

        //26/19%10

        //1.368421052631579%10

        // 1.368421052631579

 题目三：       

console.log(34 + 5 + '14'); // '3914'

        //39+'14'

        //'3914'

 题目四：

  console.log('34' + 5 + 14);//'34514'

        //'345'+14

        //'34514'

 是不是很简单呢xiao'hu~ 

2. 赋值运算符： =   +=   -=   *=   /=   %=

  //赋值运算符的作用就是将  等号右侧的结果,赋值给左侧的变量

  //赋值运算符肯定是 先执行赋值运算符掉的右边,然后有了结果 再给  左边赋值

  //赋值运算符的左侧肯定是 变量

 //  = 赋值：

 举个栗子：

        var n1 = 34;

        console.log(n1);//34

        var n2 = 45 - 9;

        console.log(n2);//36

        n1 = n1 * 3;

        console.log(n1);//102 

 //  += ：

举个栗子：

        var n3 = 15;

        n3 += 10; //相当于n3= n3+10

        console.log(n3);//25

  //  -= ：

举个栗子：

        var n4 = 55;

        n4 -= 20; //n4=n4-20

        console.log(n4);//35

 //  *= ：

举个栗子：

        var n5 = 99;

        n5 *= 2;//n5=n5*2

        console.log(n5);//198
 

  //   /= ：

举个栗子：

        var n6 = 66;

        n6 /= 3; //n6=n6/3

        console.log(n6); //22

  //  %=  ：

举个栗子：

        var n7 = 67;

        n7 %= 10; //n7=n7%10

        console.log(n7)//7

3. 比较运算符 --- 关系运算符：

        >     <     >=     <=    ==    ===    !=    !==

        // 比较运算符组成的表达式为：比较表达式

        // 比较表达式返回的结果为 boolean

        // 程序只要执行了比较操作得到结果只能是 true / false

//  >  大于：

举个栗子：

        console.log(n1 > n2);  // false

        console.log(55 > n2);  // true

        console.log(24 > 24);  // false

//  <  小于 ：

举个栗子：

        console.log(n1 < n2);  // true

        console.log(55 < n2);  // false

        console.log(24 < 24);  // false

 //  >=  大于等于：

举个栗子：

        console.log(n1 >= n2);  // false

        console.log(55 >= n2);  // true

        console.log(24 >= 24);  // true

///  <=  小于等于 ：

举个栗子：

        console.log(n1 <= n2);  // true

        console.log(55 <= n2);  // false

        console.log(24 <= 24);  // true

 // 在js中一定要注意 =  ==  === 的区别：

        // 一个等号 = 是 赋值，是将=号右侧的结果赋值给左侧的变量

        // 两个等号 == 是 相等，是比较==号两边的值是否相等

        // 三个等号 === 是 全等，是比较===号两边的值和数据类型是否全等

  // == 相等：只比较值是否相等，忽略数据类型的比较：

举个栗子：

        console.log(23 == 23);  // true

        console.log(34 == 35);  // false

        console.log(56 == '56');  // true

        console.log(1 == true);  // true

 /// === 全等(恒等)：不仅比较值，还会比较数据类型：

举个栗子：

        console.log(23 === 23);  // true

        console.log(34 === 35);  // false

        console.log(56 === '56');  // false

        console.log(1 === true);  // false

   // != 不相等：只比较值是否不相等，忽略数据类型的比较：

举个栗子：

        console.log(89 != 80);  // true

        console.log(89 != 89);  // false

        console.log(89 != '89');  // false

        console.log(1 != true);  // false

   // !== 不全等(不恒等)：不仅比较值是否不全等，还会比较数据类型：

举个栗子：

        console.log(89 !== 80);  // true

        console.log(89 !== 89);  // false

        console.log(89 !== '89');  // true

        console.log(1 !== true);  // true

4.逻辑运算符：&& 与(并且)   || 或(或者)   !非(取反)

        //逻辑运算符组成的表达式叫做逻辑表达式

        //逻辑表达式的结果大概率也都是:boolean

 //  &&  与(并且) ：

        //同时判断多个表达式,必须是所有的表达式结果都是true才会得到true,否则结果是false

举个栗子：

        console.log(55 > 23 && 10 < 66);//true

        //  true      true

        console.log(5 > 3 && 10 < 6);//false

        // true    fales

        console.log(5 > 73 && 10 < 26);//false

        //  false   true

        console.log(5 > 73 && 100 < 26);//false

        //  false   false

        &&的逻辑中断(逻辑短路)：

        // 如果第一个表达式的结果是成立的，那么由第二个表达式确定最终成立与否，输出第二个表达式的结果

        // 如果第一个表达式的结果是不成立的，直接输出第一个表达式的结果，(不成立)

举个栗子：

        console.log(5 && 'hello');//hello

        console.log(999 && undefined);//undefined

        console.log(0 && 'hello');//0

        console.log(null && undefined);//null

 

 

 //  ||  或(或者) ：

        //同时判断多个表达式，只要至少有一个表达式的结果是true结果就为true，否则结果为false

举个栗子：

        console.log(23 > 11 || 5 > 2);//true

        //  true     true

        console.log(23 > 11 || 5 > 22); //true

        //  true     false

        console.log(2 > 11 || 55 > 22); //true

        //  flase    true

        console.log(2 > 11 || 55 < 22);//false

        //  flase   false

    ||运算符的逻辑中断(逻辑短路)：

        // 如果第一个表达式的结果是成立的，直接输出第一个表达式的结果，(成立)

        // 如果第一个表达式的结构是不成立的，那么由第二个表达式确定最终成立与否，输出第二个表达式的结果

举个栗子：

        console.log(5 || 10);//5

        console.log(5 || 0);//5

        console.log(null || 10);//10

        console.log(null || 0);//0

 //  ! 非(取反) ：

        // 将真的变成假的，将假得变成真的，得到的结果肯定是布尔值

举个栗子：

        console.log(!4);//false

        console.log(!null);//true

        console.log(!!4); //true

 

        // 逻辑运算符的优先级

        // ! > || > &&

举个栗子：

        console.log(5 && 3 || 9);//3

举个栗子：

        //!3 为false值为0

        console.log(5 && !3 || 9);//9

 

4.一元运算  --- 自增自减运算符：  ++   --

 

 //变量++  后加加：先使用变量自身，然后（这句代码执行之后）给变量+1

举个栗子：

        var a = 6;

        console.log(a);//6

        a++;//相当于a=a+1

        console.log(a++);//7

        console.log(a);//8

        var b = a++ + 10;

        console.log(b);//18

        var c = a++ + 10;

        console.log(c);//19

        //为什么等于10？？？？？ 因为var c a=9 但是它是后加加  到了 a这里就变成了 9+1 = 10

        console.log(a);//10

        var d = 8;

        console.log(d++);//8

        console.log(d++);//9

        console.log(d++);//10

        console.log(d++);//11

        console.log(d); //12

题目一：

        var e = 5;

        var sum1 = e++ + e++ - e++ + e + e++ - e++;

        // 5   + 6   - 7   + 8 + 8   - 9

        console.log(sum1);//11

        console.log(e);//10

 

  // ++变量   先加加：先给变量+1，然后使用变量

举个栗子：

        var f = 10;

        console.log(f);//10

        ++f;//相当于f=f+1

        console.log(f);//11

        console.log(++f);//12

        console.log(f);//12

        var g = 4;

        console.log(++g);//5

        console.log(++g);//6

        console.log(++g);//7

        console.log(g);//7

        var h = 12;

        var sum2 = ++h - h++ + ++h + ++h - ++h + h++ - ++h;

        //13 - 13  + 15  +  16 - 17  + 17  -19

        console.log(sum2);//12

        console.log(h);//19

 

        // 变量--   后减减：先使用变量自身，然后(这句代码执行过后)给变量-1

        // --变量   先减减：先给变量-1，然后使用变量

题目一：

        var i = 8;

        var sum3 = i++ - ++i + i-- - i++ + ++i - --i + i++ - i--;

        //8    - 10  + 10  - 9   + 11  - 10  + 10  - 11

        console.log(sum3);//-1

        console.log(i);//10