自增自减与逻辑运算符

156 阅读5分钟

自增自减与逻辑运算符 位非

     *  自增自减运算符
     *      ++      --
     *      作用: 将变量自增1或者自减1
     * 
     *      语法:
     *          变量++
     *          ++变量
     * 
     *      区别:
     *          如果 符号 在 变量/数据 前, 先运算自增或者自减, 然后参与周围程序运算
     *          如果 符号 在 变量/数据 后, 先参与周围程序运算, 然后自增或者自减
    */


                 var num = 1
                 ++ 在前, 先运算
                 console.log(++num)  // 直接等于2

                 ++ 在后, 后运算
                 console.log(num++)  // 等于1
                 console.log(num)     // 然后等于2,注意  这个例子分两步
                 
                 var x=3
                 // 如果++在后,先返回x然后再+1
                 // 如果++在前,先+1在返回x的结果
                 例1
                 var y=x++;
                 console.log(y,x); //3 和 4
                 
                 例2
                 var y=++x;
                 console.log(x,y);// 4和4
                 
                 例子3
                 var x=2; 返回就是把值给y
                 ++x  先返回3  x=3
                 x++  先返回3 x=x+1   x=4
                 var y=++x + x++;
                 console.log(y,x);//6 和 4 
                 例子4
                  var x=2;
                  解题   注意x的值是通过自增自减运算符不断变化的,y就是x每一次变化后的值的集合
                  x      3    4    4    5    4    4  4   3     x=3  x的值不断随运算符变化
                  y      3  + 3   +4 +  5  + 5   -4 -4 - 3    y的值加减乘除
                  var y= ++x + x++ + x++ + x + x - --x - x - --x;
                  题目
                  var y=++x+x+++x+++x+x---x-x---x;
                  console.log(x,y);  // 3 和 9
    


   

逻辑运算符 || && !

  /**
     *    
     *      &&  逻辑与  逻辑且
     *          语法:   变量1/数据1 && 变量2/数据2
     * 
     *          运行规则: 会判断符号左边的变量的值, 转换为布尔值后
     *          如果符号左边布尔值为 true, 那么运行符号右边的代码或者返回符号右边的代码
     *          如果符号左边布尔值为 false, 那么直接运行符号左边的代码或者返回符号左边的代码
     * 
     *      ||  逻辑或
     *          语法:   变量1/数据1 || 变量2/数据2
     *              
     *          运行规则: 会判断符号左边的变量的值, 转换为布尔值后
     *          如果符号左边布尔值为 true, 那么运行符号左边的代码或者返回符号左边的代码
     *          如果符号左边布尔值为 false, 那么直接运行符号右边的代码或者返回符号右边的代码
     * 
     * 
     *      逻辑与  和   逻辑或 将来在 分支语句中经常会使用 作为 判断条件
     *              逻辑与:     满足条件1   并且   满足条件2
     *              逻辑或:     满足条件1   或者    满足条件2
     *  
     * 
     *      !   逻辑非
     *             转换为布尔值后取反
    */
     // 拓展  
     "" 0  false null undefined NaN 都是布尔值false

    // 逻辑与 &&
    console.log(true && true);// 返回第二个true
    console.log(true && false);//false
    console.log(false && true);//false
    console.log(false && false);//返回第一个false
    
    
   // ||
    console.log(false || false);//false  返回第二个false对应的值
    console.log(true || false);//true  返回true对应的值
    console.log(false || true);//true 返回true对应的值
    console.log(true || true);//true 返回第一个true对应的值
    
    
    // ??

    var a=0;
    a=a || 6//如果a是"" 0  false null undefined NaN,则返回||后面的值
    a=a ?? 6;//如果a时undefined或者null,则返回 ??后面的值
    console.log(a);


   /* 
     true && true  返回第二个true对应的值   5 && 6   5转换为布尔值是true,6转换为布尔值是true ,返回第二个true对应的值 6
     true && false 返回false对应的值   5 && 0    5转换为布尔值是true,0转换为布尔值是false,返回false对应的值 0
     false && true 返回false对应的值   0 && 5   0转换为布尔值是false,返回false对应的值 0 遇到false跳出并且返回false对应的值
     false && false 返回false对应的值  0 && false 0转换为布尔值是false,返回false对应的值 0 遇到false跳出并且返回第一个false对应的值
    
    

     true || true  返回第一个true对应的值  5 || 6   5转换为布尔值是true,跳出返回true对应的值5 遇到true跳出并且返回true对应的值
     true || false  返回true对应的值  5 || 0   5转换为布尔值是true,跳出返回true对应的值5 遇到true跳出并且返回true对应的值
     false || true 返回true对应的值  0 || 5 0转换为布尔值是false,5转换为布尔值是true,将true对应的值返回出去 5
     false || false 返回第二个false对应的值 0 || “” 0转换 // ?? 只针对如果是undefined和null则返回后面的为布尔值是false,“”转换为布尔值是false 返回第二个false对应的值""

     ?? 与 || 相似  
     // ?? 只针对如果是undefined和null则返回后面的
    */
         var a=0;
        function fn1(){
            // 判断a是不是等于undefined或者null,如果是的话就会执行??后面的语句
            // 如果不是直接返回a
            return a ?? (a=10);
        }
        var s=fn1();
        console.log(s);
    
    
    
    
     // !  非  转换为布尔值后取反 当一个值转换为布尔值是true,则得到false,如果一个值转换为布尔值是false,则得到true

    var a=true;
    console.log(!a);


    var a=10;
    console.log(!a);

    // 如果看到某个变量使用!  这就说明这个变量如果"" 0  false undefind null NaN ,使用!以后得到结果是true,除此以外得到的结果都是false

    
设置开关
    // 获取当前html中id是bn的html元素
    var bn=document.getElementById("bn");
    // 设置bool的初始值为false
    var bool=false;
 
    // 当点击bn按钮时,执行下面的内容
    bn.onclick=function(){
        // 开关取反,如果bool是false则赋值给bool为true,如果bool是true,赋值给bool为false
       bool=!bool;
    //    bn.className bn按钮的class名字 如果bool是true,返回 bn2这个字符串设置给按钮的class,否则返回bn1这个字符串给按钮的class
       bn.className= bool ? "bn2" : "bn1";//三元表达式
    }
    

~ 位非

  // ~ 位非: 变量数值+1,并且取反,如果变量值是小数会向下取整
    var a=3;
    console.log(~a);//-4
    console.log(~2);//-3
    console.log(~1);//-2
    console.log(~8);//-9

    console.log(~-5);//4
    console.log(~-2);//1

    var a = 3.12;
    var b = 3.65;
    console.log(~a);//-4
    console.log(~b);//-4
    
     
   // ~~ 就是向下取整   没有加一取反
     var b = 1.23;
     var a = 1.99
    console.log(~~a);//1
    console.log(~~b);//1