在本文中，我们将为您详细介绍js基础之流程控制语句的相关知识，并且为您解答关于js的流程控制语句的疑问，此外，我们还会提供一些关于05.流程控制语句、1、引用类型变量的创建及使用2、流程控制语句之选择
在本文中，我们将为您详细介绍js基础之 流程控制语句的相关知识，并且为您解答关于js的流程控制语句的疑问，此外，我们还会提供一些关于05.流程控制语句、1、引用类型变量的创建及使用 2、流程控制语句之选择语句 3、流程控制语句之循环语句 4、循环高级、C#基础之流程控制语句详解、go 语言基础之流程控制 if 语句的有用信息。
本文目录一览：- js基础之 流程控制语句（js的流程控制语句）
- 05.流程控制语句
- 1、引用类型变量的创建及使用 2、流程控制语句之选择语句 3、流程控制语句之循环语句 4、循环高级
- C#基础之流程控制语句详解
- go 语言基础之流程控制 if 语句
js基础之 流程控制语句（js的流程控制语句）
一、条件判断语句
1.if语句
语法：if(条件表达式){执行语句}
说明：只有为真时才会执行这些if语句
/*var box=50;
if (box>10) alert(''box大于10'');
if (box>20) {
alert(''box大于20'');
alert(''我也会被执行'');
}
if (box>30)
alert(''box大于30'');
alert(''我会被执行，因为我与上面的if语句无关。'')*/
var box=50;
if (box<10) alert(''box大于10'');
if (box<20) {
alert(''box大于20'');
alert(''我也会被执行'');
}
if (box<30)
alert(''box大于30'');
alert(''上面的都没有执行，只有我被执行了，因为上面的都不符合条件，而我与上面的if语句无关。'')2.if(条件表达式){执行语句}else{执行语句}
var box1=100;
if (box1>101) {
alert(''box1大于101'');
} else {
alert(''box1不大于101'');
}3.if(){}else if(){}........else{}
var box2=80;
if (box2>90) {
alert(''优秀'');
} else if (box2>90) {
alert(''优秀'');
} else if (box2>60) {
alert(''及格'');
} else{
alert(''不及格'')
}4.if(){ return}if(){ return}.......else{ return}
这个是用在函数内部的，在做表单验证的时候可以试验一下。
二、switch语句
语法：var var=num;switch(var){case num1: 执行语句;break; case num2: 执行语句;break; ........ default: 执行语句}
说明：var变量是值，case num1是条件，:后面为执行语句， break 用于防止语句的穿透（如果不跳出switch语句，会从匹配到的那一条语句开始逐条输出）， default 相当于else否则的意思
三、循环语句
1.do{执行语句}while(条件)
是先运行后判断的循环语句，即不管条件满不满足都要执行一次循环体
var box3=10;
do{
console.log(box3);
box3++;
}while(box3<=5);//当box3=1时，执行了5次（输出1到5）；当box3=10时，只输出了一个10;2.while(条件){执行语句}
先判断后执行的循环语句，必须满足了条件才能执行循环体
var box4=10;
while(box4<=5){
console.log(box4);
box4++;
}//当box4=1时，执行了5次（输出1到5）;当box4=10时，没有输出任何值3.for(定义变量,条件,循环){执行语句}
先判断后执行的循环语句，但是具有执行循环之前初始化变量和定义循环后要执行代码的能力
for (var i = 0; i <= 10; i++) {
console.log(i);
}
alert(i);//11
for (var j = 0; j <= 10; ++j) {
console.log(j);
}
alert(j);//114.for/in循环
用来遍历对象的属性，常用于普通对象及数组
var person={fname:"john",lname:"tom",age:25};
for( var x in person){
console.log(x);
//console.log(person.x);//好像记得对象调用属性不能是变量，不过还好可以隐性转化为数组吧？
console.log(person[x]);//这个谷歌是兼容的，不知道ie的兼容性怎么样
}
var arr=[''aa'',''bb'',''ccc'',''dd''];
for (var y in arr){
console.log(y);
console.log(arr[y]);
}四、break和continue语句
用于在循环中精确地控制代码的执行，其中break语句会立即退出循环，强制继续执行循环体后面的语句，而continue语句会退出当前循环，继续执行后面的循环
for(var box=0;box < 5;box ++){
if(box==3) break;//如果box是3，退出循环
document.write(box+''<br>'');//0 1 2
}
for(var box=0;box < 10;box++){
if(box==5) continue;
document.write(box+''<br>'');//0 1 2 3 4 6 7 8 9
}五、with语句
var person={fname:"john",lname:"tom",age:25};
with(person){//with(person)可以把person省略掉
var n=fname;//这里的fname相当于 person.fname
var m=lname;
var a=age;
}
alert(n+'',''+m+''.''+a);//john,tom.25
05.流程控制语句
1、引用类型变量的创建及使用 2、流程控制语句之选择语句 3、流程控制语句之循环语句 4、循环高级
01创建引用类型变量公式
* A: 创建引用类型变量公式
* a: 我们要学的Scanner类是属于引用数据类型，我们先了解下引用数据类型。
* b: 引用数据类型的定义格式
* 与定义基本数据类型变量不同，引用数据类型的变量定义及赋值有一个相对固定的步骤或格式。
* 数据类型 变量名 = new 数据类型();
* c: 引用数据类型的使用
* 每种引用数据类型都有其功能，我们可以调用该类型实例的功能。
* 变量名.方法名();
02Scanner类的使用
* A: Scanner类的使用
* a: 导包import java.util.Scanner;
* b：创建键盘录入对象 Scanner sc = new Scanner(System.in);
* c: 读取键盘录入的一个整数
* int enterNumber = sc.nextInt();
* d: 读取键盘录入的字符串
* String enterString = sc.next();
* B: 案例代码
import java.util.Scanner;
public class Demo05Scanner{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int enterNumber = sc.nextInt();
System.out.println("用户输入的整数为"+enterNumber);
String enterString = sc.next();
System.out.println("用户输入的字符串为"+enterString);
}
}
03Random随机数类的使用_1
* A: Random随机数类的使用_1
* a: 功能
* 生成随机数需要使用到引用类型随机数Random类
* b: 使用方式
* import导包：所属包java.util. Random
* 创建实例格式：Random random = new Random ();
* 调用方法
* nextInt(int maxValue) 产生[0,maxValue)范围的随机数,包含0不包含maxValue
* nextDouble() 产生[0,1)范围的随机数
如：
Random random = new Random ();
int myNumber = random.nextInt(100);//结果为0-99的一个数
* B: 案例代码
import java.util.Random;
public class RandomDemo{
public static void main(String[] args){
Random ran = new Random();
// Random类中的,产生随机数的功能
int i = ran.nextInt(100);
System.out.println(i);
//问题? 产生随机数,范围 1-100之间
// nextInt(100) 0-99 + 1
}
}
04Random随机数类的使用_2
* A: Random随机数类的使用_2
* a: 调用方法
* nextDouble() 产生[0,1)范围的随机数
如：
Random random = new Random ();
int myNumber = random.nextDouble();//结果为0.0-1.0之间的数(包括0.0不包括1.0)
05if语句格式第一种
* A: if语句格式第一种
* a: 书写格式
if(比较表达式) {
语句体;
}
* b：执行流程：
* 先计算比较表达式的值，看其返回值是true还是false。
* 如果是true，就执行语句体；
* 如果是false，就不执行语句体；
* B: 案例代码
public class IfDemo{
public static void main(String[] args){
int i = 5 ;
//对变量i进行if判断
if(i > 5){
System.out.println("if中的条件是true");
i++;
}
System.out.println(i);
}
}
06if语句格式第二种
* A: if语句格式第二种
* a: 书写格式
if(比较表达式) {
语句体1;
}else {
语句体2;
}
* b：执行流程：
* 首先计算比较表达式的值，看其返回值是true还是false。
* 如果是true，就执行语句体1；
* 如果是false，就执行语句体2；
* B: 案例代码
public class IfElseDemo{
public static void main(String[] args){
int i = 16 ;
//判断变量,是奇偶数, 除以2,看余数是0还是1
if( i % 2 == 0 ){
System.out.println(i+" 是偶数");
}else{
System.out.println(i+" 是奇数");
}
}
}
07if语句格式第三种
* A: if语句格式第三种
* a: 书写格式
if(比较表达式1) {
语句体1;
}else if(比较表达式2) {
语句体2;
}else if(比较表达式3) {
语句体3;
}
...
else {
语句体n+1;
}
* b：执行流程：
* 首先计算比较表达式1看其返回值是true还是false，
* 如果是true，就执行语句体1，if语句结束。
* 如果是false，接着计算比较表达式2看其返回值是true还是false，
* 如果是true，就执行语句体2，if语句结束。
* 如果是false，接着计算比较表达式3看其返回值是true还是false，
* 如果都是false，就执行语句体n+1。
* B: 案例代码
public class IfElseIfDemo{
public static void main(String[] args){
//成绩判断要求 ,成绩>80 成绩>70 成绩>60 不及格
//定义变量,保存成绩
int grade = 75;
//使用if else if 语句对成绩判断
if( grade > 80 ){
System.out.println(grade+" 成绩是优");
}else if ( grade > 70){
System.out.println(grade+" 成绩是良");
}else if ( grade > 60){
System.out.println(grade+" 成绩是中");
}else{
System.out.println(grade+" 成绩是差");
}
}
}
08if语句和三元运算符的互换
* A: 三元运算符
* a: 概念
* 用来完成简单的选择逻辑，即根据条件判断，从两个选择中选择一种执行
* b: 使用格式
* (条件表达式)？表达式1：表达式2；
* c: 运算规则
* 1: 判断条件表达式，结果为一个布尔值
* 2: true，运算结果为表达式1
* 3: false，运算结果为表达式2
* B: 案例代码
public class IfElseDemo_1{
public static void main(String[] args){
int j = 6;
int i = 15;
//使用if语句,判断出最大值
if(i>j){
int j = 6;
System.out.println(i+" 是最大值");
}else{
System.out.println(j+" 是最大值");
}
//使用三元运算实现
int k = i>j ? i : j;
System.out.println(k+" 是最大值");
}
}
* C: 使用if语句还是三元表达式
* 判断条件多,使用if
* 三元,必须有结果的, if 可以没有结果的
09while循环
* A: while循环结构
* a: 使用格式
初始化表达式；
while(条件){
循环体
}
* b: 执行顺序
当条件是true,就执行循环体,执行完循环体后
程序再次执行while中的条件,如果条件还是true,继续执行循环体
直到条件是false的时候,循环就结束
* B: 案例代码
public class WhileDemo{
public static void main(String[] args){
//输出 1-4之间的整数
//定义变量,整数类型, 循环的条件
int i = 1;
while( i < 5 ){
System.out.println(i);
i++;
}
}
}
10for循环_1
* A: for循环_1
* a: 使用格式
for(初始化变量 ; 条件 ; 增量){
循环体;
}
* b: 各模块解释
初始化变量: 定义变量,作用是用来控制循环的次数
条件: 当条件是true,执行循环体,条件是false,结束循环
增量: 变量自增情况
* B: 案例代码
public class ForDemo{
public static void main(String[] args){
//for循环,输出0-10
for(int i = 0 ; i < 11 ; i++){
System.out.println(i);
}
}
}
11for循环_2
* A: for循环的执行流程
for（① ; ② ; ③）{
④
}
第一步，执行①
第二步，执行②，如果判断结果为true，执行第三步，如果判断结果为false，执行第五步
第三步，执行④
第四步，执行③，然后重复执行第二步
第五步，退出循环
12for循环_3
* A: 案例
* a: 利用for循环,计算1+4的结果
* B: 案例代码
public class ForDemo_1{
public static void main(String[] args){
// 定义变量,记录求和后的数据
int sum = 0;
// 利用循环,将变量从1变化到4
for(int i = 1 ; i <= 4 ; i++){
//对变量进行求和
sum = sum + i;
}
System.out.println(sum);
}
}
13do_while循环
* A: do_while循环
* a: 使用格式
do{
循环体;
}while(条件);
* b: 执行顺序
先执行一次循环体，然后再判断条件，如果条件为true，继续执行循环体，
如果条件为false，循环结束。
* c: 特点
* 无条件先执行一次
* B: 案例代码
public class DoWhileDemo{
public static void main(String[] args){
int i = 0;
do{
System.out.println(i);
i++;
}while( i < 5);
}
}
14死循环
* A: 死循环概述
* 无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环
* B: 死循环格式
* while(true){}
* for(;;){}
15嵌套for循环_1
* A: 嵌套循环的概述
* 嵌套循环是指在一个循环语句的循环体中再定义一个循环语句的语法结构。while、do…while、for循环语句都可以进行嵌套，并且它们之间也可以互相嵌套，如最常见的在for循环中嵌套for循环。
* B: 嵌套循环的格式
for(初始化表达式; 循环条件; 操作表达式) {
………
for(初始化表达式; 循环条件; 操作表达式) {
执行语句
………
}
………
}
* C: 各模块解释
* 总的循环次数 = 内循环次数 * 外循环的次数
* 内循环,是外循环的循环体
* 外循环,控制的是行数
* 内循环,控制的是每行的个数
16嵌套for循环_2
* A: 案例
* a: 打印正三角形
* B: 案例代码
public class ForForDemo{
public static void main(String[] args){
for(int i = 0 ; i < 9 ; i++){
for(int j = 0; j < i+1 ;j++){
System.out.print("* ");
}
System.out.println();
}
}
}
17break语句
* A: break语句
* a: 作用
* 跳出所在的循环体
* b: 书写位置
* 必须出现在循环或选择结构内
* c: 举例
for(int i=0; i<10; i++) {
if(i>5) {
break;
}
System.out.println(“我爱Java”+i);
}
//会从0-5输出6次“我爱Java”
* B: break详细解释
* a: 作用
* 在loop/switch选择或者循环过程中，我们总是满足布尔表达条件才能执行对应的代码，然而在这些逻辑过程中，
可以使用一些关键字直接跳出正在执行的代码，去执行后边或者指定位置的代码，
这些关键字一旦出现就可以跳转语句执行顺序。
* b: 使用方式
* 无法单独使用，必须将break关键字置于switch或循环语句中
* c: 运行规律
* 不需要判断任何条件，只要遇到break变直接跳出执行后续代码。会完全跳出选择或者循环结构
* 只能跳出最近的代码块，不能跨越多级代码块
* C：循环标号
* a: 为什么使用循环标号
* 当在双层循环或者循环内有switch选择语句时，我们发现，使用break或者continue所作用的对象均是内层语句，无法直接跳出外层循环，这时就需要使用标号语句跳转了.
* b: 使用方式
* 在外层循环外的某行前边，使用后边跟有冒号”:”的标识符，即定义完毕。
使用时当在内层循环使用break或continue时后边紧跟之前定义的标号即可
* c: 运行规律
* 当外层循环外定义了标号
* 内层使用break，终止内外双层循环。
* 内层使用continue，终止内层循环，继续外层循环。18continue语句
* A: continue语句
* a: 作用
* 提前结束本次循环，继续进行下次循环
* b: 使用方式
* 无法单独使用，必须将continue关键字置于循环语句中
* c：运行规律
* 不需要判断任何条件，只要遇到continue变直接跳出本轮循环进行下次循环
* d：案例代码
public class ContinueDemo{
public static void main(String[] args){
for(int i = 0 ; i < 10 ; i++){
if(i%2==0){
continue;
}
System.out.println(i);
}
}
}
//会把0-9之间所有的奇数打印到控制台上
19猜数字小游戏
* A: 猜数字小游戏
* a: 分析
* 用户给的数可能大于、小于、或等于被猜的数，这样就会出现三种情况，用前面讲的三元运算符可以实现，
但是得用三元运算符的嵌套，比较麻烦！可以用更简单的方式if条件判断，可以有三个以上的条件
* b: 需求分析
* 后台预先生成一个随机数1-100，用户键盘录入猜数字
* 如果猜对了，打印“恭喜您，答对了”
* 如果猜错了
* 猜大了：打印“sorry，您猜大了!”
* 猜小了：打印“sorry，您猜小了!”
直到数字猜到为止
最多只能猜5次，否则提示“sorry，您没有机会了!”
* B: 案例代码
/*
猜数字小游戏
完成猜数字小游戏：
1、产生随机数
后台预先生成一个随机数1-100，用户键盘录入猜数字
2、通过if语句对用户猜的数与随机数进行比较
如果猜对了，打印“恭喜您，答对了”
如果猜错了
猜大了：打印“sorry，您猜大了!”
猜小了：打印“sorry，您猜小了!”
3、通过for循环完成用户猜数的循环
直到数字猜到为止
最多只能猜5次，否则提示“sorry，您没有机会了!”
*/
import java.util.Random;
import java.util.Scanner;
//通过*的方式可以一次导入该包下所有的类，但是不建议使用。建议使用哪个导哪个。
//import java.util.*;
public class GuessNumber{
public static void main(String[] args) {
//1、产生随机数
//后台预先生成一个随机数1-100，用户键盘录入猜数字
//创建随机数对象
Random random = new Random();
//产生一个1-100的随机数
int randomNumber = random.nextInt(100)+1;
//System.out.println("我产生的随机数是："+randomNumber+"你猜猜是多少？"); 作弊专用
//产生控制台录入的Scanner对象
Scanner sc = new Scanner(System.in);
//3、通过for循环完成用户猜数的循环
//通过for循环完成猜数字逻辑
for(int i=1; i<=5; i++){
//提示用户输入要猜的数，用变量接收
System.out.println();
System.out.println("请您输入一个1-100的数：");
int guessNumber = sc.nextInt();
//2、通过if语句对用户猜的数与随机数进行比较
//如果猜对了
if(guessNumber==randomNumber) {
//打印猜对后的提示
System.out.println("恭喜您，猜对了！");
//跳出循环，不用再猜了
break;
}else {//如果猜错了
//如果猜大了
if(guessNumber>randomNumber) {
System.out.println("sorry，您猜大了!");
}else {//如果猜小了
System.out.println("sorry，您猜小了!");
}
}
//如果猜到了最后的第5次仍然没有猜对就跳出循环
if(i==5) {
System.out.println("对不起，点太背，下次再来吧！");
break;
}
//每次猜错后，都提示还有多少次机会
System.out.println("请注意，您还有"+(5-i)+"次机会，请慎重作答！");
}
}
}
C#基础之流程控制语句详解
C#程序的执行都是一行接一行、自上而下地进行，不遗漏任何代码。为了让程序能按照开发者所设计的流程进行执行，必然需要进行条件判断、循环和跳转等过程，这就需要实现流程控制。C#中的流程控制包含了条件语句、循环语句、跳转语句和异常处理四个方面。
一、跳转语句
break语句：终止并跳出循环体。
continue语句：终止当前循环，重新开始一个新的循环。
goto语句：跳转到指定位置。
C#允许给代码行加上标签，这样就可以使用goto语句直接跳转到这些代码行上。goto语句的用法如下：
goto<labelName>;
标签用下述方式定义：
<labelName>:
goto语句有两个限制，不能跳转到像for循环这样的代码块中，也不能跳出类的范围，不能退出try…catch语句后面的finally块。
这里讲解goto语句只为了解其语法，当遇到时能知道代码的意思，本人不建议使用。
return语句：跳出循环及其包含的函数。
throw语句：抛出一个异常。
二、条件语句
条件语句可以根据条件是否满足或者根据表达式的值控制代码的执行分支。C#有两种控制控制代码分支的结构，分别是if语句和switch语句。
if语句
注意：if语句的条件可以是布尔变量，也可以是表达式，但如果是表达式，则表达式得到的结果必须是布尔值。
1、单选择if语句，即条件成立执行，语法如下：
if(条件)
{
do;
}
2、ifelse语句，即条件成立执行A否则执行B，语法如下：
if(条件)
{
do A;
}
else
{
do B;
}
延伸：三元运算符?:也相当于一个ifelse语句，语法如下：<表达式> ? <resultIfTrue> : <resultIfFalse> 其中计算表达式可得到一个布尔值，
运算符的结果根据这个值来确定是<resultIfTrue>，还是<resultIfFalse>。例：
int a = 8;
string b = (a < 10) ? "小于10" : "大于10";
3、多选择if语句，即对多个条件进行判断，成立的执行，语法如下：
if(条件1)
{
do A;
}
else if(条件2)
{
do B;
}
else if(条件3)
{
do C;
}
else
{
do D;
}
其中else if语句的个数不受限制，但是如果else if语句的个数较多，则应该考虑另一种分支结构：switch语句。
注意：多选择if语句自上而下，只要有一个条件成立就不会去判断其它任何条件。
switch语句
switch…case语句适合于从一组互斥的分支中选择一个执行分支。其形式是switch参数的后面跟一组case子句。如果switch参数中表达式的值等于某个case子句旁边的某个值，就执行该case子句中的代码。此时不需要使用花括号把语句组合到块中，只需使用break语句标记每段case代码的结尾即可。也可以在switch语句中包含一条default子句，如果表达式不等于任何case子句的值，就执行default子句的代码。其语法如下：
switch(表达式)
{
case 1:
Console.WriteLine("1");
break;
case 2:
Console.WriteLine("2");
break;
case 3:
Console.WriteLine("3");
break;
default:
Console.WriteLine("4");
break;
}
注意：switch语句每个case语句后面的值必须与表达式所得到的值的类型相同，而且必须是常量，不能是变量；switch语句中所有case语句后面的值必须是互斥的，也就是说case后面的值不能存在两个相同的值，因为所有case语句后面的值必须是互斥的，所以case语句的排放顺序无关紧要，甚至可以把default语句放在最前面！但是为养成良好的编程习惯和代码有清晰的逻辑，我不建议这样写；switch语句中default语句只能存在一个，不能存在多个；通常情况下，每个case后面都必须有一个break语句，break语句作用是中断switch语句的执行，但C#中也可以使用其它中断语句来中断switch语句的执，如return语句、goto语句。使用break语句和return语句来中断是有区别的，break语句仅仅中断switch语句的执行，如果switch语句后面还有其它代码是可以继续执行的，但是return语句中断则会中断switch语句所在的方法，也就是说switch语句后面的代码将不会执行，switch语句所在的方法将直接返回。使用goto语句可以从一个case跳到另一个case中执行，如下面这段代码：
int a = 1;
switch (a)
{
case 1:
Console.WriteLine("1");
goto case 2;
case 2:
Console.WriteLine("2");
break;
case 3:
Console.WriteLine("3");
break;
default:
Console.WriteLine("4");
break;
}程序说明：程序执行完 case 1后会直接执行case 2。但是我们不建议这样做，这会导致很难察觉的逻辑错误。
通常情况下switch语句中一个case语句处理完成后，不能自由的进入下一个case语句，但是这个规则有一个例外。如果把多个case语句放在一起，其后面加一个代码块，实际上是一次检查多个条件，如果满足这些条件中的任何一个，就会执行代码，例如：
int a = 2;
switch (a)
{
case 1:
case 2:
case 3:
Console.WriteLine("1或者2或者3");
break;
default:
Console.WriteLine("4");
break;
}
三、循环语句
循环就是重复执行语句，循环结构可以实现一个程序模块的重复执行，它对我们简化程序、更好的组织算法有着重要的意义。
1、do循环
do循环的结构如下：
do
{
语句或语句块;
}while (表达式);
do循环先执行语句或语句块，然后再判断表达式的值，如果表达式的值为true，则继续执行循环，直到表达式的值为false。注意：do循环刚执行的时候不管表达式的值为true或者是false它都要先执行一次语句或语句块，然后再来判断表达式的值。也就是说如果一开始表达式的值为false，它也会执行一次循环。do循环无论布尔表达式的值是true还是false，语句或语句块至少会执行一次。另外while语句后面必须使用分号(;)。
2、while循环
while循环的结构如下：
while(表达式)
{
语句或语句块;
}
while循环则是先判断表达式的值，然后再执行语句或语句块，直到表达式的值为false。如果循环刚开始表达式的值就为false，那么语句或语句块就不会被执行。
3、for循环
for循环的结构如下：
for(<初始化表达式>;<条件表达式>;<迭代表达式>)
{
语句或语句块;
}
初始化表达式：可以在该位置定义一个变量并为其赋一个起始值，也可以使用for循环前面定义的变量，但是使用for循环前面定义的变量必须在该位置为其重新赋一个起始值。注意：在该位置定义一个变量并为其赋一个起始值，这种用法定义的变量的作用域仅在for循环语句中，也就是说for循环语句后面的代码就不能使用该变量；但是用for循环前面定义的变量这种用法定义的变量for循环语句后面的代码就也能使用该变量。
条件表达式：它是循环继续或者终止的条件。
迭代表达式：执行完语句或语句块后就执行迭代表达式，然后再执行条件表达式判断循环是否继续。
for循环示例：
//将1到10打印到屏幕上
for (int a =1 ; a <= 10; a++)
{
Console.WriteLine(a);
}
Console.ReadKey();
4、foreach循环
foreach语句用于枚举一个集合的元素，并对该集合中的每一个元素执行一次嵌入语句。foreach循环的结构如下：
foreach(<类型> <迭代变量名> in <集合>)
{
语句或语句块;
}
注意：迭代变量的类型必须与集合的类型相同。集合内元素的个数决定循环内程序段重复执行的次数，每次进入循环，会依次将集合元素内容指定给变量，当所有元素都读完后，就会跳出foreach循环。foreach循环对集合内元素进行只读访问，不能改变任何元素的值。foreach循环在循环的过程中不能对集合进行添加元素或者删除元素的操作。示例：
List<string> strList = new List<string>();
for (int a =1 ; a <= 10; a++)
{
strList.Add(a.ToString());
}
foreach (string str in strList)
{
Console.WriteLine(str);
strList.Remove(str);
}
Console.ReadKey();以上程序中的foreach语句在输出集合strList中的第一元素并将其移除集合后进行下一次循环的时候会产生异常。
5、无限循环
在代码编写错误或者故意进行设计时，可以定义永不终止的循环，即所谓的无限循环。示例：
while(true)
{
语句或语句块;
}
无限循环语句也是有用的，而且可以使用break语句或者手工使用Windows任务管理器退出无限循环。
四、异常处理
C#中的异常处理也算一种流程控制，try…catch…finally语句用于异常的捕获和处理，具体语法如下：
try
{
语句或语句块;
}
catch(<execptionType> e)
{
语句或语句块;
}
finally
{
语句或语句块;
}
try:包含抛出异常的代码。
catch:包含抛出异常时要执行的代码。catch块可以使用<execptionType>设置为只响应特定的异常类型，以便提供多个catch块。
finally:包含始终会执行的代码，如果没有产生异常，则在try块之后执行，如果处理了异常，就在catch块后执行。
try…catch…finally语句的执行顺序依次是：
1、try块在发生异常的地方中断程序的执行。
2、如果有catch块，就检查该块是否匹配已抛出的异常类型。如果没有catch块，就执行finally块（如果没有catch块，就一定要有finally块）。
3、如果有catch块，但它与已发生的异常类型不匹配，就检查是否有其他catch块。
4、如果有catch块匹配已发生的异常类型，就执行它包含的代码，再执行finally块（如果有）。
5、如果catch块都不匹配已发生的异常类型，就执行finally块（如果有）。
从try…catch…finally语句的执行顺序可以看出try…catch…finally语句有多种组合模式，这里就不详细讲解。
go 语言基础之流程控制 if 语句
Go 语言支持最基本的三种程序运行结构：顺序结构、选择结构、循环结构。
- 顺序结构：程序按顺序执行，不发生跳转。
- 选择结构：依据是否满足条件，有选择的执行相应功能。
- 循环结构：依据条件是否满足，循环多次执行某段代码。
一、选择结构
if 语句
示例 1： 满足条件
package main //必须有一个main包
import "fmt"
func main() {
// s := "屌丝"
s := "王思聪"
//if和{就是条件，条件通常都是关系运算符
if s == "王思聪" { //左括号和if在同一行
fmt.Println("左手一个妹子，右手一个大妈")
}
}#执行结果：
左手一个妹子，右手一个大妈
示例 2：不满足条件
package main //必须有一个main包
import "fmt"
func main() {
s := "屌丝"
//if和{就是条件，条件通常都是关系运算符
if s == "王思聪" { //左括号和if在同一行
fmt.Println("左手一个妹子，右手一个大妈")
}
}#执行结果：（空的没有结果输出）
示例 3：
package main //必须有一个main包
import "fmt"
func main() {
//if支持1个初始化语句, 初始化语句和判断条件以分号分隔
if a := 10; a == 10 { //条件为真，指向{}语句
fmt.Println("a == 10")
}
}#执行结果：
a == 10
今天关于js基础之 流程控制语句和js的流程控制语句的讲解已经结束，谢谢您的阅读，如果想了解更多关于05.流程控制语句、1、引用类型变量的创建及使用 2、流程控制语句之选择语句 3、流程控制语句之循环语句 4、循环高级、C#基础之流程控制语句详解、go 语言基础之流程控制 if 语句的相关知识，请在本站搜索。
本文标签：
