En quoi la programmation réactive est-elle différente de la programmation événementielle?

En quoi la programmation réactive est-elle différente de la programmation événementielle?

La programmation axée sur les événements tourne autour de soi-disant événements, qui sont des choses abstraites qui programment le "feu" quand quelque chose se passe. D'autres endroits de votre code "écoutent" les événements et répondent avec ce qu'ils doivent faire lorsque cet événement se produit. Par exemple, un événement peut être "l'Utilisateur a appuyé sur ce bouton" ou "l'imprimante a terminé d'imprimer votre document".

Offres de programmation réactive avec données. En fin de compte, il s'agit d'un cas particulier de programmation axée sur les événements. L'événement: les données modifiées. Le gestionnaire d'événements: modifiez d'autres données (le cas échéant). Ce concept est généralement éclairci lorsque vous pensez à une feuille de calcul. Si vous définissez {[4] } Cela définit implicitement deux gestionnaires d'événements sur les événements modifiés de données de cell2 et cell3 pour mettre à jour les données de cell1. Les données de cell1 n'ont pas un tel gestionnaire d'événements, car aucune cellule ne dépend de sa valeur.

TL; DR;

Wikipedia dit qu'il existe différentes façons d'écrire du code réactif comme impératif, OORP et fonctionnel. Je veux savoir si événementiel est juste une autre façon d'écrire le réactif de code?

L'idée de programmation événementielle est orthogonale à l'idée d'impératif vs. oo vs. fonctionnel.

• programmation impérieuse : se concentre sur la modification de l'état de votre programme permettra d'atteindre ce que vous voulez. La plupart des ordinateurs sont impératifs (par opposition à programmation déclarative ), alors que les langages de niveau supérieur sont parfois déclaratifs. La programmation déclarative, en revanche, traite de l'écriture de code qui spécifie ce que vous voulez qu'il fasse plutôt que comment vous voulez que le code le fasse.
• O bjectO programmation enrichie : traite de soi-disant objets, ou sacs de données avec des méthodes associées. Diffère de la programmation fonctionnelle parce que les méthodes sont capables d'accéder aux données associées à la objet.
• programmation Fonctionnelle: traite des fonctions réutilisables, ou des procédures qui prennent des entrées et des sorties. Cela diffère de la programmation OO parce que les fonctions n'ont traditionnellement pas la capacité d'associer des données à une fonction autre que les entrées et les sorties.

La programmation événementielle: structures de votre programme afin de traiter ("poignée") autre chose qui se passe dans votre programme (un "événement"). En d'autres termes, les structures votre code logiquement comme ceci

When Event1 happens
    do A and B

When Event2 happens
    do B and C

, Mais il existe de nombreuses façons d'écrire ce code, et en fait plusieurs façons d'écrire le code impérativement, de nombreuses façons de l'écrire fonctionnellement, etc. Voici quelques exemples bien.

Impérativement (avec une boucle d'événement):

while(true)
    // some other code that you need to do...

    if Event1 then
        do A
        do B
    if Event2 then
        do B
        do C

Orienté objet (avec thread d'arrière-plan):

// event queue
events = new EventQueue()

handler = new EventHandler()
// creates background thread
Thread.DoInBackground(handler.listenForEvents(events))

// ... other code ...

// fire an event!
events.enqueue(new Event1())

// other file
class EventHandler
    Func listenForEvents(events)
        while(true)
            while events.count > 0
                newEvent = event.dequeue()
                this.handleEvent(newEvent)
            Thread.Sleep(Time.Seconds(1))

    Func handleEvent(event)
        if event is Event1
            this.A()
            this.B()
        if event is Event2
            this.B()
            this.C()

    Func A()
        // do stuff
        return

    Func B()
        // do stuff
        return

    Func C()
        // do stuff
        return

Fonctionnel (avec prise en charge de la langue pour les événements)

on Event(1) do Event1Handler()
on Event(2) do Event2Handler()

Func Event1Handler()
    do A()
    do B()

Func Event2Handler()
    do B()
    do C()

Func A()
    // do stuff
    return

Func B()
    // do stuff
    return

Func C()
    // do stuff
    return

// ... some other code ...

// fire! ... some languages support features like this, and others have
// libraries with APIs that look a lot like this.
fire Event(1)

Comment la programmation réactive est-elle liée à Promesses?

Les promesses sont une abstraction du flux d'exécution du programme qui peut se résumer comme suit:

• Asker: quand tu auras fini de faire ce que tu fais, tu me rappelleras?
• Answerer: bien sûr, je promets

Rien de vraiment spécial ici, sauf que c'est une autre façon de penser l'ordre dans lequel votre code est exécuté. Par exemple, les promesses sont utiles lorsque vous appelez une machine distante. Avec des promesses, vous pouvez dire " Rappelez-moi quand vous revenez de cet appel à distance!". Quelle que soit la bibliothèque que vous utilisez, promet de vous rappeler quand il récupère quelque chose de la machine distante. Souvent, cela est utile car il vous permet de faire autre chose en attendant sans attendre le retour de l'appel.

Punch line: Il y a beaucoup de styles de code différents, mais ils ne jouent pas un rôle trop important dans le modèle de programmation événementielle et réactive. À ma connaissance, vous pouvez le faire programmation événementielle et / ou réactive dans la plupart des langages.

Pour moi, c'est comme comparer les oranges aux pommes. Essayons de définir d'une manière simple ce qui est quoi et ainsi distinguer les choses:

La programmation réactive est un paradigme de programmation qui est appliqué quand on veut atteindre une fonctionnalité semblable à la liaison de données dans des bibliothèques comme KnockoutJS. Un exemple serait également les formules Excel: toutes les cellules sont comme des variables en mémoire. Il y a ceux qui contiennent simplement des données et ceux qui sont calculés à partir de ces données. Si l'ex-change, tardif. Faites attention que le paradigme concerne la mise en œuvre de niveau inférieur; quand quelqu'un parle de programmation réactive, il se réfère aux données, à ses changements et à ce qui se passe quand il mute.

D'autre part, la programmation axée sur les événements concerne l'architecture du système. Selon ce paradigme, les événements et les gestionnaires d'événements sont à la base d'un système et tout est construit sur et autour d'eux. Des exemples courants seraient L'interface utilisateur et le multiplexage de serveur web. Vous sentez-vous comment tout cela est-il différent? Le paradigme est appliqué au niveau d'un système entier ou d'un sous-système.

Comment la programmation réactive est-elle liée aux promesses? Je pense que promises est une alternative à l'enfer axé sur les événements et le rappel.

Promise est un outil pour atteindre la concurrence et l'ordre d'exécution spécifique. Il peut être utilisé dans un paradigme.

En pratique, les paradigmes servent des buts différents et à différents niveaux. Vous pouvez avoir une conception axée sur les événements avec quelques bits de réactif code. Vous pouvez avoir un système distribué qui utilise des modèles de conception. Cependant, les événements sont finalement concept de niveau supérieur. Reactive concerne les données et leur réévaluation, une approche pour la mise en œuvre ou son détail, et les événements sont quelque chose qui provient naturellement d'un cas et qui guide votre conception.

La programmation réactive est tout au sujet des flux, elle pourrait être des flux d'événements, ou toute autre chose. C'est en émettant / annonçant ces flux ou en s'abonnant / en regardant ces flux ou les transformations de flux qui mènent à certains événements. Donc, les deux paradigmes de programmation sont liés.