Difference between revisions of "If/fr"

Revision as of 02:04, 8 January 2008

if ( condition ) branche

•	condition	–	Si cette condition est évaluée comme vraie alors branche est exécutée.
•	branche

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