Operador 'de' vs 'de'

¿Es la única diferencia entre Observable.ofy Observable.fromel formato de los argumentos? ¿Te gusta el Function.prototype.cally Function.prototype.apply?

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

No exactamente. Al pasar una matriz a Observable.from, la única diferencia entre esta y Observable.ofla forma en que se pasan los argumentos.

Sin embargo, Observable.fromaceptará un argumento que es

un objeto suscribible, una promesa, un objeto observable, una matriz, un objeto iterable o una matriz para convertir

No existe un comportamiento similar para Observable.of, que siempre acepta solo valores y no realiza conversiones.

Es importante tener en cuenta la diferencia entre ofy fromal pasar una estructura tipo matriz (incluidas las cadenas):

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

imprimiría toda la matriz a la vez.

Por otra parte,

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

Imprime los elementos 1 por 1.

Para las cadenas, el comportamiento es el mismo, pero a nivel de personaje.

Otro hecho interesante es Observable.of ([]) será una matriz vacía cuando se suscriba. Donde como cuando se suscribe a Observable.from ([]) no obtendrá ningún valor.

Esto es importante cuando realiza una operación consecutiva con switchmap.

Por ejemplo: en el siguiente ejemplo, estoy guardando un trabajo y luego sitios, y luego los comentarios como una secuencia.

.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())
....

si no hay un sitio para guardar, es decir; data.length = 0 en la sección addSite, el código anterior devuelve Observable.of ([]) y luego va a guardar los comentarios. Pero si lo reemplaza con Observable.from ([]), no se invocarán los métodos siguientes.

rxfiddle

Diferencia de una línea:

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

from : Emite los elementos uno por uno de la matriz. Por ejemplo

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

de : Emitir toda la matriz a la vez. Por ejemplo

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

NOTA: de operador puede comportarse como del operador con el operador de difusión

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

1. desde la notificación de devoluciones en fragmentos, es decir, uno por uno. por ejemplo: from ("abcde") devolverá a => b => c => d => e
2. de devoluciones notificación completa. por ejemplo: of ("abcde") devolverá abcde.

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

from: Crear observable desde matriz, promesa o iterable. Solo tiene un valor. Para matrices, iterables y cadenas, todos los valores contenidos se emitirán como una secuencia

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

of: Crear observables con cantidades variables de valores, emitir valores en secuencia, pero matrices como valor único

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