Vue でデータコレクターを設計する

関数useA(){
 見る(新しい、古い){
  if(開始){
    if(new.type == 'need')
     定数a = {
      a:新しいa
     }
     定数aa = {
      aa:新しい.aa
     }
     アップロード(a)
     アップロード(aa)
  }
 }
}
// 複数データ分散関数 useB(){
 // 繰り返し監視 watch(new,old){
 // グローバル判定 if(start){
    // 異なる状態の判断 if(new.type =='need')
     定数b = {
      b:新しい.b
     }
     //繰り返しデータ形式 const aa = {
      b:new.aa
     }
     アップロード(b)
     アップロード(aa)
  }
 }
}

/*
 * @Description: パブリッククラスを収集 * @version: 1.0.0
 * @著者: 呉文州* @日付: 2021-04-20 19:44:35
 * @LastEditors: 呉文州* @LastEditTime: 2021-04-22 15:20:50
 */
/**
 * @name: 退会
 * @msg: 依存関係コレクションオブジェクト */
クラス Dep {
  プライベートサブ: any = []
  // オブザーバーを追加 public addSub(sub: any) {
    if (sub && sub.update) {
      this.subs.push(サブ)
    }
  }
  //通知を送信する public notify(content: any) {
    this.subs.forEach((sub: any) => {
      sub.update(コンテンツ)
    })
  }
}
/**
 * @name: ウォッチャー
 * @msg: オブザーバー オブジェクト*/
クラスウォッチャー{
  プライベート cb!: (引数: 任意) => void
  コンストラクタ(cb: (arg: any) => void) {
    // コールバック関数は this.cb = cb の更新を担当します
  }
  // データが変更されたら更新する update(content: any) {
    this.cb(コンテンツ)
  }
}
/**
 * @name: チャンネル
 * @msg: キャッシュメッセージパイプライン*/
クラスチャンネル{
  //パイプラインストレージ配列のプライベートキュー: any = []
  // パイプラインサイズ private limitSize = 1
  //パイプライン名 public name: 文字列
  コンストラクター(名前: 文字列、制限サイズ = 1) {
    this.name = 名前
    // 最小サイズは1です
    制限サイズ = 制限サイズ >= 1 ? 制限サイズ: 1
    this.limitSize = 制限サイズ
  }
  /**
   * @名前: プッシュ
   * @msg: データを追加しました*/
  プッシュ(アイテム: 任意) {
    // 制限サイズを超えた場合は最初のものを削除します if (this.limitSize == this.queue.length) {
      this.queue.shift()
    }
    this.queue.push(アイテム)
  }
  /**
   * @name: 最終取得
   * @msg: 最後に追加されたデータを取得します*/
  最後の値を取得します（）{
    （このキューの長さ＞0）の場合{
      this.queue[this.queue.length - 1]を返す
    } それ以外 {
      新しいエラーをスローします('アイテムが返されません')
    }
  }
  /**
   * @name: 最終インデックスを取得する
   * @msg: 最後のカウントダウンデータを取得します*/
  getLastIndex(インデックス: 数値) {
    試す {
      this.queue[this.queue.length - index - 1]を返します
    } キャッチ（エラー）{
      新しいエラーをスローします('アイテムが返されません')
    }
  }
  /**
   * @name: 空です
   * @msg: パイプは空ですか? */
  空です() {
    this.queue.length == 0 を返す
  }
}
エクスポートクラスコレクション{
  //依存関係コレクションオブジェクト private dep = new Dep()
  // 各データチャネルの分類 private dataQueue = ['A', 'B', 'C']
  // チャンネルコレクション private channelMap = new Map()
  // アップロードキュープライベート MQ!: LiveCollectionMQ
  // 戦略モード: 異なるデータ型は異なる処理メカニズムに対応します private strategies = {
    答え: () => {
      // 異なる論理処理ごとに異なるパイプラインで対応するデータを取得できます},
    B: () => {

    },
    C: () => {
    },
  } として Record<NotifyType, any>
  コンストラクタ() {
    この.init()
  }
  プライベートinit() {
    // ウォッチャーを初期化する
    this.intウォッチャー()
    // チャネルを初期化する this.initChannel()
    // データを初期化する this.initData()
    // キューを初期化する this.initMQ()
  }
  /**
   * @name:intウォッチャー
   * @msg: リスナーを初期化します */
  プライベートintWatcher() {
    this.dep.addSub(
      新しいウォッチャー((type: NotificationType) => {
        const ハンドラバック = this.getHandler(type)
        ハンドラバック()
      }）、
    ）
  }
  /**
   * @名前: initChannel
   * @msg: チャネルを初期化します */
  プライベートinitChannel() {
    this.dataQueue.forEach(item => {
      this.channelMap.set(item, 新しいチャンネル(item, 3))
    })
  }
  /**
   * @名前: initData
   * @msg: チャネルデータを初期化します * @param {*}
   */
  プライベートinitData() {
    
  }
  /**
   * @名前: initMQ
   * @msg: アップロードキューを初期化します*/
  プライベートinitMQ() {

  }
  /**
   * @名前: getMQ
   * @msg: メッセージキューを取得します */
  パブリック getMQ() {
    これを返す.MQ
  }
  /**
   * @name:getChannel
   * @msg: チャンネル名に基づいてチャンネルインスタンスを取得します * @param {name} チャンネル名 */
  プライベートgetChannel(名前:NotifyType) {
    if (this.channelMap.get(name)) {
      this.channelMap.get(name) を返します。
    } それ以外 {
      新しいエラーをスローします('チャンネルがありません')
    }
  }
  /**
   * @名前:通知
   * @msg: 依存通知方法 * @param {NotifyType} タイプ
   * @param {any} メス
   */
  パブリック通知(タイプ: 通知タイプ、メッセージ: 任意) {
    // パイプラインキャッシュを設定する this.setChannel(type, mes)
    // データを配布するかどうかを決定するグローバル統一判定状態 if (state.value.type) {
      this.dep.notify(タイプ)
    }
  }
  /**
   * @名前: setChannel
   * @msg: チャネルキャッシュを設定 * @param {NotifyType} name
   * @param {any} メス
   */
  プライベートsetChannel(名前:NotifyType、mes:任意) {
    定数チャンネル = this.getChannel(名前)
    チャンネル.push(mes)
  }
  /**
   * @name:getHandler
   * @msg: 取得 * @param {NotifyType} 名
   */
  プライベートgetHandler(名前:NotifyType) {
    this.strategies[name]を返す
  }
  /**
   * @name: getChannelLast
   * @msg: 指定されたパイプラインの最新データを取得します * @param {NotifyType} name
   * @戻る {*}
   */
  パブリック getChannelLast(名前: 通知タイプ) {
    試す {
      定数チャンネル = this.getChannel(名前)
      channel.getLast() を返す
    } キャッチ（エラー）{
      新しいエラー(error)をスローします
    }
  }
  /**
   * @name: getChannelLast
   * @msg: 指定されたパイプラインの逆順データを取得します * @param {NotifyType} name
   * @param {数値} インデックス
   */
  パブリック getChannelItemByLastIndex(名前: 通知タイプ、インデックス: 数値) {
    試す {
      定数チャンネル = this.getChannel(名前)
      channel.getLastIndex(index) を返します。
    } キャッチ（エラー）{
      新しいエラー(error)をスローします
    }
  }
  /**
   * @名前: generateA
   * @msg: A データメソッドを生成します */
  パブリックgenerateA() {
    
  }
  /**
   * @名前: 生成B
   * @msg: B データ生成メソッド */
  パブリック生成B() {
    
  }
  /**
   * @名前: 生成C
   * @msg: C データ メソッドを生成します */
  パブリックgenerateC() {
    
  }
}

エクスポート const CollectionHelper = new Collection()