什么是双重循环？

双重循环：我们从字面上理解它，就是有两个循环套在一起

详细解释

双重for循环就是在一个for循环里在嵌套另一个for循环，即两个循环嵌套，还有多重循环嵌套的情况，但用的比较少，一般常用的是两个循环嵌套，很少使用多重循环，因为for循环多了会导致代码执行的效率低，而且容易死机,多循环中的总循环次数是相乘的，嵌套几次后几何级数增长，因此通常情况下在循环多次嵌套时，我们是不推荐使用的。

说的再简单点就是，for循环的嵌套，跟我们之前的if嵌套一样

 for(循环变量;循环条件;循环操作){
       for(循环变量;循环条件;循环操作){
           //代码块
       }
}

这就是双重for循环的框架

运行路径

外层循环一次，内层全部循环一次（外层循环一次，内层for循环全部执行完成再进行外层的一次循环）

难点

二重循环的难点是内层循环的循环条件，如何控制内层循环的次数
记住外层循环一次，内层循环全部的原则
举个例子，我外层循环定义循环3次，内层循环定义循环2次，每次输出一个“星号”，那么，将会输出几个“星号”呢？
答案是6次（2×3）
分析:

• 外层循环第一次，里面循环完，也就是2次
• 外层循环第二次，里面又重新循环，循环完，还是2次
• 外层循环第三次，里面再次重新循环，又是2次

我们多说无益，来个实际操作

示例

打印以下图形，我们可以用上面提到的公式验证一下

图形

*
* *
* * *
* * * *
* * * * * 

这个题目的代码，我先给出，然后分析

代码

public class Star{
       public static void main(String[] args){
          for(int i=1;i<=5;i++){
                for(int j=1;j<=i;j++){
                    System.out.print("*");
                }
                System.out.println();
           }
       }
}

我们看看这个图像有多少行？ 总共有5行，也就是说我们需要循环5次打印才可以

外部循环

for(int i=1;i<=5;i++){
   //循环块2
}

这个循环控制输出的行数，我们这里是5行“星号”，所以这个循环控制成5次

我们开始写里面的循环

内部循环

里面定义一个循环，变量为 j

 for(int j=1;j<=i;j++){
   System.out.print("*");
 }

j 的初始值定义为1，并且j<=i （i也是累加，到5停止），它的循环次数也是循环5次，因为我们这个图像的最后一个输出是5颗“星号”，这里是循环输出了5颗“星号”，所以，j超出5必须停止循环

总体运行过程

到这，许多人会感到有点迷茫，不过没有关系，这是正常，我们好好看看它如何运行：

首先注意看变量：i=1、j=1、i<=5、j

循环运行变化

外层第一次循环： i为1时，开始第一次循环，开始运行里面的第 i（1）次循环，这时，里面的循环，j为1时，j<=i （此时i为1），所以会输出1颗“星号”

拆解代码：第一次外层循环
内层：

for(int j=1;j<=1;j++){
  System.out.print("*");
}
System.out.println();

外层第三次、第四次、第五次与第二次一样，i不断累加，依次输出3颗“星号”、4颗“星号”、5颗“星号”

就不多演示了，还不懂的话，就看看拆解代码的内层循环的循环条件的变化

注意：System.out.print（"*"）: 是没有ln的，所以不会换行，于是内层循环的“星号”是横排叠加的

示例二

打印九九乘法表：
因为这个题目，和上面的代码以及原理一样，只是改变了一些内容，所以我就直接放代码了

代码

public class Jjcfb {
    public static void main(String[] args) {
                for(int i=1;i<=9;i++){
                    for(int j=1;j<=i;j++){
                        System.out.print(j+"*"+i+"="+i*j+" ");
                    }
                    System.out.println();
                }
    }
}

 九九乘法表一共有九行，所以外层限制行数为9，于是i=1;i<=9
内层还是j=1;j<=i
如果还不懂，可以用IDEA调试，慢慢摸索，这样记忆力更加深刻

 扩展

给大家放一个问题：这样用“*”输出一个菱形？

点击链接查看答案：双重for循环（嵌套for循环） - 小简博客 (janyork.com)https://blog.janyork.com/index.php/archives/429/

for in 和for of的区别
1 遍历数组通常用for循环
ES5的话也可以使用forEach，ES5具有遍历数组功能的还有map、filter、some、every、reduce、reduceRight等，只不过他们的返回结果不一样。但是使用foreach遍历数组的话，使用break不能中断循环，使用return也不能返回到外层函数。

Array.prototype.method=function(){
　　console.log(this.length);
}
var myArray=[1,2,4,5,6,7]
myArray.name="数组"
for (var index in myArray) {
  console.log(myArray[index]);
}

2 for in遍历数组的毛病
1.index索引为字符串型数字，不能直接进行几何运算
2.遍历顺序有可能不是按照实际数组的内部顺序
3.使用for in会遍历数组所有的可枚举属性，包括原型。例如上栗的原型方法method和name属性
所以for in更适合遍历对象，不要使用for in遍历数组。

那么除了使用for循环，如何更简单的正确的遍历数组达到我们的期望呢（即不遍历method和name），ES6中的for of更胜一筹.

复制代码

Array.prototype.method=function(){
　　console.log(this.length);
}
var myArray=[1,2,4,5,6,7]
myArray.name="数组";
for (var value of myArray) {
  console.log(value);

}
复制代码
记住，for in遍历的是数组的索引（即键名），而for of遍历的是数组元素值。

for of遍历的只是数组内的元素，而不包括数组的原型属性method和索引name

3 遍历对象
遍历对象 通常用for in来遍历对象的键名

Object.prototype.method=function(){
　　console.log(this);
}
var myObject={
　　a:1,
　　b:2,
　　c:3
}
for (var key in myObject) {
  console.log(key);
}

for in 可以遍历到myObject的原型方法method,如果不想遍历原型方法和属性的话，可以在循环内部判断一下,hasOwnPropery方法可以判断某属性是否是该对象的实例属性

for (var key in myObject) {
　　if（myObject.hasOwnProperty(key)){
　　　　console.log(key);
　　}
}

同样可以通过ES5的Object.keys(myObject)获取对象的实例属性组成的数组，不包括原型方法和属性

Object.prototype.method=function(){
　　console.log(this);
}
var myObject={
　　a:1,
　　b:2,
　　c:3
}

总结
for…of适用遍历数/数组对象/字符串/map/set等拥有迭代器对象的集合.但是不能遍历对象,因为没有迭代器对象.与forEach()不同的是，它可以正确响应break、continue和return语句

for-of循环不支持普通对象，但如果你想迭代一个对象的属性，你可以用for-in循环（这也是它的本职工作）或内建的Object.keys()方法：
for (var key of Object.keys(someObject)) {
  console.log(key + ": " + someObject[key]);
}
遍历map对象时适合用解构,例如;
for (var [key, value] of phoneBookMap) {
   console.log(key + "'s phone number is: " + value);
}

当你为对象添加myObject.toString()方法后，就可以将对象转化为字符串，同样地，当你向任意对象添加myObjectSymbol.iterator方法，就可以遍历这个对象了。
举个例子，假设你正在使用jQuery，尽管你非常钟情于里面的.each()方法，但你还是想让jQuery对象也支持for-of循环，你可以这样做：

jQuery.prototype[Symbol.iterator] = Array.prototype[Symbol.iterator];

所有拥有Symbol.iterator的对象被称为可迭代的。在接下来的文章中你会发现，可迭代对象的概念几乎贯穿于整门语言之中，不仅是for-of循环，还有Map和Set构造函数、解构赋值，以及新的展开操作符。

for…of的步骤
for-of循环首先调用集合的Symbol.iterator方法，紧接着返回一个新的迭代器对象。迭代器对象可以是任意具有.next()方法的对象；for-of循环将重复调用这个方法，每次循环调用一次。举个例子，这段代码是我能想出来的最简单的迭代器：
复制代码

var zeroesForeverIterator = {
 [Symbol.iterator]: function () {
   return this;
  },
  next: function () {
  return {done: false, value: 0};
 }
};

复制代码

JS数组遍历：
1.普通for循环

var arr = [1,2,0,3,9];
 for ( var i = 0; i <arr.length; i++){
    console.log(arr[i]);
}

2.优化版for循环

使用变量，将长度缓存起来，避免重复获取长度，数组很大时优化效果明显

for(var j = 0,len = arr.length; j < len; j++){
    console.log(arr[j]);
}

3.forEach

ES5推出的,数组自带的循环，主要功能是遍历数组，实际性能比for还弱

arr.forEach(function(value,i){
　　console.log('forEach遍历:'+i+'--'+value);

})

forEach这种方法也有一个小缺陷：你不能使用break语句中断循环，也不能使用return语句返回到外层函数。

4.map遍历

map即是 “映射”的意思 用法与 forEach 相似,同样不能使用break语句中断循环，也不能使用return语句返回到外层函数。

arr.map(function(value,index){
    console.log('map遍历:'+index+'--'+value);
});
map遍历支持使用return语句，支持return返回值

var temp=arr.map(function(val,index){
  console.log(val);  
  return val*val           
})
console.log(temp);  

forEach、map都是ECMA5新增数组的方法，所以ie9以下的浏览器还不支持

5.for-of遍历

ES6新增功能

for( let i of arr){
    console.log(i);
}

for-of这个方法避开了for-in循环的所有缺陷
与forEach()不同的是，它可以正确响应break、continue和return语句
for-of循环不仅支持数组，还支持大多数类数组对象，例如DOM NodeList对象。for-of循环也支持字符串遍历

JS对象遍历：
1.for-in遍历

for-in是为遍历对象而设计的，不适用于遍历数组。(遍历数组的缺点：数组的下标index值是数字，for-in遍历的index值"0",“1”,"2"等是字符串)

for-in循环存在缺陷：循环会遍历对象自身的和继承的可枚举属性(不含Symbol属性)

for (var index in arr){
    console.log(arr[index]);
    console.log(index);
}

2.使用Object.keys()遍历

返回一个数组,包括对象自身的(不含继承的)所有可枚举属性(不含Symbol属性).

var obj = {'0':'a','1':'b','2':'c'};

Object.keys(obj).forEach(function(key){

     console.log(key,obj[key]);

});

3.使用Object.getOwnPropertyNames(obj)遍历

返回一个数组,包含对象自身的所有属性(不含Symbol属性,但是包括不可枚举属性).

var obj = {'0':'a','1':'b','2':'c'};
Object.getOwnPropertyNames(obj).forEach(function(key){

    console.log(key,obj[key]);

});

4.使用Reflect.ownKeys(obj)遍历

返回一个数组,包含对象自身的所有属性,不管属性名是Symbol或字符串,也不管是否可枚举.

var obj = {'0':'a','1':'b','2':'c'};
Reflect.ownKeys(obj).forEach(function(key){

　　console.log(key,obj[key]);

});

1.求1到100的累加和,所有偶数和,奇数和 ,能被3整除的数字和
2.打印5行5个星星
3.打印乘法表
4. 水仙花数

for循环

for ( 初始化变量;条件表达式;操作表达式){
		//循环体
}
	1.初始化变量：就是用var 声明的一个普通变量，在循环（代码块）开始之前执行。通常用于计数器的使用。可以不写。
	2.条件表达式 就是用来决定每一次循环是否继续执行，就是终止的条件
	3.操作表达式：会在循环（代码块）每次被执行后执行。是每次循环最后执行的代码  经常用于我们计数器变量进行更新（递增或者递减）
    
 for(var i = 0; i<=5; i++ ){
     console.log('你揍啥');
 }   
   	1.在循环开始前设置了一个变量 (var i = 0；)
    2.定义运行循环的条件  (i必须小于5)
    3.会在diam块每次执行之后对值进行递增 (i++)

       1.//求1到100的累加和
            var sum = 0;  //求和的变量
            for (var i = 0; i<=100;i++){
                sum = sum+i;
            }
              console.log(sum);

       2.//条件循环
        for(var i = 1;i<=50;i++){
            if (i == 1) {
                console.log('今年1岁了');
            }else if (i < 50){
                console.log('今年'+i+'岁了');
            }else{
                console.log('你的生命要结束了');
            }    
        }

       3.//求1~100之间所有偶数和奇数的和 我们需要一个偶数的和变量
                var even = 0;
                var odd = 0;
                for(var i = 1;i<=100;i++){
                    if( i%2 == 0){
                        even = even + i;
                    }else{
                        odd = odd +i;
                    }
                }
                console.log('偶数和：'+even);
                console.log('奇数和：'+odd);
            
        4.//1-100之间所有能被3整除的数字和
             var result = 0;
              for(var i=0;i<=10;i++){
                  if(i%3==0){
                    //   result = result+i;
                      console.log(i);
                  }
              }
              console.log(result);
		5.//输入班级总人数 ，输入每个学生的成绩 ，计算成绩和平均成绩
            var num = prompt('班级人数');
            var sum = 0;       //求和的变量
            var average = 0;  //求平均值的变量
            for(var i=1;i<=num;i++){
                var score = prompt('输入第'+i+'学生成绩')
                console.log(score);
                sum += ++score;
                //sum = score + paresFloat(score);
                average = sum/num;
            }
                console.log('总成绩'+sum);
                console.log('平均成绩'+average);

双重for循环

1.打印5行5个星星
2.打印乘法表
3. 水仙花数

嵌套循环 外循环循环1次，内循环所有次数
外循环：行
for (外层的初始化变量; 外层的条件表达式; 外层的操作表达式) {
             for (里层的初始化变量; 里层的条件表达式是; 里层的操作表达式) {
                // 执行语句;
             }
       }

## **1.打印5行5个星星**

            var str = '';
            for(var i = 1;i<=5;i++ ){
                //for(var j =i;j<=5;j++)  //里层个数不一样 j = i 
                for(var j=1;j<=5;j++){
                    str = str + '☆';
                }
                str = str + '\n';
            }
            console.log(str);


## **2.打印乘法表**

            //每一行公式的个数正好和行数一样，j<=i
            var str = '';
            for(var i=1;i<=9;i++){
                for(var j = 1;j<=i;j++){
                    str +=j +'*'+ i +'='+i*j+'\t'; 
                }
               str += '\n';
            }
            console.log(str);

		var str = 0;
        for(var i=1;i<=9;i++){
            for(var j=1; j<=i;j++){
                str = j+'*'+i+'='+i*j ;
                document.write('<td>'+str+'</td>');
            }
            document.write('<table>');
        }

    方法二：
        document.write('<table border="1" cellspacing="0">');
        for(var i = 1; i<=9; i++){
            document.write('<tr>')
            for(var j=1; j<=i;j++){
                document.write('<td>');
                document.write(i +'*'+ j  + '=' +i*j);
                document.write('</td>');
            }
            document.write('</tr>');
        }
        document.write('</table>');

	方法三：
            document.write('<table border="1" cellspacing="0">');
            for(var i = 1; i <= 9; i++){
                document.write('<tr>')
                for(var j = 1; j <= i; j++){
                    document.write('<td>'+i + '*' + j +'='+i*j+'</td>')
                }
                document.write('</tr>');
            }
            document.write('</table>');


## 3. //水仙花数

        var a = 0; b = 0; c = 0;
        for( var i = 100;i<1000;i++ ){
            //个位
            a = i%10;
            //十位
            b = parseInt( ((i/10) % 10 ));
            //百位
            c = parseInt( i/100);
            if(i == a * a * a + b * b *b + c * c * c){
                console.log('水仙花数:' + i +'<br>');
            }
        }

## 5.等腰三角形

		//行数
        for(var i =0;i<10;i++){
            //空白
            for(var j=0;j<10-i;j++){
                document.write('&ensp;');
            }
            //2*i+1 表示奇数个
            for(var k = 0;k<2*i+1;k++){
                document.write('☆');
            }
            document.write('<br>');
        }

7.1.3for循环小结

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cG0WgvCZ-1597561090022)(G:\笔记\笔记图片\image-20200813164311056.png)]

7.2 while循环

先执行表达式
小括号中的是循环次数，初始值写在大括号之外，增量写在循环体中
while  当...时候
while(条件表达式){
	//循环体
}
执行思路：当表达式结果为true则执行循环体否则退出循环；
代码验证：
var num = 1;
while(num<=100){
    console.log('12');
    num++;
}
//里面应该也有操作表达式，完成计数器的更新 防止死循环

7.4 do…while

先执行一次

do{
	//循环体
}while(表达式) 

执行思路：跟while不同的地方是do while 先执行一次循环体 在判断条件 如果是为真，则继续执行循环体，否则退出循环。
var i = 1;
do{
	console.log('how are you')；
    i++;
}while(i<100)
    
    
 1.//打印一个人的一生
        vari= 1
        do{
            console.log('这个人今年'+'岁了')
        }while(i<=100)
        console.log(i);
2.//计算1~100的和
		var sum =0;
		var i = 1;
do{
    sum = sum+i;
    i++;
}while(i<=100)
    console.log(sum);


3.//输入指定字符结束提示
do{
	var message = prompt('你爱我吗？');s
}while('我爱你');
alert('我也爱你啊');

7.4 continue 和 break

1.continue关键字用于立即跳出当次循环，继续下一次循环(continue之后的代码会少运行一次)（跳出最近的的循环的当次循环）

for(var i=0; i <= 5;i++){
    if(i == 3){
        continue; 				//遇到continue就退出本次循环，直接跳到i++
    }
    console.log("我正在吃第" +i+'个包子')；  // 不执行第三次循环
}


	//除了能被7整除之外的整数和
		var sum = 0;
        for(i=1; i<=100;i++){
            if(i%7==0){
                continue;
            }else{
                sum = sum+i;
            }
        }
         console.log(sum);



2.break：立即跳出整个循环 

for(vari=0; i<=5; i++){
    if(i==3){
        break;
    }
    console.log(i)；  //1 2 3 
}
//执行前五次
			var num = 0;
            for(var i = 1; i <=100; i++){
                if(i%3==0){
                    num++;
                    console.log(i);
                }
                if(num==5){
                    break;
                }
            }

7.5 死循环

死循环是一个无限次数循环，在程序开发中是要避免的，因为无限循环会损耗计算机内存
for:
第一种：
var i= 0；
for(;i<10;){
	consolo.log(i);
	i++;
}
第二种：
for(; true;){
	
}
第三种：
for(;;)


while:
while(true);