Cada vez que tengo que usar una variable en diferentes componentes que se pueden cambiar con el tiempo, almaceno esa variable en un servicio y envuelvo el valor en un Asunto de modo que cada registro de componente cambie cuando se llame a next. Pero luego veo tutoriales donde se menciona que hay que tener cuidado al usar temas. Hacen lo siguiente:
// in some service private subject$: Subject<any> = new Subject(); subjectAsObservable: Observable<any> = this.subject$.asObservable(); y luego el observable se usa en los componentes, pero luego no podría llamar al next para emitir nuevos valores.
¿Existe algún riesgo al usar sujeto de la siguiente manera:
// in some service subject$: Subject<any> = new Subject(); y luego suscribirse a ese tema en los componentes y si los componentes realizan cambios en la variable, se llama a next y cada componente que se suscribe a ese tema obtiene el nuevo valor.
¿La siguiente implementación es diferente (más "segura") a la implementación anterior?
private subject$: Subject<any> = new Subject(); emitNewValue(value: any): void { this.subject$.next(value); } getSubject(): Subject<any> { return this.subject$: }No entiendo muy bien los riesgos de seguridad. ¿Cómo trataría correctamente los temas?
Se trata de la encapsulación. En aplicaciones más grandes, es una buena idea tener un solo lugar que emita al flujo compartido (asunto), que está en el servicio.
Entonces, ningún otro componente puede, por ejemplo, llamar accidentalmente a complete() sobre el tema. En el servicio, solo proporcione un método para emitir (emitNewValue en su ejemplo). No se necesita un getter para el tema, ya que exponer el tema con asObservable proporciona a los componentes una copia de solo lectura del tema, a la que pueden escuchar/suscribirse.