operatore "di" vs "da"

L'unica differenza tra Observable.ofe Observable.fromil formato degli argomenti? Ti piace il Function.prototype.calle Function.prototype.apply?

Observable.of(1,2,3).subscribe(() => {})
Observable.from([1,2,3]).subscribe(() => {})

Non proprio. Quando si passa un array a Observable.from, l'unica differenza tra esso ed Observable.ofè il modo in cui vengono passati gli argomenti.

Tuttavia, Observable.fromaccetterà un argomento che è

un oggetto sottoscrivibile, una promessa, un osservabile, un array, un oggetto iterabile o un array da convertire

Non esiste un comportamento simile per Observable.of- che accetta sempre solo valori e non esegue alcuna conversione.

È importante notare la differenza tra ofe fromquando si passa una struttura simile a un array (comprese le stringhe):

Observable.of([1, 2, 3]).subscribe(x => console.log(x));

stampa l'intero array in una sola volta.

D'altro canto,

Observable.from([1, 2, 3]).subscribe(x => console.log(x));

stampa gli elementi 1 per 1.

Per le stringhe il comportamento è lo stesso, ma a livello di personaggio.

Un altro fatto interessante è Observable.of ([]) sarà un array vuoto quando ti iscrivi ad esso. Dove come quando ti iscrivi a Observable.from ([]) non otterrai alcun valore.

Questo è importante quando si esegue un'operazione consecutiva con switchmap.

Es: Nell'esempio seguente, sto salvando un lavoro, quindi i siti e quindi i commenti come flusso.

.do((data) => {
            this.jobService.save$.next(this.job.id);
        })
        .switchMap(() => this.jobService.addSites(this.job.id, this.sites)
            .flatMap((data) => {
                if (data.length > 0) {
                    // get observables for saving
                    return Observable.forkJoin(jobSiteObservables);
                } else {
                    **return Observable.of([]);**
                }
            })).do((result) => {
            // ..
        })
        .switchMap(() => this.saveComments())
....

se non è presente alcun sito da salvare, ovvero; data.length = 0 nella sezione addSite, il codice sopra restituisce Observable.of ([]) e quindi va a salvare i commenti. Ma se lo sostituisci con Observable.from ([]), i metodi successivi non verranno chiamati.

rxfiddle

Differenza di una riga:

       let fruits = ['orange','apple','banana']

da : Emette gli elementi uno per uno dell'array. Per esempio

    from(fruits).subscribe(console.log) // 'orange','apple','banana'

di : emette l'intero array contemporaneamente. Per esempio

 of(fruits).subscribe(console.log) //  ['orange','apple','banana']

NOTA: di operatore può comportarsi come da operatore con operatore di diffusione

 of(...fruits).subscribe(console.log) //  'orange','apple','banana'

1. dalla notifica di restituzione in blocchi, cioè uno per uno. per esempio: da ("abcde") restituirà a => b => c => d => e
2. di restituzione notifica completa. ad esempio: of ("abcde") restituirà abcde.

https://stackblitz.com/edit/typescript-sckwsw?file=index.ts&devtoolsheight=100

from: Crea osservabile da array, promessa o iterabile. Prende solo un valore. Per matrici, iterabili e stringhe, tutti i valori contenuti verranno emessi come sequenza

const values = [1, 2, 3];
from(values); // 1 ... 2 ... 3

of: Crea osservabile con quantità variabili di valori, emette valori in sequenza, ma array come valore singolo

const values = [1, 2, 3];
of(values, 'hi', 4, 5); // [1, 2, 3] ... 'hi' ... 4 ... 5