Was ist der Unterschied zwischen Versprechen und Observablen?

Kann mir bitte jemand erklären den Unterschied zwischen Promise und Observable im Eckigen?

Ein Beispiel zu jedem wäre hilfreich beim Verständnis der Fälle.
In welchem Szenario können wir jeweils?

  • Ich würde dir empfehlen, diesen Beitrag zu Lesen; Angular2 Versprechen vs beobachten
  • in einfacheren Worten Winkel-2-Trainings-Buch.rangle.io/handout/observablen/...
  • Zu jeder der Lektüre dieses Q&A - als jemand, der beteiligt ist in beiden Welten zu Hause von einem Betreuer, Lautsprecher und long-time-user PoV-ich möchte Sie ermutigen, Lesen Sie die offiziellen RxJS docs und die MDN-Dokumentation verspricht. ich persönlich finde die Antworten hier völlig irreführend und falsch und glauben, dass Sie, während Sie mit guten Absichten von Menschen, die versuchen zu helfen, sehr schädlich.
  • Ich schlage vor, Sie Lesen Sie diese eckige offiziellen Dokument Winkel.io/guide/Vergleich-observablen
InformationsquelleAutor Rohit | 2016-05-21
  1. 1338

    Versprechen

    Einen Promise verarbeitet einzelnes Ereignis, wenn eine asynchrone operation abgeschlossen wird oder fehlschlägt.

    Hinweis: Es gibt Promise Bibliotheken gibt, die Unterstützung Stornierung, aber ES6 Promise nicht so weit.

    Beobachtbaren

    Einer Observable ist wie ein Stream (in vielen Sprachen) und ermöglicht die übergabe von null oder mehr Ereignisse, bei denen der callback wird aufgerufen, für jedes Ereignis.

    Oft Observable ist bevorzugt über Promise weil es bietet Ihnen die Funktionen von Promise und mehr. Mit Observable ist es egal, ob Sie möchten, um zu behandeln, 0, 1, oder mehrere Ereignisse. Sie können verwenden die gleiche API in jedem Fall.

    Observable hat auch den Vorteil, über Promise werden stornierbar. Wenn das Ergebnis einer HTTP-Anfrage an einen server oder eine andere teure async operation ist nicht mehr nötig, die Subscription einer Observable ermöglicht, das Abonnement zu kündigen, während eine Promise wird schließlich rufen Sie den Erfolg "oder" fehlgeschlagen Rückruf, auch wenn Sie nicht brauchen, die Mitteilung oder das Ergebnis, es bietet mehr.

    Beobachtbaren bietet Betreiber wie map, forEach, reduce, ... ähnlich wie ein array

    Gibt es auch mächtige Operatoren wie retry() oder replay(), ... das sind oft ganz praktisch.

    • So gibt es einen guten Grund für die Verwendung Versprechen statt der Beobachtbaren in die einzelnen callback-Fall oder sollte Observablen auch verwendet werden, da Sie arbeiten können, die Möglichkeit zu? Im Grunde ist es gute Praxis "Beobachten alle Dinge" oder Versprechen immer noch seinen Platz haben?
    • Wenn Sie möchten, verwenden Sie die reaktiven Stil, nur mit observablen überall. Wenn Sie observablen nur können Sie leicht verfassen. Wenn Sie mischen Sie es so nicht mehr sauber. Wenn Sie nicht kümmern, über reaktive Stil, die Sie verwenden können, Versprechen für einzelne Veranstaltungen, bei denen Sie don ' T care über stornierbar und beobachten für-streams von Veranstaltungen.
    • Für ein gutes intro Ressource auf Observablen/RxJs/Reaktive Programmierung: gist.github.com/staltz/868e7e9bc2a7b8c1f754 ("Die Einführung in die Reaktive Programmierung haben Sie vermisst")
    • Ich stellte die gleiche Frage über eine Woche oder zwei Wochen. Hat eine Menge Forschung. Soweit ich bin besorgt, es gibt einfach NICHT einen guten Grund für die Verwendung von Observablen über Verspricht für http. Keine der Vorteile wirklich relevant sind hier in der Praxis. Mit dieser sagte, nun, ich verstehe die Observablen, ich bin zu faul zu schreiben "toPromise()"
    • was sind die Argumente gegen Observable oder warum denkst du, dass die Argumente für Observable sind nicht gültig oder nicht stark genug?
    • Hey - ich habe keine Argumente gegen Observablen oder funktionale Programmierung. Ich bin einfach nur besagt, dass ich glaube, dass die Menschen laufen in die Observablen hauptsächlich über http in NG2 haben keinen wirklichen Grund Sie zu verwenden Observablen über Versprechungen, die Anrufe zu bilden. Sie nichts verlieren praktisch durch Verwendung verspricht. Die debounce-und wiederholen-Betreiber sind irrelevant - Sie können debounce mit ng-debounce-und wenn ein Anruf erwartet wird, zu scheitern, in der Regel, es ist ein problem mit dem code. Die einzige Zeit, die ich zum arbeiten brauchte, wiederholt, fordert, wurde beim Abfragen instabil third-party-APIs für die HVT.
    • Und nur um zu betonen, diese wieder - ich Stimme völlig mit Ihrer Erklärung und Sie half mir eine Menge, während ich anfangen. Ich sage nur es gibt keinen signifikanten Mehrwert in DIESEM speziellen Anwendungsfall - Ihre Antwort (und einige andere von Ihnen zu dem Thema) sind alle großartig.
    • Ich bin damit einverstanden, dass in der normalen Fällen gibt es nicht viel Unterschied. Für komplexere Szenarien kann es IMHO durchaus einen Unterschied. Auch die Http API ein bisschen ändern, im Laufe der Zeit und machen bessere Nutzung von Observables . Http ist noch sehr basic.
    • Ich würde auch nicht sagen, dass die Verwendung toPromise ist eine schlechte Idee. Nur wenn Sie mit Observables überall reative-wie Programmierstil, das kann wirklich sein potential zeigen. Vielen Dank für Ihr feedback. Ich wusste gar nicht wahrnehmen, es als Kritik. Ich bin nur neugierig, was Sie gelernt haben, und vielleicht teilen können, etwas neues für mich.
    • Vielleicht hast du Recht - dies ist nur meine Meinung aus der Arbeit mit Beobachtbaren http-Aufrufe in NG2 und Tonnen von Erfahrung mit standard verspricht in der NG1. Ich habe auch am Ende der Einnahme von 2 Klassen auf RxJS, seit wir zuletzt gesprochen, also ich habe das Gefühl, einen guten Griff auf, was Observablen liefern.
    • Ich bin damit einverstanden - ich sehe die Vorteile von Beobachtbaren über Versprechen, aber es gibt oft Zeiten, wo es eine einzelne callback-und das ist es. In diesem Fall denke ich, Beobachtbare erzeugt code, der ist etwas schwieriger zu verstehen, so dass ich nur toPromise() in diesem Fall. Mischen tut weh Konsistenz ein wenig. Im Grunde keine richtige/falsche Antwort IMO.
    • Re: die Versprechen können nicht storniert werden. Ist das nur im Winkel 2? In angularJS, verspricht gekündigt werden kann, mit timeout-parameter.
    • Sie können gemacht werden, um mit einem Fehler vorzeitig, aber nicht, dass Sie den Vorgang Abbrechen.
    • Kann mir jemand sagen, wie die Möglichkeit zum Abbrechen einer Observable ist ein Vorteil gegenüber Promises? Bei der Verwendung verspricht, ich kann Kette Sie an und kontrollieren Sie, ob das nächste Versprechen in der Kette gefeuert werden sollte oder nicht.
    • Ein Promise (ES6) können nicht storniert werden während der Wartezeit für eine asynchrone Aufruf abgeschlossen, während Beobachtbar macht. Diese Kündigung könnte zu propagieren, zurück zu den Produzenten des async-Ergebnis und vielleicht sogar aufhören, eine teure Berechnung, während eine Promise würde immer noch die teure Berechnung, auch wenn der Empfänger bereits beschlossen, nicht daran interessiert sein, das Ergebnis mehr und nicht warten, bis es.
    • In Szenarien, In denen mein api-Aufruf gibt eine einzige Sache (dh ein JSON-Objekt oder ein array von Objekten) habe ich mich mit einem "hot" zu beobachten. vendors: Observable<any> = this.http.get(url).map(res => res.json()).publishLast().refCount(); Die kühle Sache über die Verwendung von Beobachtbaren in diesem Fall können Sie abonnieren, um es in mehreren Orten und es wird nicht requery. Jedenfalls nur ein Grund für die Verwendung von Observablen.
    • Aber bitte nicht vergessen, dass Promise zusammen mit async/await lässt sich der code wieder flach! In der Mehrheit der Situationen, und in Projekten, beschäftigen sich nicht mit Wissenschaft, gibt es keine Notwendigkeit zu schreiben, diese schrecklichen verschachtelte Funktionen mit unnötig komplizierten Ketten von Methoden. Sie können async/await heute mit transpilers, wie TypeScript und schreiben tatsächlichen lesbare Flachbild-code ohne die rxjs boilerplate. Sie wird vermutlich noch rxjs manchmal in ausgewählten Situationen, denn es hat wirklich eine Menge Dinge zu bieten.
    • Diese Antwort ist irreführend, eine beobachtbare ist nicht wie ein Strom, es ist wie ein - Funktion zurückgibt, die einen stream.
    • in meiner Erfahrung, die Verschachtelung bei der Verwendung rxjs passiert nur, wenn etwas falsch. Wenn richtig gemacht, die Sie nur selten benötigen mehr als eine Stufe der Einrückung wie die pipeline ist ein ziemlich starkes Konzept. Die Verschachtelung geschieht vor allem, wenn Sie abonnieren, um alles, was anstelle der Verkettung observablen.
    • wenn nur einzelne Wert zurückgegeben Promise oder Observable jeder kann verwendet werden. Wenn stream von Werten wird zurückgegeben, das ist, wo Observable Glanz und auch mit einigen Zusatz features, die es hat mit retry(), forEach, calcelable etc. Ich bin etwas newbie auf diesem, so können Sie bitte ein Beispiel, wo eine api würde die Rückkehr stream von Werten? Auch jedes Beispiel, wo api-Anforderung müssen abgebrochen werden?
    • api Anfrage muss abgesagt werden", wenn Sie eine teure Anfrage an einen server, und der Benutzer navigiert Weg von der aktuellen route, könnten Sie Abbrechen möchten bitte. "Strom der Werte" ein einfaches Beispiel wäre ein Dienst, der es ermöglicht die isLoggedIn Zustand. Eine Komponente oder ein service wünschen konnte, um über änderungen informiert. Die Komponente oder der Dienst abonniert, um eine Beobachtbare und wird informiert, wenn der Benutzer anmeldet oder aus. Ein weiteres Beispiel wäre ein Fortschrittsbalken Komponente übergeben bekommt eine Beobachtbare bietet die Fortschritt-updates.
    • Sie machen eine teure Anfrage an einen server, und der Benutzer navigiert Weg von der aktuellen route, könnten Sie Abbrechen möchten, der Wunsch", wie dieser Antrag kann storniert werden?
    • speichern Sie das Abonnement und abbestellen stornieren, stackoverflow.com/questions/42664741/...
    • Oder Sie können takeUntil das finde ich sauberer und einfacher zu verwenden, aber es hängt davon ab, welchen Rahmen Sie verwenden. In Eckigen verwenden Sie es in Kombination mit ngOnDestroy zum Beispiel.
    • Abbrechen eines Versprechen ist der falsche Weg, um darüber nachzudenken verspricht. Das Versprechen, die Verantwortung, die es nur zu erfassen Erfolg oder Misserfolg in einer async-kompatiblen Art und Weise. Wenn Sie kündigen möchten, eine http-Anforderung, die Sie die Anforderung Abbrechen, nicht das Versprechen, und machen das Ergebnis zu annullieren entweder zu erfüllen oder abzulehnen, die Versprechen. jsfiddle.net/greggman/ea0yhd4p
    • Ich konnte nicht mehr Zustimmen. Dies ist einer der verwirrendsten Teile der Verwendung von Observablen und ich denke, dass es wirklich, die hier angesprochen werden sollten. Die Tatsache, dass das abonnieren eines Beobachtbaren Nebenwirkungen haben können (aber nicht immer) ist der Hauptgrund, warum ich nicht gerne mit Ihnen.
    • Kopiert Inhalte von hype.codes/Unterschiede-zwischen-Versprechen-und-beobachten-Winkel
    • danke für den Hinweis it out. Ich habe nicht gefunden, einen Weg, um einen Kommentar zu hinterlassen. Ich genieße gerade, dass diese Antwort so populär geworden, dass einige finden, die es lohnt zu stehlen 😀
    • können Sie näher erläutern, ein wenig über "stream"? Ich meine, erwarten Sie, dass der server gerade geschoben Zeug an den client? Nicht 99% der web-Anwendungen verlangen eine einzelne Sache, die vom server und dann verarbeiten?
    • Beobachtbare und Versprechen nichts zu tun haben mit client und server, Sie sind nur über async Ergebnisse (das kann oder kann nicht kommen aus einer Antwort auf eine server-Anfrage. Versprechen für eine async-Ergebnis, während Beobachtbar ist über eine Reihe von Ergebnissen (null oder mehr), die kommen im Laufe der Zeit. Wie zum Beispiel aus dem DOM onLoad (Versprechen - genau einmal) oder mouseMove (Beobachtbare - Reihe von Ergebnissen, bis Sie sich vom Newsletter Abmelden)
    • Sobald Sie verstanden haben, sowohl die, Verwendung reduziert sich der Anforderung. Wie, was, wenn Sie nur wollen, um 1 http-request und die Wiederverwendung der Antwort in mehreren Orten und zu verschiedenen Zeiten - das ist, weil, wie schon erwähnt, eine observable ist ein "stream".
    • Wirklich interessant zu Lesen. Wäre das nicht eine gute design-Muster zu erstellen, alle Http Anfragen Observables innerhalb des Dienstes und bei der Verwendung in Komponenten, können Sie entweder verwenden Sie es als standard - Observable oder verwenden Sie es als eine Promise durch die Verwendung .toPromise()
    • Ich denke, das ist genau der Grund, warum Angular verwendet Beobachtbaren, für (one-shot) von HTTP-Anfragen. Natürlich können Sie Folgen Sie diesem Muster in Ihrem eigenen code. Dies ermöglicht die einfache Kombination mit allen rxjs Betreiber.

    InformationsquelleAutor Günter Zöchbauer
  2. 288

    Beide Promises und Observables uns mit Abstraktionen, die uns helfen, befassen sich mit der asynchrone Natur unserer Anwendungen. Der Unterschied zwischen Ihnen war, deutete eindeutig durch @Günter und @aufgrund der Kr.

    Da ein code-snippet, das ist mehr Wert als tausend Worte, lassen Sie uns gehen Sie durch das folgende Beispiel zu verstehen, Sie leichter.

    Danke @Christoph Burgdorf für das tolle Artikel

    Winkel verwendet Rx.js Observablen anstelle der Versprechen, die für den Umgang mit HTTP.

    Angenommen, Sie bauen eine Suchfunktion das sollte zeigen Ihnen sofort Ergebnisse während der Eingabe. Klang vertraut, aber es gibt eine Menge von Herausforderungen, die sich mit dieser Aufgabe.

    • Wollen wir nicht zu schlagen, die server-Endpunkt jedes mal, wenn Benutzer eine Taste drückt, sollte es überschwemmen Sie mit einem Sturm von HTTP Anfragen. Im Grunde wollen wir nur schlagen, sobald der Benutzer aufgehört hat, die Eingabe statt mit jedem Tastenanschlag.
    • Nicht auf der Suche Endpunkt mit der gleichen query params für nachfolgende Anfragen.
    • Deal mit out-of-order-Antworten. Wenn wir mehrere Anfragen von in-flight in der gleichen Zeit, die wir berücksichtigen müssen, für die Fälle, wo kommen Sie wieder in unerwarteten Reihenfolge. Man Stelle sich vor wir zuerst geben computer, zu stoppen, ist eine Anfrage raus geht, geben wir Auto, zu stoppen, ist eine Anfrage raus geht. Jetzt haben wir zwei Anfragen im Flug. Leider ist die Anfrage trägt die Ergebnisse für computer zurück kommt, nachdem die Anforderung führt, dass die Ergebnisse für Auto.

    Die demo wird einfach aus zwei Dateien: app.ts und wikipedia-service.ts. In einem realen Szenario würden wir wahrscheinlich aufteilen, Dinge weiter oben, obwohl.

    Unten ist Versprechen-basierend Umsetzung, dass nicht der Griff einer der beschriebenen Sonderfälle.

    wikipedia-service.ts

    import { Injectable } from '@angular/core';
import { URLSearchParams, Jsonp } from '@angular/http';

@Injectable()
export class WikipediaService {
  constructor(private jsonp: Jsonp) {}

  search (term: string) {
    var search = new URLSearchParams()
    search.set('action', 'opensearch');
    search.set('search', term);
    search.set('format', 'json');
    return this.jsonp
                .get('http://en.wikipedia.org/w/api.php?callback=JSONP_CALLBACK', { search })
                .toPromise()
                .then((response) => response.json()[1]);
  }
}

    Sind wir die Injektion der Jsonp service, um einen GET Antrag gegen die Wikipedia-API mit einem bestimmten Suchbegriff. Beachten Sie, dass wir nennen toPromise um von einem Observable<Response> zu einem Promise<Response>. Schließlich am Ende mit einem Promise<Array<string>> als Rückgabe-Typ der unsere such-Methode.

    app.ts

    //check the plnkr for the full list of imports
import {...} from '...';

@Component({
  selector: 'my-app',
  template: `
    <div>
      <h2>Wikipedia Search</h2>
      <input #term type="text" (keyup)="search(term.value)">
      <ul>
        <li *ngFor="let item of items">{{item}}</li>
      </ul>
    </div>
  `
})
export class AppComponent {
  items: Array<string>;

  constructor(private wikipediaService: WikipediaService) {}

  search(term) {
    this.wikipediaService.search(term)
                         .then(items => this.items = items);
  }
}

    Nicht viel von einer überraschung, die hier entweder. Wir Spritzen unsere WikipediaService aussetzen und seine Funktionalität über eine such-Methode, um die Vorlage. Die Vorlage einfach an sich bindet keyup und fordert search(term.value).

    Wir packen das Ergebnis der Versprechen, dass die Suche-Methode der WikipediaService zurück und setzen Sie es als ein einfaches Array von strings die zu der Vorlage, so dass wir *ngFor Schleife durch und bauen Sie eine Liste für uns.

    Siehe das Beispiel von Versprechen-basierend Umsetzung auf Plunker

    Wo Observablen wirklich glänzen

    Ändern wir unseren code nicht hammer der Endpunkt mit jedem Tastendruck, sondern nur eine Anfrage senden, wenn der Benutzer beendet die Eingabe für 400 ms

    Enthüllen solchen super-Kräfte, die wir zunächst brauchen, um eine Observable<string> führt, dass die Suche Begriff, den der Benutzer eingibt. Statt manuell die Bindung an das keyup-Ereignis, wir können den Vorteil von Angular ist formControl Richtlinie. Diese Direktive zu verwenden, müssen wir zunächst importieren Sie die ReactiveFormsModule in unserer application-Modul.

    app.ts

    import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { JsonpModule } from '@angular/http';
import { ReactiveFormsModule } from '@angular/forms';

@NgModule({
  imports: [BrowserModule, JsonpModule, ReactiveFormsModule]
  declarations: [AppComponent],
  bootstrap: [AppComponent]
})
export class AppModule {}

    Einmal importiert, können wir formControl innerhalb unserer Vorlage und legen Sie es auf den Namen "Begriff".

    <input type="text" [formControl]="term"/>

    In unserer Komponente, erstellen wir eine Instanz von FormControl aus @angular/form und setzen Sie es als ein Feld unter dem Namen Begriff auf unsere Komponente.

    Hinter den kulissen, Begriff automatisch stellt eine Observable<string> als Eigentum valueChanges dass wir abonnieren können. Jetzt haben wir eine Observable<string> überwindung der Benutzer die Eingabe so einfach wie das aufrufen debounceTime(400) auf unserer Observable. Dann kommt wieder eine neue Observable<string> wird nur emittieren einen neuen Wert, wenn es nicht kommen neue Werte für 400ms.

    export class App {
  items: Array<string>;
  term = new FormControl();
  constructor(private wikipediaService: WikipediaService) {
    this.term.valueChanges
              .debounceTime(400)        //wait for 400ms pause in events
              .distinctUntilChanged()   //ignore if next search term is same as previous
              .subscribe(term => this.wikipediaService.search(term).then(items => this.items = items));
  }
}

    Wäre es eine Verschwendung von Ressourcen zu senden, eine weitere Anforderung für einen Suchbegriff, die unsere app schon zeigt die Ergebnisse für. Alle haben wir zu tun, um das gewünschte Verhalten zu nennen, die distinctUntilChanged Betreiber Recht, nachdem wir aufgerufen debounceTime(400)

    Siehe das Beispiel von Beobachtbaren Umsetzung auf Plunker

    Für den Umgang mit out-of-order-Antworten, bitte überprüfen Sie den vollständigen Artikel
    http://blog.thoughtram.io/angular/2016/01/06/taking-advantage-of-observables-in-angular2.html

    Soweit ich es über Http im Winkel, ich bin damit einverstanden, dass in der normalen Fällen gibt es nicht viel Unterschied bei der Verwendung von Beobachtbaren über Versprechen. Keine der Vorteile wirklich relevant sind hier in der Praxis. Ich hoffe, ich kann sehen, einige erweiterte use-case in der Zukunft 🙂

    Erfahren Sie mehr

    • Ich weiß nicht ganz kaufen die Entscheidung der Dreh-Http-service in Beobachtbaren basiert. Jede Erklärung, die ich höre, basiert auf dem gleichen Beispiel: Die Suche von Begriff. Aber dass man über den Umgang mit browser-events. Ich würde gerne hören, was der Vorteil liegt in der Anwendung wird es, wenn der Umgang mit asynchronen http-requests.
    • War die Entscheidung Vorzeichen zu vermeiden, gemischte Muster?
    • es ist eigentlich eine gute Erklärung für die Vorteile des http-service-Rücksendung eines beobachtbaren auf diesem podcast mit Ben Lesh: devchat.tv/js-jabber/.... Letztlich den großen Vorteil, dass Sie Abbrechen ein beobachtbares und ein Anwendungsfall für diese beschrieben in dem link oben - zwar ein wenig gekünstelt - ist, dass, wenn Sie rufen mehrere apis und kümmert sich nur um die erste Reaktion, egal, welche von den apis, die Sie aufgerufen haben, kommt zurück zu Ihnen, ersten, kann man dann kündigen die Anfragen an die andere.
    • Im ziemlich sicher, dass Sie verwenden können, $q.Rennen() für, die?
    • Beide Plunker Projekte sind gebrochen. Wie es aussieht, konnte Sie nicht finden, ein paar Ressourcen. 'Fehler beim laden der Ressourcen: die server zurückgegeben, mit dem status 404 ()' npmcdn.com/@angular/[email protected]//bundles/...
    InformationsquelleAutor trungk18
  3. 191

    Beide Verspricht und Observablen wird uns helfen, die Arbeit mit dem asynchrone Funktionalitäten in JavaScript. Sie sind sich sehr ähnlich, in vielen Fällen, es gibt jedoch immer noch einige Unterschiede zwischen den beiden, wie gut, verspricht sind Werte, die aufgelöst wird, in asynchronous Möglichkeiten, wie http Anrufe. Auf der anderen Seite observablen Angebot mit einer Sequenz von asynchrone Ereignisse. Die wichtigsten Unterschiede zwischen Ihnen sind unten aufgeführt:

    Versprechen:

    • mit einer pipeline
    • in der Regel verwenden Sie nur mit async-Daten zurück
    • nicht einfach Abbrechen

    beobachten:

    • sind kündbar,
    • sind Wiederholungsversuch möglich von der Natur wie wiederholen und retryWhen
    • stream-Daten in mehrere pipelines
    • mit array-ähnliche Operationen wie map, filter, etc
    • erstellt werden kann aus anderen Quellen wie Veranstaltungen
    • Sie sind Funktionen, die konnten abonniert werden später auf

    Habe ich dann auch erstellt das grafische Bild für Sie unten zeigen die Unterschiede visuell:

    Was ist der Unterschied zwischen Versprechen und Observablen?

    • Versprechen "nicht einfach zu stornieren" , ist es möglich zu stornieren ?
    • ja, es ist ein Weg, zu stornieren sowie... einige Leute benutzen bluebird oder Bibliotheken von Drittanbietern... auch mit der Q-Bibliothek in Eckigen es gibt Möglichkeiten, um es abzubrechen... aber wie gesagt nicht sehr praktisch
    • Mit einer pipeline hat manchmal advantange, ex. in APP_INITIALIZER, wenn Sie mehrere pipeline kann es nie zu Ende bringen manchmal oder beenden Sie die mehrfach.
    • läuft über dieses Problem APP_INITILIZER code, den ich geerbt nutzt beobachtbare es ist nicht ganz klar, oder nutzbar sind, brauche ich nur zu Holen der Konfiguration von einem web-service ist ein einmalige scheitern oder Erfolg-Ereignis eindeutig auf für Verspricht. Gibt es einen einfachen Weg, um Sie Verhalten sich wie ein Promisse... was ich meine, ist das 'danach' Verhalten, da die Ergebnisse der Kaskade stark auf die Rückkehr des jeweils anderen.
    • Abbrechen eines Promise ist der falsche Weg, um darüber nachzudenken, wie Sie verspricht. Die Promise's Verantwortung, die Sie nur mit Erfolg oder Misserfolg in einer async-kompatiblen Art und Weise.. Wenn Sie kündigen möchten, eine http-Anforderung, die Sie die Anforderung Abbrechen, nicht das Versprechen, und machen das Ergebnis zu annullieren entweder zu erfüllen oder abzulehnen Versprechen. jsfiddle.net/greggman/ea0yhd4p
    • Genau. Das Versprechen stellt einfach irgendwann in der Zukunft Wert. Es hat nicht repräsentieren die - Betrieb erzeugt der Wert. Sie können nicht Abbrechen einen Wert. Sie können versuchen einen Wert. Es ist nur ein Wert. Es kann oder kann nicht Gegenwart doch, und es kann nie vorhanden sind, da eine Ausnahme aufgetreten ist, aber das ist es.

    InformationsquelleAutor Alireza
  4. 59

    Verspricht

    1. Definition : Hilft Ihnen, Funktionen asynchron ausführen und deren Rückgabewerte (oder Ausnahmen), aber nur einmal wenn Sie ausgeführt wurden.
    2. Nicht Faul
    3. Nicht kündbar( Es gibt Versprechen Bibliotheken gibt, die Unterstützung Stornierung, aber ES6 Versprechen nicht so weit). Die beiden möglichen Entscheidungen sind
      • Ablehnen
      • Beheben
    4. Nicht wiederholt(Verspricht, sollte Zugang zu der ursprünglichen Funktion zurückgegeben, die Versprechen, um die einen wiederholen-Funktion, die eine schlechte Praxis)

    Observablen

    1. Definition : Hilft Ihnen, Funktionen asynchron ausführen und deren Rückgabewerte in einer kontinuierlichen Sequenz(mehrfach), wenn ausgeführt.
    2. Standardmäßig ist Faul, so emittiert es Werten, wenn die Zeit fortschreitet.
    3. Hat eine Menge Betreiber, die vereinfacht den Programmieraufwand.

    4. Einem Betreiber wiederholen kann verwendet werden, zu wiederholen, Wann immer nötig, auch wenn wir brauchen, um erneut zu beobachten, basierend auf bestimmten Bedingungen retryWhen verwendet werden kann.

      Hinweis: Eine Liste mit Operatoren zusammen mit Ihrer interaktiven Diagrammen verfügbar ist hier bei RxMarbles.com

    InformationsquelleAutor Aravind
  5. 52

    Es ist ein Nachteil der Observablen fehlt in den Antworten. Versprechungen, die den ES7 async/await-Funktionen. Mit Ihnen, können Sie schreiben von asynchronem code wie es wäre, einen synchronen Funktionsaufruf, so dass Sie nicht brauchen Rückrufe mehr. Die einzige Möglichkeit für die Observablen, dies zu tun, ist zu konvertieren Verspricht. Aber wenn Sie konvertieren Sie Verspricht, Sie kann nur einen Rückgabewert wieder:

    async function getData(){
    const data = await observable.first().toPromise();
    //do stuff with 'data' (no callback function needed)
}

    Weiter Lesen: Wie kann ich `warten` auf ein Rx Beobachtbar?

    • Auch überrascht, warum niemand darauf hingewiesen, diese killer-perk Versprechungen - Einfachheit und Transparenz durch async/await. Ich wechselte zu Versprechen, nur für die Fähigkeit zu schreiben, Flachbild-code. Einfache business-Logik und UI-Interaktion-code sollte nicht Aussehen wie rocket science und verschmutzt werden durch die geschachtelte Hölle von reactive extensions. Auch async/await ist nicht nur in der Zukunft, können Sie es in die öffentliche Produktion-apps jetzt mit transpilers. Ich benutze Typoskript 2.3 und es ist genial, wie eine echte Sprache.
    • Schön, aber das denken in einer reaktiven Art und Weise und alle mit der RxOperators vielleicht ist dies nicht ein killer-feature
    InformationsquelleAutor besserwisser
  6. 29

    Verspricht und Observablen beide behandeln das asynchrone Aufruf nur.

    Hier sind die Unterschiede zwischen Ihnen:

    Beobachtbaren

    1. Strahlt mehrere Werte über einen Zeitraum von Zeit
    2. Nicht aufgerufen wird, bis wir abonnieren die Beobachtbaren
    3. Kann abgebrochen werden, indem Sie den "Abmelden" () - Methode
    4. Bietet die Karte, forEach, filter, verringern, wiederholen, und retryWhen Betreiber

    Versprechen

    1. Emittiert nur einen einzelnen Wert in einer Zeit,

    2. Fordert, die Leistungen ohne .dann und .fangen

    3. Kann nicht abgebrochen werden,

    4. Nicht alle Operatoren

    • Was genau meinst du mit Versprechen emittiert nur einen einzigen Wert, während die beobachtbaren strahlt mehrere
    • Ein Versprechen nicht geben einen Wert hat - ein Versprechen, das ist ein Wert im Laufe der Zeit. Ein Versprechen multicasts, dass der Wert von mehreren Abonnenten - sobald Sie halten die Versprechen, die Sie bereits haben einen Wert. Eine observable ist wie ein - Funktion, Zeichnung zu die Aktion aufruft.
    • Noch habe ich nicht bekommen, das bedeutet mit mehreren Teilnehmern können Sie bitte einen link oder ein Beispiel. Dank
    • observable1.abonnieren(subscriber1), observable1.abonnieren(subscriber2) - dies ruft den - Funktion mehrmals.
    • Bitte Bearbeiten Sie Ihre post, und zeigen den tatsächlichen text anstelle von screenshots. Andere können nicht kopieren und einfügen von Ihren Bildern, und auch nicht helfen kann, Sie zu beheben, die viele Grammatik-Fehler. Siehe hier für details. Danke.
    • bitte aktualisieren Sie das Bild. Haben Sie copy paste von kudvenkat videos? Und die Grammatik ist auch nicht die richtige in den text im Bild.
    • Ja Praktisch, ich haben sich geändert-Image-Datei, um text -, fühlen Sie sich frei zu ändern, Wenn irgendwelche grammatikalischen Fehler, Danke 🙂

    InformationsquelleAutor sudheer nunna
  7. 19

    Obwohl diese Antwort ist spät, habe ich eine Zusammenfassung der Unterschiede unten,

    Beobachten:

    1. Beobachtbar ist nur ein function, dass dauert an observer und gibt einen function Observer: an object with next, error.
    2. Beobachter erlaubt subscribe/unsubscribe zu seinen Daten-stream, emittieren
      nächste Wert der Beobachter, notify der Beobachter über errors und
      informieren den Betrachter über die stream completion
    3. Beobachter bietet eine function to handle next value,Irrtümer und
      das Ende des Stroms(ui-events,http-Antworten,Daten mit web sockets).
    4. Arbeitet mit multiple values im Laufe der Zeit
    5. Es ist cancel-able/retry-able und unterstützt Operatoren wie map,filter,reduce etc.
    6. Erstellen einer Beobachten können
      -Observable.create() - zurück Beobachten können Methoden aufgerufen werden, die auf
      -Observer Observable.from() - konvertiert ein array oder iterierbar in
      -Observable Observable.fromEvent() - konvertiert ein Ereignis zu Beobachten
      -Observable.fromPromise() - konvertiert ein Versprechen in die Beobachtbare
      -Observable.range() - gibt eine Sequenz von ganzen zahlen in dem angegebenen Bereich

    Versprechen:

    1. Ein Versprechen stellt eine Aufgabe, die wird fertig in die Zukunft;

    2. Verspricht sich resolved by a value;

    3. Verspricht abgelehnt bekommen von Ausnahmen;

    4. Nicht cancellable und es gibt a single value

    5. Ein Versprechen über eine Funktion (then)

      -gibt dann eine neue promise;

      -ermöglicht die attachment der, der ausgeführt wird, basierend auf
      state;

      -handlers sind guaranteed, um auszuführen,order attached;

    InformationsquelleAutor Sajeetharan
  8. 17

    Ich glaube, alle anderen Antworten sollten klar Ihre Zweifel.
    Trotzdem, ich wollte nur hinzufügen, dass observablen basieren auf der funktionalen Programmierung, und ich finde es sehr nützlich, die Funktionen, die mit ihm gekommen wie map, flatmap, reduce, zip. Die Konsistenz der web-erreicht, vor allem, wenn es hängt von API-Anfragen ist eine brutale Verbesserung.

    Empfehle ich diese Dokumentation, da es die offizielle Dokumentation von reactiveX und ich finde, es ist das beste da draußen.

    Wenn du willst in die observablen, würde ich vorschlagen, dieses 3-teilige post:
    http://blog.danlew.net/2014/09/15/grokking-rxjava-part-1/

    Obwohl es bedeutete für RxJava, die Konzepte sind die gleichen, und es ist wirklich gut erklärt. In reactiveX Dokumentation haben Sie die äquivalenzen für jede Funktion. Muss man sich für RxJS.

    InformationsquelleAutor Marc Pérez
  9. 16

    Ich habe gerade behandelt ein Thema, wo die Versprechungen waren die beste Lösung, und ich Teile es hier für alle stolpern über diese Frage in der Veranstaltung ist es nützlich, (das war genau die Antwort die ich suchte früher):

    In einem Angular2 Projekt habe ich einen service an, einige Parameter und gibt einen Wert zurück Liste zu füllen drop-down-Menüs in einem Formular. Wenn die form-Komponente initialisiert wurde, muss ich anrufen die den gleichen Dienst mehrere Male mit verschiedenen Parametern zu definieren, die eine Reihe von verschiedenen dropdown-Menüs, aber wenn ich einfach Warteschlange, bis alle Variablen, die zum Aufruf des Dienstes, nur die Letzte erfolgreich abgeschlossen, und die restlichen Fehler aus. Der service abrufen aus der Datenbank könnte nur mit einem Antrag zu einem Zeitpunkt.

    Der einzige Weg, um erfolgreich zu bevölkern, die alle dropdown-Menü Variablen war ein Telefonat mit dem service in einer Weise, die verhindert, dass eine neue Anfrage bearbeitet wird, bis die Letzte Anforderung beendet wurde, und die Versprechen /.dann Mechanismus, der das problem schön.

      fetchValueList(listCode): Promise<any> {
      return this.dataSvc.getValueList(listCode, this.stateSvc.currentContext, this.stateSvc.currentLanguageCode)
          .map(response => response.json())
          .toPromise();
  }

  initializeDropDowns() {
      this.fetchValueList('First-Val-List')
          .then(data => {
              this.firstValList = data;
              return this.fetchValueList('Second-Val-List')
          }).then(data => {
              this.secondValList = data;
              return this.fetchValueList('Third-Val-List')
          }).then(data => {
              this.thirdValList = data;
          })  }

    Definierte ich die Funktionen in die Komponente, und dann rief initializeDropDowns() in ngOnInit.

    Den fetchValueList Funktion gibt ein Versprechen, so der erste Aufruf übergibt die ersten listCode und wenn das Versprechen aufgelöst wird, ist der Rückgabewert in der variable Daten in der .dann blockieren Sie, wo wir können ordnen Sie die diese.firstValList variable. Die Funktion hat Daten zurückgegeben, wir wissen, dass der service abgeschlossen ist und es sicher wieder anrufen, mit der zweiten listCode, ist der Rückgabewert in der variable Daten in die nächste .dann blockieren Sie und wir weisen Sie der diese.secondValList variable.

    Können wir diese Kette so oft wie erforderlich, um füllen Sie alle Variablen, und die Letzte code-block, die wir einfach weglassen, die return-Anweisung und der block wird beendet.

    Dies ist ein sehr spezieller Anwendungsfall, in dem wir einen einzigen Dienst muss mehrmals aufgerufen werden, wenn die Komponente initialisiert, und wo der service zu vervollständigen Holen und einen Wert zurückgeben, bevor Sie erneut aufgerufen werden kann, aber in diesem Fall, das Versprechen /.dann war die Methode ideal.

    • Dies ist sicherlich auch möglich mit (höherer Ordnung) observablen. Sie könnten zum Beispiel verwenden scan() zu bauen, ein Strom von aufeinanderfolgenden observablen. Aber deine Herangehensweise ist vielleicht noch deutlicher und einfacher zu verstehen.
    • Sie ersetzen könnte "dann" mit "switchMap" und tun genau das gleiche w/observablen.
    • Das problem mit switchMap, wie ich es verstehe, ist, dass es alle Anforderungen parallel und warten Sie, bis Sie alle wieder, dann wieder die Werte an die aufrufende Funktion in der Erwägung, dass in meiner situation, ich habe einen einzigen server, die ich nicht nennen mehrfach parallel (als die server fallen unfertige Anforderungen, wenn neue kommen), also musste ich sicherstellen, dass jeder Aufruf der Datenbank-Dienst abgeschlossen ist, bevor ein neuer Anruf, und die Versprechen/dann schien die beste und vielleicht einzige Weg, Sie zu lösen.
    • Warum hast du nicht angekettet mergeMap? Soweit ich das verstanden Ihren code, diese ist ziemlich einfach und macht den job genauso gut wie dein Beispiel. @StephenR.Smith
    • Können Sie fügen Sie ein code-Beispiel, dass die Lösung des gleiche problem wie eine andere Antwort? Wäre eine gute Referenz und kann eine gute refactoring Gelegenheit in der Zukunft. Die Anforderung ist, dass alles, was code kann nicht rufen Sie die back-End-Dienst parallel, es zu nennen, warten auf die return-Wert und wieder anrufen.
    • Darf ich darauf hinweisen, wie viel einfacher zu Lesen, dies wäre mit async/await? async initializeDropDowns() { this.firstValList = await this.fetchValueList('First-Val-List'); this.secondValList = await this.fetchValueList('Second-Val-List'); this.thirdValList = await this.fetchValueList('Third-Val-List'); }
    • Mit async/await hier ist ein großartiges Beispiel für Verspricht wird sauberer und einfacher zu Lesen, dass die Observablen. Obwohl, ich würde wirklich schauen, warum das back-End-Dienst kann nicht in der Lage mehrere gleichzeitige Anrufe. Was ist, wenn ein Benutzer verfügt über zwei Registerkarten öffnen, um Ihre Seite? Oder wenn Sie zwei Benutzer...
    • Jeder Reiter bekommt seine eigene session, damit mehrere Benutzer haben nicht ein Problem, sondern mehrere Aufrufe desselben Dienstes mit unterschiedlichen Parametern gleichzeitig führt zu Problemen. Ich habe keine Kontrolle über die server-Seite, also bin ich mit, um sich mit den Beschränkungen der services zur Verfügung gestellt. Ihre async/await Beispiel ist ähnlich zu reinigen, um die verkettete Versprechen Ansatz, ich denke, entweder funktioniert genauso gut.

    InformationsquelleAutor Stephen R. Smith
  10. 13

    Versprechen:

    • Liefern einen einzelnen Wert in der Zukunft;
    • Nicht faul;
    • Nicht kündbar;

    Beobachtbar ist:

    • Strahlt mehrere Werte im Laufe der Zeit;
    • Faul;
    • Kündbar;
    • Unterstützt map, filter, reduce und ähnliche Betreiber

    , Die Sie verwenden können, verspricht stattdessen der observablen beim Aufruf von HTTP in Eckigen wenn Sie es wünschen.

    InformationsquelleAutor Iosua Sipos
  11. 10

    Überblick:

    • Versprechen und Observablen uns helfen, den Umgang mit asynchronen Operationen. Können Sie rufen bestimmte Rückrufe, wenn diese asynchrone Operationen durchgeführt werden.
    • Ein Versprechen kann nur mit einem Ereignis, Observablen sind für Ströme von Ereignissen über die Zeit hinweg
    • Verspricht, kann nicht rückgängig gemacht werden, wenn Sie anhängig sind
    • Daten Observablen emittieren kann, verwandelt sich die Verwendung von Operatoren

    Können Sie immer eine beobachtbare für den Umgang mit asynchronen Verhalten, da ein beobachtbares hat alle Funktionen, die ein Versprechen bietet (+ extra). Aber manchmal wird diese zusätzliche Funktionalität, die Observablen Angebot ist nicht erforderlich. Dann wäre es zusätzlicher Aufwand durch das importieren einer Bibliothek für Sie, um Sie zu benutzen.

    Wann Verspricht:

    Nutzen Versprechen, wenn Sie haben eine single asynchronen operation, die Sie verarbeiten möchten, das Ergebnis. Zum Beispiel:

    var promise = new Promise((resolve, reject) => {
  //do something once, possibly async
  //code inside the Promise constructor callback is getting executed synchronously

  if (/* everything turned out fine */) {
    resolve("Stuff worked!");
  }
  else {
    reject(Error("It broke"));
  }
});

//after the promise is resolved or rejected we can call .then or .catch method on it

promise.then((val) => console.log(val))      //logs the resolve argument
       .catch((val) => console.log(val));    //logs the reject argument

    So ein Versprechen führt einige code, wo es entweder beschließt oder ablehnt. Wenn entweder resolve oder reject aufgerufen wird, die Verheißung geht von einem Status "pending" entweder eine gelöst oder abgelehnt Zustand. Wenn Sie das Versprechen Staat gelöst werden, die then() - Methode aufgerufen wird. Wenn Sie das Versprechen Staat abgelehnt, die catch() - Methode aufgerufen wird.

    Wann Observablen:

    Verwenden Observablen, wenn es eine stream (Daten -) im Laufe der Zeit, die Sie behandelt werden müssen. Ein stream ist eine Sequenz von Daten-Elemente, die zur Verfügung gestellt werden, im Laufe der Zeit. Beispiele für Datenströme sind:

    1. Benutzer Ereignisse, z.B. Klick oder keyup-events. Die Benutzer-Ereignisse generiert (Daten) über die Zeit.
    2. Websockets, nachdem der client eine websocket-Verbindung zum server
      er schiebt Daten im Laufe der Zeit.

    In der öffentlichkeit selbst wird angegeben, wenn die nächste Veranstaltung passiert, wenn ein Fehler tritt auf,, oder wenn die Observable ist abgeschlossen. Dann können wir abonnieren dieses observable, die aktiviert werden und in diesem Abo-dann können wir auch in 3 Rückrufe (nicht immer passieren müssen in allen). Ein Rückruf, der ausgeführt werden für den Erfolg, die eine callback-für Fehler, und ein callback für die Fertigstellung. Zum Beispiel:

    const observable = Rx.Observable.create(observer => {
  //create a single value and complete
  observer.onNext(1);
  observer.onCompleted();
});

source.subscribe(
  x => console.log('onNext: %s', x),   // success callback
  e => console.log('onError: %s', e),  // error callback
  () => console.log('onCompleted')     // completion callback
 );

//first we log: onNext: 1
// then we log: onCompleted

    Beim erstellen einer beobachtbaren es erfordert eine callback-Funktion, die liefert ein Beobachter als ein argument. Auf dieser Beobachter, die Sie dann aufrufen können onNext, onCompleted, onError. Dann, wenn die Observable ist, die er abonniert ruft die entsprechenden callbacks übergeben in das Abonnement.

    InformationsquelleAutor Willem van der Veen
  12. 7

    Versprechen - Geben Sie einen einzelnen Wert in der Zukunft. Nicht faul . Nicht Abbrechen können. Es wird entweder ablehnen oder auflösen.

    Beobachten - Bieten mehrere Wert in der Zukunft. Faul . Abbrechen können . Es werden weitere Methoden live-map,filter,reduce.

    InformationsquelleAutor Gajender Singh
  13. 4

    Versprechen und Observablen uns helfen, den Umgang mit asynchronen
    Operationen. Können Sie rufen bestimmte Rückrufe, wenn diese asynchron
    Operationen werden durchgeführt.

    Winkel verwendet Observablen, die von RxJS anstelle der Versprechen, die für den Umgang mit HTTP

    Below are some important differences in promises & Observables.

    Was ist der Unterschied zwischen Versprechen und Observablen?

    • Die tabellarischen Daten scheint nicht korrekt zu sein, der Titel sollte getauscht werden
    • Bitte Bearbeiten Sie Ihre post, und zeigen den tatsächlichen Inhalt als text statt des screenshots. Andere können nicht kopieren und einfügen von Ihren Bildern. Siehe hier für details. Danke.
    InformationsquelleAutor Srikrushna Pal
  14. 2

    Unten sind einige wichtige Unterschiede in verspricht & Observablen.

    Versprechen

    • Strahlt ein einzelner Wert nur
    • Nicht kündbar
    • Nicht teilbar
    • Immer asynchron

    Beobachtbaren

    • Strahlt mehrere Werte
    • Wird nur ausgeführt, wenn Sie aufgerufen wird oder jemand abonnieren
    • Werden kann, kündbar
    • Geteilt werden kann und abonniert, der gemeinsame Wert von mehreren Abonnenten. Und alle Abonnenten ausgeführt wird, an einem einzigen Punkt der Zeit.
    • möglicherweise asynchrone

    Zum besseren Verständnis beziehen sich auf die https://stackblitz.com/edit/observable-vs-promises

    InformationsquelleAutor Bikram
  15. 1

    Kurze Antwort :

    Beobachtbaren ist besser, es hat alle Verspricht - Funktionen sowie zusätzliche Funktionen.

    Lange Antwort:

    Verspricht:

    • Einmal Verwenden "Zurück-Daten einmal"
    • Kein Abbrechen
    • Ein Zuhörer
    • Keine Socket-Unterstützung Ein Zuhörer

    Beobachten:

    • Zurück Daten oft Daten ändern
    • Unterstützung Abbrechen
    • Support socket
    • Unterstützen viele Zuhörer und Benachrichtigen Sie, wenn sich Daten ändern
    • Support map, filter, reduce
    • Ich glaube nicht, dass man sagen kann Observablen sind Objektiv besser. Es gibt eine Reihe von Nachteile Observablen darauf hingewiesen, in den verschiedenen Antworten hier. Diejenigen, die stehen für mich Beobachtbar sind, die die Komplexität, und dass Sie nicht direkt mit await/async. Ich persönlich finde Sie wirklich hart zu arbeiten, weil Sie nicht feststellen können das Verhalten Beobachten, wenn Sie es -- Sie haben sich an den code, der generiert wurde. In der Erwägung, dass mit dem Versprechen, Sie wissen genau, wie Sie funktionieren, immer. Manchmal ist zum Beispiel das abonnieren eines Beobachtbaren Nebenwirkungen (z.B. eine http-Anfrage), manchmal aber auch nicht.
    • Für eckige, es hängt von Ihrem Fall. für die meisten Fälle arbeiten wir mit den Dienstleistungen und Daten, die Sie betreffen wird, unterschiedlichen Orten, Steckdosen, Widerruf, anzeigen, filtern und reduzieren. also ist es besser auf jene Fälle als Versprechen nicht, Sie zu unterstützen. so wieder es hängt von Ihrem Fall
    InformationsquelleAutor Amr Ibrahim
  16. 1

    Während die akzeptierte Antwort ist im Allgemeinen gut, ich glaube nicht, dass es unterstreicht, dass beim Umgang mit Kantigen Komponenten, die Sie fast immer verwenden möchten, eine Beobachtbare, denn es unterstützt Kündigung. Versprechungen können nicht storniert werden und wird zu lösen, auch wenn die Komponente zerstört wird. Winkel neigt, nicht nachtragend zu sein, bis es nicht.

    Beispielsweise eine manuelle change detection auf eine zerstörte Komponente zu einer Ausnahme führen:

    ngOnInit() {
  //promise api
  this.service.getData().then(d => {
     this.data = d;
     this.changeDetectorRef.detectChanges();
  });

  //observable api
  this.service.getData().pipe(takeUntil(this.unsubscribe)).subscribe((d) => {
     this.data = d;
     this.changeDetectorRef.detectChanges();
  });
}

    Wenn die Komponente zerstört wird, bevor das Versprechen aufgelöst wird, erhalten Sie eine attempt to use destroyed view Fehler, wenn das Versprechen aufgelöst wird.

    Alternativ, wenn Sie mit der observablen mit der takeUntil Muster, dann, sobald die Komponente zerstört wird, wird das Abonnement gekündigt werden.

    Dies ist ein bisschen ein erfundenes Beispiel, aber der Ausführung von code für eine Komponente, die zerstört wird, wird wahrscheinlich dazu führen Sie zu Fehlern. Es sei denn, Sie wirklich wollen, zu tun, dass aus irgendeinem Grund :p

    InformationsquelleAutor shusson
  17. 1

    Etwas, das ich lief in das war nicht ersichtlich aus einer ersten Lektüre des Tutorials und docs war die Idee von multicasting.

    Stellen Sie sicher, Sie sind sich bewusst, dass in der Standardeinstellung mehrere Abonnements auslösen werden mehrere Ausführungen in einem Beobachtbaren. Mehrere Abonnements für einen einzigen HTTP-Aufruf Beobachtbaren auslösen werden mehrere identische HTTP-Aufrufe, es sei denn, Sie .share() (aktivieren von multicasting).

    Ein Versprechen zwingt Sie, sich zu beschäftigen mit einer Sache zu einer Zeit, packen Sie Ihre Daten, die Ausnahmen behandeln, hat die Sprache Unterstützung für Coole Dinge wie async/await, und ist ziemlich barebones sonst.

    Einen Beobachtbaren hat viele Glocken und Pfeifen, aber Sie müssen verstehen, die macht, mit der Sie arbeiten, oder es kann missbraucht werden.

    InformationsquelleAutor rpgFANATIC
  18. 1

    Versprechen:

    Einen Asynchronen Ereignishandler, Das Promise-Objekt repräsentiert die schließliche Vollendung (oder Misserfolg) eines asynchronen Betrieb, und die sich daraus ergebenden Wert.

    Syntax: neue Versprechen(executor);

    ZB:

    var promise_eg = new Promise(function(resolve, reject) {
  setTimeout(function() {
    resolve('foo');
  }, 300);
});

promise_eg.then(function(value) {
  console.log(value);
  //expected output: "foo"
});

console.log(promise_eg);

    Was ist der Unterschied zwischen Versprechen und Observablen?

    Zu Versprechen:
    Es wurde ein pipeline-so wird es wieder Werte, die nur einmal bei Ihr angerufen.
    sein ein Weg-handler so einmal genannt, Sie möglicherweise nicht in der Lage, um abzubrechen.
    nützliche syntax können Sie spielen, um, wenn() und dann()

    Observablen:

    Observablen faul sind Sammlungen von mehreren Werten über die Zeit. es ist wirklich ein tolles Konzept für asynchrone Operationen. es kann getan werden, mit rxjs die cross-Plattform-Unterstützung können mit eckig/reagieren etc.

    seine handeln, wie stream liner. kann multi-pipeline.
    also einmal definiert, können Sie abonnieren, erhalten Sie Ergebnisse zurück, in vielen stellen.

    Syntax: import * as Rx from "@reactivex/rxjs";
    init: 

    Rx.Observable.fromEvent(button, "click"),
Rx.Subject()

    etc

    abonnieren: RxLogger.getInstance();

    ZB:

    import { range } from 'rxjs';
import { map, filter } from 'rxjs/operators';

range(1, 200).pipe(
  filter(x => x % 2 === 1),
  map(x => x + x)
).subscribe(x => console.log(x));

    da es Unterstützung für multi-pipeline, den man abonnieren kann dazu führen, dass verschiedene Lage,
    Was ist der Unterschied zwischen Versprechen und Observablen?
    es hat viel Möglichkeiten als verspricht.

    Verwendung:
    es hat mehr Möglichkeiten wie map, filter, pipe, map, concatMap etc

    InformationsquelleAutor Mohideen bin Mohammed
  19. 1

    Ich sehe eine Menge Leute mit dem argument, die Beobachtbar sind "kündbar", aber es ist ziemlich trivial zu machen Versprechen "kündbar"

    JS:

    function cancellablePromise(body) {
  let resolve, reject;
  const promise = new Promise((res, rej) => {
    resolve = res; reject = rej;
    body(resolve, reject)
  })
  promise.resolve = resolve;
  promise.reject = reject;
  return promise
}

//Example 1: Reject a promise prematurely
const p1 = cancellablePromise((resolve, reject) => {
  setTimeout(() => resolve('10', 100))
})

p1.then(value => alert(value)).catch(err => console.error(err))
p1.reject(new Error('denied')) //expect an error in the console

//Example: Resolve a promise prematurely
const p2 = cancellablePromise((resolve, reject) => {
  setTimeout(() => resolve('blop'), 100)
})

p2.then(value => alert(value)).catch(err => console.error(err))
p2.resolve(200) //expect an alert with 200

    InformationsquelleAutor Batiste Bieler
  20. 1

    Versprechen vs Beobachtbare ähnlichkeit erste

    1. Sowohl für den Umgang mit async-code.
    2. Bitte schauen Sie für die Versprechen Beispiel. Versprechen Konstruktor übergibt auflösen, Verweis-Funktion, die aufgerufen wird, wenn es aufgerufen wird, mit einem Wert nach Fertigstellung einige async task.
    const promise = new Promise(resolve => {
  setTimeout(() => {
    resolve("Hello from a Promise!");
  }, 2000);
});

promise.then(value => console.log(value));

    1. Beobachtbare Beispiel jetzt. Auch hier passieren wir eine-Funktion, um zu beobachten, einen Beobachter zu behandeln das asynchrone Aufgabe. Im Gegensatz zu beheben, in dem Versprechen, es hat sich die folgende Methode und abonniert im Ort dann.

    2. Also beide Griffe asynchrone Aufgaben. Schauen wir uns jetzt den Unterschied.

    const observable = new Observable(observer => {
  setTimeout(() => {
    observer.next('Hello from a Observable!');
  }, 2000);
});

observable.subscribe(value => console.log(value));

    Versprechen vs Beobachtbaren Unterschied

    Versprechen

    1. Es aufgelöst werden oder lehnen die einen einzelnen Wert und kann mit einem einzigen Wert async task zu einer Zeit.
    2. Ein Versprechen, einmal gelöst, das async-Wert, die es vollendet, und kann nicht mehr verwendet werden.die nur eine Zeit verwenden und hier hapert es.
    3. Nicht kündbar
    4. Keine rxjs Unterstützung für die Betreiber.

    Beobachtbaren

    1. Fähigkeit, zu emittieren mehrere asynchrone Werte.
    2. Verwendet, um den Griff der Strom der Ereignisse oder Werte. Betrachten Sie ein array von zahlreichen Aufgaben oder Werte, und Sie wollen jedes mal, wenn der Wert eingefügt, in diesem sollte es automatisch behandelt werden. Wenn Sie drücken einen Wert in diesem array, alle seine Abonnenten erhalten die neueste Wert automatisch.
    3. Observablen sind nützlich für die Beobachtung der input-Veränderungen, wiederholte Intervall -, broadcast-Werte für alle Kind-Komponenten, web-socket-push-Benachrichtigungen, etc.
    4. Gekündigt werden kann, mit der unsubscribe-Methode jederzeit.
    5. Noch eine Letzte gute Teil, das Versprechen, dass hat die Unterstützung für rxjs Betreiber. Sie haben viele pipe-Operatoren majorly map, filter, switchMap, combineLatest etc. zu verwandeln, die den beobachtbaren Daten vor der Zeichnung.

    Was ist der Unterschied zwischen Versprechen und Observablen?

    InformationsquelleAutor ramesh sharma
  21. 0

    Observablen und Verspricht, Sie helfen uns die Arbeit mit der asynchronen Funktionen in JavaScript/typescript. Sie sind sich sehr ähnlich, in vielen Fällen, es gibt jedoch immer noch einige Unterschiede zwischen Ihnen.

    Was ist der Unterschied zwischen Versprechen und Observablen?

    • Bitte Bearbeiten Sie Ihre post, und zeigen den tatsächlichen text anstelle von screenshots. Andere können nicht kopieren und einfügen von Ihren Bildern. Siehe hier für details. Danke.
    • Außer, dass nicht code, sondern plain-Informationen, so dass ich denke, es ist okay, um es als ein Bild
    • stop kopieren und einfügen von Kudvenkat youtube-videos. Downvote von mir! 🙂
    InformationsquelleAutor FAISAL
  22. 0

    Den grundlegenden Unterschied zwischen beobachtbaren und verspricht sind:

    Was ist der Unterschied zwischen Versprechen und Observablen?

    • Bitte Bearbeiten Sie Ihre post, und zeigen den tatsächlichen Inhalt als text statt des screenshots. Andere können nicht kopieren und einfügen von Ihren Bildern. Siehe hier für details. Danke.
    InformationsquelleAutor Chirag
  23. -2

    Gibt es viele Antworten zu diesem Thema bereits, so würde ich nicht fügen Sie eine redundante ein.

    Aber für jemanden, der gerade angefangen zu lernen, Beobachtbaren /Winkel und Wunder, die man zu nutzen vergleichen mit Versprechen, ich würde empfehlen, Sie halten alles, was Beobachtbar und konvertieren Sie alle vorhandenen Verspricht in Ihrem Projekt zu Beobachten.

    Einfach, weil Eckige Rahmen sich selbst und die Gemeinschaft aller mit zu Beobachten. Es wäre also vorteilhaft, wenn die Integration framework-Dienste oder 3rd-party-Module und Verkettung alles zusammen.

    Während ich schätzen die downvotes, aber ich immer noch darauf bestehen, meine Meinung oben, es sei denn, jemand hat einen richtigen Kommentar zu der Liste ein paar Szenarien, die vielleicht noch nützlich sein, in Ihrer Kantigen Projekt Verspricht über Observablen.

    Natürlich, keine Meinung ist zu 100% richtig in allen Fällen, aber zumindest glaube ich, dass 98% der Zeit, die für reguläre kommerzielle Projekte umgesetzt werden, die in Eckigen Rahmen, Beobachten, den richtigen Weg zu gehen.

    Selbst wenn Sie nicht, wie es am Ausgangspunkt Ihrer einfachen hobby-Projekt, werden Sie bald merken fast alle Komponenten, die Sie interagieren mit in schräg, und die meisten der Winkelposition der freundliche 3rd-party-framework verwenden Observablen, und dann werden Sie landeten ständig konvertieren Sie Ihre Versprechen zu Beobachten, um mit Ihnen zu kommunizieren.

    Diejenigen Komponenten beinhaltet, ist aber nicht beschränkt auf: HttpClient -, Formular-generator, Winkel-material-Module/Dialoge, Ngrx-Shop/Effekte und ngx-bootstrap.

    In der Tat, das einzige Versprechen von Winkel-öko-system mit dem ich gearbeitet habe in den letzten 2 Jahren ist APP_INITIALIZER.

    InformationsquelleAutor Xinan
Schreibe einen Kommentar