Difference between revisions of "If/fr"

Latest revision as of 03:13, 8 January 2008

if ( condition ) branche

•	condition	–	Si cette condition est évaluée comme vraie alors branche est exécutée.
•	branche	–	Peut être une instruction simple, un bloc d'instructions ou une instruction vide.

if ( condition ) branche_vrai else branche_faux

•	condition	–	Si cette condition est évaluée comme vraie alors branche_vrai est exécutée, dans le cas contraire branche_faux est exécutée.
•	branche_vrai	–	Peut être une instruction simple, un bloc d'instructions ou une instruction vide.
•	branche_faux	–	Peut être une instruction simple, un bloc d'instructions ou une instruction vide.

Spécification

**Conditions par type**
Type	Condition
integer	Vrai si non nul.
float	Vrai si non nul.
string	Vrai si sa longueur est non nulle.
key	Vrai seulement s'il s'agit d'une clé valide et différente de NULL_KEY.
vector	Vrai si le vecteur est différent de ZERO_VECTOR.
rotation	Vrai si la rotation est différente de ZERO_ROTATION.
list	Vrai si sa longueur est non nulle.

L'évaluation des opérateurs en LSL n'est jamais court-circuitée. Ainsi :

// Une méthode simple pour vérifier que cette fonction a été appelée.
integer test()
{
    llOwnerSay("Fonction de test appelée !");
    
    return TRUE;
}

default
{
    touch_start(integer nombre_total)
    {
        if (FALSE && test()) // Si cette expression est optimisée par court-circuit, test() ne doit jamais être appelée.
        {
            // On n'arrive jamais ici.
        }
    }
}

Dans un language court-circuité, si le terme de gauche d'un ET logique (&&) vaut FALSE, le terme de droite n'est jamais testé. En effet, le test complet renverra toujours FALSE, quelle que soit la valeur du terme de droite. Comme LSL n'est pas court-circuité, les termes de gauche et de droite sont toujours testés à chaque fois. Le comportement d'une expression court-circuitée peut être simulée en LSL avec des if imbriqués :

default
{
    touch_start(integer nombre_total)
    {
        if (FALSE)
        {
            if (test())
            {
              // On n'arrive jamais ici.
            }
        }
    }
}

Exemples

Instruction if en ligne simple :

if (a == 1) c = b;

Bloc d'instructions if simple :

if (a == 1)
{
    // On fait quelque chose ici.
}

Bloc if/else complexe (une seule ligne de texte est dite dans cet exemple)

if (a == "Loren")
{
    llSay(0, "Lorem ipsum sic amet!");
} else if (a == "Scie")
{
    llSay(0, "Si six cent scies scient six cent cyprès, six cent six scies scient six cent six cyprès.");
} else
{
    llSay(0, "Charabia ou français ?");
}

Instruction if composée :

if (a == 1 && b == c)
{
    // La suite ici.
}

Instructions if imbriquées :

if (a == 1)
{
    if (b == c)
    {
        // La suite ici.
    }
}

Attention aux points-virgules mal placés. Ils peuvent provoquer des comportements étranges et ils ne se gêneront pas pour le faire. Par exemple, si vous placez un point-virgule entre une instruction if et un bloc de code, l'instruction if n'influencera plus l'exécution ou non du bloc de code.

if (a == "Loren");
{
    llSay(0, "Lorem ipsum sic amet!");
}

Ce code s'exécute dans l'ordre suivant :

La ligne if (a == "Loren"); s'exécute ; le point-virgule indique à LSL qu'il s'agit d'une simple instruction if en ligne.
Ensuite il rencontre le début du bloc de code et il en exécute le contenu, quel qu'aie été le résultat de l'instruction if qui précède.

Un autre problème est quand quelqu'un oublie d'utiliser les accolades :

if (a == "Loren")
    llSay(0, "Lorem ipsum sic amet!");
    llSay(0, "Je ne sais pas non plus ce que ça veut dire...");

La source de l'erreur est que l'indentation donne l'impression que les deux commandes llSay sont contrôlées par l'instruction if, alors que seule la première l'est. En fait, si a était égal à "Truc", la seule chose qui serait dite serait "Je ne sais pas non plus ce que ça veut dire...".

If

@@ Line 1: / Line 1: @@
 {{Multi-lang}}
 {{#vardefine:p__desc|
-}}{{#vardefine:p_condition_desc|If this executes as true then '''branch''' is executed.
+}}{{#vardefine:p_condition_desc|Si cette condition est évaluée comme vraie alors '''branche''' est exécutée.
-}}{{#vardefine:p_condition_d_desc| If this executes as true then '''branch_true''' is executed otherwise '''branch_false''' is executed.
+}}{{#vardefine:p_condition_d_desc|Si cette condition est évaluée comme vraie alors '''branche_vrai''' est exécutée, dans le cas contraire '''branche_faux''' est exécutée.
-}}{{#vardefine:p_branch_desc|Can be either a single statement, a block statement, or a null statement.
+}}{{#vardefine:p_branche_desc|Peut être une instruction simple, un bloc d'instructions ou une instruction vide.
 }}{{LSL_Conditional/fr
 |statement=if
 |p1_name=condition
-|p2_name=branch
+|p2_name=branche
 |statement_header
 |statement_desc
-|statement_title=if ( {{LSL Param|condition}} ) {{LSL Param|branch}}
+|statement_title=if ( {{LSL Param|condition}} ) {{LSL Param|branche}}
 |extras=
 {{!}}
 <div id="box">
-== if ( {{LSL Param|condition_d|condition}} ) {{LSL Param|branch|branch_true}} else {{LSL Param|branch|branch_false}} ==
+== if ( {{LSL Param|condition_d|condition}} ) {{LSL Param|branch|branche_vrai}} else {{LSL Param|branch|branche_faux}} ==
 <div style="padding: 0.5em;">
 {{{!}}
 {{LSL DefineRow||condition|{{#var:p_condition_d_desc}}}}
-{{LSL DefineRow||branch_true|{{#var:p_branch_desc}}}}
+{{LSL DefineRow||branche_vrai|{{#var:p_branche_desc}}}}
-{{LSL DefineRow||branch_false|{{#var:p_branch_desc}}}}
+{{LSL DefineRow||branche_faux|{{#var:p_branche_desc}}}}
 {{!}}}
 </div>
 </div>
-|spec=Operators in LSL do NOT short circuit. For example:
+|spec=L'évaluation des opérateurs en LSL n'est jamais court-circuitée. Ainsi :
 {{{!}} style="border-width: 0px;border-spacing: 0px;"
 {{!}}
 <pre>
-// A simple method to say if the method was called.
+// Une méthode simple pour vérifier que cette fonction a été appelée.
-integer test() {
+integer test()
-     llOwnerSay("Test method called!");
+{
+     llOwnerSay("Fonction de test appelée !");
      return TRUE;
 }
-default {
+default
-     touch_start(integer total_number) {
+{
-         if (FALSE && test()) { // If short-circuit optimized then the test() should never be called.
+     touch_start(integer nombre_total)
-             // Will never get here.
+    {
+         if (FALSE && test()) // Si cette expression est optimisée par court-circuit, test() ne doit jamais être appelée.
+        {
+             // On n'arrive jamais ici.
          }
      }
@@ Line 43: / Line 47: @@
 </pre>
 {{!}}}
-In a short-circuited language if the left-hand side of a logical AND (&&) is FALSE the right-hand side is never tested since the entire test would always return a FALSE output no matter what the value of the right-hand side. Since LSL is not short circuited, both the left and the right-hand sides are tested all the time.
+Dans un language court-circuité, si le terme de gauche d'un ET logique (&&) vaut FALSE, le terme de droite n'est jamais testé. En effet, le test complet renverra toujours FALSE, quelle que soit la valeur du terme de droite. Comme LSL n'est pas court-circuité, les termes de gauche et de droite sont toujours testés à chaque fois.
-This can be simulated by using a nested if structure:
+Le comportement d'une expression court-circuitée peut être simulée en LSL avec des '''if''' imbriqués :
 <pre>
-default {
+default
-     touch_start(integer total_number) {
+{
-         if (FALSE) {
+     touch_start(integer nombre_total)
-             if (test()) {
+    {
-               // Will never get here.
+         if (FALSE)
+        {
+             if (test())
+            {
+               // On n'arrive jamais ici.
              }
          }
@@ Line 57: / Line 65: @@
 }
 </pre>
-|examples=Simple inline if statement:
+|examples=Instruction if en ligne simple :
 <pre>
 if (a == 1) c = b;
 </pre>
-Simple block if statement:
+Bloc d'instructions if simple :
 <pre>
 if (a == 1)
 {
-     // Do something here.
+     // On fait quelque chose ici.
 }
 </pre>
-Complex if/else block (only one line of text will be said by this example)
+Bloc if/else complexe (une seule ligne de texte est dite dans cet exemple)
 <pre>
-if (a == "Loren") {
+if (a == "Loren")
+{
      llSay(0, "Lorem ipsum sic amet!");
-} else if (a == "Bob") {
+} else if (a == "Scie")
-     llSay(0, "Babble dabble rabble rouse.");
+{
-} else {
+     llSay(0, "Si six cent scies scient six cent cyprès, six cent six scies scient six cent six cyprès.");
-     llSay(0, "Gobbledygook?  or English?");
+} else
+{
+     llSay(0, "Charabia ou français ?");
 }
 </pre>
-Compounded if statement:
+Instruction if composée :
 <pre>
 if (a == 1 && b == c)
 {
-     // more here.
+     // La suite ici.
 }
 </pre>
-Nested if statements:
+Instructions if imbriquées :
 <pre>
 if (a == 1)
@@ Line 93: / Line 104: @@
      if (b == c)
      {
-         // more here.
+         // La suite ici.
      }
 }
 </pre>
-Watch out for misplaced semicolons.  They can, and will, cause strange things to happen.
+Attention aux points-virgules mal placés. Ils peuvent provoquer des comportements étranges et ils ne se gêneront pas pour le faire.
-For instance: If you place a semicolon between an if statement and a code block, the if statement will not control the execution of the block.
+Par exemple, si vous placez un point-virgule entre une instruction if et un bloc de code, l'instruction if n'influencera plus l'exécution ou non du bloc de code.
 <pre>
@@ Line 107: / Line 118: @@
 }
 </pre>
-This code will execute in the following order:
+Ce code s'exécute dans l'ordre suivant :
-# The line <code>if (a == "Loren");</code> will execute; the semicolon will tell LSL that this is a simple inline if statement.
+# La ligne <code>if (a == "Loren");</code> s'exécute ; le point-virgule indique à LSL qu'il s'agit d'une simple instruction if en ligne.
-# Next it meets the start of the code block and will execute the contents, in this case saying "Lorem ipsum sic amet!", no matter what the outcome of the above if statement.
+# Ensuite il rencontre le début du bloc de code et il en exécute le contenu, quel qu'aie été le résultat de l'instruction if qui précède.
-Another problem happens when someone forgets to use the curly braces.
+Un autre problème est quand quelqu'un oublie d'utiliser les accolades :
 <pre>
 if (a == "Loren")
      llSay(0, "Lorem ipsum sic amet!");
-     llSay(0, "I don't know what it means either...");
+     llSay(0, "Je ne sais pas non plus ce que ça veut dire...");
 </pre>
-The assumption is that because the indentation makes it "look" like both llSay commands are controlled by the if statement, that they are.  In fact, if <code>a</code> was equal to "Joe" then all that would be said is "I don't know what it means either..."
+La source de l'erreur est que l'indentation donne l'impression que les deux commandes llSay sont contrôlées par l'instruction if, alors que seule la première l'est. En fait, si <code>a</code> était égal à "Truc", la seule chose qui serait dite serait "Je ne sais pas non plus ce que ça veut dire...".
 |helpers
 |also_header