Ce dont vous parlez, c'est moins de syntaxe que de structure . Vous ne pouvez vraiment avoir qu'une wheninstruction comme celle-ci dans un système qui exécute une quantité finie de logique, puis exécute les wheninstructions, puis boucle et exécute à nouveau la logique, en continuant dans une boucle infinie.
Par exemple, la programmation Windows est généralement "basée sur les événements". S'abonner à l' Clickévénement d' un bouton signifie essentiellement "faire cela lorsque vous cliquez dessus". Cependant, ce qui se passe sous le capot est une boucle de traitement des messages. Windows envoie un message à l'application lorsque l'utilisateur clique sur le bouton et la boucle de traitement des messages dans l'application exécute le gestionnaire d'événements approprié.
Si vous utilisez des événements dans, par exemple, C #, vous pouvez le faire sans boucle de message, mais la limitation est que vous devez déclarer l'événement à l'avance, vous ne pouvez donc pas écrire une wheninstruction artibrary qui surveille tout type de Etat. Vous devez attendre un événement spécifique.
Pour obtenir ce comportement dans une architecture Von Neumann, vous devez exécuter une sorte de boucle infinie qui vérifie toutes les conditions à chaque fois dans la boucle exécutant le code approprié, le cas échéant. En interne, vous obtenez simplement une grande liste de if/ thenou switchdéclarations. La plupart des applications de bureau et des programmeurs Web vomiraient s'ils voyaient une telle construction, donc ce n'est vraiment acceptable que si vous l'enveloppez dans une sorte de sucre syntaxique comme le modèle d'événement Windows (même si c'est ce qui se passe sous le capot).
D'un autre côté, si vous regardez le domaine du développement de firmware embarqué, des cadres en temps réel ou des contrôleurs industriels, ce modèle de programmation est très courant. Par exemple, si vous avez un programme en temps réel, vous voudrez peut-être exprimer:
outputA = input1 && input2
Le code est simple à comprendre (car il est déclaratif). Cependant, pour le faire fonctionner, vous devez l'exécuter en boucle serrée. Vous réévaluez outputAchaque fois à travers la boucle. Beaucoup de programmeurs de bureau ou Web n'aimeraient pas cela parce que c'est inefficace. Pour eux, le seul moment où vous devez réévaluer outputAest le moment input1ou les input2changements. Ils préfèrent voir quelque chose de plus comme vous le décrivez:
when input1 changes
evaluateOutputA()
when input2 changes
evaluateOutputA()
evaluateOutputA()
outputA = input1 && input2
Maintenant, si c'est ce que vous voulez (et personnellement, je ne préfère pas cette idée), et votre objectif est l'efficacité, alors vous devez vous demander ce que le processeur fait sous le capot. De toute évidence, il existe toujours une sorte de boucle en cours d'exécution qui compare les états d'entrée aux états d'entrée précédents à chaque fois et exécute le code approprié chaque fois que l'on change. C'est vraiment moins efficace et plus difficile à lire et plus difficile à entretenir.
D'un autre côté, si le travail que vous avez à faire lorsque des input1changements sont importants, votre whenarticle pourrait avoir un sens. Dans les automates, ce type d'instruction est appelé "détection de front montant". Il enregistre l'état de input1la dernière fois dans la boucle, le compare à la valeur cette fois et exécute la logique si le dernier état était faux et que cet état est vrai.
Si vous n'avez pas d'architecture Von Neumann, alors le jeu change. Par exemple, si vous programmez un FPGA en VHDL , alors lorsque vous écrivez:
outputA = input1 && input2
(... ou quelle que soit la syntaxe VHDL appropriée serait), le FPGA se fait câblé de telle sorte que input1et input2sont câblés à l'entrée d'une porte, et la sortie de la porte est câblé outputA. Ainsi, non seulement le code est facile à comprendre, il est également exécuté en parallèle avec toutes les autres logiques, et il est efficace.
Lorsque vous parlez d'un contrôleur industriel comme un API ou un PAC, programmé dans l'un des cinq langages CEI-61131-3, le cas typique est ce type de disposition:
- Lire les entrées et stocker en mémoire
- Exécuter le programme principal
- Écrire les sorties de la mémoire sur les sorties réelles
- Passez à l'étape 1
Ceci est intégré à l'architecture du système, il est donc prévu que vous écriviez simplement:
outputA = input1 && input2
... et il sera exécuté en boucle continue.
Il existe également des routines d'interruption sur ces machines. Ils ressemblent davantage à une prise en charge matérielle pour l' whenopérateur dont vous parlez. L' interruption matérielle est un moyen d'exécuter du code sur un événement externe. Par exemple, lorsqu'une carte réseau indique qu'elle a des données en attente, le processeur doit normalement lire ces données immédiatement ou vous manquerez d'espace mémoire tampon. Cependant, pour le nombre de fois que vous devez connecter une véritable interruption matérielle, je doute que l'inclusion d'un mot-clé de langue en vaille la peine. Vous seriez limité aux broches d'entrée du processeur et il semble que vous souhaitiez tester l'état du programme interne.
Donc, dans un langage traditionnel (sans boucle serrée qui s'exécute à l'infini), vous devez vous poser la question "quand le code d'évaluation s'exécute"?
Si vous écrivez:
when A do
launchNukes()
... et en supposant qu'il As'agit d'une expression booléenne arbitraire, comment savoir quand réévaluer cette expression? Une implémentation naïve signifierait que vous deviez la réévaluer après chaque écriture de mémoire unique. Vous pourriez penser que vous pouvez le réduire, mais considérez ceci:
when systemTime > actionTime do
launchNukes()
Notez que cela systemTimechange toujours (chaque fois que vous le lirez, vous obtiendrez un numéro différent). Cela signifie que la partie conditionnelle de toutes vos whenclauses doit être réévaluée en continu. C'est presque impossible (et réfléchissez juste une seconde à ce qui se passe si votre expression conditionnelle a des effets secondaires!)
Conclusion
Vous ne pouvez avoir une wheninstruction (comme vous le décrivez) dans une architecture basée sur une boucle infinie qui exécute le programme principal, puis exécute les wheninstructions si les conditions sont passées de false à true sur cette boucle. Bien que cette architecture soit courante dans les appareils embarqués et industriels, elle n'est pas courante dans les langages de programmation à usage général.
select case table1.col1 when 1 then 'Y' else 'N' end as col1_yn from .... Aussi: msdn.microsoft.com/en-us/library/dd233249.aspx Fondamentalement, je ferais une recherche de "quand" en utilisant la recherche de code Google.