Évaluation stricte

L'évaluation stricte, également connue sous le nom d'évaluation hâtive, est la stratégie d'évaluation utilisée par la plupart des langages de programmation fonctionnels où une expression est évaluée dès qu'elle est liée à une variable. L'évaluation stricte est en opposition directe avec l'évaluation paresseuse, où l'évaluation d'une expression est retardée jusqu'à ce que sa valeur soit nécessaire. Haskell est le langage de programmation le plus populaire qui utilise l'évaluation paresseuse. La plupart des langages de programmation utilisent une évaluation stricte des arguments de fonction (parfois appelés paramètres) tels que Java, Scheme (un langage Lisp) et JavaScript.

L'utilisation d'une évaluation stricte donne un code facilement compréhensible en termes d'ordre d'exécution, un processus de débogage plus facile par rapport à d'autres stratégies d'évaluation et la responsabilité des performances du code est transférée au programmeur, ce qui signifie qu'un processus d'optimisation du code minutieux est nécessaire.


Stratégies d'évaluation dans la programmation

Les stratégies d'évaluation sont utilisées dans les langages de programmation pour déterminer quand évaluer les arguments d'un appel de fonction et quel type de valeur passer à la fonction. Il existe de nombreuses stratégies d'évaluation, mais la plupart relèvent de l'une des deux catégories suivantes: évaluation stricte et paresseuse.

Stratégies d'évaluation strictes

  • Appel par valeur: La stratégie d'évaluation la plus courante qui consiste à copier le contenu des paramètres réels dans les paramètres formels. Si la fonction est capable d'attribuer des valeurs à ses paramètres, seule sa variable locale est affectée, ce qui signifie que tout ce qui est passé dans un appel de fonction reste inchangé. L'appel par valeur n'est pas une stratégie d'évaluation unique mais plutôt une famille dans laquelle les arguments d'une fonction sont évalués avant d'être passés à la fonction. Les langages de programmation tels que C, Eiffel et Common Lisp utilisent une stratégie d'appel par valeur.
  • Appel par référence: Une autre stratégie commune. Alors que la stratégie d'appel par valeur copie le contenu du paramètre réel dans le paramètre formel, une stratégie d'appel par référence copie l'adresse du paramètre réel dans le paramètre formel. Une fonction reçoit une référence implicite à une variable utilisée comme argument plutôt qu'une copie de sa valeur. C ++ utilise la stratégie d'appel par référence.

Stratégies d'évaluation paresseuses

  • Ordre normal: Une expression est évaluée en évaluant à plusieurs reprises l'expression réductible la plus à gauche, la plus externe en premier.
  • Appel par nom: Le paramètre réel n'est évalué que s'il est utilisé dans la fonction. Si un paramètre n'est pas utilisé dans le corps de la fonction, il n'est jamais évalué. S'il est utilisé plusieurs fois, il est réévalué à chaque fois qu'il apparaît.
  • Expansion Call-by-Macro: Similaire à l'appel par nom mais évite la substitution. Fournit aux développeurs un mécanisme pour ajouter une nouvelle syntaxe à la grammaire du langage de base appelée macros. Les macros sont développées en code par un préprocesseur de macro.
  • Appel par besoin: Un paramètre est évalué uniquement s'il est utilisé. Une fois la première évaluation effectuée, le résultat est mis en cache, de sorte que d'autres utilisations du paramètre ne nécessitent pas de réévaluation.

Laisser un commentaire