observable
1.0.0
Dies ist der Erklärer für den beobachtbaren API -Vorschlag für eine ergonomische und komponierbare Ereignisbehandlung.
EventTarget Integration Dieser Vorschlag fügt EventTarget eine .when() -Methode hinzu, die zu einem besseren addEventListener() wird. Insbesondere gibt es ein neues Observable zurück, das dem Ziel einen neuen Ereignishörer hinzufügt, wenn seine subscribe() -Methode aufgerufen wird. Der Observable ruft mit jedem Ereignis den next() Handler des Abonnenten auf.
Observables verwandeln Ereignisbearbeitung, Filterung und Beendigung in einen expliziten, deklarativen Fluss, der leichter zu verstehen und zu komponieren ist als die heutige imperative Version, die häufig verschachtelte Anrufe an addEventListener() und schwer zu befolgende Rückrufketten erfordert.
// Filtering and mapping:
element
. when ( 'click' )
. filter ( ( e ) => e . target . matches ( '.foo' ) )
. map ( ( e ) => ( { x : e . clientX , y : e . clientY } ) )
. subscribe ( { next : handleClickAtPoint } ) ; // Automatic, declarative unsubscription via the takeUntil method:
element . when ( 'mousemove' )
. takeUntil ( document . when ( 'mouseup' ) )
. subscribe ( { next : e => … } ) ;
// Since reduce and some other terminators return promises, they also play
// well with async functions:
await element . when ( 'mousemove' )
. takeUntil ( element . when ( 'mouseup' ) )
. reduce ( ( soFar , e ) => … ) ; // Imperative
const controller = new AbortController ( ) ;
element . addEventListener ( 'mousemove' , e => {
console . log ( e ) ;
element . addEventListener ( 'mouseup' , e => {
controller . abort ( ) ;
} ) ;
} , { signal : controller . signal } ) ; Verfolgen Sie alle Linkklicks in einem Container (Beispiel):
container
. when ( 'click' )
. filter ( ( e ) => e . target . closest ( 'a' ) )
. subscribe ( {
next : ( e ) => {
// …
} ,
} ) ; Finden Sie die maximale Y -Koordinate, während die Maus niedergeschlagen wird (Beispiel):
const maxY = await element
. when ( 'mousemove' )
. takeUntil ( element . when ( 'mouseup' ) )
. map ( ( e ) => e . clientY )
. reduce ( ( soFar , y ) => Math . max ( soFar , y ) , 0 ) ; Multiplexen ein WebSocket , sodass eine Abonnementnachricht in Verbindung gesendet wird, und eine Meldung unsubsubScription wird an den Server gesendet, wenn sich der Benutzer abmeldet.
const socket = new WebSocket ( 'wss://example.com' ) ;
function multiplex ( { startMsg , stopMsg , match } ) {
if ( socket . readyState !== WebSocket . OPEN ) {
return socket
. when ( 'open' )
. flatMap ( ( ) => multiplex ( { startMsg , stopMsg , match } ) ) ;
} else {
socket . send ( JSON . stringify ( startMsg ) ) ;
return socket
. when ( 'message' )
. filter ( match )
. takeUntil ( socket . when ( 'close' ) )
. takeUntil ( socket . when ( 'error' ) )
. map ( ( e ) => JSON . parse ( e . data ) )
. finally ( ( ) => {
socket . send ( JSON . stringify ( stopMsg ) ) ;
} ) ;
}
}
function streamStock ( ticker ) {
return multiplex ( {
startMsg : { ticker , type : 'sub' } ,
stopMsg : { ticker , type : 'unsub' } ,
match : ( data ) => data . ticker === ticker ,
} ) ;
}
const googTrades = streamStock ( 'GOOG' ) ;
const nflxTrades = streamStock ( 'NFLX' ) ;
const googController = new AbortController ( ) ;
googTrades . subscribe ( { next : updateView } , { signal : googController . signal } ) ;
nflxTrades . subscribe ( { next : updateView , ... } ) ;
// And the stream can disconnect later, which
// automatically sends the unsubscription message
// to the server.
googController . abort ( ) ; // Imperative
function multiplex ( { startMsg , stopMsg , match } ) {
const start = ( callback ) => {
const teardowns = [ ] ;
if ( socket . readyState !== WebSocket . OPEN ) {
const openHandler = ( ) => start ( { startMsg , stopMsg , match } ) ( callback ) ;
socket . addEventListener ( 'open' , openHandler ) ;
teardowns . push ( ( ) => {
socket . removeEventListener ( 'open' , openHandler ) ;
} ) ;
} else {
socket . send ( JSON . stringify ( startMsg ) ) ;
const messageHandler = ( e ) => {
const data = JSON . parse ( e . data ) ;
if ( match ( data ) ) {
callback ( data ) ;
}
} ;
socket . addEventListener ( 'message' , messageHandler ) ;
teardowns . push ( ( ) => {
socket . send ( JSON . stringify ( stopMsg ) ) ;
socket . removeEventListener ( 'message' , messageHandler ) ;
} ) ;
}
const finalize = ( ) => {
teardowns . forEach ( ( t ) => t ( ) ) ;
} ;
socket . addEventListener ( 'close' , finalize ) ;
teardowns . push ( ( ) => socket . removeEventListener ( 'close' , finalize ) ) ;
socket . addEventListener ( 'error' , finalize ) ;
teardowns . push ( ( ) => socket . removeEventListener ( 'error' , finalize ) ) ;
return finalize ;
} ;
return start ;
}
function streamStock ( ticker ) {
return multiplex ( {
startMsg : { ticker , type : 'sub' } ,
stopMsg : { ticker , type : 'unsub' } ,
match : ( data ) => data . ticker === ticker ,
} ) ;
}
const googTrades = streamStock ( 'GOOG' ) ;
const nflxTrades = streamStock ( 'NFLX' ) ;
const unsubGoogTrades = googTrades ( updateView ) ;
const unsubNflxTrades = nflxTrades ( updateView ) ;
// And the stream can disconnect later, which
// automatically sends the unsubscription message
// to the server.
unsubGoogTrades ( ) ; Hier nutzen wir Observable so, dass sie einem geheimen Code entspricht. Dies ist ein Schlüsselmuster, den der Benutzer bei Verwendung einer App klicken könnte:
const pattern = [
'ArrowUp' ,
'ArrowUp' ,
'ArrowDown' ,
'ArrowDown' ,
'ArrowLeft' ,
'ArrowRight' ,
'ArrowLeft' ,
'ArrowRight' ,
'b' ,
'a' ,
'b' ,
'a' ,
'Enter' ,
] ;
const keys = document . when ( 'keydown' ) . map ( e => e . key ) ;
keys
. flatMap ( firstKey => {
if ( firstKey === pattern [ 0 ] ) {
return keys
. take ( pattern . length - 1 )
. every ( ( k , i ) => k === pattern [ i + 1 ] ) ;
}
} )
. filter ( matched => matched )
. subscribe ( ( ) => console . log ( 'Secret code matched!' ) ) ; const pattern = [ ... ] ;
// Imperative
document . addEventListener ( 'keydown' , e => {
const key = e . key ;
if ( key === pattern [ 0 ] ) {
let i = 1 ;
const handler = ( e ) => {
const nextKey = e . key ;
if ( nextKey !== pattern [ i ++ ] ) {
document . removeEventListener ( 'keydown' , handler )
} else if ( pattern . length === i ) {
console . log ( 'Secret code matched!' ) ;
document . removeEventListener ( 'keydown' , handler )
}
} ;
document . addEventListener ( 'keydown' , handler ) ;
}
} , { once : true } ) ;Observable API Observables sind erstklassige Objekte, die komponierbare, wiederholte Ereignisse darstellen. Sie sind wie Versprechen, aber für mehrere Ereignisse und speziell mit EventTarget -Integration sind sie zu Ereignissen, was Versprechen für Rückrufe sind. Sie können sein:
subscribe() übergeben haben.Observable.map() , um ohne ein Netz verschachtelter Rückrufe komponiert und transformiert zu werden Besser noch, der Übergang von Ereignishandlern ➡️ Observables ist einfacher als der EventTarget Rückrufen. Infolgedessen können Entwickler Observable verwenden, ohne Tonnen von Code auf der Plattform zu migrieren, da es sich heute um ein einfaches Drop-In handelt, wo Sie heute Ereignisse bearbeiten.
Die vorgeschlagene API-Form findet sich in https://wicg.github.io/observable/#core-infrastructure.
Der Schöpfer eines beobachtbaren Durchgangs in einem Rückruf, der synchron aufgerufen wird, wenn subscribe() aufgerufen wird. Die Methode subscribe() kann eine beliebige Anzahl von Male aufgerufen werden, und der aufrufe Rückruf legt ein neues "Abonnement" ein, indem der Anrufer von subscribe() als Beobachter registriert wird. In diesem Fall kann das Beobachtbare über den next() Rückruf einer beliebigen Anzahl von Ereignissen den Ereignissen signalisieren, gefolgt von einem einzelnen Aufruf, entweder zu complete() oder error() , wobei der Datenstrom abgeschlossen ist.
const observable = new Observable ( ( subscriber ) => {
let i = 0 ;
setInterval ( ( ) => {
if ( i >= 10 ) subscriber . complete ( ) ;
else subscriber . next ( i ++ ) ;
} , 2000 ) ;
} ) ;
observable . subscribe ( {
// Print each value the Observable produces.
next : console . log ,
} ) ; Während benutzerdefinierte Observables alleine nützlich sein können, ist der primäre Anwendungsfall, den sie freischalten, bei der Ereignishandhabung. Die von der neue EventTarget#when() -Methode zurückgegebene Observables werden nativ mit einem internen Rückruf erstellt, der denselben zugrunde liegenden Mechanismus wie addEventListener() verwendet. Daher registriert das Aufrufen von subscribe() im Wesentlichen einen neuen Ereignishörer, dessen Ereignisse durch die Observer -Handlerfunktionen freigelegt werden und mit den verschiedenen Kombinatoren, die allen Observablen zur Verfügung stehen, komponierbar sind.
Observables können von ihrem nativen Konstruktor erzeugt werden, wie oben oder durch die statische Methode Observable.from() . Diese Methode konstruiert native beobachtbare Objekte aus Objekten, die in dieser Reihenfolge eine der folgenden Angaben sind:
Observable (in diesem Fall gibt es nur das angegebene Objekt zurück)AsyncIterable (alles mit Symbol.asyncIterator )Iterable (alles mit Symbol.iterator )Promise (oder irgendwelche damals) Darüber hinaus kann jede Methode auf der Plattform, die ein beobachtbares als Web -IDL -Argument akzeptieren oder einen von einem Rückruf zurückgeben möchte, dessen Rückgabetyp Observable ist, dies auch mit einem der oben genannten Objekte tun, die automatisch in ein beobachtbares konvertiert werden. Wir können dies auf eine von zwei Arten erreichen, die wir in der beobachtbaren Spezifikation abschließen werden:
Observable Typ zu einem speziellen Web -IDL -Typ erstellen, der dieses ECMAScript -Objekt ➡️ Web IDL -Konvertierung automatisch ausführt, wie für andere Typen.any anzugeben, und haben die entsprechende Spezifikation sofort einen Conversion -Algorithmus auf, den die beobachtbare Spezifikation liefert. Dies ähnelt dem, was der Streams -Standard heute mit asynchronen iterablen macht.Das Gespräch in #60 neigt zur Option (1).
Entscheidend ist, dass Observable "faul" sind, als sie keine Daten abgeben, wenn sie vor dem Abonnement Daten abonniert haben, noch keine Daten in die Schluss stellt. Sie können auch während des Abonnements synchron anfangen, im Gegensatz zu Versprechen, die beim Aufrufen von .then() Handlern immer Mikrotasks anwenden. Betrachten Sie dieses Beispiel:
el . when ( 'click' ) . subscribe ( { next : ( ) => console . log ( 'One' ) } ) ;
el . when ( 'click' ) . find ( ( ) => { … } ) . then ( ( ) => console . log ( 'Three' ) ) ;
el . click ( ) ;
console . log ( 'Two' ) ;
// Logs "One" "Two" "Three" Durch die Verwendung AbortController können Sie sich von einem Observablen abmelden, auch wenn es während des Abonnements synchron ausgibt:
// An observable that synchronously emits unlimited data during subscription.
let observable = new Observable ( ( subscriber ) => {
let i = 0 ;
while ( true ) {
subscriber . next ( i ++ ) ;
}
} ) ;
let controller = new AbortController ( ) ;
observable . subscribe ( {
next : ( data ) => {
if ( data > 100 ) controller . abort ( ) ;
} } , { signal : controller . signal } ,
} ) ; Für einen beobachtbaren Abonnenten ist es entscheidend, einen willkürlichen Teardown -Rückruf registrieren zu können, um alle für das Abonnement relevanten Ressourcen aufzuräumen. Der Abneigung kann innerhalb des Abonnement -Rückrufs registriert werden, der in den Observable Konstruktor übergeben wird. Beim Ausführen (beim Abonnieren) kann der Abonnement -Rückruf eine Teardown -Funktion über subscriber.addTeardown() registrieren.
Wenn der Abonnent bereits abgebrochen wurde (dh subscriber.signal.aborted ist true ), wird der angegebene Abranddown -Rückruf sofort von addTeardown() aufgerufen. Ansonsten wird es synchron angerufen:
complete() nach dem Aufrufen des Abonnenten des Abonnenten (falls vorhanden) des Abonnenten (falls vorhanden)error() , nachdem der Fehlerbehandler des Abonnenten (falls vorhanden) aufgerufen wurde Wir schlagen zusätzlich zur Observable Schnittstelle die folgenden Operatoren vor:
catch()Promise#catch() benötigt es einen Rückruf, der nach den beobachtbaren Quellenfehlern abgefeuert wird. Anschließend wird ein neues beobachtbares, der vom Rückruf zurückgegeben wird, es sei denn, der Fehler wird überlegt.takeUntil(Observable)finally()Promise.finally() nimmt es einen Rückruf ab, der nach Abschluss der Beobachtbaren in irgendeiner Weise abgefeuert wird ( complete() / error() ).Observable zurück, das die genau beobachtbare Quelle widerspiegelt. Der Rückruf wird finally abgefeuert, wenn ein Abonnement für das resultierende Beobachtbare aus irgendeinem Grund gekündigt wird. Entweder unmittelbar nach Abschluss der Quelle oder Fehler oder wenn sich der Verbraucher durch Abbruch des Abonnements abmeldet. Versionen der oben genannten sind häufig in Userland-Implementierungen von Observables vorhanden, da sie aus beobachtbaren Gründen nützlich sind. Zusätzlich zu diesen bieten wir jedoch eine Reihe gemeinsamer Betreiber an, die den vorhandenen Plattformpräzedenzfällen folgen und das Nutzen und die Akzeptanz erheblich erhöhen können. Diese existieren auf anderen iterables und stammen aus dem Vorschlag von TC39 von Iterator Helpers, der den Iterator.prototype die folgenden Methoden hinzufügt.Prototypen:
map()filter()take()drop()flatMap()reduce()toArray()forEach()some()every()find() Und die folgende Methode statisch auf dem Iterator :
from() Wir erwarten, dass Userland -Bibliotheken mehr Nischenbetreiber zur Verfügung stellen, die sich in die Observable API für diesen Vorschlag integrieren und möglicherweise nativ schicken, wenn sie genügend Schwung erhalten, um die Plattform zu absolvieren. Für diesen ersten Vorschlag möchten wir jedoch die Anzahl der Betreiber auf diejenigen beschränken, die dem oben angegebenen Präzedenzfall folgen, ähnlich wie bei der festgelegten Webplattform -APIs, die deklariert und maplike deklariert werden, native Eigenschaften haben, die von der Karte von TC39 inspiriert sind und Objekte festgelegt werden. Daher würden wir die meisten Diskussionen über die Erweiterung dieses Sets als außerordentlich für den ersten Vorschlag betrachten, der für die Diskussion in einem Anhang geeignet ist. Jeder lange Schwanz von Operatoren könnte denkbar folgen, wenn die in diesem Erklärung vorgestellte native beobachtbare API unterstützt wird.
Beachten Sie, dass die Betreiber every() , find() , some() und reduce() return versprechen, deren Planung von der von Observablen unterscheidet, was manchmal Ereignishandler, die e.preventDefault() aufrufen, zu spät laufen. Siehe den Abschnitt "Bedenken", das in Details geht.
Um zu veranschaulichen, wie Observable in die aktuelle Landschaft anderer reaktiver Primitiven passen, siehe die folgende Tabelle, die versucht, zwei weitere Tabellen zu kombinieren, die reaktive Primitive durch ihre Interaktion mit Produzenten und Verbrauchern klassifizieren:
| Singular | Plural | |||
|---|---|---|---|---|
| Räumlich | Zeitlich | Räumlich | Zeitlich | |
| Drücken | Wert | Versprechen | Beobachtbar | |
| Ziehen | Funktion | Asynchronisation Iterator | Iterbar | Asynchronisation Iterator |
Die Plattform in TC39 im Mai 2015 wurden erstmals Observables vorgeschlagen. Der Vorschlag konnte nicht an Traktion gewinnen, teilweise aufgrund einiger Opposition, dass die API geeignet war, ein Primitiv auf Sprachebene zu sein. In dem Versuch, den Vorschlag auf einer höheren Abstraktionsebene zu erneuern, wurde im Dezember 2017 ein Problem eingereicht. Trotz reichlicher Nachfrage des Entwicklers, vieler Diskussion und keine starken Verweigerer war der Vorschlag von DOM Observables meist noch mehrere Jahre (mit einem gewissen Fluss in der API -Design) aufgrund eines Mangels an Implementierer -Priorisierung.
Später im Jahr 2019 wurde ein Versuch, den Vorschlag wiederzubeleben, im ursprünglichen TC39 -Repository zurückzuführen, bei dem einige API -Vereinfachungen und Unterstützung für das synchrone "Firehose" -Problem hinzugefügt wurden.
Dieses Repository ist ein Versuch, dem beobachtbaren Vorschlag wieder Leben zu überdenken, um eine Version davon auf die Webplattform zu versenden.
In der vorherigen Diskussion hat Ben Lesh mehrere benutzerdefinierte Userland -Implementierungen beobachtbarer Primitiven aufgeführt, von denen RXJS mit "47.000.000 Downloads pro Woche " am beliebtesten ist.
start und unsubscribe zur Beobachtung und zum Erwerb des Subscription vor der Rücksendung.Actor , um Abonnements für Änderungen im Zustand zu ermöglichen, wie in ihrem useActor -Haken gezeigt. Die Verwendung eines identischen Beobachtbaren ist auch ein dokumentierter Bestandteil der Access -Status -Maschine Änderungen bei der Verwendung von XState mit SolidJs.{ subscribe(callback: (value: T) => void): () => void } Muster in ihrem Router und DeferredData -Code. Dies wurde von den Betreuern als von beobachtbar inspiriert.{ subscribe(callback: (value: T) => void): () => void } Schnittstelle für ihre Signale.{ subscribe(callback: (value: T) => void): () => void } an mehreren Stellen{ subscribe(callback: (value: T) => void): () => void } .{ observe_(callback: (value: T)): () => void } .| async "Async Pipe" -Funktionalität in Vorlagen.Angesichts der umfangreichen früheren Kunst in diesem Bereich gibt es einen öffentlichen "beobachtbaren Vertrag".
Zusätzlich haben viele JavaScript-APIs versucht, sich an den durch den TC39-Vorschlag von 2015 definierten Vertrag zu halten. Bis zu diesem Zweck gibt es eine Bibliothek, die symbolbeobachtbar ist, dass PonyFills (Polyfills) Symbol.observable , um mit der Interoperabilität zwischen beobachtbaren Typen zu helfen, die genau an der hier definierten Grenzfläche hilft. symbol-observable verfügt über 479 abhängige Pakete auf NPM und wird mehr als 13.000.000 Mal pro Woche heruntergeladen. Dies bedeutet, dass es mindestens 479 Pakete auf NPM gibt, die den beobachtbaren Vertrag in irgendeiner Weise verwenden.
Dies ist ähnlich wie Versprechen/A+ -Paten, die vor Promise entwickelt wurden, als erstklassiger Sprachprimitive in ES2015 übernommen wurden.
Eines der wichtigsten Bedenken, die im ursprünglichen Whatwg Dom-Thread mit vielversprechenden APIs für Observable zu tun haben, wie z. B. dem vorgeschlagenen first() . Die potenzielle Fußgun hier mit mikrotaskischer Planung und Ereignisintegration. Insbesondere würde der folgende unschuldig aussehende Code nicht immer funktionieren:
element
. when ( 'click' )
. first ( )
. then ( ( e ) => {
e . preventDefault ( ) ;
// Do something custom...
} ) ; Wenn Observable#first() ein Versprechen zurückgibt, das bei der Entlassung des ersten Ereignisses auf ein EventTarget entschlossen ist, wird das von Benutzer gelieferte Versprechen .then() Handler ausgeführt:
element.click() )e.preventDefault() bedeutetIn WebIDL nach einem Rückruf wird der HTML -Algorithmus nach dem Ausführen von Skript aufgerufen , und dieser Algorithmus -Aufruf führt einen Mikrotask -Checkpoint aus, wenn der JavaScript -Stack leer ist.
Konkret bedeutet das für element.click() Im obigen Beispiel treten die folgenden Schritte auf:
element.click() wird zuerst ein JavaScript -Ausführungskontext auf den Stapel gedrücktclick -Ereignis -Listener -Rückruf aus (der nativ von der Observable#from() Implementierung erstellt wurde) ein weiterer Kontext der Ausführung von JavaScript auf den Stapel, da WebIDL darauf vorbereitet, den internen Rückruf auszuführenObservable#first() zurückgegeben wurde, sofort behoben wird. Jetzt enthält die Microtask-Warteschlange den Benutzer des Versprechens, then() Handler ist, der das Ereignis nach dem Ausführen storniertclick -Ereignisrückruf ausgeführt wurde, wird der Rest des Ereignispfades fortgesetzt, da das Ereignis während oder unmittelbar nach dem Rückruf nicht abgesagt wurde. Das Ereignis macht alles, was es normalerweise tun würde (senden Sie das Formular, alert() den Benutzer usw.)element.click() enthält, und der endgültige Ausführungskontext wird aus dem Stapel und der Warteschlange für die Mikrotasks gespült. Der von Benutzer gelieferte .then() -Handler wird ausgeführt, wodurch versucht wird, das Ereignis zu spät abzusagen Zwei Dinge mildern diese Sorge. Erstens gibt es eine sehr einfache Problemumgehung, um immer den Fall zu vermeiden, in dem Ihr e.preventDefault() zu spät ausgeführt wird:
element
. when ( 'click' )
. map ( ( e ) => ( e . preventDefault ( ) , e ) )
. first ( ) ; ... oder wenn beobachtbar eine .do() -Methode hatte (siehe whatwg/dom#544 (Kommentar)):
element
. when ( 'click' )
. do ( ( e ) => e . preventDefault ( ) )
. first ( ) ; ... oder durch Änderung der Semantik von first() um einen Rückruf zu nehmen, der einen Wert erzeugt, den das zurückgegebene Versprechen beschließt:
el . when ( 'submit' )
. first ( ( e ) => e . preventDefault ( ) )
. then ( doMoreStuff ) ;Zweitens existiert diese "Eigenart" bereits im blühenden beobachtbaren Ökosystem von heute, und es gibt keine ernsthaften Bedenken oder Berichte dieser Gemeinschaft, die Entwickler konsequent darauf treffen. Dies gibt ein gewisses Vertrauen, dass das Backen dieses Verhaltens in die Webplattform nicht gefährlich ist.
Es gab viele Diskussionen darüber, welcher Standards Veranstaltungsort letztendlich einen Observablen -Vorschlag ausrichten sollte. Der Veranstaltungsort ist nicht belanglos, da er effektiv entscheidet, ob Observablen zu einem primitiven Sprachniveau, dem Promise , das in allen JavaScript-Browser-Engines oder eine Webplattform, die primitiv ist, mit einer wahrscheinlich (aber technisch optionalen ) Berücksichtigung in anderen Umgebungen wie Node.js (siehe AbortController ) geliefert wird (siehe zum Beispiel).
Observables integrieren reibungslos in die Haupt-Event-Emitting-Schnittstelle ( EventTarget ) und die primitive Stornierung ( AbortController ), die auf der Webplattform leben. Wie hier vorgeschlagen, verbinden sich Observables dieser vorhandenen stark vernetzten Komponente aus dem DOM-Standard: Observables hängen von AbortController/AbortSignal ab, die von EventTarget abhängen, und EventTarget hängt sowohl von Observables als auch von ABORTCONTROLLER/AbortSignal ab. Da wir der Meinung sind, dass Observables am besten dort passt, wo seine unterstützenden Primitiven leben, ist der Veranstaltungsort WhatWG Standards wahrscheinlich der beste Ort, um diesen Vorschlag voranzutreiben. Darüber hinaus könnten Nicht-Wir-ECMAS-Einbettder wie Node.js und Deno immer noch in der Lage sein, Observables zu übernehmen, und sie werden wahrscheinlich sogar angesichts ihres Engagements für die Abbrüche und Ereignisse der Webplattform wahrscheinlich.
Dies schließt die zukünftige Standardisierung von Ereignisemittierungs- und Stornierungsprimitiven in TC39 in Zukunft nicht aus, was Observables theoretisch auf später überlagert werden könnte. Aber im Moment sind wir motiviert, Fortschritte in Whatwg zu machen.
Um diese Diskussion zu vermeiden, forderten wir den Leser auf, die folgenden Diskussionskommentare zu sehen: Kommentare:
Dieser Abschnitt enthält eine Sammlung von Webstandards und Standardpositionen, mit denen das Leben des beobachtbaren Vorschlags außerhalb dieses Repositorys verfolgt wird.
Observables sind so konzipiert, dass Ereignisse ergonomischer und komponierbarer werden. Daher sind ihre Auswirkungen auf Endbenutzer indirekt und kommen hauptsächlich in Form von Benutzern, die weniger JavaScript herunterladen müssen, um Muster zu implementieren, für die Entwickler derzeit Bibliotheken von Drittanbietern verwenden. Wie oben im Erklärung erwähnt, gibt es ein florierendes Userland Observables -Ökosystem, das täglich zu einer Menge übermäßiger Bytes führt.
In einem Versuch, den starken Präzedenzfall der Userland der beobachtbaren API zu kodifizieren, speichern dieser Vorschlag, dass Dutzende benutzerdefinierter Implementierungen jeden Tag heruntergeladen werden.
Als API wie EventTarget , AbortController und eine mit Promise S, ermöglicht es den Entwicklern, weniger konform zu erstellen, indem Ereignisabwicklungen erstellt werden, indem sie deklarativ konstruieren, was es ihnen ermöglichen kann, mehr solide Benutzererlebnisse im Web zu erstellen.
