Architettura consigliata per un widget di una tabella interattiva con più comportamenti in Javascript / jQuery

1

Caso d'uso:
Per un'interfaccia utente di amministrazione, voglio un widget di tabella interattiva con un numero di comportamenti:

  • Comprimi / espandi (sì, questo significa che le righe sono una gerarchia)
  • Aggiornamento dei dati in una cella figlio basato su una cella genitrice.
  • Nascondere o rivelare una riga o un intero sotto-albero basato su un aggiornamento del valore.
  • Due o più elementi del form in ogni riga, che possono dipendere l'uno dall'altro. Per esempio. una casella di controllo che farà confusione con il valore di un campo di testo nella stessa riga.
  • Manipolazione DOM sulle righe appena create. Per esempio. la casella di controllo potrebbe essere trasformata in un tipo più visivo di widget. O

In un altro caso d'uso, ho i seguenti comportamenti aggiuntivi:

  • Aggiunta e rimozione di righe, manualmente o automaticamente.
  • Trascina e rilascia le righe. (probabilmente non in combinazione con il collapse / expand, ma chi lo sa)

Il problema:

  • Idealmente, vogliamo che ciascuno di questi comportamenti sia implementato come modulo / plugin separato e indipendente. MA
  • Se un comportamento cambia il DOM, allora altri comportamenti devono saperlo. Per esempio. se inserisci una riga, allora il collasso / espandi deve sapere, per decidere se la nuova riga deve essere mostrata o nascosta. E la riga appena aggiunta ha bisogno di nuovi listener di eventi da vari altri comportamenti.
  • Potrebbero esserci comportamenti innescati dallo stato di altri comportamenti. Per esempio. ogni riga potrebbe contenere un campo di testo e, a seconda del valore, la riga deve essere spostata verso l'alto o verso il basso (trascina / rilascia).

La domanda:

Ho dovuto affrontare questo tipo di problema un paio di volte e generalmente sono riuscito a farlo funzionare. Tuttavia, ho sempre odiato l'architettura che ne è uscita.

Quello che mi piacerebbe è un approccio che consente di creare i diversi comportamenti come moduli indipendenti e quindi in qualche modo collegarli tra loro.

Alcune domande più specifiche:

  • Dove dovrebbero ciascuno dei comportamenti mantenere le informazioni di stato
  • Per quanto riguarda le informazioni di stato per una riga della tabella specifica? Dovrebbe essere memorizzato come variabile sull'elemento DOM? (ad esempio $('tr')[5].isExpanded = true ) o piuttosto in un contenitore di dati nel modulo stesso?
  • Come possono sapere i moduli sugli aggiornamenti DOM?
  • In che modo i moduli devono comunicare tra loro?
  • Come dovrebbe essere strutturato il codice di ogni modulo? Che tipo di API dovrebbe esporre?
  • Come gestire più istanze di questo tipo di widget su una pagina? (In questo caso, le istanze globali non funzionano)

Esempio: link (mi dispiace, tutto quello che ho atm è i moduli Drupal)

    
posta donquixote 02.01.2014 - 22:54
fonte

1 risposta

1

Recentemente ho dovuto sviluppare qualcosa di vagamente simile. Ho finito per usare la fabbrica di widget di jQuery UI, come in, ho sviluppato i widget.

Puoi leggere molto su come funzionano i widget dell'interfaccia utente jQuery. Se vuoi un esempio davvero complicato, guarda il link . Si tratta di un'interfaccia a pagina singola molto moderna creata su jQuery (e un backend server ASP.NET MVC) e risponde a tutti i tipi di domande architettoniche. Nonostante sia ASP.NET MVC, ci sono molti fantastici JavaScript da imparare.

Ecco in poche parole mie. Un widget è un plugin jQuery, ma ha alcune funzionalità di interfaccia utente jQuery aggiunte. Un'istanza del widget non può essere creata da "thin air", viene aggiunta sopra un elemento DOM preesistente. Il widget aggiunge un determinato comportamento in cima a quell'elemento DOM. Questa è una bella architettura a due livelli: l'elemento DOM è la presentazione, l'istanza del widget è la logica dietro di esso.

I widget dell'interfaccia utente jQuery forniscono la separazione di cui hai bisogno. Ogni widget è un modulo diverso, una classe diversa, con un proprio ciclo di vita di costruttore / distruttore, eventi personalizzati, proprietà, opzioni, ecc.

Il fatto che tu voglia ascoltare gli aggiornamenti DOM sembra pessimo. Il DOM non dovrebbe guidare i tuoi widget, dovrebbe essere il contrario. Non dovresti semplicemente aggiungere nuovi elementi DOM, ma dovresti creare un elemento DOM, aggiungere un widget su di esso e lasciare che il widget faccia il lavoro: metti il suo elemento da qualche parte all'interno del documento, notifica altri widget, ecc.

I widget dell'interfaccia utente jQuery supportano l'attivazione di eventi, eventi DOM e anche i tuoi eventi personalizzati. Ti consente di associare liberamente i tuoi widget. Ad esempio, quando si crea il widget A, si potrebbe desiderare di informare il widget B su di esso, questo è un accoppiamento stretto. Invece, il widget A potrebbe innescare un evento, e se c'è un widget B, otterrà il messaggio, questo è un accoppiamento lento. Ciò rende la vita molto più semplice e rende anche i test più facili. C'è un approccio simile in Silk, hanno creato un sistema di notifica degli eventi molto interessante, ma ho scoperto che è troppo complesso per le mie esigenze quando ho pochissimi eventi e sottoscrizioni.

Un'istanza di widget è anche un luogo perfetto per memorizzare il suo stato.

Credo che sia la maggior parte se non tutte le tue domande. Non esitate a fare domande più specifiche. Ho passato molto tempo a pensare all'architettura della mia ricca applicazione, e mi piace molto quello che ho avuto.

    
risposta data 07.01.2014 - 17:56
fonte

Leggi altre domande sui tag