JavaScript里的各种运算符

最新推荐文章于 2021-11-04 22:56:51 发布

刘大哥就是6

最新推荐文章于 2021-11-04 22:56:51 发布

阅读量196

点赞数 1

分类专栏：笔记文章标签： javascript

本文链接：https://blog.csdn.net/tony_yang6/article/details/106834952

版权

笔记专栏收录该内容

99 篇文章 0 订阅

订阅专栏

1.比较运算符

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>

        // 比较运算符 :  运算结果是布尔值;
        // ==  近似等于  : 会发生隐式数据类型转换; 性能消耗比较大。
        // === 绝对等于  : 编程之中推荐使用绝对等于; 优先比对数据类型。

        // 小重点 : 赋值运算符的权重最低，所以我们见到= 默认就从右边开始计算;
        // var str = "1";
        // var num = 1;
        
        // var res = str == num;
        // str == num; => true;
        // res = true;
        
        // var res = true == 1;
        // var res = false == 0;

        // console.log(res);

        // 绝对等于 
        var str = "1";
        var num = 1;

        var res = str === num;
        console.log(res);


    </script>
</body>
</html>

2.比较运算符

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <!-- <title>Document</title> -->
</head>
<body>
    <script>
        // !  取反;
        // !true  =>  false
        // console.log(!true); 

        // 和比较运算符组合 : 
        // !=  近似不等于
        // !== 绝对不等于;

        // var str = "1";
        // var num = 1;

        // var res = str != num; // false
        // console.log(res);

        // var res = str !== num;
        // console.log(res);
        
        // > 大于 < 小于

        // var num1 = 1 ;
        // var num2 = 2;

        // console.log(num1 > num2);// false;


        // 会发生隐式数据类型转换;
        // var num1 = 1 ;
        // var num2 = "2";

        // console.log(num1 > num2);// false;

        // 字符串大小比对;
        // var num1 = "1" ;
        // var num2 = "2";

        // console.log(num1 > num2); // false;

        // * 特殊情况;
        // 字符串会转换成 ASCII 之后再进行比对。

        // var str1 = "一";
        // var str2 = "丁";

        // console.log(str1 > str2)


        // >=  <=   
        // 会不会发生隐式数据类型转换 ?   会!
        // JavaScript是一个弱类型语言 :  隐式数据类型转换是常态!;

        var num1 = 10;
        var num2 = 10;

        console.log(num1 <= num2); // true;

    </script>
</body>
</html>

3.逻辑运算符

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        // 数学逻辑 : 
        // 漂亮的 并且 有钱的 并且 温柔的 并且 贤惠的 并且 上得厅堂下得厨房的 并且 是异性 
        // 并且 => &&  
        // && 左右两侧都为true 那么结果才为true ; 如果左右两次有一侧是 false 那么最终结果就是false;

        // 漂亮的 也行 有钱的 也行 温柔的 也行 贤惠的 也行 上得厅堂下得厨房的 也行 是异性  
        // 也行 => || 
        // || 左右两侧有一侧是true 那么我们的计算结果就为true ，反之则为false;

        // var bool1 = true;
        // var bool2 = true;

        // console.log(bool1 && bool2);
        // console.log(bool1 && false);

        console.log(false || false);



    </script>
</body>
</html>

4.自增运算符

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        // 赋值运算 : += -= 
        // var num = 10;
        // num += 10;
        // console.log(num)

        // 自增运算 : 
        // 元 | 目  : 参与运算的数字;

        // 一元运算符 
        // 二元运算符
        // 三元运算符

        // var res = 1 + 1;
        // typeof 12;

        // ++ 自增运算符;
        // 1. 针对于变量的改变;
        // var num = 0;
        // num ++; 
        // num = num + 1;
        // num = 0 + 1;
        // num = 1;
        // console.log(1);

        // 2. 运算结果; ++在后, 运算结果是变量当前的值;
        // var num = 0;
        // console.log(num ++); 

        // ++ 在前 , 运算结果是经过自增的变量值;
        // var num = 0;
        // console.log(++ num );


        // 再说一元运算 : 

        // 自增运算 :  数数!; (变量才有自增) 
        // 自增是赋值运算;
        // 程序运行规则 : 从上到下，从左到右;
        // var count = 0;
        // count ++;
        // count ++;
        // console.log(count);
        // 关注点两个部分 : 
        // 1. 变量增加了1 ;
        
        // 2. 运算就有结果;
        // var count = 0; // 0 => 1
        // var res = count ++;
        // // 运算结果就是未经运算的 count 值;
        // var res2 = count ++;
        // console.log(res2);

        // 前置 ++; 就是变量则增之后的值;
        // var count = 0; // 0 => 1
        // var res  = ++ count;
        // var res2 = ++ count;
        // console.log(res2);

        // 面试题的前置;
        var num = 0; // 变量值是 0;
        console.log(num ++); //  1. 运算结果为 0; 
                             //  2. num的值被自增了一次 0 => 1 ; num => 1; 
        num += 20;           //  num => 21
        console.log(--num);  //  1. 运算结果 21 => 20 
                             //  2. num的值被自减了一次 21 => 20;
        num *= 3 ;           //  num => 60
        console.log(++num);  //  1. 运算结果 60 => 61
                             //  2. num的值被自增了一次 60 => 61
        console.log(num ++); //  1. 运算结果 61 
                             //  2. num的值被自增了一次 61 => 62 
        console.log(num);    //  62

        
    </script>
</body>
</html>