En este capítulo, te explicaré las técnicas de comprobación sucia y de Verknüpfung de datos de accesores y señalaré sus fortalezas y debilidades.
Eine Einführung in die Datenbindung
Die Datenbindung ist eine allgemeine Technik, bei der Datenquellen von Anbietern und Verbrauchern zusammengeführt und synchronisiert werden.
Dies ist eine allgemeine Definition, die die allgemeinen Bausteine von Datenbindungstechniken beschreibt.
- Eine Syntax zum Definieren des Anbieters und des Verbrauchers.
- Eine Syntax zum Definieren, welche Änderungen die Synchronisierung auslösen sollen.
- Eine Möglichkeit, diese Änderungen beim Anbieter zu erfahren.
- Eine Synchronisationsfunktion, die ausgeführt wird, wenn diese Änderungen auftreten. Von nun an werde ich diese Funktion hhandler () andler () aufrufen.
Die obigen Schritte werden auf unterschiedliche Weise unter Verwendung unterschiedlicher Datenbindungstechniken implementiert. In den nächsten Abschnitten werden zwei solche Techniken behandelt, nämlich die Fehlerprüfung und die Zugriffsmethode. Beide haben ihre Stärken und Schwächen, die ich kurz nach ihrer Präsentation erörtern werde.
Schmutzige Kontrolle
Dirty Checking ist wahrscheinlich die beliebteste Methode zur Datenbindung. Das Konzept ist einfach und erfordert keine komplexen Sprachfunktionen. Daher ist es ein guter Kandidat für die Verwendung in Legacy-Versionen.
Syntax
Definir el proveedor y el consumidor no requiere ninguna sintaxis especial, solo objetos simples de Javascript.
const provider = {message: 'Hello World'} const consumer = document.createElement ('p')
Die Synchronisation wird im Allgemeinen durch Eigenschaftsmutationen im Anbieter ausgelöst. Die Eigenschaften, die für Änderungen zu beachten sind, müssen explizit mit ihren zugeordnet werden Handler ().
beobachten (Anbieter, 'Nachricht', Nachricht => {consumer.innerHTML = Nachricht})
Die Funktion Ich beobachtete() Speichern Sie einfach die Zuordnung (Anbieter, Eigenschaft) -> Handler zur späteren Verwendung.
Funktion beobachten (Provider, Prop, Handler) {provider._handlers [prop] = Handler}
Damit haben wir eine Syntax zum Definieren von Anbieter und Verbraucher sowie eine Möglichkeit zum Registrieren von Funktionen Handler () para los cambios de propiedad. La API pública de nuestra biblioteca está lista, ahora viene la implementación interna.
Hören über die Änderungen
Der Dirty Check wird aus einem bestimmten Grund als Dirty bezeichnet. Führen Sie regelmäßige Überprüfungen durch, anstatt direkt auf Eigenschaftsänderungen zu achten. Nennen wir diesen Check von nun an einen Verdauungszyklus. Eine Zusammenfassungsschleife durchläuft jeden Eintrag (Anbieter, Eigenschaft) -> Handler hinzugefügt zu Ich beobachtete() und überprüfen Sie, ob sich der Eigenschaftswert seit der letzten Iteration geändert hat. Wenn es sich geändert hat, führen Sie die Funktion aus Handler (). Eine einfache Implementierung wäre unten zu sehen.
Funktion Digest () {providers.forEach (DigestProvider)} Funktion DigestProvider (Provider) {für (Prop in Provider._Handler einlassen) {if (Provider._prevValues [Prop]! == Provider [Prop]) {Provider._prevValues [Prop] = Anbieter [prop] Handler (Anbieter [prop])}}}
Die Funktion verdauen () Es muss von Zeit zu Zeit ausgeführt werden, um einen synchronisierten Status sicherzustellen.
Die Zubehörtechnik.
Die Zugangstechnik ist der aktuelle Trend. Es wird etwas weniger unterstützt, da es die Get / Set-Funktionalität von ES5 erfordert, aber dies macht dies elegant wieder wett.
Syntax
Das Definieren des Anbieters erfordert eine spezielle Syntax. Das flache Provider-Objekt muss an die Funktion übergeben werden Beobachter (), das verwandelt es in ein beobachtbares Objekt.
const provider = Beobachter ({Begrüßung: 'Hallo', Betreff: 'Welt'}) const consumer = document.createElement ('p')
Diese kleine Unannehmlichkeit wird durch die einfache Mapping-Syntax mehr als wettgemacht Handler (). Bei Dirty Check müssten wir jede beobachtete Eigenschaft explizit wie unten gezeigt definieren.
Beobachter (Anbieter, 'Begrüßung', Begrüßung => {consumer.innerHTML = Begrüßung + '' + provider.subject}) beobachten (Anbieter, 'subject', subject => {consumer.innerHTML = provider.greeting + '' + subject })
Dies ist detailliert und klobig. Die Zugriffstechnik kann automatisch die Eigenschaften des in der Funktion verwendeten Anbieters erkennen handler (), Dies ermöglicht es uns, den vorherigen Code zu vereinfachen.
Observer (() => {consumer.innerHTML = provider.greeting + '' + provider.subject})
Die Implementierung von Ich beobachtete() es unterscheidet sich von der schmutzigen Prüfung. Führen Sie einfach die Funktion aus Handler () bestanden und markiert es als aktuell aktiv, während es ausgeführt wird.
Lassen Sie die Funktion activeHandler beobachten (Handler) {activeHandler = Handler handler () activeHandler = undefined}
Beachten Sie, dass wir hier die Single-Threaded-Natur von JavaScript ausnutzen, indem wir die Single-Variable verwenden activeHandler verfolgen handler () Funktion momentan laufend.
Hören über die Änderungen
Hier ist der Name von "Zubehörtechnik". Der Anbieter wird ergänzt durch Getter / Setter, sie machen das schwere Heben im Hintergrund. Die Idee ist, die Operationen von abzufangen Erhalten / Einstellen von den Anbietereigenschaften wie folgt.
- erhalten: wenn es eine Ausführung gibt activeHandler, Zuordnung speichern (Anbieter, Eigentum) -> activeHandler zur späteren Verwendung.
- einstellen: Führen Sie alle Funktionen aus handler (), die mit dem Paar zugeordnet sind (bieten, Eigentum).
Die Zugriffsdatenverbindungstechnik.
Der folgende Code zeigt eine einfache Implementierung für eine einzelne Anbietereigenschaft.
Funktion ObservableProp (Provider, Prop) {const Wert = Provider [Prop] Object.defineProperty (Provider, Prop, {get () {if (ActiveHandler) {Provider._Handler [Prop] = ActiveHandler} Rückgabewert}, Set (NewValue) {value = newValue const handler = obj._handlers [prop] if (handler) {activeHandler = handler handler () activeHandler = undefined}}})}
Die Funktion beobachtbar () Der im vorherigen Abschnitt erwähnte Vorgang durchläuft die Anbietereigenschaften und macht sie mit der obigen Funktion beobachtbar ObservableProp ().
[/ php]
Funktion beobachtbar (Anbieter) {
für (Prop in Provider lassen) {
ObservableProp (Anbieter, Requisite)
if (Typ des Anbieters [prop] === 'Objekt') {
beobachtbar (Anbieter [Stütze])
}
}
}
[/ php]
Dies ist eine sehr einfache Implementierung, die jedoch für einen Vergleich zwischen den beiden Techniken ausreicht.
Vergleich der Techniken.
In diesem Abschnitt werde ich kurz die Stärken und Schwächen der Dirty Verification- und Access-Technik beschreiben.
Syntax
Die Dirty Check erfordert keine Syntax, um den Anbieter und den Verbraucher zu definieren, sondern weist das Paar zu (Anbieter, Eigentum) Handler () es ist ungeschickt und nicht flexibel.
Für die Zugriffstechnik muss der Anbieter die Rolle anpassen beobachtbar (), aber automatische Zuordnung Handler () macht das wieder wett. Für große Projekte mit Datenbindung ist dies ein Muss.
Performance
Der Dirty Check ist bekannt für seine schlechte Leistung. Sie müssen jeden Eintrag überprüfen (Anbieter, Eigenschaft) -> Handler möglicherweise mehrmals während jedes Zusammenfassungszyklus. Außerdem müssen Sie auch dann schleifen, wenn die App inaktiv ist, da sie nicht erkennen kann, wann Eigenschaftsänderungen auftreten.
Die Zugriffsmethode ist schneller, aber die Leistung kann bei großen beobachtbaren Objekten unnötig beeinträchtigt werden. Das Ersetzen jeder Provider-Eigenschaft durch Accessoren ist im Allgemeinen übertrieben. Eine Lösung wäre, den Baum zu bauen Getter / Setter dinámicamente cuando Sein necesario, en lugar de hacerlo por adelantado en un lote. Alternativamente, una solución más simple es envolver las propiedades innecesarias con una función noObserve (), das sagt beobachtbar () Lass diesen Teil unberührt. Dies führt leider eine zusätzliche Syntax ein.
Flexibilität
Dirty Check funktioniert natürlich sowohl mit expando-Eigenschaften (dynamisch hinzugefügt) als auch mit Zugriffseigenschaften.
Die Zugangstechnik hat hier eine Schwachstelle. Expando-Eigenschaften werden nicht unterstützt, da sie außerhalb des ursprünglichen get / set-Baums liegen. Dies führt beispielsweise zu Problemen mit Arrays, kann jedoch durch manuelles Ausführen behoben werden ObservableProp () nach dem Hinzufügen einer neuen Eigenschaft. Funktionseigenschaften werden seitdem nicht mehr unterstützt Accessoren kann nicht umhüllt werden von Accessoren nochmal. Eine übliche Lösung hierfür ist die Verwendung einer Funktion berechnet () anstelle einer Getter. Dies führt noch mehr benutzerdefinierte Syntax ein.
Zeitalternativen
Der Dirty Check gibt uns hier nicht viel Spielraum, da wir nicht wissen können, wann die tatsächlichen Eigenschaftsänderungen eintreten. Die Funktionen Handler () kann nur asynchron ausgeführt werden Verdauungszyklus () abundzu.
Trigger / Setter, die mithilfe der Accessor-Technik hinzugefügt wurden, werden synchron ausgelöst, sodass wir die freie Wahl haben. Wir können entscheiden, die Datei auszuführen Handler () sofort oder speichern Sie es in einem Stapel, der später asynchron ausgeführt wird. Der erste Ansatz bietet den Vorteil der Vorhersagbarkeit, während der zweite Leistungsverbesserungen durch Eliminieren von Duplikaten ermöglicht.
