JavaScript程序控制流程语句之循环

一时失言乱红尘 2022-10-16 12:24 226阅读 0赞

### 循环语句 ###

*  一、循环
 *  二、语句
 *   *   1、while 循环 语句
     *   2、break 跳出循环
     *   3、do - while 循环 语句
     *   4、for 循环 语句
     *   5、break 和 continue
     *   6、nest 嵌套

# 一、循环 #

1、含义：重复执行相同或相似的代码。

2、要素：循环条件和循环体

(1)循环条件：控制循环是否往后执行，控制循环次数；

(2)循环体：要执行的相同或相似的代码。

# 二、语句 #

##  1、while 循环 语句 ##

(1) 含义：一旦循环条件为true，就执行循环体；

(2) 特点：先判断再执行；

(3) 语法：

while(循环条件)\{  
循环体  
\}

(4) 示例：打印30~21之间所有整数

var i=50;
        while(i>=21){
         //循环条件
          //循环体
          console.log(i);
          //增量
          i--;
        }

(5) 练习 1：循环打印50 55 60 65 70

var i=50;
        while(i<=70){
          //循环条件
          //循环体
          console.log(i);
          //增量
          i+=5;
        }

练习 2：结合if语句，循环打印出1~100之间所有的奇数

var i=1;
        while(i<=100){
          //循环条件
          //循环体
          if(i%2===1){
        
            console.log(i);
          }
          //增量
          i++;
        }

练习 3：使用循环计算1~100之间所有整数的和

var i=1;
        var sum=0;
        while(i<=100){
          //循环条件
          //循环体
          sum+=i;
          //增量
          i+=1;
        }
        //循环结束，打印最终结果
        console.log(sum);

练习 4：打印1~100之间所有奇数和

var i=1;
        var sum=0;
        while(i<=100){
          //循环条件
          //循环体
          if(i%2===1){
        
            sum=sum+i;
          }
          //增量
          i++;
        }
        //循环结束，打印最终结果
        console.log(sum);

##  2、break 跳出循环 ##

(1) 含义：强制结束循环或者跳出循环，不再执行循环；

(2) 特点：在循环体中使用，不确定次数时可交由循环体来结束；

(3) 语法：

while(循环条件)\{  
循环体 - break  
\}

(4) 示例：循环打印1~50，一旦打印出50后结束循环

var i=1;
        while(true){
          //循环条件为true，死循环
          //循环体
          console.log(i);
          //循环体中使用break，跳出循环
          if(i===50){
          //i=50，强制结束循环
            break;  
          }
          //增量
          i++;
        }

(5) 练习 1：使用死循环方式，计算1~10之间所有整数的乘积

var i=1;
        var area=1;
        while(true){
          //死循环
          //循环体
          area=area*i;
          //跳出循环
          if(i===10){
        
            break;
          }
          //增量
          i++;
        }
        //循环结束，打印最终结果
        console.log(area);

练习 2：使用死循环，计算11~20之间所有整数的乘积，当值为20跳出循环

var i=11;
        var area=1;
        while(true){
        
          //循环体
          area=area+i;
          //跳出循环
          if(i === 20){
        
            break;
          }
          //增量
          i++;
        }
        //循环结束，打印最终结果
        console.log(area);

##  3、do - while 循环 语句 ##

(1) 含义：第一遍无论对错先执行；

(2) 特点：先执行再判断；

(3) 语法：

do \{  
循环体  
\} while (循环条件);

(4) 示例：使用 do - while 打印1~10之间所有整数

var i=1;
        do{
        
          //循环体
          console.log(i);
          //增量
          i++;
        } while(i<=10);  //循环条件
        //注：do-while第一次先执行，若定义var =100，结果直接打印100

(5) 练习1：使用循环打印50~30之间所有的整数

var i=50;
        do{
        
          //循环体
          console.log(i);
          //增量
          i--;
        } while(i>=30);  //循环条件

练习 2：使用循环打印1~100之间所有的偶数，结合if判断

var i=1;
        do{
        
          //循环体
          if(i%2 === 0){
        
            console.log(i);
          }
          //增量
          i++;
        } while(i<=100);  //循环条件

练习 3：计算1~100之间所有偶数的和

var i=1;
        var sum=0;
        do{
        
          //循环体
          if(i%2 === 0){
        
            sum+=i;
          }
          //增量
          i++;
        } while(i<=100);
        //循环结束后，打印最终结果
        console.log(sum);

练习 4：假设一张纸厚度为0.0001米，折叠多少次可以达到珠穆朗玛峰的高度8848米，厚度没有达到8848米就会一直折叠，记录其次数。

var height=0.0001;  //厚度
        var count=0;        //记录折叠次数
        do{
        
          //循环体
          height*=2;  //折叠椅次，厚度加倍
          //增量
          count++;    //折叠一次，记录一次
        } while(height<=8848);
        //循环结束后，查看总次数
        console.log(count);

##  4、for 循环 语句 ##

(1) 含义：计算循环；

(2) 特点：通过次数控制，实际应用最多，较方便

(3) 语法：

for(初始值；循环条件；增量) \{  
循环体  
\}

(4) 示例：循环打印1~10之间所有整数

for(var i=1;i<=10;i++){
        
          //循环体
          console.log(i);
        }

(5) 练习1：打印1~100之间所有能被3整除的数字

for(var i=1;i<=100;i++){
        
          //循环体
          if(i%3 === 0){
        
            console.log(i);
          }
        }

练习 2：计算1~100之间所有能被7整除的数字的和

for(var i=1,sum=0;i<=100;i++){
        
          //循环体
          if(i%7 === 0){
        
            sum+=i;
          }
        }
        console.log(sum);

练习 3：打印2000~2100年之间所有的闰年

for(var year=2000;year<=2100;year++){
        
          if(year%4===0 && year%100!==0 || year%400===0){
        
            console.log(year);
          }
        }

练习 4：假设本金10000元，银行利率4%，存5年侯本金利息共多少

for(var i=1,money=10000;i<=5;i++){
        
          money=money+money*0.04;
        }
        console.log(money);

练习 5：循环打印12345成一行展示

for(var i=1,str='';i<=5;i++){
        
          //循环体
          str+=i;  ///在空字符串基础上拼接，即''+1+2+3+4+5
        }
        console.log(str);

##  5、break 和 continue ##

(1) 区分：

① break：跳出循环，不再执行任何循环中的代码；

② continue：跳过某一次，剩余的，循环体还会继续下一次循环。

(2) 示例：打印1~10，不包含5

for(var i=1;i<=10;i++){
        
          //循环体
          if(i ===5 ){
        
            continue;
          }
          cosnsole.log(i);
        }

(3) 练习：打印1~100之间所有整数，遇到能被3或能被4整除的就跳过

for(var i=1;i<=4;i++){
        
          //循环体
          if(i%3===0 || i%4===0){
        
            continue;
          }
          console.log(i);
        }

##  6、nest 嵌套 ##

(1) 含义：一个循环的循环体中，又出现了其他循环；

(2) 特点：任意两个循环之间都可以相互嵌套。

(3) 练习1：打印五行五列的矩形

//外层循环：控制循环的行数
        for(var i=1;i<=5;i++){
        
          //内层循环：控制每一行循环的列数
          for(var j=1,str='';j<=5;j++){
         // ***** 一行五列
             str+='*';
          }
          console.log(str);
        }

练习 2：打印2000~2100年之间的前10个闰年

for(var i=2000,count=0;i<=2100;i++){
        
          if(i%4===0  && i%100!==0 || i%400===0){
        
            //循环体
            console.log(i);
            //增量
            count++;
            //每加一个闰年就判断当前闰年个数是否为10
            if(count===10){
        
              break;
            }
          }
        }
        //循环结束后查看闰年个数
        console.log(count);

练习 3：打印1~100之间所有的素数

for(var i=2;i<=100;i++){
        
          //i代表所有整数2~100
          //内层循环：产生1~i之间所有的整数，不包含1和i
          for(var j=2,count=0;j<i;j++){
          //count记录中间产生的能被整除的数字
            //判断任意一个整数i是否能被中间数j整除，若能不是素数，否则为素数
            if(i%j===0){
        
              count++;
            }
            //循环结束后，count记录下来了是否能被整除的数字
            //count=0，说明中间没有能被整除的数字，是素数
            if(count===0){
        
              console.log(i);
            }
          }
        }

练习 4：打印五行且每一列依次递增的\*。

//外层循环：控制循环的行数
        for(var i=1;i<=5;i++){
        
          //内层循环：控制每一行循环的列数
          //循环条件由每一行的i决定
          for(var j=1,str='';j<=i;j++){
        
            //每循环一次，拼接一个
            str+='*';
          }
          //每行拼接结束后，打印出这一行
          console.log(str);
        }

练习 5：打印九九乘法表

//外层循环：控制循环的行数,i为行号
        for(var i=1;i<=9;i++){
        
          //内层循环：控制每一行循环的列数,j为列号
          for(var j=1,str='';j<=i;j++){
        
            str+=j+'*'+i+'='+(i*j)+' ';  //空格，显得不那么紧凑
            //若第3行或第4行且为第二列再拼接一个空格：整齐
            if((i===3  || i===4)  && j===2){
        
              str+=' ';
            }
          }
          //每行拼接结束后，打印出这一行
          console.log(str);
        }