In che modo la programmazione reattiva è diversa dalla programmazione a evento?
La programmazione guidata dagli eventi ruota intorno ai cosiddetti eventi, che sono cose astratte che i programmi "sparano" quando qualcosa accade. Altri posti nel tuo codice "ascoltano" gli eventi e rispondono con ciò che devono fare quando accade quell'evento. Ad esempio, un evento potrebbe essere "l'utente ha premuto questo pulsante" o "la stampante ha finito di stampare il documento".
La programmazione reattiva riguarda i dati . In definitiva, questo è un caso speciale di programmazione basata sugli eventi. L'evento: i dati sono cambiati. Il gestore di eventi: modifica alcuni altri dati (se applicabile). Questo concetto viene solitamente risolto quando si pensa a un foglio di calcolo. Se si imposta cell1 = cell2 + cell3, in modo imprevisto vengono impostati due gestori di eventi sugli eventi modificati di dati di cell2 e cell3 per aggiornare i dati di cell1. I dati di cell1 non hanno un gestore di eventi di questo tipo, poiché nessuna cella dipende dal suo valore.
TL; DR;
Wikipedia dice che ci sono vari modi per scrivere codice reattivo come imperativo, OORP e funzionale. Voglio sapere se event-driven è solo un altro modo per scrivere codice reattivo?
L'idea della programmazione basata sugli eventi è ortogonale all'idea di imperativo rispetto a OO rispetto a funzionale.
- Imperitive programming: si concentra sulla modifica dello stato del programma per ottenere ciò che si desidera. La maggior parte dei computer è indispensabile (al contrario di declarative programming), mentre i linguaggi di livello superiore sono a volte dichiarativi. La programmazione dichiarativa, al contrario, riguarda il codice di scrittura che specifica COSA vuoi che faccia, piuttosto che COME vuoi che il codice lo faccia.
- Object Oriented programming: si occupa di cosiddetti oggetti o sacchi di dati con metodi associati. Differisce dalla programmazione funzionale perché i metodi sono in grado di accedere ai dati associati agli oggetti.
- Functional programming: si occupa di funzioni riutilizzabili o procedure che prendono input e output. Questo differisce dalla programmazione OO perché le funzioni tradizionalmente non hanno la capacità di associare i dati con una funzione diversa dagli input e dagli output.
Event driven programming: struttura il programma per gestire ("handle") qualcos'altro che accade nel programma (un "evento").In altre parole, le strutture il codice logicamente come questo
When Event1 happens
do A and B
When Event2 happens
do B and C
Ma ci sono molti modi per scrivere questo codice, e infatti molti modi per scrivere il codice in modo imperativo, molti modi di scriverlo in modo funzionale, ecc Qui ci sono alcuni esempi, però.
imperativamente (con un ciclo di eventi):
while(true)
// some other code that you need to do...
if Event1 then
do A
do B
if Event2 then
do B
do C
Object Oriented (con thread in background):
// 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
funzionale (Con il supporto per la lingua per gli eventi)
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)
In che modo la programmazione reattiva è correlata a Promises?
promesse sono un'astrazione del flusso di esecuzione del programma, che può essere riassunta come segue:
- Richiedente: Ogni volta che il gioco è fatto fare quello che stai facendo, mi avrebbe richiamarti?
- Answerer: Sicuro, io prometto
Niente di speciale qui, tranne che è un altro modo di pensare l'ordine in cui viene eseguito il codice. Ad esempio, le promesse sono utili quando si effettua una chiamata a una macchina remota. Con le promesse, puoi dire "richiamami quando torni da questa chiamata remota!". Qualunque libreria tu usi, allora promette che ti richiamerà quando tornerà qualcosa dal computer remoto. Spesso, questo è utile perché ti permette di fare qualcos'altro nel frattempo senza aspettare che la chiamata torni.
Punch line: ci sono molti stili diversi di codice, ma non giocano un ruolo troppo grande nel modello di programmazione guidata da eventi e reattivo. Per quanto ne so, puoi programmare eventi guidati e/o reattivi nella maggior parte delle lingue.
correlati: [Vantaggio della programmazione reattiva funzionale su event-listeners] (http://stackoverflow.com/q/23848221/6445533) – ftor
Check out: https://www.oreilly.com/ideas/reactive-programming -vs-reactive-systems – XML