Instructions conditionnelles
Mise à jour : novembre 2007
Les instructions dans le code JScript s'exécutent, par défaut, de façon séquentielle. Toutefois, il est parfois utile de modifier la séquence logique et de transférer le contrôle vers une section non séquentielle du code en fonction de certaines conditions spécifiques. Une structure de contrôle transfère le contrôle du programme à deux emplacements selon que le test de l'instruction conditionnelle est true ou false. Toute expression convertible en valeur booléenne peut être utilisée comme instruction conditionnelle. Vous trouverez ci-dessous quelques-unes des instructions conditionnelles les plus courantes.
Égalité et identité
L'opérateur d'égalité (==) d'une instruction de condition vérifie si les deux arguments qui lui ont été passés ont la même valeur. Il peut éventuellement effectuer une conversion de type pour réaliser une comparaison. L'opérateur d'identité (===) compare la valeur et le type de deux expressions ; la valeur true est retournée uniquement si la valeur et le type de données sont identiques pour les deux opérandes. Notez que l'opérateur d'identité ne fait pas la différence entre les divers types de données numériques.
Le code JScript suivant combine un opérateur d'égalité avec une instruction if qui l'utilise. Pour plus d'informations, consultez Structures de contrôle.
function is2000(x) : String {
// Check if the value of x can be converted to 2000.
if (x == 2000) {
// Check is the value of x is strictly equal to 2000.
if(x === 2000)
print("The argument is number 2000.");
else
print("The argument can be converted to 2000.");
} else {
print("The argument is not 2000.");
}
}
// Check several values to see if they are 2000.
print("Check the number 2000.");
is2000(2000);
print("Check the string \"2000\".");
is2000("2000")
print("Check the number 2001.");
is2000(2001);
Voici le résultat de ce code :
Check the number 2000.
The argument is number 2000.
Check the string "2000".
The argument can be converted to 2000.
Check the number 2001.
The argument is not 2000.
Inégalité et non identité
L'opérateur d'inégalité (!==) retourne le résultat inverse de l'opérateur d'égalité. Si les opérandes ont la même valeur, l'opérateur d'inégalité retourne la valeur false, sinon, il retourne la valeur true. De la même façon, l'opérateur de non-identité (!==) retourne le résultat inverse de l'opérateur d'identité.
Examinons l'exemple de code JScript suivant dans lequel l'opérateur d'inégalité sert à contrôler une boucle while. Pour plus d'informations, consultez Structures de contrôle.
var counter = 1;
// Loop over the print statement while counter is not equal to 5.
while (counter != 5) {
print(counter++);
}
Voici le résultat généré par ce code :
1
2
3
4
Comparaison
Les opérateurs d'égalité et d'inégalité sont utiles dans le cas où une donnée a une valeur particulière. Dans certains cas toutefois, le code doit vérifier si une valeur figure dans une plage spécifique. Il est possible, dans de tels cas, d'utiliser les opérateurs relationnels Inférieur à (<), Inférieur ou égal à (<=), Supérieur à (>), Supérieur ou égal à (>=).
if(tempInCelsius < 0)
print("Water is frozen.")
else if(tempInCelsius > 100)
print("Water is vapor.");
else
print("Water is liquid.);
Court-circuit
Si vous devez tester en même temps plusieurs conditions dont l'une est plus susceptible de se vérifier ou d'échouer que les autres, vous pouvez faire appel à une fonctionnalité appelée « évaluation par court-circuit » pour accélérer l'exécution de votre script et éviter des effets secondaires susceptibles de provoquer des erreurs. Lorsque JScript évalue une expression logique, il se contente de prendre en compte le nombre de sous-expressions requises pour obtenir un résultat.
L'opérateur logique AND (&&) évalue d'abord l'expression de gauche qui lui a été transmise. Si cette expression donne pour résultat la valeur false, le résultat de l'opérateur logique AND ne peut avoir la valeur true quelle que soit la valeur de l'expression de droite. Par conséquent, cette dernière n'est pas évaluée.
Par exemple, dans l'expression ((x == 123) && (y == 42)), JScript commence par vérifier si x a pour valeur 123. Si ce n'est pas le cas, le test portant sur y n'est pas effectué et JScript retourne la valeur false.
De manière similaire, l'opérateur OR logique (||) évalue d'abord l'expression de gauche et, si elle donne pour résultat la valeur true, l'expression de droite n'est pas évaluée.
L'évaluation par court-circuit est intéressante lorsque les conditions à tester font intervenir des appels de fonction ou d'autres expressions complexes. Pour une exécution de script la plus efficace possible, placez en premier les conditions les plus susceptibles d'avoir la valeur true pour l'opérateur logique OR. Pour l'opérateur logique AND, placez en premier les conditions susceptibles de donner false comme résultat.
Le code ci-dessous illustre un des avantages de ce principe : runsecond() ne sera pas exécuté dans l'exemple suivant si la valeur de retour de runfirst() est false.
if ((runfirst() == 0) || (runsecond() == 0)) {
// some code
}
Le code ci-dessous en est un autre exemple : runsecond() ne sera pas exécuté dans l'exemple suivant si la valeur de retour de runfirst() est false.
if ((x == 0) && (y/x == 5)) {
// some code
}
Autres
Toute expression convertible en valeur booléenne peut être utilisée comme instruction de condition. Par exemple, vous pouvez utiliser l'expression suivante :
if (x = y + z) // This may not do what you expect - see below!
Notez que le code ci-dessus ne vérifie pas si x est égal à y + z, étant donné que la syntaxe utilise un seul signe égal (opérateur d'assignation). En revanche, le code ci-dessus assigne la valeur de y + z à la variable x, puis vérifie si le résultat de l'expression entière (la valeur de x) peut être converti en valeur true. Pour vérifier si x est égal à y + z, utilisez le code suivant.
if (x == y + z) // This is different from the code above!