Entwerfen Sie einen Datensammler mit Vue

Funktion useA(){
 Uhr (neu, alt) {
  wenn(starten){
    wenn(neuer.Typ == "brauchen")
     Konstante a = {
      a:neu.a
     }
     konstant aa = {
      aa:neu.aa
     }
     hochladen(a)
     hochladen(aa)
  }
 }
}
// Mehrere Daten verstreut Funktion useB(){
 // Wiederholte Überwachung watch(new,old){
 // Globale Beurteilung if(start){
    // Unterschiedliche Zustandsbeurteilung, wenn (new.type =='need')
     const b = {
      b:neu.b
     }
     //Datenformat wiederholen const aa = {
      b:neu.aa
     }
     hochladen(b)
     hochladen(aa)
  }
 }
}

/*
 * @Description: Öffentliche Klassen sammeln * @version: 1.0.0
 * @Autor: Wu Wenzhou* @Datum: 2021-04-20 19:44:35
 * @LetzteEditoren: Wu Wenzhou* @LetzteEditZeit: 2021-04-22 15:20:50
 */
/**
 * @name: Dep
 * @msg: Abhängigkeitssammlungsobjekt */
Klasse Dep {
  private Subs: beliebig = []
  // Beobachter hinzufügen public addSub(sub: any) {
    wenn (sub und sub.update) {
      dies.subs.push(sub)
    }
  }
  //Benachrichtigung senden public notify(content: any) {
    dies.subs.forEach((sub: any) => {
      sub.update(Inhalt)
    })
  }
}
/**
 * @name: Beobachter
 * @msg: Beobachterobjekt*/
Klasse Watcher {
  private cb!: (Argument: beliebig) => ungültig
  Konstruktor(cb: (arg: any) => void) {
    // Die Callback-Funktion ist für die Aktualisierung von this.cb = cb verantwortlich
  }
  // Aktualisieren, wenn sich die Daten ändern update(content: any) {
    dies.cb(Inhalt)
  }
}
/**
 * @name: Kanal
 * @msg: Nachrichtenpipeline zwischenspeichern*/
Klasse Kanal {
  //Private Warteschlange des Pipeline-Speicherarrays: any = []
  // Pipelinegröße privat limitSize = 1
  //Pipeline-Name öffentlicher Name: Zeichenfolge
  Konstruktor(Name: Zeichenfolge, Grenzgröße = 1) {
    dieser.name = Name
    // Die Mindestgröße beträgt 1
    Grenzgröße = Grenzgröße >= 1 ? Grenzgröße : 1
    this.limitSize = Grenzgröße
  }
  /**
   * @name: drücken
   * @msg: Daten hinzugefügt*/
  push(Element: beliebig) {
    // Entfernen Sie das erste, wenn die Grenzgröße überschritten wird, if (this.limitSize == this.queue.length) {
      diese.Warteschlange.Verschiebung()
    }
    diese.Warteschlange.push(Element)
  }
  /**
   * @name: getLast
   * @msg: Die zuletzt hinzugefügten Daten abrufen*/
  getLast() {
    wenn (diese.Warteschlangenlänge > 0) {
      gib diese.Warteschlange zurück[diese.Warteschlangenlänge - 1]
    } anders {
      neuen Fehler werfen ('kein Artikel zurückgegeben')
    }
  }
  /**
   * @name: getLastIndex
   * @msg: Holen Sie sich die letzten Countdown-Daten */
  getLastIndex(index: zahl) {
    versuchen {
      gib diese.Warteschlange zurück[diese.Warteschlangenlänge - Index - 1]
    } Fehler abfangen {
      neuen Fehler werfen ('kein Artikel zurückgegeben')
    }
  }
  /**
   * @name: istEmpty
   * @msg: Ist das Rohr leer? */
  istLeer() {
    gibt diese.Warteschlangenlänge zurück == 0
  }
}
Exportklasse Sammlung {
  //Abhängigkeitssammlungsobjekt private dep = new Dep()
  // Klassifizierung jedes Datenkanals private dataQueue = ['A', 'B', 'C']
  // Kanalsammlung private channelMap = new Map()
  // Upload-Warteschlange private MQ!: LiveCollectionMQ
  // Strategiemodus: Verschiedene Datentypen entsprechen unterschiedlichen Verarbeitungsmechanismen private strategies = {
    EIN: () => {
      // Sie können entsprechende Daten in verschiedenen Pipelines für unterschiedliche logische Verarbeitungen erhalten},
    B: () => {

    },
    C: () => {
    },
  } als Datensatz<Benachrichtigungstyp, beliebig>
  Konstruktor() {
    dies.init()
  }
  private init() {
    // Den Watcher initialisieren
    dies.intWatcher()
    // Initialisiere den Kanal this.initChannel()
    // Daten initialisieren this.initData()
    // Initialisiere die Warteschlange this.initMQ()
  }
  /**
   * @name:intWatcher
   * @msg: Listener initialisieren */
  private intWatcher() {
    dies.dep.addSub(
      neuer Watcher((Typ: Benachrichtigungstyp) => {
        const handlerBack = this.getHandler(Typ)
        handlerBack()
      }),
    )
  }
  /**
   * @name: initChannel
   * @msg: Kanal initialisieren */
  private initChannel() {
    dies.dataQueue.forEach(item => {
      this.channelMap.set(Element, neuer Kanal(Element, 3))
    })
  }
  /**
   * @name: initData
   * @msg: Kanaldaten initialisieren * @param {*}
   */
  private initData() {
    
  }
  /**
   * @name: initMQ
   * @msg: Upload-Warteschlange initialisieren*/
  private initMQ() {

  }
  /**
   * @name: getMQ
   * @msg: Nachrichtenwarteschlange abrufen */
  öffentliche getMQ() {
    gib dies zurück.MQ
  }
  /**
   * @name:getChannel
   * @msg: Ruft die Kanalinstanz basierend auf dem Kanalnamen ab * @param {name} Kanalname */
  private getChannel(name: Benachrichtigungstyp) {
    wenn (diese.channelMap.get(name)) {
      gib this.channelMap.get(Name) zurück
    } anders {
      wirf einen neuen Fehler (,kein Kanal‘)
    }
  }
  /**
   * @name:benachrichtigen
   * @msg: Abhängige Benachrichtigungsmethode * @param {NotifyType} Typ
   * @param {any} mes
   */
  öffentliche Benachrichtigung (Typ: Benachrichtigungstyp, mes: beliebig) {
    // Pipeline-Cache festlegen this.setChannel(type, mes)
    // Globaler einheitlicher Beurteilungsstatus, um zu bestimmen, ob Daten verteilt werden sollen, wenn (state.value.type) {
      this.dep.notify(Typ)
    }
  }
  /**
   * @name: setChannel
   * @msg: Kanal-Cache festlegen * @param {NotifyType} Name
   * @param {any} mes
   */
  private setChannel(name: Benachrichtigungstyp, mes: beliebig) {
    const channel = this.getChannel(name)
    channel.push(Nachrichten)
  }
  /**
   * @name:getHandler
   * @msg: abrufen * @param {NotifyType} Name
   */
  private getHandler(name: Benachrichtigungstyp) {
    gib diese.Strategien[Name] zurück
  }
  /**
   * @name: getChannelLast
   * @msg: Holen Sie sich die neuesten Daten in der angegebenen Pipeline * @param {NotifyType} Name
   * @zurückkehren {*}
   */
  öffentliche getChannelLast(Name: Benachrichtigungstyp) {
    versuchen {
      const channel = this.getChannel(name)
      Rückgabekanal.getLast()
    } Fehler abfangen {
      neuen Fehler werfen (Fehler)
    }
  }
  /**
   * @name: getChannelLast
   * @msg: Holen Sie sich die Daten in umgekehrter Reihenfolge in der angegebenen Pipeline * @param {NotifyType} Name
   * @param {Zahl} Index
   */
  public getChannelItemByLastIndex(name: BenachrichtigenTyp, index: zahl) {
    versuchen {
      const channel = this.getChannel(name)
      Rückgabekanal.getLastIndex(index)
    } Fehler abfangen {
      neuen Fehler werfen (Fehler)
    }
  }
  /**
   * @name: generierenA
   * @msg: A-Datenmethode generieren */
  öffentliche generateA() {
    
  }
  /**
   * @name: generierenB
   * @msg: B-Datenmethode generieren */
  öffentliche generateB() {
    
  }
  /**
   * @name: generateC
   * @msg: C-Datenmethode generieren */
  öffentliche generateC() {
    
  }
}

exportiere const CollectionHelper = neue Sammlung()