Day3 笔记-CSDN博客

本文链接：https://blog.csdn.net/qq_68113637/article/details/142405838

Chp - 4 运算符

1.运算符概念

运算符（operator）也被称为——是用于实现赋值、比较和执行算数运算等功能的符号。

JavaScript中常用的运算符有:

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

2.算数运算符

1.算术运算符概述

概念：算数运算使用的符号，用于执行两个变量或值的算术运算。

注意：使用运算符%时，若除数小于取余数，则返回除数。例如： 2%9 =2

       let a=10;
       let b=20;
       let c=a+b;
       console.log("c="+c);//c=30
       console.log(a-b,a*b,a/b);//-10 200 0.5
        // //%(取余  取模) 
       console.log(a%b);//10
       console.log(9%3,15%20,100%200,9%2);//0  15  100  1
       console.log(-a);//-10

2.浮点数的精度问题

浮点数值的最高精度是17位小数，但在进行算术计算时其精确度远远不如整数。

var result = 0.1 + 0.2;

// 结果不是 0.3,而是:0.30000000000000004

console.log(0.07 * 100) ;// 结果不是7, 而是 : 7.000000000000001

所以：不要直接判断两个浮点数是否相等

3.自增和自减运算符

一元运算符

运算符	描述	实例
++	自增	x=y++; x=++y;
--	自减	x=y--; x=--y;

1.概述

如果需要反复给数字变量添加或减去］，可以使用自增或自减运算符来完成。

在JavaScript中，自增（+ +）和自减（--）在变量前面时，我们可以称为前置运算符

在变量后面时，我们可以称为后置运算符。

注意：递增和递减运算符必须和变量配合使用

2.自增（减）运算符

前置自增（减）运算符

++num 前置递增，就是自加，类似于num=num+1，但是++num写起来更简单使用更方便使用口诀：先自加，再赋值

let num=10;
        alert(++num+10);// 21
        /* 
        let num1 =++num+10;
        式子      11+10    21
        内存      11
        alert(num1);
         */

--num 前置递减，就是自减，类似于num=num-1，但是--num写起来更简单使用更方便使用口诀：先自减，再赋值

后置自增（减）运算符

num++后置递增，就是自加1，类似于num=num+1，但是num++写起来更简单使用更方便使用口诀：先赋值（返回原值）,后自加

    let num1=10;
         alert(10+num1++); //20
         /* 
           let num2=10+num1++
           式子      10+10   20
           内存         11
           alert(num2);
         */

num--后置递减，就是自减1，类似于num=num-1，但是num--写起来更简单使用更方便使用口诀：先赋值（返回原值）,后自减

小结

前置递增（减）和后置递增（减）可以简化代码的编写，让变量的值+1（-1）写法更简单

单独使用时，前置递增（减）和后置递增（减）运行结果相同

与其他代码联用时（参与运算），执行结果会不同

• 前置递增（减）：先自加（减），后运算（先自增（减），后赋值先己后人）

• 后置递增（减）：先原值计算，后自加（减）（先赋值，后自增（减）先人后己）

//自增
        let i=1;
        // i++;
        // console.log("i="+i); // i=2
        // ++i;  // i=i+1
        // console.log("i="+i);// i=3
        // 参与运算
        let j=i++;  // 后置
        /* 
         j=i=1
         i=i+1=2
        */   
        console.log("i="+i,"j="+j);  // i=2  j=1
        let k=++i;  // 前置
        /* 
        k=i=i+1=3
        */
        console.log("i="+i,"k="+k); // i=3 k=3   

 //自减
        let a=10;
        a--; // a=a-1;
        console.log("a="+a); //a=9
        --a; // a=a-1;
        console.log("a="+a); // a=8
        //参与运算
        let b=a--;  // 后置  先赋值，后运算
        console.log("a="+a,"b="+b); 
        // a=7 b=8
        b=--a; // 前置 先运算，后赋值
        console.log("a="+a,"b="+b);
        //a=6 b=6

// 获取m,n的最终结果
    let m=10,n=2;
    m=  m++ + --m - n-- + m++ + ++n - --m - m-- +  m++ + --n
    /* 
         m++   --m  n--   m++   ++n   --m  m--    m++   --n
    式子  10 +  10 - 2  +  10  +  2 -  10 - 10  +   9  +  1   
    样子  11    10   1     11     2    10    9     10     1
    */
   console.log("m="+m,"n+"+n); //m =20 n=1

3.赋值运算符

let a=10; //把10赋值给变量a
          a+=10 // a=a+10
        console.log(a);//20
         a-=10; // a=a-10
         a*=10; //a=a*10
         a/=10; //a=a/10
         a%=10; //a=a%10

4.比较运算符

概念：比较运算符（关系运算符）是比较两个值，比较运算后，会返回布尔值

（true/false）作为比较运算的结果

   let a=10;
            let b=20;
            let c= a>=b;  // 大于或等于只要一个成立立即成立
            console.log(c); // false
            console.log(5>=5); //true
            console.log(a<=b); //true          
            // --------
            console.log('5'==5); //true
            console.log('5'===5); //false        
            console.log('5'!=5);//false
            console.log('5'!==5);//true
            //---------------特例   两边都是字符串  比较的ascii码  一位一位比  第一位比值 ，决定结果 不再比较
            console.log("12">"9"); //false            
            //实际工作
            let num1=prompt("请输入一个数字");
            let num2=prompt("请输入一个数字");
            console.log(num1,typeof num1); //   String
            console.log(num1>num2);// false  "100" "9"
            console.log(+num1>+num2);// true  100  9

5.逻辑运算符

概述

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

逻辑与&&

两边都是true才返回true ,否则返回false

逻辑或 ||

两边都为false才返回false ,否则都为true

逻辑非！

逻辑非（!）也叫作取反符，用来取一个布尔值相反的值，如true的相反值是false

短路运算(逻辑中断)

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

1.逻辑与

•语法：表达式1 &&表达式2

•如果第一个表达式的值为真，则返回表达式2

•如果第一个表达式的值为假，则返回表达式1

2. 逻辑或

•语法：表达式1 ||表达式2

•如果第一个表达式的值为真，则返回表达式1

•如果第一个表达式的值为假，则返回表达式2

如果运算符两边和操作数，有一个操作数不是布尔值的情况，返回的不一定是布尔值，可能是原值

注意：这些操作数中，只有通过大小比较得到true或false 或者直接写的true和false 才能返回true和false，否则可能是原值

//逻辑与
        let a=10;
        let b=20;
        let c=a>=b && a<b;
              //false
        console.log(c); // false
        console.log(0&&2); //0
        
        console.log(8>5&&false); //false
        console.log(8>5&&"hello");// hello
        console.log(7&&12);//  7转为true  12
        console.log(NaN&&"hello"+1+null); //NaN
        console.log(8>6&&undefined);// undefined
        
        //2.逻辑或

       console.log(8>5||9<6);//true
       console.log(true||[]);//true

       console.log(false||true);//true
       console.log(false||null);//null        Boolean(null)
       console.log(false||{});//{}
       console.log(false||'5'+null+undefined);//'5nullundefined'
         
       var num =    7;
       var str = "我爱你~中国 ";
       console.log(num > 5 && str.length >= num);  //true
       console.log(num <5 && str.length >= num);  //false 
       console.log ( ! (num < 10));  //false             
       console.log(!(num< 10 ||str.length == num )); //false   
     //逻辑非  ！
      console.log( !(8>5));//false    
      var num1 =    0;
      console.log(123 || num1++);// 123
      console.log(num1);//0

6.条件运算符（三元或三目运算符）

let res = 判断条件? 条件成立，返回值1 ：条件不成立，返回值2

相当于 if...else

 if(判断条件){
     条件成立，执行代码块
 }else{
     条件不成立，执行代码块
 }

//如果考试成绩大于等于80，合格的，否则不合格
        let score= +prompt("请输入一个成绩");
        // score>=80?console.log('合格'):console.log('不合格');
        // let res= score>=80?'合格':'不合格';
        // console.log(res);
        if(score>=80){
            console.log('合格');
        }else{
            console.log('不合格');
        }
    
        //如果工资大于7662 按7662*0.225,否则的话工资*0.225

        //三元表达式
        let sarlay= prompt("请输入你的工资");
        let wuXian =sarlay>7662?7662*0.225:sarlay*0.225;
        console.log(wuXian);