La idea de la reactividad

Patrones Observer e Iterator de comportamiento. Ojala platzi siga haciendo cursos como estos; de nivel intermedio para arriba.

De las mejores diapositivas que he visto en Platzi, me ha gustado mucho esta clase, este curso tiene potencial para ser uno de mis favoritos ❤️

Observables y Observadores

Un observable es un patrón de diseño que representa una cadena de valores que vambian en el tiempo y se comunica con los observadores usando los siguientes tres métodos:

1. Next: Cuando envía un dato.
2. Complete: Cuando deja de enviar datos
3. Error: Cuando algo falla.

Un observador es un objeto o una función que se suscribe a un observable puede comunicarse a través de los métodos:

1. Subscribe: Para empezar a recibir valores.
2. Unsubscribe: Para dejar de recibir valores

Patern Observer
Subject: Es el que notifica cualquier cambio de estado a los observadores además para que los observadores se subscriban y cancelen la suscripción.
Observers: cuando suscribirse o cuando cancelar la suscripción

Patern Iterator:
utiliza un objecto iterator como mecanismo para recorrer una colección o contenedor ejemplo un Array de elementos de forma secuencial(iterar la colección sin necesidad de conocer la estructura de la colección )
un iterador tiene solo dos metodos:

• hasNext()
• Next()
  
  

let coleccion = new iterableList (1,2,3,4,5,6);

let iterator = coleccion.iterator();

while (iterator.hasNext()) { 
    console.log (iterator.next());
}

import {interval} from rxjs;

const observable = interval(1000); //emite un evento por segundo

const subscription = observable.subscribe( 
    x => console.log(x) //es el imprime cada evento
);

setTimeout( () => {
    subscription.unsubscribe()
},4000); //cancel Stream

//output 1 valor cada segundo   0, 1, 2, 3,

La explicación de Marcelo muy entendible , me está gustando. Me costó trabajo entenderlo cuando empece el desarrollo de micros con Webflux.

Excelente explicación, se nota la preparación, los slides son una obra de arte

Son las mejores diapositivas que he visto, es casi una pelicula

muy bonitas las animaciones, sirven de mucho para dar a entender el funcionamiento de este patron

Resumen:
Los observables son secuencias de eventos.
Un observador se puede subscribe y unsubscribe a un observable, y consumir los datos que son enviados a través del observable.
El observable puede:

• enviar uno a uno datos con next,
• o dejar de enviar con complete indicando que la secuencia terminó y no se observará más,
• y también puede enviar con error la información del error y se detiene la observación.

La idea de la reactividad

• Patron Observador
• Patron Iterador

El patrón observador es un diseño de software que se utiliza para establecer una relación de dependencia uno a muchos entre objetos. En este patrón, hay dos tipos principales de objetos: el sujeto (también conocido como observable o publicador) y los observadores (también conocidos como suscriptores o subscriptores).

El flujo típico del patrón observador es el siguiente:

1. El sujeto tiene métodos para permitir que los observadores se registren y cancelen su registro.
2. Cuando ocurre un cambio en el sujeto, este notifica a todos los observadores llamando al método de actualización en cada uno de ellos.
3. Los observadores reciben la notificación y realizan las acciones necesarias en función de la información proporcionada por el sujeto.

Esta clase es espectacular! No había visto una clase tan descriptiva en mucho tiempo. Gracias profe Marcelo, quedaron super claros los conceptos.

No puedo creer que una clase tan larga y con tanta información. Fue tan sencilla de entender y tan clara 😍. Creo que así es el formato en el que platzi siempre tiene que apuntar los cursos, no las clases de 2min en donde se siente que el profesor no explica, sino que lee documentación…

que buen ejemplo

An Observable communicates with its observers with the following notifications:
OnNext
conveys an item that is emitted by the Observable to the observer
OnCompleted
indicates that the Observable has completed successfully and that it will be emitting no further items
OnError
indicates that the Observable has terminated with a specified error condition and that it will be emitting no further items
OnSubscribe (optional)
indicates that the Observable is ready to accept Request notifications from the observer (see Backpressure below)
An observer communicates with its Observable by means of the following notifications:

Subscribe indicates that the observer is ready to receive notifications from the Observable
Unsubscribe
indicates that the observer no longer wants to receive notifications from the Observable
Request (optional)
indicates that the observer wants no more than a particular number of additional OnNext notifications from the Observable (see Backpressure below)

https://reactivex.io/documentation/contract.html

Hay que hablar del grandísimo nivel que tienen las diapositivas. Son espectaculares. Sin ellas creo que la clase no hubiera sido lo mismo, gracias por eso Profe.

Esta teoría de observable y observador me recuerda mucho a un sistema de gestión de colas como RabbitMQ, ActiveMQ, Amazon MQ, SQS, entre otros…

¡Qué manera tan sencilla de entender los conceptos básicos de la programación reactiva! Gran profesor

Les comparto 2 enlaces a articulos que explican muy bien y con ejemplos estos patrones al igual que muchos otros 😃

https://refactoring.guru/es/design-patterns/observer
https://refactoring.guru/es/design-patterns/iterator

Muy bien explicado todo.

Excelente!!

Es de gran ayuda el uso diapositivas con las animaciones, hace mas facil de entender el concepto.

Woooww entendí muy bien, muy buena explicación!