Structures de contrôle
Le langage des fonctions d’extension fournit les instructions habituelles pour contrôler l’exécution du programme.
- Si alors sinon
- Tout en faisant et en répétant jusqu’à
- Pour numérique
- Pause
- Goto
Si alors sinon
Si les instructions sélectionnent des blocs d’instructions à exécuter en fonction d’une ou de plusieurs conditions. Il existe trois formes :
Si c’est le cas, formulaire
if expression then
statements to execute if expression is not false or nil
end
<!--NeedCopy-->
Si c’est le cas, sinon, formulaire
if expression then
statements to execute if expression is not false or nil
else
statements to execute if expression is false or nil
end
<!--NeedCopy-->
Si alors sinon sinon Formulaire
if expression1 then
statements to execute if expression1 is not false or nil
elseif expression2 then
statements to execute if expression2 is not false or nil
. . .
else
statements to execute if all expressions are false or nil
end
<!--NeedCopy-->
Exemple :
if headers[name] then
local next_value_index = #(headers[name]) + 1
headers[name][next_value_index] = value
else
headers[name] = {name .. ":" .. value}
end
<!--NeedCopy-->
Remarque :
- L’expression n’est pas entre parenthèses comme c’est le cas en C et Java.
- Il n’existe pas d’équivalent à l’instruction de commutation C/Java. Vous devez utiliser une série d’instructions if elseif pour obtenir l’équivalent.
Tout en faisant et en répétant jusqu’à
Les instructions while et repeat fournissent des boucles contrôlées par une expression.
while expression do
statements to execute while expression is not false or nil
end
repeat
statements to execute until expression is not false or nil
until expression
<!--NeedCopy-->
Exemple pour tandis que :
local a = {1, 2, 3, 4}
local sum, i = 0, 1 -- multiple assignment initializing sum and i
while i <= #a do -- check if at the end of the array
sum = sum + a[i] -- add array element with index i to sum
i = i + 1 -- move to the next element
end
<!--NeedCopy-->
Exemple de répétition :
sum, i = 0, 1 -- multiple assignment initializing sum and i
repeat
sum = sum + a[i] -- add array element with index i to sum
i = i + 1 -- move to the next element
until i > #a -- check if past the end of the array
<!--NeedCopy-->
Bien entendu, il est possible d’écrire une boucle qui ne se termine pas, par exemple, si vous omettez l’instruction i = i + 1 dans l’un ou l’autre de ces exemples. Lorsqu’une telle fonction est exécutée, NetScaler détecte que la fonction ne s’est pas terminée dans un délai raisonnable et la supprime avec une erreur d’exécution :
Cpu limit reached. Terminating extension execution in [[string "function extension function..."]]: line line-number.
sera indiqué dans /var/log/ns.log.
Pour numérique
Il existe deux types de boucles. Le premier est le for numérique, qui est similaire à l’utilisation habituelle de l’instruction for en C et Java. L’instruction numeric for initialise une variable, teste si la variable a dépassé une valeur finale et, dans le cas contraire, exécute un bloc d’instructions, incrémente la variable et répète. La syntaxe de la boucle numérique for est la suivante :
for variable = initial, final, increment do
statements in the loop body
end
<!--NeedCopy-->
où initial, final et incrément sont toutes des expressions qui produisent (ou peuvent être converties en) nombres. La variable est considérée comme locale par rapport au bloc d’instructions for loop ; elle ne peut pas être utilisée en dehors de la boucle. L’incrément peut être omis ; la valeur par défaut est 1. Les expressions sont évaluées une seule fois au début de la boucle. La condition finale est variable > finale si l’incrément est positif et variable < finale si l’incrément est négatif. La boucle se termine immédiatement si l’incrément est égal à 0.
Exemple (équivalent aux boucles while et repeat de la section précédente) :
sum = 0
for i = 1, #a do -- increment defaults to 1
sum = sum + a[i]
end
<!--NeedCopy-->
Le second type de boucle for est le for générique, qui peut être utilisé pour des types de boucles plus flexibles. Cela implique l’utilisation de fonctions, nous en parlerons donc plus tard après l’introduction des fonctions.
Pause
L’instruction break est utilisée à l’intérieur d’une boucle while, repeat ou for. Il mettra fin à la boucle et reprendra l’exécution à la première instruction suivant la boucle. Exemple (également équivalent aux précédents while, repeat et pour les boucles) :
sum, i = 0, 1
while true do
if i > #a then
break
end
sum = sum + a[i]
i = i + 1
end
<!--NeedCopy-->
Goto
L’instruction goto peut être utilisée pour accéder à une étiquette en avant ou en arrière. L’étiquette est un identifiant et sa syntaxe est ::label : :. L’instruction goto est goto label. Exemple (encore une fois équivalent aux boucles précédentes) :
sum, i = 0, 1
::start_loop::
if i > #a then
goto end_loop -- forward jump
end
sum = sum + a[i]
i = i + 1
goto start_loop -- backwards jump
::end_loop::
. . .
<!--NeedCopy-->
L’utilisation de gotos dans la programmation fait l’objet d’une longue controverse. En général, vous devez essayer d’utiliser les autres structures de contrôle pour rendre vos fonctions plus lisibles et plus fiables. Mais une utilisation judicieuse et occasionnelle de gotos peut conduire à de meilleurs programmes. Les gotos peuvent notamment être utiles pour gérer les erreurs.