date1203自增自减运算符

150 阅读4分钟

自增自减运算符

  1. ++

  2. --

概念:自增自减运算符 每次执行 变量储存的原始数据都会 自增1 或者 自减1。

  • 可以理解为 ++ 就是 +=1 的效果
  • 可以理解为 -- 就是 -=1 的效果

注意:但是 ++ 和 -- 和 +=1 -=1 的执行原理完全不同

自增自减 和 +=1 -=1 的区别:

            +=1 -=1 
                直接执行 算数运算 
                在 变量储存 原始数据的基础上 累加 或者 累减操作

            ++  --
                先 将变量储存的原始数据 转化为 数值类型
                对 转化结果 执行 累加1 或者 累加1 的操作

                也就是 变量储存的原始数据 
                可以 自动转化为 数值类型 就支持 ++ -- 的操作
第一种情况:
        var a = 100 ;
        // 相对于 执行累加1 的效果 
        // 每次执行 ++ 操作 都会 累加1
        a++;
        a++;
        a++;
        a++;
        a++;
        a++;
        console.log( a );  // 106
第二种情况:
        var b = 100 ;
        // 相对于 执行累减1 的效果
        // 每次执行 -- 操作 都会 累减1
        b--;
        b--;
        b--;
        b--;
        b--;
        console.log( b );   // 运行结果:95
第三种情况:
        // ++ 和 +=1 的区别

        var d = '100' ;
        // 加等操作 有字符串参与 执行的是 字符串拼接操作
        // 字符串'100' 拼接 数值100 结果是 100100
        d += 100 ;

        console.log( d );   // 100100
第四种情况:
        var s = '100';
        // ++操作 先将变量储存的数值 转化为 数值类型
        // 再执行 加1 操作
        // 变量b 存储的是 字符串'100' 专业为数值类型是 数值100
        // 对 数值100 执行 +1 操作 执行结果是 101
        s++;

        console.log( s );  // 101

第五种情况:

// 变量 存储的原始数据 只要可以转化为数值类型 就支持 ++ -- 操作

        var a = '2e3' ;   // 2 * 10的三次方
        a++ ;
        console.log( a );   // 2001
第六种情况:
        // 只要执行 ++ -- 操作 变量储存的原始数值 一定会累加1 或者 累加1
        var a = 100 ;
        a++;
        console.log( a );  // 101

        var b = 100 ;
        ++b ;
        console.log( b );  // 101
第七种情况:
        // 前缀语法 执行原理
        var a = 100 ;
        // 变量a存储的原始数据是 100
        // var b = ++a 执行的是 前缀语法形式
        // 先 执行 ++a 也就是 变量a 先累加1 新的数值是 101
        // 使用的是 新的数值101 参与当前位置程序的执行
        // 也就是 将 新的数值101 赋值给 变量b 存储
        // 变量b 存储的数值 就是 101
        var b = ++a ;
        // 先 累加变成101 使用 101 参与程序
        console.log( b );  // 101
第八种情况:
        // 后缀语法 执行原理
        var c = 100 ;
        // 变量c 存储的原始数值是 100
        // 当期位置 是 变量c 是 后缀语法 
        // 先使用 原始数据 参与当前位置 程序的执行
        // 也就是 先将原始数据100 赋值给 变量d
        // 赋值结束 当前位置 没有其他程序执行 执行 c++操作 
        // 变量c 存储的数据 累加1 变量c 存储的数值 累加变成101
        var d = c++ ;
        // 先使用原始数据100 参与程序 之后在 累加变成101
        console.log( d );   // 100
第九种情况:
        var a = 0 ;
        // a的原始值是 0 
        // 当前位置是 后缀 
        // 先 使用原始值参与程序运算 
        // 也就是 b = 0 + 100 结果是 b 赋值存储 100
        // 当前位置计算结束 a 执行累加操作 数值累加成 1
        var b = a++ + 100 ;

        console.log( a );   // 1
        console.log( b );   // 100
第十种情况:
        var a = 0 ;
        // a的原始值是 0 
        // 当期位置是 前缀语法 
        // 先执行 累加操作 a变成1
        // 使用 新数值 1 参与运算
        // 也就是 b = 100 + 1;
        // b 是 101
        var b = 100 + ++a ;
        console.log( a );   // 1
        console.log( b );   // 101
第十一种情况:
        var a = 0 ;
        // 当前位置 a 的原始值是 0
        var b = 100 + ++a ;
        // 当前位置 a 的原始值是 1
        // 前置语法 先 执行累加 a变成 2 
        // 使用 新数值 2 参与运算 
        // c 的结果是 102 
        var c = ++a + 100 ;

        console.log( a );  // 2
        console.log( b );  // 101
        console.log( c );  // 102
第十二种情况:
        var a = 0 ;
    /*

        原始值           0      1
        前/后           后      前
        运算             0      2
        公式             0  +   2  结果是 2
        下一个位置       1       2
    */        
        // var b = a++ + ++a ;
        var b = ++a + a++;

        console.log( a );  // 2
        console.log( b );  // 2
第十三种情况:
        var a = 0 ;
    /*

        原始值           0      1    0      1
        前/后           前     后    后     前
        运算             1      1    0      0
        公式             1  -   1 +  0  -   0
        下一个位置       
    */    
        var b = ++a - a-- + a++ - --a;

        console.log( a );  // 0
        console.log( b );  // 0