Structures de contrôle

Le langage des fonctions d’extension fournit les instructions habituelles pour contrôler l’exécution du programme.

  • If Then Else
  • While Do and Repeat Until
  • Pour numérique
  • Pause
  • Goto

If Then Else

Si les instructions sélectionnent des blocs d’instructions à exécuter en fonction d’une ou de 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 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.

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 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.

Structures de contrôle