Savez-vous comment utiliser la boucle pour ASP? Ensuite, le rédacteur en chef de Foxin vous expliquera comment utiliser la boucle pour ASP en fonction de son expérience accumulée, pour référence par Friends in Need.
Une boucle fait référence à l'exécution répétée d'un ensemble d'instructions plusieurs fois dans un cas spécifié. Le plus couramment utilisé (pour… Suivant, faire… Loop),
1. Les instructions d'exécution répétées sont appelées instructions de boucle.
Les instructions de boucle peuvent être divisées en trois types:
(1) Répétez l'instruction lorsque la condition n'est pas fausse.
(2) Répétez l'instruction avant que la condition ne devienne vraie.
(3) Répétez la déclaration en fonction du nombre de fois spécifié.
2. Pour… Loop Suivant Si le nombre d'opérations répétés est fixé, en utilisant pour… la boucle suivante est un bon choix. De plus, la boucle pour chaque… NEXT avec une syntaxe très similaire sera également introduite. Il convient aux boucles répétées dans les tableaux ou les ensembles. (I) Pour… Utilisez ensuite la valeur initiale, la valeur finale, la taille des étapes et les variables de boucle dans la syntaxe de… Loop Next pour terminer le travail de comptage répété. Lorsque la boucle est exécutée pour la première fois, la variable de boucle commence à accumuler la taille de l'étape à partir de la valeur initiale jusqu'à ce qu'elle soit égale ou dépasse la valeur finale.
Par exemple:
La valeur initiale est 1, la valeur finale est de 10 et la taille de pas est de 2.
La boucle sera exécutée 5 fois.
Les valeurs de la variable de boucle sont respectivement de 1, 3, 5, 7 et 9.
La sixième fois est que la variable de boucle est accumulée à 11 et a dépassé 10, de sorte que la boucle n'est plus exécutée.
3. La syntaxe de la boucle FOR… est la suivante:
Pour la variable de boucle = valeur initiale à l'étape de la valeur finale étape
Déclarations de programme…
[Sortir pour]
Déclarations de programme…
Suivant
illustrer:
(1) Variable de boucle: cette variable utilise généralement des entiers, mais il peut également être d'autres types numériques si nécessaire, et c'est une variable numérique.
(2) Valeur initiale: il s'agit de la valeur initiale de la variable de boucle, qui est un type numérique. Sa valeur n'est pas nécessairement un entier ou une décimale. VB obtiendra automatiquement un entier pour cela.
(3) Valeur finale: la valeur finale de la variable de boucle, qui est un type numérique. Sa valeur n'est pas nécessairement un entier ou une décimale. VB obtiendra automatiquement un entier pour cela.
(4) Taille de l'étape: le nombre d'incréments des variables de boucle à chaque fois, le type numérique de la taille de l'étape doit être le même que la variable de boucle. La valeur peut être un nombre positif (boucle incrémentielle) ou un nombre négatif (boucle croissante). Lorsqu'il ne peut pas être 0, s'il n'est pas spécifié, la taille du pas est par défaut à 1.
(5) Corps de boucle: une déclaration entre une instruction pour et une instruction suivante peut être une ou plusieurs instructions.
(6), Suivant: est une déclaration de terminal de boucle. La "variable de boucle" après le suivant doit être la même que la "variable de boucle" dans l'instruction FOR.
Par exemple: pour i = 0 à 10 étape 1
......
Suivant
Processus d'exécution:
(1) Attribuez la valeur initiale 1 à la variable de boucle I
(2) Comparez la valeur de I avec la valeur finale 10. Si i> 10, la boucle sautera et exécutera (5), sinon le corps de la boucle sera exécuté.
(3) Ajouter I à une valeur de taille de pas, c'est-à-dire i = i + 1
(4), retour (2) Continuez à exécuter
(5) Exécutez le code après l'instruction suivante
La fonction de ce cycle est de déterminer le nombre de cycles en fonction de la valeur initiale, de la valeur finale et de la taille de l'étape dans l'instruction FOR, et d'exécuter à plusieurs reprises chaque instruction dans le corps de la boucle. Pour… les boucles suivantes suivent le principe de «vérifier d'abord, puis exécuter», c'est-à-dire vérifier si la variable de boucle dépasse la valeur finale,
Décidez ensuite d'exécuter le corps de la boucle. Par conséquent, le corps de boucle ne sera pas exécuté dans les cas suivants,
(1) Lorsque la taille de l'étape est positive, la valeur initiale est supérieure à la valeur finale
(2) Lorsque la taille de l'étape est négative, la valeur initiale est inférieure à la valeur finale
Lorsque la valeur initiale est égale à la valeur finale, une boucle est effectuée, que la taille de l'étape soit positive ou négative.
L'instruction FOR et l'instruction suivante doivent apparaître par paires et ne peuvent pas être utilisées seule, et l'instruction FOR doit être précédée par la déclaration suivante.
La formule générale du nombre de cycles n est:
N = int ((valeur finale valeur initiale) / longueur de pas) + 1
Lorsque la valeur initiale dans la boucle FOR… suivante est inférieure à la valeur finale, la taille de l'étape doit être une valeur positive, indiquant le nombre de petits à grands; Si la valeur initiale est supérieure à la valeur finale, la taille de l'étape doit être définie sur une valeur négative, indiquant le nombre de grands à petits.
Par exemple: lorsque la valeur initiale est inférieure à la valeur finale
La copie de code est la suivante:<%
pour i = 0 à 10 étape 1 'La taille de l'étape par défaut est 1 et vous ne pouvez pas l'écrire
Réponse.write (i & "<br>")
Suivant
%>
Par exemple: lorsque la valeur initiale est supérieure à la valeur finale
La copie de code est la suivante:<%
pour i = 10 à 1 étape -1
Réponse.write (i & "<br>")
Suivant
%>
Lorsque la taille de l'étape est supérieure à 0: lorsque la valeur d'origine est <= valeur finale, l'instruction entre pour… Suivant sera exécutée une fois, puis la variable de boucle sera ajoutée avec la taille de l'étape. S'il est encore inférieur à la valeur finale, l'instruction entre pour… Next sera à nouveau exécutée. Jusqu'à ce que la variable de boucle ne soit accumulée pour être supérieure à la valeur finale, elle sautera de la boucle FOR… suivante.
La copie de code est la suivante:<%
pour i = 1 à 1 étape 0,5
Réponse.write (i & "<br>")
Suivant
%>
Lorsque la taille de l'étape est inférieure à 0: lorsque la valeur d'origine> = valeur finale, l'instruction dans la boucle sera exécutée une fois, puis la variable de boucle sera soustraite de la taille de pas (négative). Si la variable de boucle est toujours> = valeur finale, l'instruction dans la boucle sera à nouveau exécutée et la variable de boucle ne sera pas séparée de la boucle FOR… jusqu'à ce que la variable de boucle soit accumulée à moins de la valeur finale.
Le processus d'exécution des instructions de boucle:
La copie de code est la suivante:<%
pour i = 2 à 1 étape -1
Réponse.write (i & "<br>")
Suivant
%>
4. Le processus d'exécution des instructions de boucle:
(1) Entrez la boucle via l'instruction FOR. Si la valeur initiale, la valeur finale et la taille de l'étape de la variable de boucle sont des expressions arithmétiques, le système calcule d'abord la valeur de l'expression arithmétique, puis attribue la valeur initiale à la variable de boucle et stocke la valeur de la valeur finale et de la taille de pas dans la mémoire
(2) Comparez la valeur de la variable de boucle avec la valeur finale. Lorsque la valeur de la variable de boucle ne dépasse pas la plage de la valeur finale, chaque instruction du corps de boucle sera exécutée en séquence. Si la valeur de la variable de boucle dépasse la plage de la valeur finale, la boucle est sortie et l'instruction suivante de la suivante est exécutée.
(3) Après avoir exécuté chaque instruction dans le corps de la boucle, rencontrez l'instruction suivante, ajoutez la variable de boucle par une valeur d'étape, puis accédez à la valeur finale, comparez, si elle ne dépasse toujours pas le point de départ, exécutez les instructions dans le corps de la boucle, répétez l'exécution jusqu'à ce que la valeur de la variable de boucle dépasse la plage de la valeur finale, mettant fin à la boucle, et exécutez les prochains statuts suivants.
Exemples de classe:
【Exemple 1】
Simple 1 à 10, ajouter 1 à chaque fois en utilisant les caractéristiques du cycle
La copie de code est la suivante:<%
pour i = 0 à 10
sum = sum + i
Suivant
Response.Write (SUM)
%>
Résultat de l'affichage final: 55
【Exemple 2】
La copie de code est la suivante:<%
pour i = 0 à 10 étape 2
Réponse.write (i & "<br>")
Suivant
%>
Résultats de l'affichage final: 0, 2,4, 6, 8, 10
【Exemple 3】
La copie de code est la suivante:<%
pour i = 0 à 10
Réponse.write (i & "<br>")
Si i = 5 alors
sortir pour la boucle d'extrémité forcée
terminer si
Suivant
%>
Dans le programme ci-dessus, je serai accumulé de 1 à 10 et exécuté 10 fois, mais lorsque je suis accumulé à partir de 5, il est conforme à la formule de jugement de i = 5.
Si la sortie de la déclaration est exécutée, la boucle est sautée, donc la page Web finale affiche le résultat "0,1,2,3,4,5", "
【Exemple 4】
La copie de code est la suivante:<%
pour i = 10 à 0 étape -1
sum = sum + i
Suivant
Response.Write (SUM)
%>
Résultat de l'affichage final: 55
5. Utilisons des exemples pour illustrer les différents usages de… Loops Next:
【Exemple 1】
La copie de code est la suivante:<% Pour i = 1 à 10
Response.Write I & ","
Suivant
%>
Le programme ci-dessus ajoutera I, et le I dans la boucle ajoutera 1 à partir de 1, 2, 3, ... à chaque fois, 1, jusqu'à 10 ans et un total de 10 exécutions. Enfin, la page Web affichera "1, 2, 3, 4, 5, 6, 7, 8, 9, 10,"
【Exemple 2】
La copie de code est la suivante:<%
Pour a = 1 à 10 étape 0,5
Response.Write A & ","
Suivant
%>
Dans le programme A ci-dessus, chaque fois sera accumulé de 0,5 et un total de 20 exécutions seront effectuées. Enfin, dans la page Web, le "1, 1,5, 2, 2,5, 3, 3,5 ...
9.5,
【Exemple 3】
La copie de code est la suivante:<%
Pour j = 10 à 1 étape -1
Response.Write J & ","
Suivant
%>
Dans le programme ci-dessus, J sera réduit de 10 à 1, à chaque fois par 1, et enfin sur la page Web, "10, 9, 8, 7, 6, 5, 4, 3, 2, 1,"
【Exemple 4】
La valeur initiale, la valeur finale et la taille de l'étape dans la boucle ne sont lues qu'une seule fois lorsque le programme est exécuté au début, puis même si sa valeur est modifiée dans la boucle, elle n'affectera pas l'exécution de la boucle.
La copie de code est la suivante:<%
StepNum = 1
Endnum = 1
Pour i = 1 pour financer StepNum
Response.Write I & ","
StepNum = StepNum-0.1
Endnum = endnum + 1
Suivant
%>
Dans le programme ci-dessus, la taille des étapes est délibérément réduite de 0,1 à chaque fois dans la boucle et la valeur finale est augmentée de 1 à chaque fois, afin de faire en sorte que je n'atteigne jamais la valeur finale. Cependant, comme la taille de l'étape et la valeur finale ne sont lues qu'une seule fois, elles ne changeront plus, donc le résultat de sortie de ce programme est toujours "1".
【Exemple 5】
Les variables de boucle dans la boucle changent dans la boucle, donc:
La copie de code est la suivante:<%
Pour k = 1 à 10
Response.Write K & ","
Suivant
%>
Le programme ci-dessus ajoutera K, et le K dans la boucle ajoutera 1, 2, 3, ... 1 à chaque fois sera accumulé jusqu'à 10 ans, et un total de 10 exécutions seront effectuées 10 fois et la page Web sera affichée.
Montre "1,2,3,4,5,6,7,8,9,10,
Après avoir lu cet article, savez-vous comment utiliser la boucle pour ASP? Si vous ne comprenez pas, veuillez laisser un message à l'éditeur et l'éditeur vous donnera une réponse détaillée ~