精华内容
下载资源
问答
  • asp循环语句总结

    2021-01-02 22:40:15
    asp的循环语句有以下几类循环语句的作用就是重复执行程序代码,循环可分为三类:一类在条件变为“假”之前重复执行语句,一类在条件变为“真”之前重复执行语句,另一类按照指定的次数重复执行语句。在VBScript ...
  • 如果人告诉你学习 ASP 不需要任何编程知识,那么他错了;如果我告诉你学习 ASP 必须掌握一门编程... 循环语句的作用就是重复执行程序代码,循环可分为:一在条件变为“假”之前重复执行语句,一在条件变
  • 今天让我们走进C语言中的两个基本语句的世界中,C语言呢,一共两大种语句,即分支语句和循环语句,他们的身影几乎遍插整个编程界,是最最基本的...知道了语句,那么现在我们来看看分支语句分为哪几类:分支语句...

    今天让我们走进C语言中的两个基本语句的世界中,C语言呢,一共有两大种语句,即分支语句和循环语句,他们的身影几乎遍插整个编程界,是最最基本的语法知识。所以不可小看他们!接下来先看看分支语句:

    分支语句(选择语句)

    分支语句又称选择语句,那么先看看语句是什么?

    语句:以分号(;)结尾的一条命令行代码,例如:int i = 0 ;

    知道了语句,那么现在我们来看看分支语句分为哪几类:分支语句有两类

    if 语句

    switch语句

    举个 if 语句的例子:

    	if (1 == i)
    	{
    		printf("you will have good offers!\n");
    	}
    	else if (2 == i)
    	{
    		printf("you maybe have no good offers!\n");
    	}
    	else if (3 == i)
    	{
    		printf("good bye!\n");
    	}
    	else
    	{
    		;
    	}

    由上面的例子我们可以总结一下关键点:

    1 一组 { } 的代码叫做:代码块 (上面一共4个代码块)

    2 if ( 表达式 )    计算机会判断表达式是否为真,为真的话(即非0)则执行紧接着它下面的代码块语句,为假的话(即 0)则跳过当前 if 语句,去判断下一条语句。注意啦:我们可以看到上面 if () 语句中,我把数字放在 == 前面,这是个很棒的做法,因为这样就可以防止我们把 == 写成了  ,一旦我们写错了,编译器就立刻会报错,提示我们去调试代码。(有没有很机智~嘿嘿)

    3 分支语句可以嵌套使用

    4 分支语句有单分支语句和多分支语句,上面的例子就是多分支语句。(提一下:单分支语句就是只有一个 if 语句 和 一个else 语句组合使用)。

    5 格外注意:else 语句与离它最近的一个 if 语句匹配。

    6 语句可以为空,即一行语句可以只写一个分号   ' ;'   。

     

    举个switch多分支语句例子:

    #include <stdio.h>
    int main()
    {
        int day = 0;
        switch(day)
       {
            case 1:
                printf("星期一\n");
                break;
            case 2:
                printf("星期二\n");
                break;
            case 3:
                printf("星期三\n");
                break;    
            case 4:
                printf("星期四\n");
                break;    
            case 5:
                printf("星期五\n");
                break;
            case 6:
                printf("星期六\n");
                break;
            case 7:
                printf("星期天\n");    
                break;
            default:  
                break;
       }
        return 0;
    }

    需要注意的几个关键点:

    1 每一条case语句最后都要记住带上 break;  否则程序就会按顺序往下执行,带来意想不到的后果。

    2 在switch语句的最后,必须要带上 default 语句,这是一个好习惯!!!

    3 switch语句还有一种写法,如下:

    我们的需求是:如果输入1-5  则输出"weekday"   ,   如果输入6-7  则输出"weekend" 。

    #include <stdio.h>
    #include <windows.h>
    
    int main
    {
    	int day = 2;
    	switch (day)
    	{
    	case 1:
    	case 2:
    	case 3:
    	case 4:
    	case 5:
    		printf("weekday\n");
    		break;
    	case 6:
    	case 7:
    		printf("weekend\n");
    		break;
    	default:
    		break;
    	}
    
        system("pause");
        return 0;
    }
    
    

     上面这个例子,用if语句相比,提高了效率。一看就应该能感觉得到吧~

     

     

    聊完分支语句,那么现在我们来聊聊循环语句,其实很简单:循环语句有三种(其实有第四种,只是强烈建议慎用!!!待会下面我们会谈到,这里先卖个关子~):

    while () 语句

    for () 语句

    do 

    while () ; (这里有分号,别忘了!!!)

    我们先来看看while()语句:

    #include <stdio.h>
    #include <windows.h>
    
    int main()
    {
    	int i = 0;//初始条件
    	while (i < 10)//判断条件
    	{
    		printf("hello bit!\n");
    		i++;//更新条件
    	}
    	system("pause");
    	return 0;
    }

    上面的例子我们已经知道了while循环语句的用法,下面我们来看看while循环语句中的break  和  continue

    break

    #include <stdio.h>
    #include <windows.h>
    
    int main()
    {
    	int i = 1;
    	while (i <= 10)
    	{
    		if (i == 5)
    			break;
    		printf("%d ", i);
    		i = i + 1;
    	}
    	system("pause");
    	return 0;
    }

    输出结果应该为:1 2 3 4

    其实在循环中只要遇到break,就停止后期的所有的循环,直接终止循环。 所以:while中的break是用于永久终止循环的。

     

    continue

    #include <stdio.h>
    #include <windows.h>
    
    int main()
    {
    	int i = 1;
    	while (i <= 10)
    	{
                    i = i + 1
    		if (i == 5)
    	        continue;
    		printf("%d ", i);
    		//i = i + 1;//放到这里的话就是死循环,因为i没有改变
    	}
    	system("pause");
    	return 0;
    }

    continue是用于终止本次循环的,也就是本次循环中continue后边的代码不会再执行,而是直接跳转到while语句的判断部分。进行下一次循环的入口判断。

     

    现在我们来看看for循环语句:

    for(表达式1;表达式2;表达式3)

    {
             循环语句;

    }

    表达式1 表达式1为初始化部分,用于初始化循环变量的。 表达式2 表达式2为条件判断部分,用于判断循环时候终
    止。 表达式3 表达式3为调整部分,用于循环条件的调整。

    可以发现在while循环中依然存在循环的三个必须条件,但是由于风格的问题使得三个部分很可能偏离较远,这样
    查找修改就不够集中和方便。所以,for循环的风格更胜一筹。 for循环使用的频率也最高。

     

    break在for循环中

    #include <stdio.h>
    #include <windows.h>
    
    int main()
    {
    	int i = 0;
    	for (i = 1; i <= 10; i++)
    	{
    		if (i == 5)
    			break;
    		printf("%d ", i);
    	}
    	system("pause");
    	return 0;
    }

     

    continue在for循环中

    #include <stdio.h>
    #include <windows.h>
    
    int main()
    {
    	int i = 0;
    	for (i = 1; i <= 10; i++)
    	{
    		if (i == 5)
    		    continue;
    		printf("%d ", i);
    	}
    	system("pause");
    	return 0;
    }

     

    一些建议:
    1. 不可在for 循环体内修改循环变量,防止 for 循环失去控制。
    2. 建议for语句的循环控制变量的取值采用“半开半闭区间”写法。

     

    for循环的变种1

    #include <stdio.h>
    #include <windows.h>
    
    int main()
    {
    	//变种1
    	for (;;)
    	{
    	    printf("hehe\n");
    	}
    	system("pause");
    	return 0;
    }

    结果是死循环

     

    for循环的变种2

    #include <stdio.h>
    #include <windows.h>
    
    int main()
    {
    	int x, y;
    	for (x = 0, y = 0; x<2, y<5; ++x, y++)
    	{
    		printf("hehe\n");
    	}
    	system("pause");
    	return 0;
    }

    逗号表达式,从左到有依次运算,但是依照最后一个表达式为准!!!

     

    do语句的特点
    循环至少执行一次,使用的场景有限,所以不是经常使用

    #include <stdio.h>
    #include <windows.h>
    
    int main()
    {
    	int i = 10;
    	do
    	{
    		printf("%d\n", i);
    	} while (i<10);
    	system("pause");
    	return 0;
    }

     

    goto语句

    C语言中提供了可以随意滥用的 goto语句和标记跳转的标号。
    从理论上 goto语句是没有必要的, 实践中没有goto语句也可以很容易的写出代码。
    但是某些场合下goto语句还是用得着的, 最常见的用法就是终止程序在某些深度嵌套的结构的处理过程, 例如一次跳出两层或多层循环。这种情况使用break是达不到目的的。 它只能从最内层循环退出到上一层的循环。

    关机的例子

    int main()
    {
        char input[10] = {0};
        system("shutdown -s -t 60");
        while(1)
       {
            printf("电脑将在1分钟内关机,如果输入:我是猪,就取消关机!\n请输入:>");
            scanf("%s", input);
            if(0 == strcmp(input, "我是猪"))
           {
                system("shutdown -a");
                break;
           }
       }
        return 0;
    }

     

    goto语言真正适合的场景如下:
    for(...)
        for(...)
       {
            for(...)
           {
                if(disaster)
                    goto error;
           }
       }
        …
    error:
     if(disaster)
             // 处理错误情况

    展开全文
  • 常见循环语句

    千次阅读 2019-01-25 16:44:29
    switch switch语句的格式: switch(表达式){ case 常量值1: 语句体1; break; case 常量值2: 语句体2; break;...语句体3;...语句体n+1;...表达式:这个地方的表达式是限定的 byte/short/int/char JDK5的...

    选择结构:

    条件语句可根据不同的的条件执行不同的语句。条件语句包括if条件语句与switch多分支语句。本章节将向读者介绍条件语句的用法。
    if / switch

    if语句格式1:
    if(最终值为布尔类型的东西【表达式】){
    语句体;
    }
    

    执行流程:

    先计算你的表达式的值,看其是false还是true,如果是true,就执行语句体,如果是false就不执行语句体

    if注意事项:

    1.你的if里面的表达式,不管是简单还是复杂,里面的最终结果必须是boolean类型

    2.如果你的if里面只有一条语句,原则上是可以省略大括号,但是不建议这样去做

    if语句格式2:
    if(表达式){
    语句体1;
    }else{
    语句体2;
    }
    

    执行流程:
    1.首先计算表达式的值 看其返回的是false还是true

    2.如果是true执行语句体1

    3.如果是false执行语句体2

    if语句的格式3:
    if(表达式1){
    语句体1;
    }else if(表达式2){
    语句体2;
    }else if(表达式3){
    语句体3;
    }else{
    语句体n+1;
    }
    

    执行流程:
    1.先计算表达式1的值,看其返回的结果是true还是false

    2.如果是true,执行语句体1 并且结束整个语句

    3.如果是false,继续计算表达式2,看其返回的是true还是false(依次类推)

    4.如果上面所有的表达式都不成立,那么就执行else的语句体(else可以不写)

    if的第二种格式和三目运算符执行的过程几乎一致,如何区别使用:

    1、三元运算符能够实现的,if语句的第二种格式都能实现反之,if能够实现的,三目并不一定能够实现

    2、三目运算符必须返回一个明确具体数据值。

    3、三目运算符里面,原则不能写任何的语句,包括变量、常量、循环等等等,而if则可以几乎写java出了类和方法的所有语句

    switch

    switch语句的格式:

    switch(表达式){
    case 常量值1:
    语句体1;
    break;
    case 常量值2:
    语句体2;
    break;
    case 常量值3:
    语句体3;
    break;
    ...
    default:
    语句体n+1;
    }
    

    格式的解释:

    switch:表示是一个switch的分支结构

    表达式:这个地方的表达式是有限定的,byte/short/int/char,JDK5的版本以后支持枚举,JDK7的版本以后支持String

    case:后面的常量值需要给表达式的最终结果进行比较

    语句体:就是需要被执行的代码

    break:表示结束的意思,一旦碰到break 整个switch结束

    default:当上面的所有case的值都不匹配的时候,所执行的代码

    switch需要注意的实现:

    1.case后面跟着的值,必须是常量值 不能是变量,而且同一个switch当中不能出现相同case值

    2.break能否省略?可以省略,但是不建议,因为会造成结果的穿透

    3.default可以省略吗?可以,但是不建议 因为你没有办法给用户一个友好的错误提示

    4.default一定要放在最后面吗?default可以放在switch的任意位置,但是建议一般放在最后面,如果放在任意位置 一定要记得加上break。

    那么在平时的开发当中,我们一般是使用if还是switch?

    if和switch的区别:

    if语句:

    a.针对的只能是一个布尔类型的计算

    b.if语句针对的是一个范围内的判断

    switch:

    a.针对的是一个不可变的常量的计算

    b.针对的是多个范围内的判断

    如果说,你的判断和计算的结果是事先就已经明确和固定的,我们使用switch,如果我们的结果是不明确的,而且代码范围较大 一般使用if语句 switch的代码结构要比if清晰。

    while

    循环语句就是在满足一定条件的情况下反复执行某一个操作。在Java中提供了3中常用的循环语句,分别是while循环语句、do···while循环语句和for循环语句,下面分别进行介绍。

    while循环语句格式:

      while(判断条件语句) {
            循环体语句;
      }
    

    while循环语句扩展格式

     初始化语句;
      while(判断条件语句) {
            循环体语句;
            控制条件语句;
       }
    

    通过这个格式,我们是不是发现几乎跟for循环一致,while循环的区别在哪儿?

    使用区别:
    如果你想在循环结束之后,继续使用控制条件的那个变量,那么就使用while循环,否则使用for循环。虽然说,for循环也可以单独将变量提出来,但是不建议 因为涉及到一个使用率的问题 因为for循环结束后,这个变量会及时从内存当中消失。

    场景的区别:

    如果是一个非常明确的范围的数据,我们使用for循环。如果你的数据范围不明确,那么就使用while循环。

    do_while循环:

    do…while循环语句格式:

    基本格式

    do {
            循环体语句;
      }while((判断条件语句);
    

    扩展格式

    初始化语句;

      do {
            循环体语句;
            控制条件语句;
       } while((判断条件语句);
    

    循环语句的区别:

    do…while循环保证最少会执行一次,而for循环和while必须是先判断条件是否成立,然后再去决定是否执行

    一般我们使用哪种循环比较多?

    优先考虑for循环,其次while循环,最后doWhile循环


    for循环

    for循环的格式:

    for(初始化条件;判断条件语句;控制条件语句){
    循环体语句;
    }
    

    执行流程:

    a.执行初始化条件 int a = 5;

    b.执行判断条件语句,看其返回的结果是true还是false,如果是true,就继续执行循环体 a < 50如果是false,就结束循环

    c.执行循环体语句

    d.执行控制条件语句 a++

    e.继续回到b步骤进行执行

    注意事项:

    1.判断条件语句,不管你写出什么样子,是简单还是复杂 你的结果必须是boolean类型

    2.循环体里面的语句如果只有1条,你可以省略大括号 但是不建议

    循环控制:

    1.break : 结束

    2.continue : 中断

    3.return : 返回

    break常见的使用:

    a.swtich

    b.所有循环语句

    注意:离开上面的场景 无效,同一个作用域当中,break后面不能存在任何的代码

    如何使用?

    大家都知道跳出单层循环,但如何跳出多层循环还是需要点操作:

    1.在外面定义一个开关标记,然后使用标记来判断是否结束

    2.使用标签,语法如下:

    标签名:循环体{
    break 标签名;
    }
    如:Loop:for(int i=0;i<3;i++){
    		for(int j=0;j<6;j++){
    			if(j==4){
    				break Loop;
    			}
    		}
    }
    

    流程控制语句的介绍大概说到这里;使用复合语句可为变量定义一个有效区域;通过if或switch,可以基于布尔值类型的测试,将程序分成不同的部分;通过while、do···while以及for循环语句,将部分程序重复执行,直到满足某个终止循环的条件。通过学习和之后的练习,读者应该学会在程序中灵活使用流程控制及语句。

    展开全文
  • javascript语句——条件语句、循环语句和跳转语句  默认情况下,javascript解释器依照语句的编写顺序依次执行。而javascript中的很多语句可以改变语句的默认执行顺序。本文介绍可以改变语句默认 执行...

    javascript语句——条件语句、循环语句和跳转语句




      默认情况下,javascript解释器依照语句的编写顺序依次执行。而javascript中的很多语句可以改变语句的默认执行顺序。本文介绍可以改变语句默认


    执行顺序的条件语句、循环语句和跳转语句


     


    条件语句
      脚本的威力体现在它们可以根据人们给出的各种条件做出决策,javascript使用条件语句来做判断


      条件语句(conditianal statement)通过判断表达式的值来决定执行还是跳过某些语句,包括if语句和switch语句


    【if语句】


      最常见的条件语句是if语句。if语句的条件必须放在if后面的圆括号内,条件的求值结果永远是一个布尔值,即只能是true或false。花括号中的语句,


    不管它们有多少条,只有在给定条件的求值结果是true的情况下才会执行


    if(expression){
        statements;
    }
      [注意]if语句中,括住expression的圆括号在语法上是必需的


      实际上,if语句中的花括号不是必不可少的。如果if语句中的花括号部分只包含一条语句,可以不使用花括号。但因为花括号可以提高脚本的可读性,


    所以在if语句中总是使用花括号是个好习惯


    复制代码
    //可行,但不推荐
    if(1>2)alert('1');


    //推荐写法
    if(1>2){
        alert('1');
    }
    复制代码
      if语句根据表达式的值改变程序流程。当expression的值为true时执行跟在其后的代码块,当expression的值为false时,执行else的逻辑


    if(expression)
        statement1
    else
        statement2
      当在if/else语句中嵌套使用if语句时,必须注意确保else语句匹配正确的if语句


    //错误暗示
    if( i == j)
        if(j == k)
            console.log('i == k');
    else console.log('i != j');
      javascript中的if/else匹配规则是:else总是和就近的if语句匹配


    复制代码
    //实际解释
    if( i == j){
        if(j == k)
            console.log('i == k');
        else
            console.log('i != j');//错误
    }
    复制代码
    复制代码
    //使用花括号
    if(i == j){
        if(j == k){
            console.log('i == k');
        }
    }else{
        console.log('i != j');
    }
    复制代码
      当代码有多条分支时,需要使用else if语句。else if语句并不是真正的javascript语句,它是多条if/else语句连在一起时的一种惯用写法 


    复制代码
    if(n == 1){
        //代码1
    }else if(n == 2){
        //代码2
    }else if(n == 3){
        //代码3
    }else{
        //其他代码
    }
    复制代码
      可以用if语句的嵌套形式来完成在语法上等价的代码,但没有else if语句清晰


    复制代码
    if(n == 1){
        //代码1
    }else{
        if(n == 2){
            //代码2
        }else{
            if(n == 3){
                //代码3
            }else{
               //其他代码
            }
        }
    }
    复制代码
    【switch语句】


      当所有的分支都依赖于同一个表达式的值时,else if并不是最佳解决方案。在这种情况下,重复计算多条if语句中的条件表达式是非常浪费的做法,而


    switch语句正适合处理这种情况


      switch语句执行一个多路分支,首先计算expression的值,然后查找case子句的表达式是否和expression的值相同。如果找到匹配的case,那么将会


    执行这个case对应的代码块。如果找不到匹配的case,那么将会执行default标签中的代码块。如果没有default标签,switch语句将跳过它的所有代码块


    复制代码
    switch (expression)
      case value1: statement1;
        break;
      case value2: statement2;
        break;
      case value3: statement3;
        break;
      default: statement4;
    复制代码
    复制代码
    if(n == 1){
        //代码1
    }else if(n == 2){
        //代码2
    }else if(n == 3){
        //代码3
    }else{
        //其他代码
    }
    复制代码
    复制代码
    //等价于
    switch(n){
        case 1:
            //代码1
            break;
        case 2:
            //代码2
            break;
        case 3:
            //代码3
            break;
        default:
            //代码4
    }
    复制代码
      每一个case语句块的结尾处都使用了关键字break。break语句可以使解释器跳出switch语句或循环语句


      在switch语句中,case只是指明了要执行的代码起点,但并没有指明终点。如果没有break语句,那么switch语句就会从与expression的值相匹配的


    case标签处的代码块开始执行,依次执行后续的语句,一直到整个switch代码块的结尾


    复制代码
    //如果没有break语句,若switch语句匹配1,则不仅执行代码1,也会执行代码2和代码3
    switch(n){
        case 1:
            //代码1
        case 2:
            //代码2
        default:
            //代码3
    }
    复制代码
      如果确实需要混合几种情形,要在代码中添加注释,说明是有意省略了break关键字


    复制代码
    switch(i){
        //合并两种情形
        case 25:
        case 35:
            console.log('25 or 35');
            break;
        case 45:
            console.log('45');
            break;
        default:
            console.log('other');
    }
    复制代码
      如果在函数中使用switch语句,可以使用return来代替break,return和break都用于终止switch语句,也会防止一个case语句块执行完后继续执行下


    一个case语句块


    复制代码
    //函数中使用switch语句
    function convert(x){
        switch(typeof x){
            case 'number':
                return x.toString(16);
            case 'string':
                return '"' + x + '"';
            default:
                return String(x);
        }
    }
    复制代码
      虽然ECMAScript中的switch语句借鉴自其他语言,但这个语句也有自己的特色。可以在switch语句中使用任何数据类型(在很多其他语言中只能使用


    数值),而且每个case的值不一定是常量,可以是变量或表达式


    复制代码
    var num = 25;
    switch(true){
        case num < 0:
            console.log('less than 0.');
            break;
        case num >=0 && num <=10:
            console.log('between 0 and 10.');
            break;
        case num >10 && num <=20:
            console.log('between 10 and 20.');
            break;
        default:
            console.log('more than 20.');
    }
    复制代码
      使用switch语句时,要注意以下几点:


      【1】由于每次执行switch语句时,并不是所有的case表达式都能执行到,因此,应该避免使用带有副作用的case表达式,比如函数调用表达式和赋


    值表达式,最安全的做法是在case表达式中使用常量表达式


      【2】default标签一般都出现在switch的末尾,位于所有case标签之后,当然这是最合理也是最常用的写法,实际上,default标签可以放置在switch


    语句内的任何地方


      【3】switch语句中,对每个case的匹配操作实际上是'==='恒等运算符比较,而不是'=='相等运算符比较,因此,表达式和case的匹配并不会做任何


    类型转换


    复制代码
    //由于1并不会转换为'1',所以结果是3
    var n = 1;
    switch(n){
        case '1':
            console.log(1);
            break;
        case 2:
            console.log(2);
            break;
        default:
            console.log(3);
    }
    复制代码
     


    循环语句
      条件语句把javascript中的代码变成一条条的分支路径,而循环语句(looping statement)就是程序路径的一个回路,可以让一部分代码重复执行


      javascript有4种循环语句:while、do/while、for、for/in,它们的工作原理几乎一样:只要给定条件仍能得到满足,包含在循环语句里的代码就将


    重复地执行下去。一旦给定条件的求值结果不再是true,循环也就到此为止。其中最常用的循环就是对数组元素的遍历


    【while语句】


      while语句属于前测试循环语句,也就是说,在循环体内的代码被执行之前,就会对出口条件求值


    while(expression){
      statement
    }
      当表达式expression是真值时则循环执行statement,直到expression的值为假值为止;如果是假值,那么程序将跳过循环


      [注意]使用while(true)会创建一个死循环


      大多数循环都会有一个像count这样的计数器变量。尽管循环计数器常用i、j、k这样的变量名,但如果想要让代码可读性更强,就应当使用更具语义


    的变量名


    var count = 0;
    while(count < 10){
        console.log(count);
        count++;
    }
    【do while语句】


      do while语句是后测试循环,即退出条件在执行循环内部的代码之后计算。这意味着在计算表达式之前,至少会执行循环主体一次


    do{
        statement
    }while(expression);
      do/while循环和普通的while循环有两点语法方面不同:


      【1】do/while循环要求必须使用关键字do来标识循环的开始,用while来标识循环的结尾并进入循环条件判断


      【2】do/while循环用分号结尾。如果while循环体使用花括号括起来,则while循环也不用使用分号做结尾


    复制代码
    function printArray(a){
        var len = a.length,i=0;
        if(len == 0){
            console.log('empty');
        }else{
            do{
                console.log(a[i]);
            }while(++i<len);
        }
    }
    复制代码
    【for语句】


      for语句提供了一种比while语句更加方便的循环控制结构,用for循环来重复执行一些代码的好处是循环控制结构更加清晰


      大部分的循环都具有特定的计数器变量,计数器的三个关键操作是初始化、检测和更新。for语句将这三步明确声明为循环语法的一部分,各自使用一


    个表达式来表示


    for(initialize;test;increment){
        statement;    
    }
    复制代码
    //等价于:
    initialize;
    while(test){
        statement
        increment;
    }
    复制代码
      [注意]使用contnue语句时,while循环和for循环并不等价


      initialize、test和increment三个表达式之间用分号分隔,它们分别负责初始化操作、循环条件判断和计数器变量的更新。将它们放在循环的第一行会


    更容易理解for循环正在做什么,而且也可以防止忘记初始化或者递增计数器变量


      initialize表达式只在循环开始之前执行一次;每次循环执行之前会执行test表达式,并判断表达式的结果来决定是否执行循环体,如果test计算结果为


    真值,则执行循环体中的statement,最后,执行increment表达式


      在for循环的变量初始化表达式中,也可以不使用var关键字,该变量的初始化可以在外部执行


    var count = 10;
    var i;
    for(i = 0; i < count; i++){
        console.log(i);
    }
      由于ECMAScript中不存在块级作用域,因此在循环内部定义的变量也可以在外部访问到


    var count = 10;
    for(var i = 0; i < count; i++){
        console.log(i);
    }
    console.log(i);//10
      for循环常见用途是对某个数组里的全体元素进行遍历处理


    var beatles = Array('John','Paul','George','Ringo');
    for(var count = 0; count < beatles.length; count++){
        alert(beatles[count]);
    }
      如果循环中的一次迭代会改变多个变量,则需要用到逗号运算符,它将初始化表达式和自增表达式合并入一个表达式中以用于for循环


    var i,j;
    for(i = 0,j =10; i<10; i++,j--) sum+= i*j;
      代码中的循环变量除了是数字外,也可以是其他类型


      可以使用for循环来遍历链表数据结构,并返回链表中的最后一个对象(也就是第一个不包含next属性的对象)


    function tail(o){
        for(;o.next;o = o.next)/*empty*/;
        return o;
    }
      for循环中那三个表达式中的任何一个都可以忽略,但是两个分号必不可少。如果省略test表达式,那么这将是一个死循环,同样,和while(true)类似


    ,死循环的另外一种写法是


    for(;;)
    【for in语句】


      for/in语句也使用for关键字,但它和常规的for循环是完全不同的一类循环


    for(variable in object){
        statement
    }
      variable通常是一个变量名,也可以是一个可以产生左值的表达式或一个通过var语句声明的变量,总之必须是一个适用于赋值表达式左侧的值。


    object是一个表达式,这个表达式的计算结果是一个对象。同样,statement是一个语句或语句块,它构成了循环的主体


      for/in循环可以用来更方便地遍历对象属性成员


    for(var p in o){
        console.log(o[p]);
    }
      在执行for/in语句的过程中,javascript解释器首先计算object表达式。如果表达式为null或undefined。javascript解释器将会跳过循环并执行后续的


    代码。如果表达式等于一个原始值,这个原始值将会转换为与之对应的包装对象(wrapper object)。否则,expression本身已经是对象了。javascript会依


    次枚举对象的属性来执行循环。然而,在每次循环这前,javascript都会先计算variable表达式的值,并将属性名(一个字符串)赋值给它


      [注意]只要for/in循环中variable的值可以当做赋值表达式的左值,它可以是任意表达式,每次循环都会计算这个表达式,也就是说每次循环它计算的


    值有可能不同


    var o = {x:1,y:2,z:3};
    var a = [],i=0;
    for(a[i++] in o)/*empty*/;
      javascript数组不过是一种特殊的对象,因此,for/in循环可以像枚举对象属性一样枚举数组索引


    for(i in a){
        console.log(i);
    }
      [注意]for/in循环并不会遍历对象的所有属性,只有可枚举(enumerable)的属性才会遍历到


      ECMAScript规范并没有指定for/in循环按照何种顺序来枚举对象属性。但实际上,主流浏览器厂商的javascript实现是按照属性定义的先后顺序来枚


    举简单对象的属性,先定义的属性先枚举。如果使用对象直接量的形式创建对象,则将按照直接量中属性的出现顺序枚举。有一些网站和javascript库是依


    赖于这种枚举顺序的,浏览器厂商不大可能会修改这个顺序


     


    跳转语句
      跳转语句(jump statement)可以让解释器跳转到程序的其他部分继续执行,包括break、continue和return语句


    【label语句】


      介绍跳转语句不得不提到标签(label)语句,通过给语句定义标签,就可以在程序的任何地方通过标签名引用这条语句


      标签语句通常与break语句和continue语句配合使用,跳出特定的循环


    identifier: statement
      [注意]用做标签的identifier必须是一个合法的javascript标识符,而不能是一个保留字


    mainloop: while(token != null){
        //Todo
        continue mainloop;
    }
      标签的命名空间和变量或函数的命名空间是不同的,因此可以使用同一个标识符作为语句标签和作为变量名或函数名


      语句标签只有在它所起作用的语句(当然也可以在它的子句中)内是有定义的。一个语句标签不能和它内部的语句标签重名,但在两个代码段不相互嵌套


    的情况下,是可以出现同名的语句标签的。带有标签的语句还可以带有标签,也就是说,任何语句可以有很多个标签


    【break语句】


      单独使用break语句的作用是立即退出最内层的循环或switch语句


    break;
    for(var i = 0; i < a.length; i++){
        if(a[i] == target) break;
    }
      break语句只有出现在循环语句或switch语句中才合法,出现在其他语句中会报错


    复制代码
    //报错
    if(true){
        break;
    }
    //报错
    function test(){
        var i = 0;
        break;
    }
    test();
    复制代码
      当希望通过break来跳出非就近的循环体或switch语句时,就会用到带标签的break语句


    break labelname;
      当break和标签一块使用时,程序将跳转到这个标签所标识的语句块的结束,或者直接终止这个闭合语句块的执行。当没有任何闭合语句块指定了


    break所用的标签,这时会产生一个语法错误


    复制代码
    top:
      for (var i = 0; i < 3; i++){
        for (var j = 0; j < 3; j++){
          if (i === 1 && j === 1) break top;
          console.log( i, j);
        }
      }
    复制代码
      不管break语句带不带标签,它的控制权都无法越过函数的边界。比如,对于一条带标签的函数定义语句来说,不能从函数内部通过这个标签来跳转


    到函数外部


    【continue语句】


      continue语句和break语句非常类似,但它不是退出循环,而是转而执行下一次循环


    continue;
    continue labelname;
      不管continue语句带不带标签,它只能在循环体内使用。在其他地方使用将会报语法错误


      当执行到continue语句时,当前的循环逻辑就终止了,随即执行下一次循环。但在不同类型的循环中,continue行为也有所不同:


      【1】while循环中,循环开始处指定的exression会重复检测,如果检测结果为true,则循环体会从头开始执行


      【2】do while循环中,程序执行直接跳到循环结尾处,这时会重新判断循环条件,之后才会继续下一次循环


      【3】for循环中,首先计算自增表达式,然后再次检测test表达式,用以判断是否执行循环体


      【4】在for/in循环中,循环开始遍历下一个属性名,这个属性名赋给了指定的变量


      [注意]continue语句在while和for循环中的区别:while循环直接进入下一轮的循环条件判断,但for循环首先计算其increment表达式,然后判断循环


    条件


    复制代码
    //1 3
    for(i = 0; i < 5; i++){
        if(i % 2 === 0)continue;
        console.log(i);
    }


    //1 3 5
    var i = 0;
    while(i<5){
        i++;    
        if(i % 2 === 0)continue;
        console.log(i);
    }
    复制代码
      由于continue在这两种循环中的行为表现不同,因此使用while循环不可能完美地模拟等价的for循环


      和break语句类似,带标签的continue语句可以用在嵌套的循环中,用以跳出多层次嵌套的循环体逻辑


    复制代码
    top:
      for (var i = 0; i < 3; i++){
        for (var j = 0; j < 3; j++){
          if (i === 1 && j === 1) continue top;
          console.log('i=' + i + ', j=' + j);
        }
      }
    复制代码
    【return语句】


      函数调用是一种表达式,而所有表达式都有值。函数中的return语句就是指定函数调用后的返回值


    return expression;
      return语句只能出现在函数体内,如果不是会报语法错误。当执行到return语句时,函数终止执行,并返回expression的值给调用程序


    function square(x)
    {    
        return x*x
    };
    square(2);
      如果没有return语句,则函数调用仅仅依次执行函数体内的每一条语句直到函数结束,最后返回调用程序。这种情况下,调用表达式的结果是


    undefined。return语句经常作为函数内的最后一条语句出现,但并不是说一定要放在函数最后,即使在执行return语句的时候还有很多后续代码没有执


    行到,这时函数也还会返回调用程序


      return语句可以单独使用而不必带有expression,这样的话也会向调用程序返回undefined


    function display_object(o){
        if(!o) return;
    }
      在javascript词法结构中,已经提到过分号的用法。所有的跳转语句包括break、continue、return等语句,都不可以在关键字和表达式之间换行,因


    为javascript会在换行处填补分号


    //以及return语句举例,break、continue语句也类似
    return
    true;
      javascript将其解析为:


    return;true;
      而代码的本意是:


    return true;
     


    参考资料


    【1】 ES5/语句 https://www.w3.org/html/ig/zh/wiki/ES5/statements
    【2】 阮一峰Javascript标准参考教程——语法概述 http://javascript.ruanyifeng.com/grammar/basic.html#toc12
    【3】 W3School-Javascript高级教程——语句 http://www.w3school.com.cn/js/pro_js_statements_if.asp
    【4】《javascript权威指南(第6版)》第5章 语句
    【5】《javascript高级程序设计(第3版)》第3章 基本概念 
    【6】《javascript DOM编程艺术(第2版)》第2章 Javascript语法
    【7】《javascript语言精粹》 第2章 语法
     
    此文章收集自一位博主:http://www.cnblogs.com/xiaohuochai/p/5673241.html#anchor1

    转载请注明出处;








    展开全文
  • Kotlin入门(7)循环语句的操作

    千次阅读 2017-07-17 09:40:58
    上一篇文章介绍了简单分支与多路分支的实现,控制语句除了这两种条件分支之外,还有对循环处理的控制,那么本文接下来继续阐述Kotlin如何对循环语句进行操作。Koltin处理循环语句依旧采纳了for和while关键字,只是在...
    上一篇文章介绍了简单分支与多路分支的实现,控制语句除了这两种条件分支之外,还有对循环处理的控制,那么本文接下来继续阐述Kotlin如何对循环语句进行操作。
    

    Koltin处理循环语句依旧采纳了for和while关键字,只是在具体用法上有所微调。首先来看for循环,Java遍历某个队列,可以通过“for (item : list)”形式的语句进行循环操作。同样Kotlin也能使用类似形式的循环,区别在于把冒号“:”换成了关键字“in”,具体语句形如“for (item in list)”。下面是Kotlin对数组进行循环处理的代码例子:
        val poemArray:Array<String> = arrayOf("朝辞白帝彩云间", "千里江陵一日还", "两岸猿声啼不住", "轻舟已过万重山")
        btn_repeat_item.setOnClickListener {
            var poem:String=""
            for (item in poemArray) {
                poem = "$poem$item,\n"
            }
            tv_poem_content.text = poem
        }
    上述代码的目的是将一个诗句数组用逗号与换行符拼接起来,以便在界面上展示完整的诗歌内容。拼接后的诗歌显示界面如下图所示:

    注意到截图中每行诗句都以逗号结尾,这有个句点问题,因为每首绝句的第一、三行末尾才是逗号,第二、四行的末尾应该是句号;所以这个循环代码得加以改进,补充对数组下标的判断,如果当前是奇数行,则末尾加逗号;如果当前是偶数行,则末尾加句号。倘若使用Java编码,要是涉及到下标的循环,基本采取“for (初始的赋值语句; 满足循环的条件判断; 每次循环之后的增减语句)”这般形式,具体实现可参考以下的示例代码:
        for (int i=0; i<array.length; i++) {
            ...
        }
    出人意料的是,Kotlin废除了“for (初始; 条件; 增减)”这个规则;若想实现上述功能,取而代之的,则为“for (i in array.indices)”语句,其中indices表示该数组对象的下标数组,每次循环都从下标数组依次取出当前元素的下标。根据该规则判断下标的数值,再分别在句尾添加逗号与句号,改造后的Kotlin代码如下所示:
        btn_repeat_subscript.setOnClickListener {
            var poem:String=""
            for (i in poemArray.indices) {
                if (i%2 == 0) {
                    poem = "$poem${poemArray[i]},\n"
                } else {
                    poem = "$poem${poemArray[i]}。\n"
                }
            }
            tv_poem_content.text = poem
        }
    正确补充标点的诗歌显示界面如下图所示:


    然而取消“for (初始; 条件; 增减)”这个规则是有代价的,因为实际开发中往往存在非同一般的需求,比如以下几种情况,Kotlin的“for (i in array.indices)”语句就无法很好地处理:
    1、如何设定条件判断的起始值和终止值?
    2、每次循环之后的递增值不是1的时候要怎么办?
    3、循环方向不是递增而是递减,又如何是好?
    4、与条件判断有关的变量不止一个,咋整?
    5、循环过程中的变量,在循环结束后还能不能使用?
    针对以上情况,其实Kotlin也给出了几个解决办法,代价是多了几个诸如until、step、downTo这样的关键字,具体用法见下列代码:
        // 左闭右开区间,合法值包括11,但不包括66
        for (i in 11 until 66) { ... }
        // 每次默认递增1,这里改为每次递增4
        for (i in 23..89 step 4) { ... }
        // for循环默认递增,这里使用downTo表示递减
        for (i in 50 downTo 7) { ... } 
    可是这些解决办法并不完美,因为业务需求是千变万化的,并非限定在几种固定模式。同时,以上规则容易使人混淆,一旦没搞清楚until和downTo的开闭区间,在判断边界值时会产生问题。所以更灵活的解决方案是,起止数值、条件判断、循环方向与递增值都应当在代码中明确指定,“for (初始; 条件; 增减)”这个规则固然废除了,但开发者依旧能够使用while语句实现相关功能,Kotlin的while循环与Java的处理是一致的,下面是使用while进行循环判断的代码例子:
        btn_repeat_begin.setOnClickListener {
            var poem:String=""
            var i:Int = 0
            while (i < poemArray.size) {
                if (i%2 ==0) {
                    poem = "$poem${poemArray[i]},\n"
                } else {
                    poem = "$poem${poemArray[i]}。\n"
                }
                i++
            }
            poem = "${poem}该诗歌一共有${i}句。"
            tv_poem_content.text = poem
        }
    既然while语句保留了下来,do/while语句继续保留,写法也没什么变化,采用do/while写法的代码如下所示:
        btn_repeat_end.setOnClickListener {
            var poem:String=""
            var i:Int = 0
            do {
                if (i%2 ==0) {
                    poem = "$poem${poemArray[i]},\n"
                } else {
                    poem = "$poem${poemArray[i]}。\n"
                }
                i++
            } while (i < poemArray.size)
            poem = "${poem}该诗歌一共有${i}句。"
            tv_poem_content.text = poem
        }

    前面的循环处理其实都还中规中矩,只有内忧没有外患,但要是数组里的诗句本身就不完善,比如有空指针、有空串、有空格串、有多余串等等,此时就得进行诗句的合法性判断,如此方可输出正常的诗歌文字。合法性判断主要由两块代码组成:
    1、如果发现有空指针、有空串、有空格串,则忽略此行,即使用关键字continue继续下个循环;
    2、如果合法诗句达到四句,则不管是否遍历完成,直接拼好绝句并结束循环,即使用关键字break跳出循环;
    加入了合法性判断的代码见下,主要演示了continue和break:
        val poem2Array:Array<String?> = arrayOf("朝辞白帝彩云间", null, "千里江陵一日还", "", "两岸猿声啼不住", "   ", "轻舟已过万重山", "送孟浩然之广陵")
        btn_repeat_continue.setOnClickListener {
            var poem:String=""
            var pos:Int=-1
            var count:Int=0
            while (pos <= poem2Array.size) {
                pos++
                if (poem2Array[pos].isNullOrBlank())
                    continue
                if (count%2 ==0) {
                    poem = "$poem${poem2Array[pos]},\n"
                } else {
                    poem = "$poem${poem2Array[pos]}。\n"
                }
                count++
                if (count == 4)
                    break
            }
            tv_poem_content.text = poem
        }
    看来合法性判断用到的continue和break,Kotlin并没有做什么改进呀?这是真的吗?如果是真的,那真是图样图森破。以往我们操作多层循环的时候,有时在内层循环发现某种状况,就得跳出包括外层循环在内的整个循环。例如遍历诗歌数组,一旦在某个诗句中找到“一”字,便迅速告知外界“我中奖啦”之类的欢呼。可是这里有两层循环,如果使用Java编码,只能先跳出内层循环,然后外层循环通过判断标志位再决定是否跳出,而不能从内层循环直接跳出外层循环。现在Kotlin大笔一挥,干嘛这么麻烦,咱想跳到哪里就跳到哪里,只消给外层循环加个@标记,接着遇到情况便直接跳出到这个标记,犹如孙悟空蹦上筋斗云,想去哪就去哪,多方便。这个创意真好,省事省力省心,赶紧看看下面代码是怎么实现的:
        btn_repeat_break.setOnClickListener {
            var i:Int = 0
            var is_found = false
            outside@ while (i < poemArray.size) {
                var j:Int = 0
                var item = poemArray[i];
                while ( j < item.length) {
                    if (item[j] == '一') {
                        is_found = true
                        break@outside
                    }
                    j++
                }
    //            //如果内层循环直接跳出两层循环,那么下面的判断语句就不需要了
    //            if (is_found)
    //                break
                i++
            }
            tv_poem_content.text = if (is_found) "我找到'一'字啦" else "没有找到'一'字呀"
        }

    总结一下,对于循环语句的操作,Kotlin仍然保留了for和while两种循环,主要区别在于:Kotlin取消了“for (初始; 条件; 增减)”这个规则,不过新增了对跳出多重循环的支持(通过“break@标记位”实现)。


    点此查看Kotlin入门教程的完整目录


    __________________________________________________________________________
    本文现已同步发布到微信公众号“老欧说安卓”,打开微信扫一扫下面的二维码,或者直接搜索公众号“老欧说安卓”添加关注,更快更方便地阅读技术干货。
    展开全文
  • 代码当中有几个注意点: 判断的时候用双等号表示判断是否一致(三个等号表示赋值) 你有没有注意到这里不是用的大括号而是用的冒号! python3对父级和子级的写法是极为严格的,就像这里的if跟else,都是父级,...
  • if语句和循环语句

    千次阅读 2015-10-02 10:28:36
    if语句: 格式一: if(条件表达式){执行语句;} 当满足条件表达式的时候,执行if语句块中的内容。如果不满足,则不执行。 格式二: if(条件表达式){执行语句;} else{执行语句;} if。。。。。else ...
  • C# 循环语句foreach用法

    千次阅读 2015-04-22 17:26:57
    foreach循环用于列举出集合中所有的元素,foreach语句中的表达式由关键字in隔开的两个项组成。in右边的项是集合名,in左边的项是变量名,用来存放该集合中的每个元素。 该循环的运行过程如下:每一次循环时,从集合...
  • 03 switch&循环语句

    千次阅读 多人点赞 2021-04-12 18:19:07
    1. switch语句 ...其次,和case依次比较,一旦对应的值,就会执行相应的语句,在执行的过程中,遇到break就会结 束。 最后,如果所有的case都和表达式的值不匹配,就会执行default语句体部分,然后程序结
  • 流程控制 判断语句和循环语句

    千次阅读 2018-06-16 12:07:31
    什么是流程控制呢?流程就是做一件事情的顺序,或者说是次序。在程序设计中,流程就是要完成一个功能,而流程控制则是指如何在程序设计...实现这些控制结构的语句分为5:表达式语句、复合语句、分支语句循环语...
  • 表达式3) 第一步 如果条件不满足 因此do-while至少要执行一次循环体 第二步 则一次循环语句也不执行 若值为真(非0)则执行循环体一次 计算表达式1的值 第三步 计算表达式2的值 for:for(初始值;范围;自增或自减){...
  • C语言中的三种循环语句及其使用方法

    千次阅读 多人点赞 2016-05-03 14:26:25
    C语言是C系列编程语言学习的基础,所以很多高校都开设了C语言课程。作为一编程怨言,C语言的学习可谓...汇盈天下:C语言循环语句用法三种主要形式: for()循环 while()循环 do {} while();循环 for()循环用法: f
  • switch语句及三种循环语句

    千次阅读 多人点赞 2019-07-31 18:21:21
    switch语句 语句格式 switch(表达式){ case 1: 语句1; break; case 2: 语句2; break; .... default: 语句体n+1; break; } 执行流程 首先计算出表达式的值 其次,和case依次比较,...
  • 流程控制语句之循环语句 什么是循环结构: 循环语句可以在满足循环条件的情况下,反复执行某一段代码,这段被重复执行的代码被称为循环体语句,当反复执行这个循环体时,需要在合适的时候把循环判断条件修改为false...
  • Python while循环语句详解

    千次阅读 2019-08-14 18:42:38
    Python 中,while 循环和 if 条件分支语句类似,即在条件(表达式)为真的情况下,会执行相应的代码块。不同之处在于,只要条件为真,while 就会一直重复执行那段代码块。 while 语句的语法格式如下: while 条件...
  • C++ for循环语句讲解

    千次阅读 2014-05-26 09:47:33
    如果我们把粉丝的标牌换成了语句cout 赛车里最有名的是Formular 1(一级方程式赛车...for语句称为循环语句,大括号内的语句块称为循环体,而这种赛车的结构在C++中称为循环结构。根据上面的语法格式,我们来描述一
  • 选择语句+循环语句作业及答案

    千次阅读 2019-04-24 10:15:41
    1.Java中两种类型的选择结构的控制语句,分别是if语句和________。 2.在Java JDK1.7之前,switch只能支持byte、short、char、int或者其对应的封装以及Enum类型。在JDK1.7中又加入了________类型。 3.for循环的...
  • 【Python】python条件及循环语句

    千次阅读 2015-05-18 16:34:24
    2、循环语句 3、迭代器 4、列表解析 5、生成器表达式 1、条件语句 最简单的条件语句: if expression:  expr_true_suite 如上,if是关键字,expression是条件表达式,条件表达式支持多重条件判断,可以用布尔操作...
  • 一、Java语句的执行结构 ...3.循环语句 重复执行某句代码 for语句、while语句、do-while语句 二、分支语句 1.什么是分支? 判断所给定的条件是否满足,根据不同的结果执行对应的不同的语
  • 字符串和分支以及循环的不解之谜
  • 详解Python中的循环语句的用法

    千次阅读 2017-10-14 07:25:11
     Python的条件和循环语句,决定了程序的控制流程,体现结构的多样性。须重要理解,if、while、for以及与它们相搭配的 else、 elif、break、continue和pass语句。 二、详解 1、if语句  Python中的if子句由三...
  • js常见的4种循环语句

    2021-02-23 11:24:23
    while循环 输出结果全是布尔值(‘true’ 、‘false’) var num = 1;//1、声明循环变量 while (num<=10){//2、判断循环条件; document.write(num+"<br />");//3、执行循环体操作; num++;//4、更新...
  • [Python]第二章(条件语句和循环语句)—(建议收藏)

    多人点赞 热门讨论 2021-09-15 18:50:05
    各位小伙伴们大家好,在此之前我跟大家介绍过[python]的第一章,如果还没有看的小...那么在这里我跟大家先分别说下什么是判断语句以及循环语句 条件语句: 条件语句是用来判断给定的条件是否满足(表达式值是.
  • 6.ASP脚本循环语句

    千次阅读 2005-02-16 06:03:00
    在本文上两篇中,我们学习了脚本语言 VBScript 的变量、函数、过程和条件语句,本篇将继续给大家介绍 VBScipt 的循环语句,并对脚本语言在 ASP 中的应用加以总结。 如果人告诉你学习 ASP 不需要任何编程知识,那么...
  • 文章目录流程控制一、接收用户输入二、执行结构概述三、if分支四、switch五、循环_while六、do while循环七、for循环八、循环嵌套图形打印九、break与continue十、如何退出多重循环十一、图形打印详解十二、判断用户...
  • 文章目录★ 语法格式分为:1、语法格式 1 的介绍:1.1、语法格式 1 的工作原理:1.2、语法格式 1 的取值列表:①、字符串:②、范围集合:③、文件名:④、命令执行结果:⑤、位置变量 及 系统变量:2、语法格式...
  • 顺序、选择和循环语句(程序的三种基本控制结构) 复合语句 1、在了解程序的三种基本控制结构之前,我们先了解以下什么是复合语句,即块语句。 2、与C语言及其他语言不同,Java语言的复合语句是以整个块区为单位的...
  • 分支结构2:switch语句       /* switch(变量){ case 值1:   case 值2:   case 值3:   default:   } 1.根据变量的值,选择相应的case去判断,一旦满足case条件,就执行case的相应...
  • 上图(循环语句if)  1.它是通过在index.js中设置数据,然后再index.wxml中进行判断,首先上index.wxml的代码。 //微信是封装过if语句的,你只要在index.js中设置好值,然后就可以直接想这样拿来判断了,还有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 236,322
精华内容 94,528
关键字:

循环语句分为哪几类