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

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

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

Exemple :

if headers[name] then

     local next_value_index = #(headers[name]) + 1
     headers[name][next_value_index] = value

else

     headers[name] = {name .. ":" .. value}

end

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

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

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

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

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

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

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

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.