Lo stile di programmazione imperativo è stato praticato nello sviluppo web dal 2005 fino al 2013.
Con la programmazione imperativa, abbiamo scritto passo per passo il codice che elencava esattamente cosa dovrebbe fare la nostra applicazione.
Lo stile di programmazione funzionale produce astrazione attraverso modi intelligenti di combinare le funzioni.
Si fa menzione della programmazione dichiarativa nelle risposte e riguardo a ciò dirò che la programmazione dichiarativa elenca alcune regole che dobbiamo seguire. Forniamo quindi ciò che chiamiamo stato iniziale alla nostra applicazione e lasciamo che quelle regole definiscano in che modo si comporta l'applicazione.
Ora, queste descrizioni rapide probabilmente non hanno molto senso, quindi passiamo attraverso le differenze tra programmazione imperativa e dichiarativa camminando attraverso un'analogia.
Immagina che non stiamo costruendo software, ma invece creiamo torte per vivere. Forse siamo dei cattivi fornai e non sappiamo come preparare una deliziosa torta come dovremmo.
Quindi il nostro capo ci fornisce un elenco di indicazioni, ciò che conosciamo come ricetta.
La ricetta ci dirà come fare una torta. Una ricetta è scritta in uno stile imperativo come questo:
- Mescola 1 tazza di farina
- Aggiungi 1 uovo
- Aggiungi 1 tazza di zucchero
- Versare il composto in una padella
- Metti la padella in forno per 30 minuti e 350 gradi F.
La ricetta dichiarativa farebbe quanto segue:
1 tazza di farina, 1 uovo, 1 tazza di zucchero - Stato iniziale
Regole
- Se tutto è mescolato, mettere in padella.
- Se tutto non miscelato, metterlo nella ciotola.
- Se tutto in padella, mettere in forno.
Quindi gli approcci imperativi sono caratterizzati da approcci graduali. Si inizia con il passaggio 1 e si passa al passaggio 2 e così via.
Alla fine si finisce con un prodotto finale. Quindi, facendo questa torta, prendiamo questi ingredienti, li mescoliamo, li mettiamo in una padella e nel forno e ottieni il tuo prodotto finale.
In un mondo dichiarativo, è diverso. Nella ricetta dichiarativa separeremmo la nostra ricetta in due parti separate, iniziamo con una parte che elenca lo stato iniziale della ricetta, come le variabili. Quindi le nostre variabili qui sono le quantità dei nostri ingredienti e il loro tipo.
Prendiamo lo stato iniziale o gli ingredienti iniziali e applichiamo loro alcune regole.
Quindi prendiamo lo stato iniziale e li passiamo continuamente attraverso queste regole fino a quando non otteniamo una torta di fragole al rabarbaro pronta da mangiare o qualsiasi altra cosa.
Quindi, in un approccio dichiarativo, dobbiamo sapere come strutturare correttamente queste regole.
Quindi le regole che potremmo voler esaminare i nostri ingredienti o dichiarare, se mescolate, metterle in una padella.
Con il nostro stato iniziale, ciò non corrisponde perché non abbiamo ancora miscelato i nostri ingredienti.
Quindi la regola 2 dice che se non si mescolano, mescolali in una ciotola. Va bene sì, si applica questa regola.
Ora abbiamo una ciotola di ingredienti misti come il nostro stato.
Ora applichiamo di nuovo quel nuovo stato alle nostre regole.
Quindi la regola 1 dice che se gli ingredienti vengono mescolati mettili in una padella, okay sì ora la regola 1 si applica, facciamolo.
Ora abbiamo questo nuovo stato in cui gli ingredienti vengono mescolati e in padella. La regola 1 non è più pertinente, la regola 2 non si applica.
La Regola 3 dice che se gli ingredienti sono in una padella, mettili nel forno, la regola è ciò che si applica a questo nuovo stato, lascialo fare.
E finiamo con una deliziosa torta di mele calda o altro.
Ora, se sei come me, potresti pensare, perché non stiamo ancora facendo una programmazione imperativa. Questo ha senso.
Bene, per flussi semplici sì, ma la maggior parte delle applicazioni web ha flussi più complessi che non possono essere correttamente catturati dal design della programmazione imperativa.
In un approccio dichiarativo, potremmo avere alcuni ingredienti iniziali o uno stato iniziale come textInput=“”una singola variabile.
Forse l'inserimento del testo inizia come una stringa vuota.
Prendiamo questo stato iniziale e lo applichiamo a una serie di regole definite nella tua applicazione.
Se un utente inserisce del testo, aggiorna l'inserimento del testo. Bene, in questo momento non si applica.
Se il modello è reso, calcola il widget.
- Se textInput viene aggiornato, eseguire nuovamente il rendering del modello.
Bene, nulla di tutto ciò si applica, quindi il programma attenderà semplicemente che si verifichi un evento.
Quindi ad un certo punto un utente aggiorna l'inserimento del testo e quindi potremmo applicare la regola numero 1.
Potremmo aggiornarlo a “abcd”
Quindi abbiamo appena aggiornato il nostro testo e gli aggiornamenti di input del testo, la regola numero 2 non si applica, la regola numero 3 dice se l'input di testo è aggiornato, che si è appena verificato, quindi riutilizza il modello e poi torniamo alla regola 2 che dice se il modello è reso , calcola il widget, ok andiamo a calcolare il widget.
In generale, come programmatori, vogliamo lottare per progetti di programmazione più dichiarativi.
L'imperativo sembra più chiaro ed evidente, ma un approccio dichiarativo si adatta molto bene per applicazioni più grandi.