Pour ceux qui ne le savent pas encore, lorsque vous utiliser des opérateur booléens dans une condtion (&& ou ||), toutes les conditions ne sont pas forcément testées. En effet, une expression booléenne composée uniquement de && est forcément false si un seul de ses éléments est à false. L'évaluation de l'expression d'arrête donc dés qu'un élément false est trouvé. De la même manière, une expression composée de || est true si un seul de ses élements est à true ... :)

L'optimisation de conditions booléennes dans des instructions telles que if(...) ou while(...) passe donc par une estimation des probabilités de chaque expression booléenne unitaire d'être true ou false ... Ainsi, dans une expression &&, nous mettrons en premier les expressions qui ont le plus de chance d'être false, arrêtant ainsi l'évaluation des booléens suivants. 8)

// Retourne true
function getTrue() {
        trace("getTrue");
        return true;
}
// Retourne false
function getFalse() {
        trace("getFalse");
        return false;
}
/* Condition "et" non optimisée
   Les deux fonctions sont appelées */
if (getFalse() && getTrue()) {
        trace("OK");
}
// - Sortie -
// getTrue
// getFalse
/* Condition "et"
   La condition qui a le plus de chances de
   retourner false est mise en premier
   Ainsi, les condtions suivantes ont moins de
   chances d'être executées */
if (getFalse() && getTrue()) {
        trace("OK");
}
// - Sortie -
// getFalse
/* Condition "ou" non optimisée
   Les deux fonctions sont appelées */
if (getTrue() || getFalse()) {
        trace("OK");
}
// - Sortie -
// getFalse
// getTrue
// OK
/* Condition "ou"
   La condition qui a le plus de chances de
   retourner true est mise en premier
   Ainsi, les condtions suivantes ont moins de
   chances d'être executées */
if (getTrue() || getFalse()) {
        trace("OK");
}
// - Sortie -
// getTrue
// OK Dans le cas donné ici, on sait exactement quel booléen va être retourné, mais de manière générale, il s'agit de faire preuve de bon sens. Il s'agit lors de la conception de ces conditions de faire la part entre la charge induite par l'évaluation d'une expression unitaire, et sa probabilité de mettre fin à l'évaluation de l'expression booléenne entière. Parfois, une condition a plus de chances de mettre fin à l'évaluation, mais provoque beaucoup de calculs, alors qu'une autre partie de l'expression est bien plus rapide à calculer, mais moins de chances d'arrêter l'évaluation. Il faut à ce moment la faire a part des choses entre probabilité et temps d'éxecution. 8| La négation "!" peut parfois servir à intervertir l'ordre de calcul, et ainsi inverser les probabilités. L'ordre sera à redéterminer en fonction de ca. :) if (getTrue() && getFalse()) {
        trace("OK");
}
// est équivalent à
if (!getTrue() || !getFalse()) {
        trace("OK");
}

Ce type d'optimisation est souvent négligé, alors que l'utilisation des conditions est trés fréquente en programmation ... Elle s'applique également à la plupart des langages, bien que certains commencent à évaluer les condtions par la fin ...^^