programmez-en-d/operateurs_paresseux.whata

68 lines
2.7 KiB
Plaintext
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

[set
title = "Opérateurs paresseux (''lazy'')"
partAs = chapitre
translator = "Raphaël Jakse, Olivier Pisano"
proofreader = "Stéphane Gouget, Raphaël Jakse"
]
Le évaluation paresseuse consiste à retarder l'exécution d'expressions jusqu'au moment où l'on a besoin du résultat de ces expressions. Les évaluations paresseuses font partie des fonctionnalités fondamentales de certains langages de programmation.
Naturellement, retarder l'exécution d'expressions jusqu'à ce que leurs résultats soient vraiment nécessaires peut rendre les programmes plus rapides.
Le comportement raccourci des opérateurs suivants est conceptuellement similaire aux évaluations paresseuses~ :
- [
L'opérateur [c > ||] (ou)~ : la seconde expression est évaluée seulement si la première est fausse ([c false]).
[code=d <<<
if (uneExpression() || peutNePasÊtreÉvaluée()) {
// ...
}
>>>]
Si le résultat de [c uneExpression()] est [c true], le résultat de l'expression [c > ||] est aussi vrai et la seconde expression n'est pas évaluée.
]
- [
L'opérateur [c &&] (et)~ : la seconde expression est évaluée seulement si la première est vraie ([c true]).
[code=d <<<
if (uneExpression() && peutNePasÊtreÉvaluée()) {
// ...
}
>>>]
Si le résultat de uneExpression est faux ([c false]), le résultat de l'expression [c &&] est également faux et la seconde expression n'est pas évaluée.
]
- [
L'opérateur ternaire [c ?:]~ : soit la première, soit la deuxième expression est évaluée, si la condition est vraie ou fausse, respectivement.
[code=d <<<
int i = condition() ? soitCeci() : soitCela();
>>>]
]
La paresse de ces opérateurs n'est pas seulement une question de performance. Parfois, évaluer une des expressions peut être une erreur.
Par exemple, ci-après, vérifier la condition «~ [* si la première lettre est A]~ » serait une erreur si la chaîne est vide~ :
[code=d <<<
dstring s;
// ...
if (s[0] == 'A') {
// ...
}
>>>]
Pour pouvoir accéder à l'élément d'indice zéro de [c s], il faut d'abord s'assurer que la chaîne contient un tel élément. Pour cette raison, la vérification de condition suivante déplace cette expression logique potentiellement erronée du côté droit de l'opérateur [c &&] afin de s'assurer qu'elle ne sera évaluée que lorsqu'effectuer cette évaluation sera sans risque~ :
[code=d <<<
dstring s;
// ...
if ((s.length >= 1) && (s[0] == 'A')) {
// ...
}
>>>]
Les évaluations paresseuses peuvent également être effectuées par les pointeurs de fonctions, les déléguées ([i delegates]) et les tranches. Nous verrons cela dans un chapitre ultérieur.