Progtwigción reactiva con Javascript

Soy nuevo en progtwigción reactiva y estoy un poco perdido leyendo todos estos artículos que no puedo entender.

En realidad, soy un desarrollador de JavaScript de Nodejs, Angularjs, Angular 2 y React.

Lo que hago

Utilizo promises todo el time, para get datos de manera remota, resolución asíncrona local, etc … Mejor capacidad de testing que las devoluciones de llamada y se ajustan a mis necesidades.

Lo que entiendo usando streams

No puedo entender dónde las streams pueden salvarme excepto en un caso particular.

Este caso especial es que no puedo usar las promises mientras escucho en las transmisiones porque la promise se resolvería solo una vez.

Un ejemplo con SocketIo:

io.on('connection', (socket) => { // this works }); io.on('connection').then((socket) => { // this can't work, promise would be resolved only once }); 

Si no estoy equivocado, podría usar flujos reactivos para administrar este caso simplemente devolviendo un observable. Correcto ?

Lo que no entiendo

Estoy estudiando Angular 2 y todo lo demás. De hecho, en muchos blogs, la gente usa los observables para get datos remotos y no puedo entender lo que podría ser una ventaja de usarlo en lugar de promises.

El hecho es que necesitaría hacer un control remoto como en ambos casos, entonces ¿por qué más uno que el otro? ¿Es esto un problema de performance?

Lo que necesito

Si ha leído toda la pregunta, lo que necesito es comprender cuáles son las ventajas de usar progtwigción reactiva en lugar de promises en el caso de la obtención remota de datos.

¿En qué (otros casos) podría ser mejor usar material reactivo que lo habitual?

@ Günter te dio los fundamentos de los observables, especialmente la capacidad de las promises de ser llamado.

Para ir un poco más allá, creo que la ventaja key de los observables es la capacidad de build un flujo / flujo de datos asíncrono usando operadores.

Aquí hay algunos casos de uso concretos:

  • debounceTime / switchMap . Cuando desee aprovechar un ingreso de formulario para filtrar una list en function de las requestes HTTP correspondientes, el valor que necesita usar para la request es el que el usuario ha terminado de escribir. No es necesario enviar varias requestes: una por cada nuevo carácter (uno para 's', uno para 'así', uno para 'som', …, uno para 'algo para search'). El operador debounceTime permite mediante el almacenamiento en búfer de events y proporciona el último después de una cantidad de time de inactividad.

    Aquí hay una muestra:

     @Component({ (...) template: ` <input [ngFormControl]="ctrl"/> ` }) export class MyComponent { constructor() { this.ctrl = new Control(); this.ctrl.valueChanges .debounceTime(500) .distinctUntilChanged() .switchMap((vallue: string) => { // Get data according to the filled value return this.service.getData(entry); }) .subscribe(data => { // Update the linked list this.list = data; }); } } 

    Si solo usa switchMap , tendrá una request por input, pero las requestes anteriores en progreso serán canceladas. Esto le permite get el resultado correcto, especialmente si los times de ejecución de request son más largos para algunas requestes.

    En este caso, puede vincular el evento desde la IU web (events DOM) a las requestes HTTP para ejecutarlo en consecuencia (reactjsr ante events) y aplicar algunos comportamientos avanzados.

  • Implementar el rebash Al mezclar retryWhen , los operadores de delay y timeout , puede implementar rebashs fácilmente (y transparentemente)

     searchPlaces(searchText:string) { var params = new URLSearchParams(); params.set('placename_startsWith', searchText); params.set('username', 'templth'); return this.http.get('http://api.geonames.org/postalCodeSearchJSON', { search: params }) .retryWhen(error => error.delay(500)) .timeout(2000, return new Error('delay exceeded')) .map(res => res.json().postalCodes); } 

Creo que este es el poder real de los observables: el flujo de datos / cadena de procesamiento asíncrono y las diferentes partes vinculadas de la aplicación en function de los events. Es algo que no se puede hacer con promises y permite implementar casos de uso para hacer que su aplicación sea más robusta.

Aquí hay una serie de artículos que podrían darle más detalles:

Básicamente, si tiene un solo evento asíncrono que desea recibir notifications sobre (callback), utiliza una Promise . Si espera que una serie de events use Observable

Ventajas de Observable over Promise

  • Observable puede ser cancelado
  • Observables son flojos (no hagas nada antes de suscribirte)
  • Observable puede hacer lo que promete pero solo al usar Observable permite codificar de la misma manera (usando operadores rx en lugar de .then() sin importar si espera uno o una serie de events.