004day 嵌套循环的练习及函数的引用

最新推荐文章于 2022-08-31 22:57:31 发布

码小白的求学之路

最新推荐文章于 2022-08-31 22:57:31 发布

阅读量472

点赞数 1

文章标签： javascript

本文链接：https://blog.csdn.net/Yanxiaona111/article/details/107647067

版权

一、do-while循环
do-while循环
语法：
do{
//循环体
}while(循环条件);
while(循环条件){循环体}
执行过程：
1：先执行一次循环体。然后再进行条件的判断。
2：如果条件成立，继续执行循环体，周而复始。
3：直到循环条件为false，结束整个循环。
do-while的事情的情形：
如果循环条件的判断要依赖于一次循环的执行可以使用do-while
总结：while和do-while的区别
1：语法不同
2：while先进行条件的判断，然后在执行循环体。
3：do-while先执行循环体，然后再进行循环条件的判断。
4：【while有可能一次循环体都不执行。do-while至少执行一次循环】

<script>
    //1-100的累加和
    var sum = 0;
    var num = 1;
    do{
        sum += num;
        num ++;
    }while(num < 101);
    console.log ("sum = " + sum);

    //1-100的偶数的累加和
    var sum = 0;
    var num = 2;
    do{
        sum += num;
        num +=2;
    }while(num < 101);
    console.log ("sum = " + sum);

    //
    const MIN = 1;
    const MAX = 101;
    //先得到一个随机数
    /*var ran = ~~(Math.random () * (MAX - MIN) + MIN);
    while (!(ran % 5 === 0 && ran % 7 === 0)) {//ran是5和7的公倍数的条件
        ran = ~~(Math.random () * (MAX - MIN) + MIN);
    }
    console.log ("ran = " + ran);*/
    do{
        var ran = ~~(Math.random () * (MAX - MIN) + MIN);
    }while(!(ran % 5 === 0 && ran % 7 === 0));
    console.log ("ran = " + ran);

</script>

二、for循环
语法：
for(循环条件初始化; 循环条件 ; 迭代){ 循环体 }
执行过程：
1：循环条件初始化：执行且仅执行一次。最先被执行。
2：进行循环条件的判断。成立，执行循环体，然后执行迭代部分。
然后再进行条件的判断，循环体，迭代，周而复始。直到循环条件为false
立即结束循环。

    注意：
        1：初始化部分可以同时初始化多个变量，迭代部分，可以同时迭代多个变量。循环条件只要返回一个布尔值即可。
        2：for循环的小括号内使用2个分号分隔成了3部分。这三部分的内容都可以没有，但是2个分号是必不可少的。
        3: 如果循环条件不写，意味着循环条件永远为真。

<script>
    //1--100的累加和
    var sum = 0;
     for (var i = 1; i <= 100; i++) {
         sum += i;
     }
     console.log ("sum = " + sum);
    //1--100偶数累加和
     var sum = 0;
     for (var i = 2; i <= 100; i += 2) {
         sum += i;
     }
     console.log ("sum = " + sum);

    //三部分比较特殊的情况
    for (var i = 0, j = 0, k = 0; i < 100 && j < 100 && k < 100; i++, j += 2, k += 3) {
    }

    var sum = 0;
    var num = 1;
    for(;num < 100;){
        sum += num;
        num ++;
    }

    //男程序员给女程序员的表白
    for (var i = 0; i < 10000; i++) {
        console.log ("I Love U");
    }
    for (;;){
        console.log ("I Love U Too");
    }
    
</script>

三、循环的选择
1：如果循环的次数是固定的，通常使用for
2：如果循环的次数不固定，通常使用while

四、break
break：中断的意思。
语法： break;
1：js 的关键字
2：break 只能在 switch 中和循环体中使用。
3：在swtich中，用来结束switch语句的。
4：在循环体中使用，用来结束当前循环的。只能结束一层。

<script>
    //使用while 和 for 实现1--100的累加和使用 break 实现
    var sum = 0;
    var num = 1;
    while (true) {
        sum += num;
        //当num为100 就可以结束循环了
        if (num === 100) break;
        num++;
    }
    console.log ("sum = " + sum);



    var sum = 0;
    for (var i = 1; ; i++) {
        sum += i;
        if (i === 100) break;
    }
    console.log ("sum = " + sum);

</script>

五、continue
continue:继续的意思
1: js的一个关键字。
2：只能在循环体中使用。
3：作用：用来跳过本次循环，继续下次循环。
4：while、do-while的循环体中使用continue。continue后续循环体中的代码将被跳过，去到下次循环条件的判断处去执行。
5：for 循环体中使用，会跳过continue 后续的代码，跳到迭代处去执行。

<script>
    //1--100的奇数的累加和
    var sum = 0;
    var num = 0;
    while (num < 100) {
        num++;
        //当num是偶数的时候执行continue。就直接跳转到了循环条件判断处去执行了。
        if (num % 2 === 0)
            continue;
        //偶数的时候，下面的代码被跳过。
        sum += num;
    }
    console.log (sum);
</script>

六、关于分支选择的嵌套问题
单分支if
双分支 if-else
多分支等等
有嵌套的需求：
那么嵌套的深度不要太深，不建议超过3层。
循环的嵌套：循环体中包含了其他的循环。
嵌套循环的特点：
1：外层循环迭代一次，内层循环执行一遍。
2：内层循环体执行的次数等于，每一层循环执行的次数的乘积。
关于使用率：
单层循环使用最多。双层的使用一般般。三层很少使用。

<script>
    for (var i = 0; i <3 ; i++) {//外层循环
        for (var j = 0; j <3 ; j++) {//内层循环
            console.log (`i=${i}\tj=${j}`);
        }
    }

    console.log ("-----------------");
    for (var i = 0; i <3 ; i++) {//外层循环
        for (var j = 0; j <3 ; j++) {//内层循环
            for (var k = 0; k <3 ; k++) {
                console.log (`i=${i}\tj=${j}\tk=${k}`);
            }
        }
    }

</script>

七、素数练习
1–100以内的素数
素数：又称为质数，只能被1和自身整除的数。1不是质数。
2,3,5,7,11,13,17,19

<script>
    //遍历1-100以内的所有的数
    for (var i = 2; i <= 100; i++) {
        //对每一个i进行是否是素数的判断。
        var flag = false;
        for (var j = 2; j < i; j++) {
            //在整个内层循环中，如果所有的j的取值都不能整除i，那么i就是素数
            if (i % j === 0) {
                flag = true;
                //i不是素数
                break;
            }
        }
        //如果内层循环执行完毕之后，flag 还是false。意味着if (i % j === 0)条件在整个内层循环中都没有成立。i是素数。
        //不建议的写法
        // if(flag === false){
        //     console.log (i);
        // }
        // if(flag = false){
        //     console.log (i);
        // }
        //好理解的，也不回有误操作的写法
        // if(false === flag){
        //     console.log (i);
        // }
        //最简便的写法
        if(!flag){
            console.log (i);
        }
    }
</script>

八、嵌套循环练习
1：随机得到两个整数，一个代表宽，一个代表高度。在页面输出
该宽高的 * 组成的矩形。使用单层循环实现。
要求 document.write("");
2: 嵌套循环实现上述的内容
3：打印指定宽高的平行四边形
******** 2 0 height-i-1
******** 1 1
******** 0 2
4: 打印等腰三角形
* 2 0 height-i-1 1 i2+1
*** 1 1 3
***** 0 2 5

<script>
    var width = ~~(Math.random () * 10 + 5);
     var height = ~~(Math.random () * 5 + 2);
     console.log (`width = ${width}\theight = ${height}`);

     var loopCount = width * height;
     for (var i = 1; i <= loopCount; i++) {
         document.write (" * ");
         //i是width的倍数的时候，换行
         if (i % width === 0) {
             document.write ("<br>");
         }
     }



    var width = ~~(Math.random () * 10 + 5);
    var height = ~~(Math.random () * 5 + 2);
    console.log (`width = ${width}\theight = ${height}`);
    //外层循环控制行数
    for (var i = 0; i <height ; i++) {
        //内层循环控制每一行的*的打印
        for (var j = 0; j <width ; j++) {
            document.write(" * ");
        }
        //末尾添加换行符
        document.write ("<br>");
    }

     //平行四边形
     var width = ~~(Math.random () * 10 + 5);
     var height = ~~(Math.random () * 5 + 2);
     console.log (`width = ${width}\theight = ${height}`);
     //外层循环控制行数
     for (var i = 0; i <height ; i++) {
         //每一行的前面添加若干个空格。
         for (var j = 0; j <height-i-1 ; j++) {
             document.write ("<span style='opacity: 0'>*</span>");
         }
         //内层循环控制每一行的*的打印
         for (var j = 0; j <width ; j++) {
             document.write("*");
         }
         //末尾添加换行符
         document.write ("<br>");
     }

    //等腰三角形
    var width = ~~(Math.random () * 20 + 15);
    var height = ~~(Math.random () * 20 + 2);
    console.log (`width = ${width}\theight = ${height}`);
    //外层循环控制行数
    for (var i = 0; i < height; i++) {
        //每一行的前面添加若干个空格。
        for (var j = 0; j < height - i - 1; j++) {
            document.write ("<span style='opacity: 0'>*</span>");
        }
        //内层循环控制每一行的*的打印
        for (var j = 0; j < 2 * i + 1; j++) {
            document.write ("*");
        }
        //末尾添加换行符
        document.write ("<br>");
    }
</script>

九、函数的引入
需求：使用嵌套循环，打印指定宽高的 * 号矩形。
代码中出现了严重的冗余现象，
去冗余的过程：
1：将重复的代码，放到一个独立的空间内。给该代码起一个名字。
然后再需要使用的地方，通过名字来访问该代码。

函数好处：
    1：方便代码的复用。
    2：方便代码的维护

<script>
    //单独的存放代码的空间。
    function printStarRect(width,height) {
        for (var i = 0; i <width ; i++) {
            //内层循环控制每一行的*的打印
            for (var j = 0; j <height ; j++) {
                document.write("&nbsp;* ");
            }
            //末尾添加换行符
            document.write ("<br>");
        }
        document.write ("<br>");
    }

    printStarRect(5,7);

    printStarRect(6,6);

    printStarRect(7,4);

</script>

十、函数的定义
函数的定义的语法：
function 函数名(参数列表){ 函数体 }
解释：
1：函数，也称为方法。
2：function：js 的关键字。用来定义函数的。
3：函数名：是一种标识符，命名规范和变量的规范一致，首字符小写，多个单词构成，从第二个单词的首字符大写。一定要可以通过函数名体现出要实现的功能。
4：(参数列表)：小括号必不可少，可以为空。可以称为形参列表，简称参数、或者是形参。
参数代表了，函数体功能中变化的量，有几个变化的量，就要写几个参数，使用逗号分隔。
语法：（参数1，参数2，参数3…）
上面的参数1，参数2，这些参数的命名都要符合变量的命名，本质上就是变量。
5: { 函数体 }：大括号中是函数的主体实现部分。
函数的使用：
通过函数名(实参列表); 调用函数。

<script>
    //自定义方式，实现打印任意两个数的和。
    function logSum(num1,num2) {
        var sum = num1 + num2;
        console.log (`${num1}+${num2}=${sum}`);
    }

    logSum(1,2);
</script>

十一、函数的分类
函数的分类：
1：定义的源
a: js的内置函数 isNaN
b：自定义函数开发者自定义函数
2：是否有参数
a：有参函数
b：无参函数
3：是否有返回值
a：有返回值函数 Math.random();
b: 无返回值，返回值为undefined。

十二、函数的参数说明
函数的参数说明：
定义函数的参数部分：形参列表。
形参列表：
1：参数的存在可以更好的扩展函数的功能。
2：形参代表了函数这个功能体需要的外部提供的数据列表。
3: 形参的个数没有限制，个数取决于希望外部提供几个数据。就需要
定义几个参数来接收外部提供的数据。
4：形参的名字和变量的命名方式一样，希望接收外部什么样的数据就起什么样的名字。
5：参数之间使用逗号分开。最后一个参数后不需要添加逗号。
调用函数的时候使用的参数：实参列表。
实参列表：
1：实际参与函数内部运算的数据的列表。
2：通常情况下，实参的个数和形参的个数应该是一致的。其他语言中必须一致。
3：在js中实参的个数可以和形参的个数不一致。不建议。
4：实参的个数多于形参的个数，实参多出来的部分直接被忽略。没有形参接收这些数据。
5：实参个数少于形参的个数，那么多余的形参的值为undefined。

<script>
    //自定义方式，实现打印任意两个数的和。
    function logSum(num1,num2) {//num1,num2是形参列表。
        console.log (num1);
        console.log (num2);
        var sum = num1 + num2;
        console.log (`${num1}+${num2}=${sum}`);
    }

    logSum(1,2);//传参的过程
    logSum(1);
</script>