JS笔记（js中的流程控制语句介绍）

流程控制：控制代码执行的过程。

在任何的语言中，流程控制部分分为三类：
1：顺序执行。 从上到下依次执行。
2：分支选择：根据条件，有选择的执行某些代码，跳过某些代码。
if：单分支
if-else：双分支
if-else if…else：多分支
switch：多分支
3：循环：反复执行某些代码。
while
do-while
for

if单分支选择语句

1：语法： if(条件){ //任意的js代码  if代码块  }
2：解释：
    if是js的关键字。
    小括号必须要有
    条件：要求是一个boolean表达式。返回值为boolean。如果条件返回的不是boolean值，那么
        js底层会进行隐式的类型转换，转换为boolean值。
    一对大括号：里面是任意行的js代码。
3：执行过程：
    1：首先判断if后的条件的返回值。
    2：如果返回值为true，那么就执行if 代码块。 然后执行后续的内容。
    3：如果返回为false，那么就跳过if代码块，执行后续的内容。

注意：
    1：if是一个单分支选择语句，被选择执行的语句，根据条件是否成立，选择执行或者不执行。
    2: 如果if代码块中只有一条js代码。可以省略大括号。
        如果是多条js代码，那么必须使用大括号包裹。
    3：if后的条件的小括号后，不能添加 ;  .如果添加了分号，那么条件控制的是否执行的代码
        就是分号。而不是后面的大括号中的内容了。

<script>
    //随机得到两个数，将比较大的求得，并打印。使用if实现。
    const MIN = 10;
    const MAX = 20;
    var num1 = ~~(Math.random () * (MAX - MIN) + MIN);
    var num2 = ~~(Math.random () * (MAX - MIN) + MIN);
    var num3 = ~~(Math.random () * (MAX - MIN) + MIN);
    console.log ("num1 = " + num1 + "\tnum2 = " + num2 + "\tnum3 = " + num3);

    /*var max = num1;
    if (max < num2) {
        max = num2;
    }
    if(num3 > max){
        max = num3;
    }*/
    var max;
    if(num1 >= num2 && num1 >= num3){
        max = num1;
    }
    if(num2 >= num1 && num2 >= num3){
        max = num2;
    }
    if(num3 >= num2 && num3 >= num1){
        max = num3;
    }
    //等价于上面的写法
    if(num3 >= num2){
        if(num3 >= num1){
            max = num3;
        }
    }
    console.log ("max = " + max);
</script>

if-else双分支选择

语法：if(条件){ //if 代码块 }else{ //else代码块 }
解释：
    条件：和if中的条件一致。
    else：是js中的一个关键字。否则的意思。
    else后的大括号：里面是任意的js代码。
 执行过程：
    1：先计算条件。必须返回一个布尔值，可能存在隐式的转换。
    2：如果条件返回的结果为true，那么就执行if代码块。而不执行else代码块。
    3：如果返回的结果为false，那么就跳过if代码块，执行else代码块中的内容。

 注意：
    1：if可以单独使用。else 不能单独存在，必须和某一个if 配对使用。
    2：if 代码块和else代码块中的内容，如果只有一行js代码，可以省略大括号。
    3：不要在条件小括号后添加分号，else就没有配对的if了。报错了。
    4: if 和 else之间，要么是一条js代码，要么是一个if代码块。
    5：if-else 双分支。这两个分支是条件互斥的。两个分支执行且必须执行其中的一个分支。

<script>
    //练习：两个英雄pk，一人攻击一次。
    //一个叫阿基里斯，一个叫赫克托
    var aHp = 100;
    var aAtk = 100;

    var hHp = 100;
    var hAtk = 100;
    //赫克托攻击阿基里斯
    var damage = hAtk + ~~(Math.random () * (11) - 5);//【-5 +5】
    aHp -= damage;
    if (aHp <= 0) {//阿基里斯挂了
        aHp = 0;
        console.log ("赫克托攻击了阿基里斯，产生了伤害：" + damage);
        console.log ("阿基里斯挂了！");
    } else {//阿基里斯残血反击
        damage = aAtk + ~~(Math.random () * (11) - 5);//【-5 +5】
        hHp -= damage;
        if (hHp <= 0) {
            hHp = 0;
            console.log ("阿基里斯残血反杀了赫克托。");
            console.log ("赫克托挂了");
        }
    }
    //结果：
    if (aHp === 0) {//阿基里斯的血量为0
        console.log ("赫克托胜利了！");
    } else {阿基里斯的血量不为0，还活着
        if (hHp === 0) {//赫克托血量为0
            console.log ("阿基里斯胜利了！");
        } else {
            console.log ("aHp = " + aHp + "\thHp = " + hHp);
            console.log ("平局！");
        }
    }
</script>

if-else if…else 多分支选择语句

语法：
    if(条件-1){ //代码块-1}
    else if(条件-2){ //代码块-2}
    else if(条件-3){ //代码块-3}
    ......
    else{代码块-n}
 执行过程：
    1：先判断 条件-1，如果成立，执行 代码块-1。后续的所有的分支都被跳过。
    2：条件-1 不成立。继续判断 条件-2.成立执行对应的代码块，不成立，继续判断后续的条件。
    3：一次类推，只要有一个条件成立了，就执行对应的代码块，其他的代码块都被跳过。
    4：如果所有的条件都不成立，那么执行最后的else 的代码块。

 注意：
    1：如果代码块中的内容为一条js代码，大括号可以省略。
    2：这些所有的分支的条件理论上应该是互斥的。不应该存在重叠的条件。
    3：每个else 都和它前面的距离它最近的if 配对。
    4：if-else 多分支，执行且仅能执行其中的一个分支。
    5：最后的else可以不写。取决于业务的要求。如果最后的else没有，那么这么多的分支可能
        一个都不执行。如果前面的所有的条件都不成立，那么就都不执行。

<script>

    /*练习 随机 得到一个分数[0,100],
    * [90-100]:打印 优秀
    * [80-89]:良好
    * [70-79]:中等
    * [60-69]:及格
    * [0-59]:回炉重造。
    * */
    const MIN_SCORE = 0;
    const MAX_SCORE = 101;
    var score = ~~(Math.random () * (MAX_SCORE - MIN_SCORE) + MIN_SCORE);
    console.log (`score = ${score}`);

    if (score >= 90) {
        console.log ("优秀");
    } else if (score >= 80) {
        console.log ("良好");
    }else if(score >= 70){
        console.log ("中等");
    }else if(score >= 60){
        console.log ("及格");
    }else{
        console.log ("回炉重造");
    }
</script>

switch-case 多分支选择:

语法：
    switch(变量表达式){
    case 常量表达式-1:
        代码块-1
    break;
    case 常量表达式-2:
        代码块-2
    break;
    case 常量表达式-3:
        代码块-3
    break;
    .....
    default:
    代码块-n
    break;
    }
解释：
    switch：js关键字，开关的意思。
    小括号中的变量表达式：包含变量的表达式。
    后面是一对大括号。大括号中有若干对 case-break 结构体。
    case 后通常是常量表达式:
    代码块：任意行js代码分支语句。
    break：js关键字。后面直接跟分号即可。

执行过程：
    1：首先计算 switch后的变量表达式的结果。
    2：然后从上到下依次计算每个case 后的常量表达式计算的结果。
        然后依次和switch变量表达式计算的结果进行等值比较。
        比较是否相等。如果和某一个case 后的值相等，那么就执行对应的
        代码块的内容。如果不相等，就继续比对下一个case 后的值。
    3：如果某一个case 相等了，那么就执行里面的内容，遇到break，
        直接结束整个switch语句。
    4：如果和每个case后的值都不相等，那么就执行default后的代码块。

注意：
    1：每个case后的常量表达式的值应该是不同的。
    2：多少个case 取决于业务的要求，没有数量的限制。
    3：每个case 后的break，都是可以没有的。取决于业务的需求。
        如果执行了case后需要结束switch，那就需要添加break。
    4：default：是可选择添加的。根据业务要求。
    5: 该机构只且最多比对相等一次。

 break：在switch语句中的作用
    就是用来结束switch语句的。
    如果执行了case后的代码，但是case后没有break，那么后面的所有的case都将被继续执行。
    直到遇到了一个break，才会结束switch。

<script>
    /*练习 随机 得到一个分数[0,100],
   * [90-100]:打印 优秀
   * [80-89]:良好
   * [70-79]:中等
   * [60-69]:及格
   * [0-59]:回炉重造。
   * */
    const MIN_SCORE = 0;
    const MAX_SCORE = 101;
    var score = ~~(Math.random () * (MAX_SCORE - MIN_SCORE) + MIN_SCORE);
    console.log (`score = ${score}`);
    score /= 10;
    score = ~~(score);
    console.log (`score = ${score}`);//[0-10]
    switch (score) {
        case 10: case 9:
            console.log ("优秀");
            break;
        case 8:
            console.log ("良好");
            break;
        case 7:
            console.log ("中等");
            break;
        case 6:
            console.log ("及格");
            break;
        case 5:
        case 4:
        case 3:
        case 2:
        case 1:
        case 0:
            console.log ("回炉重造");
            break;
            //等价代码
        // default:
        //     console.log ("回炉重造");
        //     break;
    }
</script>