Javascript 离子2：呼叫事件同时订阅和取消订阅

我正在尝试使用爱奥尼亚的

Publish

和

Subscribe

subscribe.js

this.events.subscribe('done:eventA', (userEventData) => {
  //Perform some operations
  this.startEventB();
  this.events.unsubscribe('done:eventA');    <---
}

this.events.subscribe('done:eventB', (userEventData) => {
  //Perform some operations
  this.startEventA();
}

this.events.subscribe('done:eventA', (userEventData) => {
  //Perform some operations
  this.startEventC();
}

startEventB(){ 
  this.events.publish('done:eventB', data);
}

startEventA(){
  this.events.publish('done:eventA', data);
}

this.events.subscribe（'done:eventA'，（userEventData）=>{
//执行一些操作
这个.startEventB（）；
this.events.unsubscribe（'done:eventA'）{
//执行一些操作
这个。startEventA（）；
}
this.events.subscribe（'done:eventA'，（userEventData）=>{
//执行一些操作
this.startEventC（）；
}
startEventB（）{
this.events.publish（'done:eventB'，data）；
}
startEventA（）{
this.events.publish（'done:eventA'，data）；
}

第一次事件是我要执行的发布

startEventB（）

第二个时间事件A是发布，我想执行

startEventC（）

，所以我尝试

取消第一部分的订阅。

但是当我取消订阅时，我所有的订阅都消失了

我能知道订阅和取消订阅活动的好方法吗？
如果不向“取消订阅”传递第二个参数，则所有订阅方都是。如果要取消订阅给定的订阅方，则必须订阅和取消订阅同一对象，如前所述

我更喜欢的另一个解决方案是，在具有RxJS主题类型之一的组件之间共享服务。源类可以使用服务函数发布，该函数将在主题上执行下一步操作，而目标类可以观察到获取主题作为可观察对象的流

这里有一个此类服务的示例：

import {Injectable} from '@angular/core';
import {Observable} from 'rxjs/Observable';
import {Subject} from 'rxjs/Subject';

import {Booking} from '../../common/model/booking';


@Injectable()
export class BookingEventsService
{
    private _newChannel: Subject<Booking> = new Subject<Booking>();


    constructor()
    {
    }

    publishNew( booking: Booking )
    {
        this._newChannel.next( booking );
    }

    newChannel(): Observable<Booking>
    {
        return this._newChannel.asObservable();
    }
}

从'@angular/core'导入{Injectable}；
从“rxjs/Observable”导入{Observable}；
从'rxjs/Subject'导入{Subject}；
从“../../common/model/Booking”导入{Booking}；
@可注射（）
导出类BookingEvents服务
{
private _newChannel:Subject=newsubject（）；
构造函数（）
{
}
publishNew（预订：预订）
{
这个。_newChannel.next（预订）；
}
newChannel（）：可观察
{
返回此项。_newChannel.asObservable（）；
}
}

希望有帮助。问候，
Xavi
如果不向“取消订阅”传递第二个参数，则所有订阅服务器都是。如果要取消订阅给定订阅服务器，则必须订阅并取消订阅同一对象，如前所述

我更喜欢的另一个解决方案是，在具有RxJS主题类型之一的组件之间共享服务。源类可以使用服务函数发布，该函数将在主题上执行下一步操作，而目标类可以观察到获取主题作为可观察对象的流

这里有一个此类服务的示例：

import {Injectable} from '@angular/core';
import {Observable} from 'rxjs/Observable';
import {Subject} from 'rxjs/Subject';

import {Booking} from '../../common/model/booking';


@Injectable()
export class BookingEventsService
{
    private _newChannel: Subject<Booking> = new Subject<Booking>();


    constructor()
    {
    }

    publishNew( booking: Booking )
    {
        this._newChannel.next( booking );
    }

    newChannel(): Observable<Booking>
    {
        return this._newChannel.asObservable();
    }
}

从'@angular/core'导入{Injectable}；
从“rxjs/Observable”导入{Observable}；
从'rxjs/Subject'导入{Subject}；
从“../../common/model/Booking”导入{Booking}；
@可注射（）
导出类BookingEvents服务
{
private _newChannel:Subject=newsubject（）；
构造函数（）
{
}
publishNew（预订：预订）
{
这个。_newChannel.next（预订）；
}
newChannel（）：可观察
{
返回此项。_newChannel.asObservable（）；
}
}

希望有帮助。问候，
哈维