JS循环语句

什么是循环语句？

• 根据给出的某一些条件 重复执行某一段代码
• 循环必须要有某些固定的内容组成
  • 初始化
  • 条件判断
  • 要执行的代码
  • 自身改变

1. while循环语句

语法： while (条件) { 满足条件就会执行 }

        // 1. 初始化
        var num = 1
        // 2. 条件判断
        while (num < 5) {
            // 3. 要执行的代码 (这里的代码数量不限制)
            console.log(num)

            // 4. 自身的改变
            num++
        }

        console.log(num)    // 5

        // 案例1：利用循环计算1~100所有数字相加的和
        /*逻辑： 利用循环拿到 1~100 的所有数字
                想办法保存 1~100 数字相加的和
        */ 
        var num = 1
        var s = 0
        while (num <= 100) {
            s += num
            num++
        }
        console.log(s)
        
        
        // 利用循环计算1~100所有偶数相加的和
        var num = 1
        var s = 0
        while (num <= 100) {
            if(num % 2 === 0){
                s += num
            }            
            num++
        }
        console.log(s)

        // 案例2.打印出 1000~5000,内的所有闰年，否则不打印
        var num = 1000
        while (num <= 5000) {
            if (num % 4 === 0 && num % 100 !== 0 || num % 400 === 0) {
                console.log(num + '年是闰年')
            }
            num++
        }

2. do...while 循环语句

• 是一个和 while 循环类似的循环
• 语法: do { 要执行的代码 } while (条件)
• do...while和while区别:
  1. while: 会先判断条件, 如果条件成立那么在开始执行循环;
  2. do...while: 不管条件是否成立, 先执行一次循环的代码, 然后判断条件是否成立, 决定是否开启下一轮循环。

       /** 案例:
              1.打开页面的时候 弹出一个输入框，让用户输入密码，密码必须为'123456'
                   如果输入正确，那么控制台打印'登录成功'
                   如果输入错误重新弹出一个输入框，让用户重新输入，直到输入正确为止  
        */

        do {
            var pw = prompt()
            if (pw === '123456') {
                console.log('登录成功')
            }
        } while (pw !== '123456')

3. for 循环语句

语法: for (var i = 0; i < 10; i++) { 要执行的代码 }

        //1.求 1~100 所有数字相乘
        var sum = 1
        for(var num = 1;num <= 100;num++){
            sum *= num
        }
        console.log(sum)  

        //2.求 2000~3000 内的所有闰年,每打印4次闰年, 换行一次
        var i = 0 //作为计数器
        for(var year = 2000;year <= 3000;year++){
            if(year % 4 === 0 && year % 100 !== 0 || year % 400 === 0){
                document.write(year + ' ')
                i++    // 上述代码执行1次, 那么计数器 + 1
                if (sum === 4) {
                    document.write('<br>')
                    sum = 0 // 清零计数器, 方便开始新一轮的计算
                }             
            }           
        }

        //3.找出三位数所有的水仙花数
        for (var num = 100; num <= 999; num++) {
            var b = parseInt(num / 100)
            var s = parseInt(num / 10) % 10
            var g = num % 10
            // if (b * b * b + s * s * s + g * g * g === num) {
            if (b ** 3 + s ** 3 + g ** 3 === num) {
            //    **  会得到符号左边数字的 x 次幂   4**5表示4的5次幂
                console.log(num)
            }
        }

        //求两个数的最大公约数
        // num1 和 num2 是用户输入的两个数字
        var num1 = 12
        var num2 = 8

        // num3 存储 num1 和 num2 中 最小的数字
        var num3 = num1 > num2 ? num2 : num1

        // num4 用于存储最大的公约数
        var num4 = 0

        // 1. 先找到 1~12 或者 1~8 的所有数字, 为了性能更好, 我们这里选择的是 1~8 的所有数字
        for (let i = num3; i >= 1; i--) {

            // 2. 寻找 12 和 8 的公约数
            if (num1 % i === 0 && num2 % i === 0) {
                // console.log(i)   // i 是 num1 和 num2 的公约数
                // num4 = i         // 这种书写方式存储的是最后一个 公约数, 不是最大公约数

                // 3. 找到所有的公约数中 最大的
                if (num4 < i) {
                    num4 = i
                }
            }
        }

        console.log('最大公约数: ', num4)

4. 循环嵌套的书写

• 循环嵌套其实就是一个循环内部又写了一个循环
• 两个循环的循环变量不能相同, 会有冲突

for (var i = 0; i < 3; i++) {   // 这个循环称为 外层循环
    for (var k = 1; k < 4; k++) {   // 这个循环称为 内层循环
        /**
         * 重点!!!
         *          两个循环的循环变量不能相同, 会有冲突
        */
    }
}

        // 求 1~30 以内的所有质数

        // 当前循环只是拿到了 1~30 的所有数字, 没有任何特殊含义, 但是这样写 会将 数字 1 也算作 质数
        for (var n = 1; n < 31; n++) {  
            var sum = 0 // 用于完成计数器, 当 for 循环内部的 if 语句 执行的时候, 会改变 sum 的值

            // 1. 找到 2~n-1 的所有数字
            for (var i = 2; i < n; i++) {
                // 2. 找有没有能够和 n 完成 整除的 数字
                if (n % i === 0) {
                    sum++
                }
            }
            // 只要 当前 sum === 0 就证明 上述的 循环内的分支没有执行过
            if (sum === 0) {
                console.log(n, '是一个质数')
            }
        }