Structures de contrôle
Le langage de la fonction d’extension fournit les instructions habituelles pour contrôler l’exécution du programme.
- If Then Else
- While Do and Repeat Until
- Numeric For
- Break
- Goto
If Then Else
Si les instructions sélectionnent des blocs d’instructions à exécuter en fonction d’une ou plusieurs conditions. Il existe trois formes :
If then Form
if expression then
statements to execute if expression is not false or nil
end
<!--NeedCopy-->
If then else Form
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-->
If then elseif else Form
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 comprise entre parenthèses comme c’est le cas en C et Java.
- Il n’y a pas d’équivalent à l’instruction de commutateur C/Java. Vous devez utiliser une série d’instructions if elseif pour faire l’équivalent.
While Do and Repeat Until
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 tout :
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 sûr, 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 de ces exemples. Lorsqu’une telle fonction est exécutée, Citrix ADC détectera que la fonction ne s’est pas terminée dans un délai raisonnable et la tuera avec une erreur d’exécution :
Cpu limit reached. Terminating extension execution in [[string "function extension function..."]]: line line-number.
sera signalé dans /var/log/ns.log.
Numeric For
Il existe deux types de boucles pour. Le premier est le numérique for, qui est similaire à l’utilisation habituelle de l’instruction for en C et Java. L’instruction numérique pour initialise une variable, teste si la variable a passé une valeur finale, et sinon exécute un bloc d’instructions, incrémente la variable et se répète. La syntaxe de la boucle numérique for est :
for variable = initial, final, increment do
statements in the loop body
end
<!--NeedCopy-->
où initial, final et incrément sont toutes les expressions qui génèrent (ou peuvent être converties en) des nombres. variable est considérée comme locale au bloc d’instruction de boucle for ; elle ne peut pas être utilisée en dehors de la boucle. incrément peut être omis ; la valeur par défaut est 1. Les expressions sont évaluées une fois au début de la boucle. La condition de fin est variable > final si l’incrément est positif et variable < final si l’incrément est négatif. La boucle se termine immédiatement si l’incrément est 0.
Exemple (équivalent aux boucles while et repeat dans la section précédente) :
sum = 0
for i = 1, #a do -- increment defaults to 1
sum = sum + a[i]
end
<!--NeedCopy-->
Le deuxième type de boucle for est le générique pour, qui peut être utilisé pour les types de boucles plus flexibles. Il implique l’utilisation de fonctions, donc sera discuté plus tard après l’introduction des fonctions.
Break
L’instruction break est utilisée dans une boucle while, repeat ou for. Il mettra fin à la boucle et reprendra l’exécution à la première instruction après la boucle. Exemple (également équivalent à la précédente 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 sauter en avant ou en arrière vers une étiquette. L’étiquette est un identifiant et sa syntaxe est ::label::. L’instruction goto est l’étiquette goto. Exemple (une fois de plus é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-->
Il y a eu une controverse depuis longtemps sur l’utilisation de gotos dans la programmation. En général, vous devriez essayer d’utiliser les autres structures de contrôle pour rendre vos fonctions plus lisibles et fiables. Mais l’utilisation judicieuse occasionnelle des gotos peut conduire à de meilleurs programmes. En particulier, les gotos peuvent être utiles pour gérer les erreurs.