Ho un'applicazione in cui mi piacerebbe aggiungere modi per moduli / componenti esterni per hook durante i processi e il flusso di dati ed eseguire azioni / modificare dati.
Per il primo requisito - eseguire azioni - presumo che lo schema migliore sarebbe quello di emettere eventi e avere altri moduli / componenti di sottoscrivere tali eventi ed eseguire le loro azioni, correggere?
Il secondo requisito è dove diventa molto difficile per me, cercherò di spiegarlo con un esempio:
someObject = {
... // properties and stuff
performComputation: function() {
let data = this.data;
return this.x * data.amount;
}
}
Ora, voglio un modo per eseguire modifiche dinamiche su qualche valore di quella funzione, e forse il valore return . Quello che voglio ottenere è molto simile a ciò che WordPress fa con filter hook . WordPress mantiene una serie di callback per chiamare in un certo ordine per consentire la manipolazione dei dati. Se implemento qualcosa di simile, il mio codice sarebbe simile a questo:
someObject = {
... // properties and stuff
performComputation: function() {
let data = applyFilters('computationData', this.data);
return applyFilters('computationResult', this.x * data.amount);
}
}
e potrei quindi collegarlo utilizzando un'API che sarebbe simile a questa:
addFilter('computationResult', (res) => { return res * 2; });
Questo ovviamente funziona, ma dal fatto che non ho mai visto questo pattern utilizzato in nessuna libreria JS e il fatto che con ore di ricerca non ho trovato nessuno che implementasse un semplice modulo di nodo al riguardo, ho l'impressione che questo potrebbe essere un anti-pattern che dovrei evitare (capisco che può diventare complicato e difficile da eseguire il debug, ad esempio).
Quindi, ecco le mie domande:
- Come si chiama questo modello? Forse non so come cercarlo.
- Questo ha a che fare con Programmazione orientata agli aspetti ?
- Sarebbe un approccio di pattern migliore a cui non sto pensando che soddisfi le mie esigenze? In particolare: (1) aggancio in parti delle applicazioni per manipolare i dati (2) gli hook devono essere aggiunti e rimossi abbastanza spesso durante l'interazione dell'utente con l'applicazione.
Modifica
Sembra che il mio obiettivo venga frainteso, quindi cercherò di spiegarlo meglio. L'invio Osservabile o l'invio Evento mi consente di eseguire codice nell'esecuzione di un altro codice. Tuttavia, il motivo per cui non è abbastanza per me è perché gli osservatori non restituiscono valori che possono essere manipolati.
Come per AOP, come sottolineato dalla risposta di Candied Orange , l'obiettivo non sa che è stato agganciato sopra. Anche questo non è il mio obiettivo.
Il mio obiettivo è che una funzione esporti determinate parti di dati per altre funzioni in hook e manipoli .
Ancora, con un altro esempio di pseudo-codice:
someObject = {
name: "Jim",
greet: function(str) {
let greeting = applyFilters('greeting', str);
return '${greeting} I am ${name}.';
}
}
addFilter('greeting', (str) => { return str.toUppercase(); });
addFilter('greeting', (str) => { return str + "!!"; });
someObject.greet("Hello"); // => HELLO!! I am Jim.
Questo è il tipo di funzionalità di cui ho bisogno e può essere facilmente implementato con iterazioni sui callback come ho detto, ma non sono sicuro che questo sia in alcun modo un buon modello o se ho alternative per raggiungere questo obiettivo.