(javascript)(基础知识+实例） 2.分支判断

NaN

• not a number 不是一个数字 是一个非数字
• 是一个数值类型的 但是不是一个数字
• undefined --> NaN
• ‘1234’ --> 1234
• ‘hello’ --> NaN
• 注意事项
  1. NaN和任何数比较都是不相等
  2. NaN参与任何运算的结果都是NaN

运算符

• 数学运算符

  • + - *(乘) /(除) %(余)
  • 如果是加法运算，只要符号有一侧是字符串，另一侧也会转换成字符串 然后进行拼接
  • 其他的任何运算任何类型进行运算的时候都会将符号左右自动转换成数值然后再参与运算

• 赋值运算符

  • 将一个数据赋值给变量
  • = += -= *= /= %=

• 比较运算符

  • 比较运算符得到结果是一个布尔值
  • > < == != >= <= === !==
  • == 只要两个数据的值相等就是满足
  • === 既要两个数据值相等 又要他们的类型相同
  • != 只有两个数据的值不相等才满足
  • !== 要么两个数据的值不相等 要么类型不相同都是满足

• 逻辑运算

  • && 并且 符号左右两个条件都为真 才满足
  • || 或者 符号左右两个条件只要有一个满足 就满足
  • ! 取反 非

• 逻辑短路

  • 短路：编程上面的短路代表有一段代码不执行
  • && 当左侧条件为false的时候 右侧就不执行
  • || 当左侧条件为true的时候 右侧就不执行

• 自增和自减运算（一元运算符）

  • 后置
    • num++
    • num–
  • 前置
    • ++num
    • –num
  • 无论是前置还是后置都会将数据改变
  • 在参与其他运算的时候前置和后置是有区别
    • 前置的会先改变自身的值再参与运算
    • 后置的会先拿当前的值参与运算之后在改变自身

• 三元（目）运算符

  • 条件 ? 条件成立执行的语句 : 条件不成立执行的语句

判断 选择 分支

• 代码执行方式
  1. 顺序语句：每一句都会执行 代码执行的顺序是从上往下
  2. 分支语句：代码执行不是每一句都会执行 会根据某个条件选择性执行
  3. 循环语句： 重复执行一段代码
• 分支语句
  • if…else语句
    • 单分支
      • 只有一个条件 只考虑条件满足一种情况
    • 双分支
      • 只有一个条件 既考虑满足的情况也考虑不满足的情况
    • 多分支
      • 可以有多个条件 考虑每一个条件满足执行的情况
      • if必须要有
      • else if依据条件可以写多个
      • else可以省略不写
    • 分支是可以嵌套
      • if里面可以嵌套if…else else里面也可以嵌套if…else
      • 但是如果是多个条件 优先使用多分支 不推荐用嵌套
  • switch…case语句

        switch(固定值){
            case 场景值01: 
                语句01;
            case 场景值02: 
                语句02;
            case 场景值03: 
                语句03;
            case 场景值04: 
                语句04;
            default:
                默认语句
        }
    

    • switch语句将固定值和场景值进行一一比较 比较是全等比较
    • 如果某一个场景值匹配上了 会将这个case后面所有的语句都执行，这种效果叫做穿透
    • 如果希望阻止这种穿透效果 可以在每一个case语句最后加上break
  • switch语句和if语句有什么区别
    • 当条件是一个范围的时候 用if语句
    • 当条件是几个固定值 既可以用if也可以用switch
    • switch语句带有穿透效果

实例

（以下代码均为课程实例）
​

（1）数学运算之其他类型

<script>
        // 字符串参与运算
        // 当数学运算符号左右有一侧是字符串的时候 加法不会进行数学运算 会拼接
        // 其他减乘除余都会将符号左右两侧数据自动转换成数值类型再参与运算
        // 自动转数值 Number方法
        var str1 = '10'
        var str2 = '3'
        console.log(str1 + str2) // '103'
        console.log(str1 - str2) // '10'--> 10  - '3' --> 3 = 7
        console.log(str1 * str2)
        console.log(str1 / str2)
        console.log(str1 % str2)
        // 布尔值
        // 布尔值参与运算 会自动转换成数值类型
        console.log(true + 1) // true --> 1 + 1
        console.log(false - 10) // false --> 0 - 10
        // undefined
        console.log(undefined + 10) // NaN + 10
        // null
        console.log(null + 2) // null --> 0 + 2

        // 如果是加法运算，只要符号有一侧是字符串，另一侧也会转换成字符串 然后进行拼接
        console.log('1' + true) // '1' + 'true' = '1true'
        console.log(true + '1') // 'true' + '1' = 'true1'
    </script>

（2）赋值运算

    <script>
        var num = 1
        // 当你写var num  我们就声明或者定义了一个变量
        // 当你写=1 将数值1赋值给num这个变量
        var num2 = 2
        num2 += 10 // 相当于 num2 = num2 + 10 简写方式
        num2 *= 10 // 相当于 num2 = num2 * 10
        console.log(num2)
    </script>

（3）比较运算符

    <script>
        var num1 = 1
        var num2 = 2
        var num3 = 2
        var num4 = '2'
        console.log(num1>num2)
        console.log(num1<num2)
    
        // console.log(num1 = num2) // 相当于将num2值赋值给num1
        console.log(num1 == num2)
        console.log(num1 != num2)
        console.log(num1>=num2) // 要么大于要么等于
        console.log(num1<=num2) // 要么小于 要么等于
        console.log(num2<=num3) // 要么小于 要么等于

        console.log(num1 === num2)
        // == 只关注值相等  === 既关注值也关注类型
        console.log(num2 == num3)
        console.log(num2 === num3)
        console.log(num2 == num4) // 2和'2'值是相等
        console.log(num2 === num4) // 2和'2'值是相等 类型不相同

        console.log(num1 != num2) // num1和num2的值是不相等
        console.log(num2 != num4) // num1和num2的值
        console.log(num2 !== num4) // num1和num2的值 类型不相同
    </script>

（4）逻辑运算符

    <script>
        var num1 = 10
        var num2 = 2
        console.log(num1>=num2)
        console.log(num1>num2 || num1 == num2)
        console.log(num1>num2 && num1 == num2)

        // &&必须符号左右两侧都是true 整个结果才是true
        console.log(true && true)
        console.log(false && true)
        console.log(true && false)
        console.log(false && false)
        // ||只要符号左右有一侧是true 整个结果就是true
        console.log(true || true)
        console.log(false || true)
        console.log(true || false)
        console.log(false || false)

        // !代表取反 如果原来的条件是true加上!变成false 如果原来条件是false加上!变成true
        console.log(!true)
        console.log(!false)
    </script>

（5）逻辑短路问题

    <script>
        console.log(1)
        console.log(2)
        console.log(3)
        true && console.log(4)
        // 左侧条件已经是false 右侧无论是true还是false 整个表达式结果都是false
        false && console.log(5)
        console.log(6)

        false || console.log(7)
        // 左侧为true 右侧无论是true还是false 整个表达式结果都是true
        true || console.log(8)
        console.log(9)
    </script>

（6）一元运算符

    <script>
        var num = 10
        num++ // 相当于 num = num+1
        console.log(num)
        num-- // 相当于 num = num-1
        console.log(num)
        var num = 10
        ++num // 相当于 num = num+1
        console.log(num)
        --num // 相当于 num = num-1
        console.log(num)
    </script>

（7）前置和后置的区别

    <script>
        var num = 10
        // var num2 = num++ // 有一个赋值运算
        var num2 = ++num // 有一个赋值运算
        // 是先将num的值+1之后赋值给num2 --> 前置
        // 是先将num的值赋值给num2之后在+1 --> 后置
        console.log(num)
        console.log(num2)
    </script>

（8）三目运算

    <script>
        false ? console.log('条件成立') : console.log('条件不成立')
        // 简单的判断
        // 要求用户输入一个数字
        var num = prompt('请输入一个数字')
        // 考虑用户输入的数是大于0还是小于还是等于0
        num>0 ? alert('用户输入的数大于0') : alert('用户输入的数不大于0')
        
    </script>

（9）单分支

    <script>
         // 要求用户输入一个数字
         var num = prompt('请输入一个数字')
         if(num>0){
            // 条件成立执行的语句
            alert('用户输入的数大于0')
         }

         console.log('后面的代码')
    </script>

（10）双分支

    <script>
         // 要求用户输入一个数字
         var num = prompt('请输入一个数字')
         if(num>0){
            // 条件成立执行的语句
            alert('用户输入的数大于0')
         }else{
            // 条件不成立执行的语句
            alert('用户输入的数不大于0')
         }

         console.log('后面的代码')
    </script>

（11）多分支

    <script>
         // 要求用户输入一个数字
         var num = prompt('请输入一个数字')
         // 考虑大于0
         // 考虑小于0
         if(num>0){
            alert('用户输入的数字大于0')
         }else if(num<0){
            alert('用户输入的数字小于0')
         }else if(num==0){
            alert('用户输入的数等于0')
         }
         console.log('后面的代码')
    </script>

（12）判断星期

    <script>
      var num = prompt("请输入一个（0-6）数字");
      // 如果用户输入的是0 打印星期日
      // 如果用户输入的是1 打印星期一
      // ...
      if (num == 0) {
        alert("星期日");
      } else if (num == 1) {
        alert("星期一");
      } else if (num == 2) {
        alert("星期二");
      } else if (num == 3) {
        alert("星期三");
      } else if (num == 4) {
        alert("星期四");
      } else if (num == 5) {
        alert("星期五");
      } else {
        alert("星期六");
      }
    </script>

（13）判断用户输入的数据是不是奇数

    <script>
        // 只考虑是奇数情况 用单分支
        var num = prompt('请输入一个数字')
        // 所有的奇数除以2都会余1
        // if(num%2 === 1){
        //     alert('是一个奇数')
        // }
        // 既要考虑是奇数 也要考虑是偶数 用双分支
        if(num%2 === 1){
            alert('是一个奇数')
        }else{
            alert('是一个偶数')
        }
    </script>

（14）分支嵌套

    <script>
        var num = prompt('请输入一个数')
        // 判断用户输入的数是大于0 小于0 等于0
        if(num > 0){
            if(num>10){
                alert('大于10')
            }else{
                alert('0-10')
            }
        }else{
            // 进入else 还存在两种情况 可能小于0 可能等于0
            if(num<0){
                alert('小于0')
            }else{
                alert('等于0')
            }
        }
    </script>

（15）判断成绩01

    <script>
      /* 
            要求用户输入一个成绩(0-100)
            [90-100] 优秀
            [80-90) 良好
            [70-80) 中等
            [60-70) 及格
            [0-60)  埋了
        */
      var score = prompt("请输入一个成绩（0-100）");
      console.log(score); // 'string'
      // 首先排除错误的范围
      if (score < 0 || score > 100) {
        console.error("用户输入的数有问题");
      } else {
        // 用户输入就是合理的范围
        if (score >= 90) {
          alert("优秀");
        } else if (score >= 80) {
          // 自带满足<90
          alert("良好");
        } else if (score >= 70) {
          alert("中等");
        } else if (score >= 60) {
          alert("及格");
        } else {
          alert("埋了");
        }
      }
    </script>

（16）判断成绩02

    <script>
      /* 
            要求用户输入一个成绩(0-100)
            [90-100] 优秀
            [80-90) 良好
            [70-80) 中等
            [60-70) 及格
            [0-60)  埋了
        */
      var score = prompt("请输入一个成绩（0-100）");
      // 首先排除错误的范围
      if (score < 0 || score > 100) {
        console.error("用户输入的数有问题");
      } else {
        switch(score){
          // case后面一般写的是一个值 不是一个条件
          case 0:
        }
      }
    </script>

（17）作业01

    <script>
        var k = -1
        console.log(k++ + ++k + k + --k + k-- + ++k + k) // 1
        // k=-1 -1 + ++k + k + --k + k-- + ++k + k   k=0
        // k=0 -1+1 + k + --k + k-- + ++k + k k=1
        // k=1 -1+1 + 1 + --k + k-- + ++k + k k=1
        // k=1 -1+1 + 1 + 0 + k-- + ++k + k k=0
        // k=0 -1+1 + 1 + 0 + 0 + ++k + k k=-1
        // k=-1 -1+1 + 1 + 0 + 0 + 0 + k k=0
        // k=0 -1+1 + 1 + 0 + 0 + 0 + 0 k=0
    </script>

（18）作业02

    <script>
        // 开发一款软件，根据公式（身高-108）*2=体重，可以有10斤左右的浮动。来观察测试者
        // 180  140 [130, 150]  小于130弹出偏瘦  大于150弹出该减肥
        // 要求用户输入自己的身高 自己的体重
        var height = prompt('请输入您的身高')
        var weight = prompt('请输入您的体重')
        // 根据公式算出标准体重的值
        var bw = (height - 108) * 2
        console.log(bw)
        // 算出标准体重的范围
        console.log(bw-10, bw+10)
        // 进行判断

        // bw-10<=weight<=bw+10   weight>=bw-10 && weight<=bw+10
        if(weight<bw-10){
            // 小于最小的体重值
            alert('您偏瘦了')
        }else if(weight>bw+10){
            // 大于最大的体重值
            alert('您偏胖了')
        }else{
            alert('您的体重是标准的')
        }
    </script>

​