亲宝软件园·资讯

展开

Javascript基础:运算符与流程控制 Javascript基础:运算符与流程控制详解

宇智波-林中路 人气:0
想了解Javascript基础:运算符与流程控制详解的相关内容吗,宇智波-林中路在本文为您仔细讲解Javascript基础:运算符与流程控制的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:Javascript运算符,Javascript流程控制,下面大家一起来学习吧。

1. 运算符(操作符)

「运算符」是用于实现赋值、比较和执行算数运算等功能的符号。常用运算符分类如下

1.1 算数运算符

运算符 描述 案例
+ 10+20=30
- 10-20=-10
* 10*20=200
/ 10/20=0.5
% 取余(取模) 返回除法的余数9%2=1
  //alert(1 + 1);
        console.log(1 + 1);  //运算符的左右两侧都要敲空格
        //alert(1 - 1);         //0
        //alert(1 * 1);         //1
        //alert(1 / 1);         //1

1. % 取余(取模)

//alert(4 % 2);           //0
 //alert(5 % 3);           //2
//alert(3 % 5);           //3  注意!!!!!!!!!!

2.浮点数 算数运算里面会有问题

  var result = 0.1 + 0.2;    // 结果不是 0.3,而是:0.30000000000000004
  console.log(0.07 * 100);   // 结果不是 7,  而是:7.000000000000001

浮点数值的最高精度是17位小数,但是在进行算数运算时其精确度远远不如整数,所以不要直接判断两个浮点数是否相等!

3. 我们不能直接拿浮点数来进行相比较 是否相等

 var num = 0.1 + 0.2;
 alert(num == 0.3);          //false   要转化为2进制,精确度会有误差
  // 是由数字、运算符、变量等组成的式子 我们称为表达式   1+1 // alert(1 + 1);  //2 就是返回值    //写法    //1 + 1=2    // 在我们程序里面  2 = 1 + 1 把我们右边表达式计算完毕把返回值给左边    var num = 1 + 1;    // alert(num);  //2

1.2 递增和递减运算符

如果需要反复给数字变量添加或减去1,可以使用递增( + + )和递减( - - )运算符来完成。

在javascript 中,递增( + + )和递减( - - )运算符既可以放在变量前面,也可以放在变量后面。放在变量前面时,称为前置递增( 递减 )运算符,放在后面是后置递增( 递减 )运算符

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

前置递增运算符使用口诀:先自加,后返回值

 <script>
        //1. 想要一个变量自己加1   num=num+1 比较麻烦
        var num = 1;
        num = num + 1; // ++num
        num = num + 1;
        //alert(num);  //3
        //2. 前置递增运算符  ++写在变量前面
        var age = 20;
        ++age; //类似于 age = age + 1
        //alert(age);  //21
        // 3. 先加1 后返回值
        var p = 10;
        alert(++p + 10); //21
    </script>

前置递增运算符使用口诀:先返回值原值 后自加1

 <script>
        var num = 10;
        num++; // num = num + 1  ++num
        // alert(num);         //11
        //1. 前置自增和后置自增如果单独使用  效果是一样的
        //2. 后置自增 口诀:先返回值原值  后自加1
        var age = 10;
        //alert(age++ + 10);   //20
        //alert(age);         //11
        //alert(age + 10);    //21
    </script>

案例:

 <script>
        var a = 10;
        ++a; //++a = 11    a=11          ++a 是表达式
        var b = ++a + 2; // a=12    a++ = 12        前置:先自加,后返回值
        //alert(b);   //14  
        var c = 10;
        c++; //c++ = 11  c = 11
        var d = c++ + 2; //c++ = 11  c = 12      后置:先原值返回,后自加
        //alert(d);                 //13
        var e = 10;
        var f = e++ + ++e; // e++ =10  e=11  ++e=12
        console.log(f); //22
        // 后置自增  先表达式返回原值  后面变量再自加1
        // 前置自增  先自加,后运算
        // 单独使用 ,运行结果相同
        // 开发时,大多数使用后置递增/减,并且代码独占一行,例如:num++;或者num--
 </script>

1.3 比较运算符

比较运算符是两个数据进行比较时所使用的运算符,比较运算符,会返回一个布尔值(true/false)作为比较运算的结果。

运算符 描述 案例
+ 10+20=30
- 10-20=-10
* 10*20=200
/ 10/20=0.5
% 取余(取模) 返回除法的余数9%2=1
<script>
        // alert(3 >= 5);  //false
        // alert(2 <= 5);     //true
        //1. 我们程序员里面的等于符号是 == 默认转换数据类型 会把字符串型的数据转换为数字型
        // 只要求值相对
        //alert(3 == 5);                     //false
        //alert('pink老师' == '刘德华');       //false 
        //alert(18 == 18);                    //true
        //alert(18 == '18');                  //true
        //alert(18 != 18);                    //false   !=  不等于
        //2. 我们程序员里面有全等 一模一样   要求两侧的值,还有数据类型完全一致才可以 true
        //alert(18 === 18);             //true
        //alert(18 === '18');           //false 
</script>
符号 作用 用法
= 赋值 把右边给左边
== 判断 判断两边值是否相等(注意此时有隐式转换)
=== 全等 判断两边的值和数据类型是否完全相等

1.4 逻辑运算符

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

 <script>
        // 1. 逻辑 与&&(and)  两侧都为true 结果才是true 只要一侧结果为false  结果就为false
        //alert(3 > 5 && 3 > 2);   //false
        //alert(3 < 5 && 3 > 2);     //true
        // 2. 逻辑或|| (or)   两侧都为 false  结果才是假 false ,只要一侧为true ,结果就是true
        //alert(3 > 5 || 3 > 2);    //true
        //alert(3 > 5 || 3 < 2);    //false
        //3. 逻辑非 ! (not)
        alert(!true); //false
    </script>

练习:

   <script>
        var num = 7;
        var str = "我爱你~中国~";
        alert(num > 5 && str.length >= num); //true
        alert(num < 5 && str.length >= num); //false
        alert(!(num < 10)); //false
        alert(!(num < 10 || str.length == num)); //false
    </script>

短路运算(逻辑中断):(js API)

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

  3. 逻辑与短路运算  如果表达式1 结果为真 则返回表达式2  如果表达式1为假 那么返回表达式1
        alert(123 && 456);              //456   除了0之外,所有的数字都为真
        alert(0 && 456);                // 0
        alert(0 && 1 + 2 && 456 * 56789); // 0
        alert('' && 1 + 2 && 456 * 56789); // ''
        如果有空的或者否定的为假 其余是真的    :  0  ''  null undefined  NaN
 4. 逻辑或短路运算  如果表达式1 结果为真 则返回的是表达式1 如果表达式1 结果为假 则返回表达式2
        alert(123 || 456); // 123
        alert(123 || 456 || 456 + 123); // 123
        alert(0 || 456 || 456 + 123); // 456
逻辑中断很重要 它会影响我们程序运行结果
        var num = 0;
        //alert(123 || num++);      //123  num++不会运行
        //alert(num);                 // 0

1.5 赋值运算符

运算符 描述 案例
= 直接赋值 var userName = 'fan'
+= -= 加减一个数后 再赋值 var age=5; age+=5
*= /= %= 乘、除、取模后再赋值 var age=5; age*=5
  <script>
        var num = 10;
        // num = num + 1;   //num++
        // num = num + 2        //num+=2;
        var num = 10;
        num += 5;
        // alert(num);   //15
        var num = 10;
        num -= 5;
        // alert(num);   //5
        var age = 2;
        age *= 3;
        // alert(age);     //6
        var age = 6;
        age /= 3;
        // alert(age);     //2
        var age = 4;
        age %= 2;
        // alert(age);     //0
    </script>

1.6 运算符优先级

优先级 运算符 顺序
1 小括号 ()
2 一元运算符 ! ++ --
3 算数运算符 先* / % 后+ -
4 关系运算符 > >= < <=
5 相等运算符 == != === !==
6 逻辑运算符 先&& 后||
7 赋值运算符 =
8 逗号运算符 ,
  <script>
        //  一元运算符:++num   !num     二元运算符: 2 + 3
        // 练习1
        console.log(4 >= 6 || '人' != '阿凡达' && !(12 * 2 == 144) && true) //true
        var num = 10;
        console.log(5 == num / 2 && (2 + 2 * num).toString() === '22'); //true
        console.log('-------------------');
        // 练习2
        var a = 3 > 5 && 2 < 7 && 3 == 4;
        console.log(a); //false
        var b = 3 <= 4 || 3 > 1 || 3 != 2;
        console.log(b); //true
        var c = 2 === "2";
        console.log(c); //false
        var d = !c || b && a;
        console.log(d); //true
    </script>

2. 流程控制

流程控制」在一个程序执行的过程中,各条代码的执行顺序对程序的结果是有直接影响的。很多时候我们要通过控制代码的执行顺序来实现我们要完成的功能。流程控制主要有三种结构,分别是顺序结构、分支结构和循环结构,代表三种代码执行的顺序。

分支流程控制:

2.1 if 的语法结构

        if (条件表达式) {
            //执行语句
        }
        2. 执行思路 如果
        if 里面的条件表达式结果为真 true 则执行大括号里面的 执行语句
        如果if 条件表达式结果为假 则不执行大括号里面的语句 则执行if 语句后面的代码
        3. 体验代码:
        if (3 < 5) {
            alert('沙漠骆驼');
        }

案例:

  <script>
        // 弹出 prompt 输入框,用户输入年龄, 程序把这个值取过来保存到变量中
        // 使用 if 语句来判断年龄,如果年龄大于18 就执行 if 大括号里面的输出语句
        var age = prompt('请输入年龄');
        if (age >= 18) {
            alert('可以进入网吧')
        }
    </script>

2.2 if else双分支语句

<script>
        // 1. 语法结构  if 如果  else 否则
        // if (条件表达式) {
        //     // 执行语句1
        // } else {
        //     // 执行语句2 
        // }
        // 2. 执行思路 如果表达式结果为真 那么执行语句1  否则  执行语句2
        // 3. 代码验证
        var age = prompt('请输入您的年龄:');
        if (age >= 18) {
            alert('我想带你去网吧偷耳机');
        } else {
            alert('滚, 回家做作业去');
        }
        // 5. if里面的语句1 和 else 里面的语句2 最终只能有一个语句执行  2选1
        // 6.  else 后面直接跟大括号
    </script>

案例:闰年

  //  算法:能被4整除且不能整除100的为闰年(如2004年就是闰年,1901年不是闰年)或者能够被 400 整除的就是闰年
        // 弹出prompt 输入框,让用户输入年份,把这个值取过来保存到变量中
        // 使用 if 语句来判断是否是闰年,如果是闰年,就执行 if 大括号里面的输出语句,否则就执行 else里面的输出语句
        // 一定要注意里面的且 &&  还有或者 || 的写法,同时注意判断整除的方法是取余为 0
         var year = prompt("请输入要检测的年份:")
        if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
            alert(year + '是闰年')
        } else {
            alert(year + '是平年')
        }

2.3 if else if语句(多选1)

<script>
        // 1. 多分支语句   就是利用多个条件来选择不同的语句执行 得到不同的结果  多选1 的过程
        // 2. 是多分支语句
        // 3. 语法规范if else if语句
        if (条件表达式1) {
            //语句1;
        } else if (条件表达式2) {
            //语句2;
        } else if (条件表达式3) {
            //语句3;
        } else {
            //最后语句;
        }
        // 4. 执行思路
        // 如果条件表达式1 满足就执行 语句1 执行完毕后,退出整个if 分支语句  
        // 如果条件表达式1 不满足,则判断条件表达式2  满足的话,执行语句2 以此类推
        // 如果上面的所有条件表达式都不成立,则执行else 里面的语句
        // 5. 注意点
        // (1) 多分支语句还是多选1 最后只能有一个语句执行
        // (2) else if 里面的条件理论上是可以任意多个的
        // (3) else if 中间有个空格了
    </script>

案例:成绩

    <script>
        //  伪代码       按照从大到小判断的思路
        // 弹出prompt输入框,让用户输入分数(score),把这个值取过来保存到变量中
        // 使用多分支 if else if 语句来分别判断输出不同的值
        var score = prompt('请输入分数:');
        if (score >= 90) {
            alert('A');
        } else if (score >= 80) {      //不用写:90>score>=80 能运行下面,一定是小于90的
            alert('B');
        } else if (score >= 70) {
            alert('C');
        } else if (score >= 60) {
            alert('D');
        } else {
            alert('E');      //要带引号,不然以为是一个变量,就要声明了
        }
    </script>

2.4 三元表达式

<script>
        // 1. 有三元运算符组成的式子我们称为三元表达式
        // 2. 一元运算符:++num   二元运算符:  3 + 5    三元运算符: ? :
        // 3. 语法结构 
        // 条件表达式 ? 表达式1 : 表达式2
        // 4. 执行思路
        // 如果条件表达式结果为真 则 返回 表达式1 的值 如果条件表达式结果为假 则返回 表达式2 的值
        // 5. 代码体验
        var num = 10;
        var result = num > 8 ? '是的' : '不是' // 我们知道表达式是有返回值的,赋值给result 
        console.log(result); //是的
        //等价于:
        var num = 10;
        if (num > 5) {
            alert('是的');
        } else {
            alert('不是的');
        }
        // 三元表达式是简化版的if else
    </script>

案例 : 数字补0​​​​​​​

   <script>
        //  用户输入0~59之间的一个数字
        // 如果数字小于10,则在这个数字前面补0,(加0 拼接) 否则  不做操作
        // 用一个变量接受这个返回值,输出
        var num = prompt('请输入0~59之间的一个数字?')
            //三元表达式: 表达式? 表达式1: 表达式2;
        var result = num < 10 ? '0' + num : num; //字符型的0   把返回值赋值给一个变量
        alert(result);
    </script>

2.5 switch分支流程控制

switch 语句也是多分支语句,它用于基于不同的条件来执行不同的代码。当要针对变量设置一系列的特定值的选项时,就可以使用 switch。

    <script>
        //1. switch 语句也是多分支语句 也可以实现多选1
        // 2. 语法结构 switch 转换、开关    case小例子或者选项的意思   break 退出
        /*     switch (表达式) {
                case value1: 执行语句1; break;
                case value2: 执行语句2; break;
                case value3: 执行语句3; break;
                default: 执行最后的语句;
            } */
        // 3. 执行思路  利用我们的表达式的值 和 case 后面的选项值相匹配 如果匹配上,就执行该case 里面的语句  如果都没有匹配上,那么执行 default里面的语句
        switch (2) {
            case 1: alert('这是1'); break;
            case 2: alert('这是2'); break;  //这是2
            case 3: alert('这是3'); break;
            default: alert('没有匹配结果');
        }
    </script>

注意事项:

        var num=1;
        switch(num){
            case 1: console.log(1);break; //1
            case 2: console.log(2);break;
            case 3: console.log(3);break;
        }
        // 1. 我们开发里面 表达式我们经常写成变量
        // 2. 我们num 的值 和 case 里面的值相匹配的时候是 全等   必须是值和数据类型一致才可以 num === 1

break 如果当前的case里面没有break 则不会退出switch 是继续执行下一个case

  var num=1;
        switch(num){
            case 1: console.log(1);//1
            case 2: console.log(2);//2
            case 3: console.log(3);//3
        }

案例:查询水果案例

<script>
        //  弹出 prompt 输入框,让用户输入水果名称,把这个值取过来保存到变量中。
        // 将这个变量作为 switch 括号里面的表达式。
        // case 后面的值写几个不同的水果名称,注意一定要加引号 ,因为必须是全等匹配。
        // 弹出不同价格即可。同样注意每个 case 之后加上 break ,以便退出 switch 语句。
        // 将 default 设置为没有此水果。
        var fruit = prompt('请输入水果名称')
        switch (fruit) {
            case '苹果':
                alert('苹果的价格是 3.5/斤');
                break;
            case '榴莲':
                alert('榴莲的价格是 35/斤');
                break;
            default:
                alert('没有此水果');
        }
    </script>

switch 语句和 if else if区别:

1. 一般情况下,它们两个语句可以相互替换

2. switch...case 语句通常处理case为比较确定值的情况,而if...else...语句更加灵活,常用于范围判断(大于、等于某个范围)

3. switch 语句进行条件判断后直接执行到程序的条件语句,效率更高。而if..else 语句有几种条件,就得判断多少次。

4. 当分支比较少时,if...else语句的执行效率比switch语句高。

5. 当分支比较多时,switch语句的执行效率比较高,而且结构更清晰。

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注的更多内容!

加载全部内容

相关教程
猜你喜欢
用户评论