RxJS-Observable设计思想中运用的设计模式

// 基于源代码有删减
/**
 *表示任意时间内的任意一组值。这是RxJS最基本的构件
 *
 * @class Observable*/
export declare class Observable implements Subscribable {
    
    /**
     * @constructor
     * @param {Function} 订阅当被初始订阅时被调用的函数。这个函数有一个订阅者，它有新的值
     *可以‘next‘，也可以调用‘error‘方法来引发错误，或者‘complete‘可以被调用来通知成功完成。
     */
    constructor(subscribe?: (this: Observable, subscriber: Subscriber) => TeardownLogic);
    /**
     * 通过调用Observable构造函数创建一个新的cold Observable
     * @static true
     * @owner Observable
     * @method create
     * @param {Function} subscribe? 要传递给Observable构造函数的订阅函数
     * @return {Observable} a new cold observable
     * @nocollapse
     * @deprecated use new Observable() instead
     */
    static create: Function;
    /**
     * 创建一个新的可观察对象，将这个可观察对象作为源，并将传递的操作符定义为新可观察对象的操作符。
     * @method lift
     * @param {Operator} operator the operator defining the operation to take on the observable
     * @return {Observable} a new observable with the Operator applied
     */
    lift(operator: Operator): Observable;
    
    /** @deprecated Use an observer instead of a complete callback */
    subscribe(next: null | undefined, error: null | undefined, complete: () => void): Subscription;
    
    /** @deprecated This is an internal implementation detail, do not use. */
    _trySubscribe(sink: Subscriber): TeardownLogic;
    /**
     * @method forEach
     * @param {Function} next a handler for each value emitted by the observable
     * @param {PromiseConstructor} [promiseCtor] a constructor function used to instantiate the Promise
     * @return {Promise} a promise that either resolves on observable completion or
     *  rejects with the handled error
     */
    forEach(next: (value: T) => void, promiseCtor?: PromiseConstructorLike): Promisevoid>;
    /** @internal This is an internal implementation detail, do not use. */
    _subscribe(subscriber: Subscriber): TeardownLogic;
    //省略重载的方法
    pipe(op1: OperatorFunction): Observable;
    //省略重载的方法
    toPromise(this: Observable): Promise;
   
}
// 基于源代码有删减
export interface Subscribable {
    
    /** @deprecated Use an observer instead of a complete callback */
    subscribe(next: null | undefined, error: null | undefined, complete: () => void): Unsubscribable;
    //省略重载的方法
}

// 基于源代码有删减
/**
 * Subject 是一个特殊类型的可观察对象，允许值被多播给许多观察者。主题就像事件发射器。
 *
 * 每一个Subject都是可观察的(Observable)和观察者(Observer)。您可以订阅一个主题，还可以调用next来获取提要值以及error和complete。
 *
 * @class Subject*/
export declare class Subject extends Observable implements SubscriptionLike {
    observers: Observer[];
    closed: boolean;
    isStopped: boolean;
    hasError: boolean;
    thrownError: any;
    constructor();
    /**@nocollapse
     * @deprecated use new Subject() instead
    */
    static create: Function;
    lift(operator: Operator): Observable;
    next(value?: T): void;
    error(err: any): void;
    complete(): void;
    unsubscribe(): void;
    /** @deprecated This is an internal implementation detail, do not use. */
    _trySubscribe(subscriber: Subscriber): TeardownLogic;
    /** @deprecated This is an internal implementation detail, do not use. */
    _subscribe(subscriber: Subscriber): Subscription;
    /**
     * 创建一个以这个主题为源的新观察对象。您可以这样做来创建主题的自定义observer逻辑，并对使用Observable的代码隐藏它。code that uses the Observable.
     * @return {Observable} Observable that the Subject casts to
     */
    asObservable(): Observable;
}

/** SUBSCRIPTION INTERFACES */
export interface Unsubscribable {
    unsubscribe(): void;
}

export interface SubscriptionLike extends Unsubscribable {
    unsubscribe(): void;
    readonly closed: boolean;
}

export interface Observer {
    closed?: boolean;
    next: (value: T) => void;
    error: (err: any) => void;
    complete: () => void;
}

export interface Observer {
    closed?: boolean;
    next: (value: T) => void;
    error: (err: any) => void;
    complete: () => void;
}

// 结合迭代器Iterator进行理解：
next() => Observer 提供一个 next 方法来接收 Observable 流，是一种 push 形式；而 Iterator 是通过调用 iterator.next() 来拿到值，是一种 pull 的形式。
complete() => 当不再有新的值发出时，将触发 Observer 的 complete 方法；而在 Iterator 中，则需要在 next 的返回结果中，当返回元素 done 为 true 时，则表示 complete。
error() => 当在处理事件中出现异常报错时，Observer 提供 error 方法来接收错误进行统一处理；Iterator 则需要进行 try catch 包裹来处理可能出现的错误。

"use strict";

class Iterator {
    index = 0;
    list = [];
    constructor(container){
      this.list = container.list;
      this.index = 0;
    }
  
    next() {
      if(this.hasNext()){
        return {
          value: this.list[this.index++],
          done: false
        }
      }
      return {value: null,done: true}
    }
  
    hasNext() {
      if(this.index >= this.list.length){
        return false;
      }
      return true;
    }
  }
  
  
  class Container {
    list = [];
    constructor(list) {
      this.list = list;
    }
  
    getIterator() {
      return new Iterator(this);
    }
  }

  let container = new Container([1,2,3,4,5]);
  let iter = container.getIterator();

  console.log(iter.next());
  console.log(iter.next());
  console.log(iter.next());
  console.log(iter.next());
  console.log(iter.next());
  console.log(iter.next());
  console.log(iter.next());
  console.log(iter.next());

import { of } from ‘rxjs‘;

of(10, 20, 30)
.subscribe(
  next => console.log(‘next:‘, next),
  err => console.log(‘error:‘, err),
  () => console.log(‘the end‘),
);
// result:
// ‘next: 10‘
// ‘next: 20‘
// ‘next: 30‘