一、循环结构的思想及意义：
 知道了循环结构，那么在生活中也一样，我们每天都在重复做着相同的事情，例如：吸气呼气的过程；又如夏天开电扇，电扇一圈一圈的转，这都是在重复。现在大家玩个游戏，一个人A来说一个人B来做，一个人A说命令“敬礼，礼毕”，另一人B做动作十遍；第一种思维那就是说一下命令就让B执行动作，B执行完动作后，A再继续说命令，B再继续做动作，同样的事情重复十遍。如果利用所学的知识，让你输出十遍“敬礼，礼毕”，你会怎么写程序呢？
 
/* 输出敬礼礼毕十遍 */
#include "stdio.h"
void main()
{
    printf("1.敬礼、礼毕\n");
    printf("2.敬礼、礼毕\n");
    printf("3.敬礼、礼毕\n");
    printf("4.敬礼、礼毕\n");
    printf("5.敬礼、礼毕\n");
    printf("6.敬礼、礼毕\n");
    printf("7.敬礼、礼毕\n");
    printf("8.敬礼、礼毕\n");
    printf("9.敬礼、礼毕\n");
    printf("10.敬礼、礼毕\n");    
}
 
那A要让B说一万遍呢，显然如果还是用上面的程序来写的话，那么今天你一个小时不用做别的了，你就在这里慢慢复制粘贴吧！所以肯定有好的办法：A应该对B说执行命令动作“敬礼、礼毕”十遍。同样的问题大家来看第二段程序代码：
 
/* 输出敬礼礼毕十遍 */
#include "stdio.h"
void main()
{
	int i;
	i=1;
    while(i<=10)
	{
printf("%d.敬礼、礼毕\n",i);
i=i+1;
	}   
}
 
二、while的基本格式
 while的基本格式：（流程图如右图所示）
 while(表达式)
 {
 语句1;
 ……
 语句 n;
 }
 其中表达式代表了循环条件，整个复合语句为循环体。
 while语句规范：
 1：{和}自成一行
 2：语句1—语句n自动缩进
 while循环属于当型循环，也就是先判断表达式的值是否为真的（也可以理解为条件是否成立），若为真则循环，否则退出循环。
 它的格式变形如下；
 表达式1；
 while(表达式2)
 {
 语句；
 表达式3；
 }
 其中表达式1代表了程序循环前的初始值，表达式2代表了控制条件，表达式3代表了增量变化
 拿输出1到100为例分析。
 最初始的值（假设变量为i）应该是i=1；条件是i<101（或i<=100）;语句是输出相应的变量值 printf(“%d ”，i);而表达式3应该是输出一个后进入下一个数，也就是i++;
 所以它的代码也就很容易就出来了：
 
void main（）
{
    int i;
    i=1;
    while(i<101)
{
  printf(“%d ”,i);
  i++;   
}
}
 
do—while循环语句
 do–while语句
 在循环中有当型循环，还有直到型循环。接下来我们就来学习下直到型循环。
 一、do—while语句格式
 1.do—while语句格式1
 表达式1；
 do
 {
 语句；
 表达式3；
 } while(表达式2)；
 其中表达式1代表了程序循环前的初始值，表达式2代表了控制条件，表达式3代表了增量变化
 这种格式在程序中已经很少用了。主要应用于下种变形格式：
 2.do—while语句格式变形
 do
 {
 语句；
 } while(条件表达式)；
 二、do-while语句的思想及意义
 do英文翻译成中文是做的意思，那么从上面的结构我们也能看出，do语句后判断条件表达式，如果条件还表达式成立，再次执行语句，直到条件表达式不成立，往下继续执行。所以do—while的中心思想是至少执行一次循环语句。
 三、do-while循环结构实例
 下面我们一些操作实例来讲解循环结构的逻辑思维过程。
 1.求1+2+3+4±—+100和是多少?
 （1）步骤1，首先我们应该分析的是，我们要求一个数即和，那么和初值是几呢？ sum=0
 （2）sum+=1;
 （3）sum+=2;
 （4）sum+=3;
 （5）假如我们如一个变量i来代表值的变化的话那么我们应该也能推算去，求和其实就是
 （6）sum+=i;只是i要从1变化到100
 （7）while代码参考代码如下
 
/*求1+2+3+---+100的和*/
#include "stdio.h"
void main()//求各
{
	//定义变量并初始化
	int i=1;
	int sum=0;
	while(i<=100)  //条件表达式
	{
		sum+=i;
		i+=1; //步长
	}	
	printf("和是%d",sum);
}
 
（8）do–while代码参考代码如下
 
/*求1+2+3+---+100的和*/
#include "stdio.h"
void main()//求各
{
	//定义变量并初始化
	int i=1;
	int sum=0;
	do
	{
		sum+=i;
		i+=1; //步长
	}	while(i<=100); //条件表达式
	printf("和是%d",sum);
}
 
2.输入qq的密码；输入正确则显示登录成功，否则可以一直输入密码直到对为至，假设密码为123456
 （1）那么我们分析题目，应该是先输入后判断的一种循环方式，那么应该选择do—while语句
 （2）程序中要求我们输入密码，密码可以变，所以要给密码定义成一个变量，我们假设int password;
 （3）因为密码是输入的，所以没有初始值
 （4）输入密码以后我们应该判断密码是否和默认密码相同
 （5）相同则登录成功
 （6）不相同则重新
 （7）do–while代码参考代码如下
 
/*判断qq密码*/
#include "stdio.h"
void main()//登录
{
	//定义变量并初始化
	int password;
    do	
	{
		printf("请输入qq登录密码:");
		scanf("%d",&password);
	}while(password!=123456);  	//条件表达式
	printf("登录成功");
}
 
（8）do—while语句是可以被while()替换，其实循环之间的语句都可以相互替换，哪种方法更适合你，就选那种，也就是说一定要有一种是自己专长的。
 
（9）参考代码如下
/*登录*/
#include "stdio.h"
#include "stdlib.h"
void main()//登录
{
	//定义变量并初始化
	int password;
    while(1)
	{
		printf("请输入qq登录密码:");
		scanf("%d",&password);
		if(password==123456)
		{
			printf("登录成功");
			break;
			}
	}
	
}
 
3.while 与do—while的相同与不同总结?
 （1）while 语句是先计算表达式的值，再执行循环体，do…while是执行完一次循环体，再计算表达式的值
 （2）当表达式的值第一次为假时，while的循环体一次都不执行，do…while则执行一次循环体;
 （3）当表达式的值为真时，两者无区别
 （4）在不确定条件次数的情况下，程序一般用while比较多
 
for循环语句
 for 循环为当型循环。for循环最容易实现计数控制循环方法。for循环的使用最为灵活,且适合应用在循环次数确定的情况下。
 for循环的思想是，先分析清楚循环的初始值，循环的控制条件，循环变量的步长变化，然后直接把语句再写到for的循环体里即可，这样可以让问题想的很清楚，流程也很清楚。
 二、for循环语句的应用
 for语句是c语言所提供的功能更强，使用更广泛的一种循环语句。
 1.for语句的一般格式
 （1）第1种情况
 for(表达式1；表达式2；表达式3)
 语句；
 （2）第2种情况
 for(表达式1；表达式2；表达式3)
 {
 语句块；
 }
 2.for语句的注意事项
 （1）各表达式之间分号不能省略
 （2）表达式1与表达式2与表达式3均可省略，一般是不省略的。
 ①当表达式1省略时，相当于省去了为循环变量赋初值，此时应在for语句之前给循环变量赋初值
 ②当表达式2省略时，表示不判断循环条件，也就是认为表达式2始终为真， 这时应在循环体内设法结束循环，否则将成为死循环
 ③当表达式3省略时，即省去修改循环变量的值，但此时应在循环体内设法结束循环
 （3）虽然说表达式可以省略，但是在使用for时，还是要正常使用的，也就是该有的都有。
 三、for的逻辑思维过程
 for语句和while语句一样，它的思想是在做循环之前，也是先有一个初值表达式1，然后判断条件表达式2是否成立，如果成立就执行{}里的语句然后跳转到表达式3，表达式3再跳转到表达式2，再次判断表达式2，如若成立再次，执行{}里的语句语句然后跳转到表达式3，表达式3再跳转到表达式2，如果成立就再重复执行，如果不成立就退出循环。
 for的流程图走向和while语句一模一样，但是for的思维过程，可以直接先分析从第一次开始执行，执行条件是什么，步长是多少，然后执行的语句是什么，套用for的结构即可。

while循环
while语句用于循环执行程序，执行过程依赖指定条件
 
语法：
 
while(条件表达式):
 
         语句块
 
示例
 
x = 5

count = 1

while(x<=20):

    print("第%s次循环输出:"%count,x)

    x = x + 5

    count = count + 1
 
当x小于等于20时，执行while内的语句块，打印x，并且将x的值增加5，第四次循环结束时，x的值为25，不再满足小于等于20，循环终止
 
count用于记录循环次数，每次循环后次数增1
 
结果输出
 
第1次循环输出: 5
 
第2次循环输出: 10
 
第3次循环输出: 15
 
第4次循环输出: 20
 
 
 
continue语句
在循环的执行过程中，如果遇到continue语句，将结束本次循环，直接进行下一次循环
 
示例
 
weekDays = ["Monday","Tuesday","Wednesday","Thursday","Friday"]

count = 0

while(count<len(weekDays)):

    print(weekDays[count])

    count += 1

    continue

    print("遇到continue语句，本次循环结束")

    print("continue之后的代码不会被执行")
 
结果输出
 
Monday
 
Tuesday
 
Wednesday
 
Thursday
 
Friday
 
可以看出continue之后的语句都没有执行
 
 
 
break语句
break语句用于停止整个循环的执行
 
示例
 
weekDays = ["Monday","Tuesday","Wednesday","Thursday","Friday"]

count = 0

while(count<len(weekDays)):

    print(weekDays[count])

    if(weekDays[count] == "Wednesday"):

        print("终止整个循环")

        break

    count += 1
 
结果输出
 
Monday
 
Tuesday
 
Wednesday
 
终止整个循环
 
当循环执行到第三次的时候，if条件weekDays[2] == "Wednesday"成立，触发break，整个循环结束。

 
sql中的while循环
 
 The SQL While loop is used to repeatedly execute a certain piece of SQL script. 
 
 SQL While循环用于重复执行某段SQL脚本。 
 
 
 This article covers some of the basic functionalities of the SQL While loop in Microsoft SQL Server, with the help of examples. 
 
 
 本文通过示例介绍了Microsoft SQL Server中SQL While循环的一些基本功能。 
 
 
 SQL While循环语法 (SQL While loop syntax)
 
 
 The syntax of the SQL While loop is as follows: 
 
 
 SQL While循环的语法如下： 
 
 
WHILE condition
BEGIN
   //SQL Statements
END;

 
 The while loop in SQL begins with the WHILE keyword followed by the condition which returns a Boolean value i.e. True or False. 
 
 
 SQL中的while循环以WHILE关键字开头，后跟返回布尔值（即True或False）的条件。 
 
 
 The body of the while loop keeps executing unless the condition returns false. The body of a while loop in SQL starts with a BEGIN block and ends with an END block. 
 
 
 除非条件返回false，否则while循环的主体将继续执行。 SQL中while循环的主体以BEGIN块开始，以END块结束。 
 
 
 一个简单的示例：使用SQL While循环打印数字 (A simple example: Printing numbers with SQL While loop)
 
 
 Let’s start with a very simple example where we use a SQL While loop to print the first five positive integer values: 
 
 
 让我们从一个非常简单的示例开始，在该示例中，我们使用SQL While循环打印前五个正整数值： 
 
 
DECLARE @count INT;
SET @count = 1;
    
WHILE @count<= 5
BEGIN
   PRINT @count
   SET @count = @count + 1;
END;

 
 In the script above, we first declare an integer type variable @count and set its value to 5. 
 
 
 在上面的脚本中，我们首先声明一个整数类型变量@count并将其值设置为5。 
 
 
 Next, we execute a While loop which checks if the value of the @count variable is less than or equals to 5. If the @count variable has a value less than or equals to 5, the body of the loop executes, and the current value of the @count variable is printed on the console. 
 
 
 接下来，我们执行一个While循环，该循环检查@count变量的值是否小于或等于5。如果@count变量的值小于或等于5，则执行循环主体，并执行当前操作。 @count变量的值将打印在控制台上。 
 
 
 In the next line, the value of the @count variable is incremented by 1. The While loop keeps executing until the value of the @count variable becomes greater than 5. Here is the output: 
 
 
 在下一行，@count变量的值增加1。While循环一直执行，直到@count变量的值大于5。这是输出： 
 
 
 
 

  
 
 
 
 使用SQL While循环插入记录 (Inserting records with SQL While loop)
 
 
 Let’s now see how the SQL While loop is used to insert dummy records in a database table. 
 
 
 现在，让我们看看如何使用SQL While循环在数据库表中插入伪记录。 
 
 
 For this we need a simple database “CarShop”: 
 
 
 为此，我们需要一个简单的数据库“ CarShop”： 
 
 
CREATE DATABASE CarShop

 
 We will create one table i.e. Cars within the CarShop database. The Cars table will have three columns Id, Name and Price. Execute the following script: 
 
 
 我们将在CarShop数据库中创建一个表，即Cars。 汽车表将具有三列ID，名称和价格。 执行以下脚本： 
 
 
USE CarShop
CREATE TABLE Cars
(
Id INT PRIMARY KEY IDENTITY(1,1),
Name VARCHAR (50) NOT NULL,
Price INT
)

 
 Let’s now use the While loop in SQL to insert 10 records in the Cars table. Execute the following script: 
 
 
 现在，让我们使用SQL中的While循环在Cars表中插入10条记录。 执行以下脚本： 
 
 
DECLARE @count INT;
SET @count = 1;
    
WHILE @count<= 10
BEGIN
   INSERT INTO Cars VALUES('Car-'+CAST(@count as varchar), @count*100)
   SET @count = @count + 1;
END;

 
 In the script above, we again declare a variable @count and initialize it with 1. Next, a while loop is executed until the value of the @count variable becomes greater than 10, which means that the while loop executes 10 times. 
 
 
 在上面的脚本中，我们再次声明变量@count并用1对其进行初始化。接下来，执行while循环，直到@count变量的值大于10，这意味着while循环执行10次。 
 
 
 In the body of the while loop, the INSERT query is being used to insert one record into the Cars table. For the Name column, the value of the @count variable is appended with the string Car-. For the Price column of the Cars table, the value of the @count variable is multiplied by 100. 
 
 
 在while循环的主体中，使用INSERT查询将一条记录插入Cars表中。 对于“名称”列，@ count变量的值后面附加字符串Car- 。 对于Cars表的Price列，@ count变量的值乘以100。 
 
 
 Now if you select all the records from the Cars table with the “SELECT * FROM Cars” query, you should see the following output: 
 
 
 现在，如果使用“ SELECT * FROM Cars”查询从Cars表中选择所有记录，则应该看到以下输出： 
 
 
 
 

  
 
 
 使用SQL While循环实现分页 (Implementing paging with SQL While loop)
 
 
 The while loop can also be used to implement paging. Paging refers to displaying a subset of records from a data table at any particular time. 
 
 
 while循环还可用于实现分页。 分页是指在任何特定时间显示数据表中记录的子集。 
 
 
 In the following script, the while loop will be used to select two records from the Cars table at a time. The selected records are then displayed in the console output: 
 
 
 在以下脚本中，while循环将用于一次从Cars表中选择两个记录。 然后，所选记录将显示在控制台输出中： 
 
 
DECLARE @count INT
DECLARE @limit INT;
SET @count = 0
SET @limit = 2;
    
WHILE @count< 10
BEGIN
   SELECT * FROM Cars 
   ORDER BY Id
   OFFSET @count ROWS
   FETCH NEXT @limit ROWS ONLY
   SET @count = @count + 2;
END;

 
 In the script above, we initialize two variables i.e. @count and @limit. The initial values for the @count and @limit variables are 0 and 2, respectively. The while loop executes while the value of the @count variable remains less than 10. 
 
 
 在上面的脚本中，我们初始化了两个变量，即@count和@limit。 @count和@limit变量的初始值分别为0和2。 当@count变量的值保持小于10时，将执行while循环。 
 
 
 Inside the while loop, the OFFSET clause is used to skip the first N rows of the Cars table. The FETCH NEXT clause fetches the next N records. 
 
 
 在while循环内，OFFSET子句用于跳过Cars表的前N行。 FETCH NEXT子句获取接下来的N条记录。 
 
 
 In the first iteration, the value of OFFSET will be 0 since @count is 0, the first two records will be displayed. In the second iteration, since the @count variable will have the value 2, the first two records will be skipped and the records 3 and 4 will be retrieved. 
 
 
 在第一次迭代中，由于@count为0，因此OFFSET的值为0，将显示前两个记录。 在第二次迭代中，由于@count变量的值为2，因此将跳过前两个记录，并检索记录3和4。 
 
 
 In this way, all the records from the Cars table will be retrieved in sets of two. The output is as follows: 
 
 
 这样，Cars表中的所有记录将以两个为一组进行检索。 输出如下： 
 
 
 
 

  
 
 
 
 In the output, you can see all the records from the Cars table, printed in sets of two on the console. 
 
 
 在输出中，您可以查看Cars表中的所有记录，这些记录以两个一组的形式打印在控制台上。 
 
 
 CONTINUE和BREAK语句 (The CONTINUE and BREAK statements)
 
 
 The CONTINUE statement is used to shift the control back to the start of a while loop in SQL. The BREAK statement is used to terminate the loop. 
 
 
 CONTINUE语句用于将控件移回SQL中的while循环的开始。 BREAK语句用于终止循环。 
 
 
 The following script shows how to use the CONTINUE statement inside a while loop to print the first five positive even integers: 
 
 
 以下脚本显示了如何在while循环中使用CONTINUE语句打印前五个正偶数整数： 
 
 
DECLARE @count INT;
DECLARE @mod INT;
SET @count = 1;
    
WHILE @count<= 10
BEGIN
   set @mod =  @count % 2 
   IF @mod = 1
    BEGIN
    SET @count = @count + 1;
       CONTINUE
    END
   PRINT @count
   SET @count = @count + 1;
END;

 
 In the script above, the while loop executes until the value of the @count variable remains less than or equal to 10. The initial value of the @count variable is 1. 
 
 
 在上面的脚本中，执行while循环，直到@count变量的值保持小于或等于10。@count变量的初始值为1。 
 
 
 In the body of the loop, the value of the remainder of the @count divided by 2 is stored in the @mod variable. If the value of the @count variable is odd, the remainder will be 1, and if the remainder is 0, the CONTINUE statement is used to shift the control back to the start of the while loop and the value of the @count variable is not printed. 
 
 
 在循环的主体中，@ count的余数除以2将存储在@mod变量中。 如果@count变量的值为奇数，则余数为1，如果余数为0，则使用CONTINUE语句将控件移回到while循环的开始，并且@count变量的值为不打印。 
 
 
 Otherwise, the value of the @count variable is printed on the console. Here is the output of the above script: 
 
 
 否则，@ count变量的值将打印在控制台上。 这是上面脚本的输出： 
 
 
 
 

  
 
 
 
 The following example demonstrates the use of a BREAK statement. The while loop in the following script will terminate after printing the first five integers: 
 
 
 下面的示例演示BREAK语句的用法。 在打印前五个整数后，以下脚本中的while循环将终止： 
 
 
DECLARE @count INT;
SET @count = 1;
    
WHILE @count<= 10
BEGIN
   IF @count > 5
    BEGIN
        BREAK
    END
   PRINT @count
   SET @count = @count + 1;
END;

 
 结论 (Conclusion)
 
 
 If you want to repeatedly execute a particular SQL script, the SQL While loop is the way to go. The article explains how to use the SQL While loop in Microsoft SQL Server to perform a variety of tasks ranging from record insertion to pagination. 
 
 
 如果要重复执行特定SQL脚本，则可以使用SQL While循环。 本文介绍了如何在Microsoft SQL Server中使用SQL While循环执行从记录插入到分页的各种任务。 
 
 

  
翻译自: https://www.sqlshack.com/sql-while-loop-understanding-while-loops-in-sql-server/
 
 
sql中的while循环

 
sql while循环
 
 SQL WHILE loop provides us with the advantage to execute the SQL statement(s) repeatedly until the specified condition result turn out to be false. 
 
 SQL WHILE循环为我们提供了重复执行SQL语句的优势，直到指定的条件结果为假。 
 
 
 In the following sections of this article, we will use more flowcharts in order to explain the notions and examples. For this reason, firstly, we will explain what is a flowchart briefly. The flowchart is a visual geometric symbol that helps to explain algorithms visually. The flowchart is used to simply design and document the algorithms. In the flowchart, each geometric symbol specifies different meanings. 
 
 
 在本文的以下各节中，我们将使用更多流程图以解释概念和示例。 因此，首先，我们将简要解释什么是流程图。 流程图是可视的几何符号，有助于直观地解释算法。 该流程图仅用于设计和记录算法。 在流程图中，每个几何符号都有不同的含义。 
 
 
 The following flowchart explains the essential structure of the WHILE loop in SQL: 
 
 
 以下流程图说明了SQL中WHILE循环的基本结构： 
 
 
 
 

  
 
 
 
 As you can see, in each iteration of the loop, the defined condition is checked, and then, according to the result of the condition, the code flow is determined. If the result of the condition is true, the SQL statement will be executed. Otherwise, the code flow will exit the loop. If any SQL statement exists outside the loop, it will be executed. 
 
 如您所见，在循环的每次迭代中，都会检查定义的条件，然后根据条件的结果确定代码流。 如果条件的结果为true，则将执行SQL语句。 否则，代码流将退出循环。 如果循环外存在任何SQL语句，它将被执行。 
 
 
 SQL WHILE循环语法和示例 (SQL WHILE loop syntax and example)
 
 
 The syntax of the WHILE loop in SQL looks like as follows: 
 
 
 SQL中的WHILE循环的语法如下所示： 
 
 
WHILE condition
BEGIN
   {...statements...}
END

 
 After these explanations, we will give a very simple example of a WHILE loop in SQL. In the example given below, the WHILE loop example will write a value of the variable ten times, and then the loop will be completed: 
 
 
 经过这些解释，我们将给出一个非常简单SQL WHILE循环示例。 在下面给出的示例中，WHILE循环示例将写入该变量的值十次，然后循环将完成： 
 
 
DECLARE @Counter INT 
SET @Counter=1
WHILE ( @Counter <= 10)
BEGIN
    PRINT 'The counter value is = ' + CONVERT(VARCHAR,@Counter)
    SET @Counter  = @Counter  + 1
END

 
 
 

  
 
 
 
 Now, we will handle the WHILE loop example line by line and examine it with details. 
 
 
 现在，我们将逐行处理WHILE循环示例，并对其进行详细检查。 
 
 
 In this part of the code, we declare a variable, and we assign an initializing value to it: 
 
 
 在代码的这一部分中，我们声明一个变量，并为其分配一个初始化值： 
 
 
DECLARE @Counter INT 
SET @Counter=1

 
 This part of the code has a specified condition that until the variable value reaches till 10, the loop continues and executes the PRINT statement. Otherwise, the while condition will not occur, and the loop will end: 
 
 
 这部分代码具有指定条件，直到变量值达到10为止，循环才会继续并执行PRINT语句。 否则，while条件将不会发生，并且循环将结束： 
 
 
WHILE ( @Counter <= 10)

 
 In this last part of the code, we executed the SQL statement, and then we incremented the value of the variable: 
 
 
 在代码的最后一部分，我们执行了SQL语句，然后增加了变量的值： 
 
 
BEGIN
    PRINT 'The counter value is = ' + CONVERT(VARCHAR,@Counter)
    SET @Counter  = @Counter  + 1
END

 
 The following flowchart illustrates this WHILE loop example visually: 
 
 
 以下流程图直观地说明了此WHILE循环示例： 
 
 
 
 

  
 
 
 无限SQL WHILE循环 (Infinite SQL WHILE loop )
 
 
 In the infinite loop AKA endless loop, the condition result will never be false, so the loop never ends and can work forever. Imagine that we have a WHILE loop, and we don’t increment the value of the variable. In this scenario, the loop runs endlessly and never ends. Now, we will realize this scenario with the help of the following example. We need to take account of one thing that we should not forget to cancel the execution of the query manually: 
 
 
 在无限循环（又称为无穷循环）中，条件结果永远不会为假，因此循环永远不会结束并且可以永远工作。 想象一下，我们有一个WHILE循环，并且我们不增加变量的值。 在这种情况下，循环将无限地运行，并且永远不会结束。 现在，我们将在以下示例的帮助下实现此方案。 我们需要考虑一件事，我们不应忘记手动取消查询的执行： 
 
 
DECLARE @Counter INT 
SET @Counter=1
WHILE ( @Counter <= 10)
BEGIN
    PRINT 'Somebody stops me!'
  
END

 
 
 

  
 
 
 
 In the following flowchart, it is obvious that the value of the variable never changes; therefore, the loop never ends. The reason for this issue is that the variable is always equal to 1 so the condition returns true for each iteration of the loop: 
 
 
 在下面的流程图中，很明显，变量的值从不改变。 因此，循环永远不会结束。 出现此问题的原因是，变量始终等于1，因此条件对于循环的每次迭代都返回true： 
 
 
 
 

  
 
 
 BREAK声明 (BREAK statement )
 
 
 BREAK statement is used in the SQL WHILE loop in order to exit the current iteration of the loop immediately when certain conditions occur. In the generally IF…ELSE statement is used to check whether the condition has occurred or not. Refer to the SQL IF Statement introduction and overview article for more details about the IF…ELSE statement. 
 
 
 在SQL WHILE循环中使用BREAK语句，以便在发生某些情况时立即退出循环的当前迭代。 通常在IF…ELSE语句中使用该语句检查条件是否发生。 有关IF…ELSE语句的更多详细信息，请参见SQL IF语句介绍和概述文章。 
 
 
 The following example shows the usage of the BREAK statement in the WHILE loop: 
 
 
 以下示例显示了WHILE循环中BREAK语句的用法： 
 
 
DECLARE @Counter INT 
SET @Counter=1
WHILE ( @Counter <= 10)
BEGIN
  PRINT 'The counter value is = ' + CONVERT(VARCHAR,@Counter)
  IF @Counter >=7
  BEGIN
  BREAK
  END
    SET @Counter  = @Counter  + 1
END

 
 
 

  
 
 
 
 In this example, we have checked the value of the variable, and when the value is equal or greater than 7, the code entered the IF…ELSE block and executed the BREAK statement, and so it exited the loop immediately. For this reason, the message shows the values of the variable up to 7. If the condition of the IF…ELSE statement does not meet, the loop will run until the condition result will be false. The following flowchart explains the working logic of the BREAK statement example as visually: 
 
 
 在此示例中，我们检查了变量的值，当该值等于或大于7时，代码进入IF…ELSE块并执行BREAK语句，因此它立即退出循环。 因此，该消息显示变量的值最多为7。如果IF…ELSE语句的条件不满足，则循环将运行，直到条件结果为false。 下面的流程图从视觉上解释了BREAK语句示例的工作逻辑： 
 
 
 
 

  
 
 
 继续声明 (CONTINUE statement )
 
 
 CONTINUE statement is used in the SQL WHILE loop in order to stop the current iteration of the loop when certain conditions occur, and then it starts a new iteration from the beginning of the loop. Assume that we want to write only even numbers in a WHILE loop. In order to overcome this issue, we can use the CONTINUE statement. In the following example, we will check whether the variable value is odd or even. If the variable value is odd, the code enters the IF…ELSE statement blocks and increment the value of the variable, execute the CONTINUE statement and starts a new iteration: 
 
 
 为了在某​​些情况发生时停止循环的当前迭代，在SQL WHILE循环中使用了CONTINUE语句，然后从循环的开头开始了新的迭代。 假设我们只想在WHILE循环中只写偶数。 为了克服这个问题，我们可以使用CONTINUE   声明。 在下面的示例中，我们将检查变量值是奇数还是偶数。 如果变量值是奇数，则代码进入IF…ELSE语句块并递增变量的值，然后执行CONTINUE   语句并开始新的迭代： 
 
 
DECLARE @Counter INT 
SET @Counter=1
WHILE ( @Counter <= 20)
BEGIN
 
  IF @Counter % 2 =1
  BEGIN
  SET @Counter  = @Counter  + 1
  CONTINUE
  END
    PRINT 'The counter value is = ' + CONVERT(VARCHAR,@Counter)
    SET @Counter  = @Counter  + 1
END

 
 
 

  
 
 
 
 The following flowchart explains the working logic of the CONTINUE statement example as visually: 
 
 
 以下流程图从视觉上解释了CONTINUE语句示例的工作逻辑： 
 
 
 
 

  
 
 
 

 
  
 
 
 通过WHILE循环读取表记录 (Reading table records through the WHILE loop)
 
 
 In the following example, we will read table data, row by row. Firstly we will create a sample table: 
 
 
 在下面的示例中，我们将逐行读取表数据。 首先，我们将创建一个示例表： 
 
 
USE tempdb
GO
DROP TABLE IF EXISTS SampleTable
CREATE TABLE SampleTable
(Id INT, CountryName NVARCHAR(100), ReadStatus TINYINT)
GO
INSERT INTO SampleTable ( Id, CountryName, ReadStatus)
Values (1, 'Germany', 0),
        (2, 'France', 0),
        (3, 'Italy', 0),
    (4, 'Netherlands', 0) ,
       (5, 'Poland', 0)
 
 
 
  SELECT * FROM SampleTable

 
 
 

  
 
 
 
 In this step, we will read all data row by row with the help of the WHILE loop: 
 
 
 在这一步中，我们将借助WHILE循环逐行读取所有数据： 
 
 
USE tempdb
GO
 
DECLARE @Counter INT , @MaxId INT, 
        @CountryName NVARCHAR(100)
SELECT @Counter = min(Id) , @MaxId = max(Id) 
FROM SampleTable
 
WHILE(@Counter IS NOT NULL
      AND @Counter <= @MaxId)
BEGIN
   SELECT @CountryName = CountryName
   FROM SampleTable WHERE Id = @Counter
    
   PRINT CONVERT(VARCHAR,@Counter) + '. country name is ' + @CountryName  
   SET @Counter  = @Counter  + 1        
END

 
 
 

  
 
 
 
 In this example, we read the table rows via the WHILE loop. We can also develop more sophisticated and advanced loops based on our needs. 
 
 在此示例中，我们通过WHILE循环读取表行。 我们还可以根据需要开发更复杂和更高级的循环。 
 
 
 结论 (Conclusion)
 
 
 In this article, we learned the SQL WHILE loop with quite simple examples. We also virtualized and explained the examples with flowcharts. WHILE loop helps us to achieve iterative operations in SQL Server. At the same time, BREAK and CONTINUE statements can be used to control iteration of the WHILE loop in SQL Server. 
 
 
 在本文中，我们通过非常简单的示例学习了SQL WHILE循环。 我们还通过流程图虚拟化并说明了示例。 WHILE循环可帮助我们在SQL Server中实现迭代操作。 同时，BREAK和CONTINUE语句可用于控制SQL Server中WHILE循环的迭代。 
 
 

  
翻译自: https://www.sqlshack.com/sql-while-loop-with-simple-examples/
 
 
sql while循环