Konvertierung von virtuellem Dom in reales Dom mit Vue

Es gibt eine andere Baumstruktur Javascript-Objekt, alles was wir tun müssen, ist, diesem Baum zu sagen, dass er real ist Der Dom-Baum bildet eine Zuordnungsbeziehung. Lassen Sie uns das Vorherige überprüfen mountComponent-Methode:

Exportfunktion mountComponent(vm, el) {
  vm.$el = el
  ...
  callHook(vm, 'vor Mount')
  ...
  const updateComponent = Funktion () {
    vm._update(vm._render())
  }
  ...
}

Wir haben die Methode vm._render ausgeführt und den VNode erhalten. Jetzt übergeben wir ihn als Parameter an die Methode vm._update und führen ihn aus. Die Funktion der Methode vm._update besteht darin, einen VNode in einen echten Dom umzuwandeln, sie hat jedoch zwei Ausführungszeiten:

Erstes Rendern

Wenn ein neues Vue ausgeführt wird, erfolgt dies als erstes Rendering, und das eingehende Vnode-Objekt wird dem realen Dom zugeordnet.

Seite aktualisieren

Datenänderungen führen zu Seitenänderungen, was eine der einzigartigsten Funktionen von Vue ist. Vor und nach den Datenänderungen werden zum Vergleich zwei VNodes generiert. Wie man die kleinsten Änderungen am alten VNode vornimmt, um die Seite zu rendern, ist bei einem solchen Diff-Algorithmus ziemlich kompliziert. Wenn wir nicht zunächst klären, was Datenreaktivität ist, können wir den Gesamtprozess von Vue durch die direkte Verwendung von diff nicht gut verstehen. Nachdem in diesem Kapitel das erste Rendering analysiert wird, geht es im nächsten Kapitel um die Datenreaktivität und anschließend um den Differenzvergleich.

Schauen wir uns zunächst die Definition der Methode vm._update an:

Vue.prototype._update = Funktion(vnode) {
  ... Erstes Rendern vm.$el = vm.__patch__(vm.$el, vnode) // Überschreibe das Original vm.$el
  ...
}

Das vm.el wurde hier zuvor in der Mount-Komponentenmethode gemountet, einem echten Dom-Element. Beim ersten Rendering wird vm.el übergeben, das zuvor in der Methode ==mountComponent== gemountet wurde, ein echtes ==Dom==-Element. Das erste Rendering wird in vm. el übergeben, das zuvor in der Methode ==mountComponent== gemountet wurde, ein echtes ==Dom==-Element. Das erste Rendering wird in vm.el und dem resultierenden VNode übergeben, sehen Sie sich also die vm.patch-Definition an:

Vue.prototype.__patch__ = createPatchFunction({ nodeOps, module })

patch ist eine von der Methode createPatchFunction zurückgegebene Methode, die ein Objekt akzeptiert:

nodeOps-Attribut: kapselt eine Sammlung von Methoden zum Betrieb von nativem Dom, wie Erstellen, Einfügen und Entfernen. Lassen Sie uns sie im Detail erklären, wo sie verwendet werden.

Modulattribute: Zum Erstellen eines echten Doms ist auch das Generieren seiner Attribute wie Klasse/Attrs/Stil erforderlich. Module sind eine Array-Sammlung, jedes Element im Array ist die Hook-Methode, die diesen Attributen entspricht. Die Erstellung, Aktualisierung und Zerstörung dieser Attribute hat alle entsprechende Hook-Methoden. Wenn zu einem bestimmten Zeitpunkt etwas getan werden muss, führen Sie einfach den entsprechenden Hook aus. Beispielsweise verfügen sie alle über die Methode „Create Hook“. Wenn diese Create-Hooks in einem Array gesammelt werden und diese Attribute im realen Dom erstellt werden müssen, wird jedes Element im Array nacheinander ausgeführt, d. h. sie werden nacheinander erstellt.

PS: Die Hook-Methoden im Modulattribut sind hier plattformspezifisch. Web, Weex und SSR rufen VNode-Methoden auf unterschiedliche Weise auf, daher verwendet Vue erneut Funktionscurrying, um die Plattformunterschiede in createPatchFunction auszugleichen, sodass die Patch-Methode nur die neuen und alten Knoten empfangen muss.

Dom generieren

Hier müssen Sie sich nur einen Satz merken: Unabhängig davon, um welchen Knotentyp es sich bei VNode handelt, werden nur drei Knotentypen erstellt und in Dom eingefügt: Elementknoten, Kommentarknoten und Textknoten.

Werfen wir einen Blick auf createPatchFunction und sehen wir, welche Art von Methode es zurückgibt:

Exportfunktion Patchfunktion erstellen (Backend) {
  ...
  const { module, nodeOps } = backend // Dekonstruieren Sie die eingehende Sammlung return function (oldVnode, vnode) { // Empfangen Sie neue und alte vnodes
    ...
    const isRealElement = isDef(oldVnode.nodeType) // Ist es ein echter Dom?
    if(isRealElement) { // $el ist das echte DOM
      oldVnode = emptyNodeAt(oldVnode) // In VNode-Format konvertieren und sich selbst überschreiben}
    ...
  }
}

Beim ersten Rendern gibt es keinen oldVnode. OldVnode ist $el, ein echter Dom, der von der Methode emptyNodeAt(odVnode) umschlossen wird:

Funktion emptyNodeAt(ulme) {
  gib neuen VNode zurück(
    nodeOps.tagName(elm).toLowerCase(), // Entsprechendes Tag-Attribut {}, // Entsprechende Daten
    [], // entsprechend den Kindern
    undefiniert, //entspricht Text
    elm // Dem elm-Attribut wird der echte DOM zugewiesen)
}

Nach dem Verpacken:
{
  Tag: 'div',
  elm: '<div id="app"></div>' // echtes Dom
}

----------------------------------------------------------

nodeOps:
export function tagName (node) { // Gibt den Tag-Namen des Knotens zurück return node.tagName  
}

Nachdem wir das übergebene Attribut ==$el== in das VNode-Format konvertiert haben, fahren wir fort:

Exportfunktion Patchfunktion erstellen (Backend) { 
  ...
  
  return function (oldVnode, vnode) { // Alte und neue Vnodes empfangen
  
    const eingefügtVnodeQueue = []
    ...
    const oldElm = oldVnode.elm //Der echte Dom nach dem Verpacken <div id='app'></div>
    const parentElm = nodeOps.parentNode(oldElm) // Der erste übergeordnete Knoten ist <body></body>
  	
    createElm( // Erstelle einen echten Dom
      vnode, // Der zweite Parameter insertVnodeQueue, // Leeres Array parentElm, // <body></body>
      nodeOps.nextSibling(oldElm) // nächster Knoten)
    
    return vnode.elm // Gibt den echten Dom zurück, um vm.$el zu überschreiben
  }
}
                                              
------------------------------------------------------

nodeOps:
export function parentNode (node) { // Den übergeordneten Knoten abrufen return node.parentNode 
}

export function nextSibling(node) { // Den nächsten Knoten abrufen return node.nextSibling  
}

Die Methode createElm beginnt mit der Generierung des echten Dom. Die Art und Weise, wie VNode den echten Dom generiert, ist immer noch in zwei Arten unterteilt: Elementknoten und Komponente. Daher verwenden wir den im vorherigen Kapitel generierten VNode, um sie separat zu erklären.

1. Elementknoten generiert Dom

{ // Elementknoten VNode
  Tag: 'div',
  Kinder: [{
      tag: 'h1',
      Kinder: [
        {text: 'Titel h1'}
      ]
    }, {
      tag: 'h2',
      Kinder: [
        {text: 'Titel h2'}
      ]
    }, {
      tag: 'h3',
      Kinder: [
        {text: 'Titel h3'}
      ]
    }
  ]
}

Sie können sich zunächst dieses Flussdiagramm ansehen, um einen Eindruck zu bekommen. Wenn Sie sich dann die konkrete Implementierung ansehen, wird die Idee viel klarer (hier leihe ich mir ein Bild aus dem Internet):

Beginnen wir mit Dom und schauen uns seine Definition an:

Funktion createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) { 
  ...
  const children = vnode.children // [VNode, VNode, VNode]
  const tag = vnode.tag // div
  
  wenn (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
    return // Wenn das Komponentenergebnis true zurückgibt, wird nicht fortgefahren. CreateComponent wird später ausführlich erläutert.
  }
  
  if(isDef(tag)) { // Elementknoten vnode.elm = nodeOps.createElement(tag) // Übergeordneten Knoten erstellen createChildren(vnode, children, insertedVnodeQueue) // Untergeordneten Knoten erstellen insert(parentElm, vnode.elm, refElm) // Einfügen } else if(isTrue(vnode.isComment)) { // Kommentarknoten vnode.elm = nodeOps.createComment(vnode.text) // Kommentarknoten erstellen insert(parentElm, vnode.elm, refElm); // In übergeordneten Knoten einfügen } else { // Textknoten vnode.elm = nodeOps.createTextNode(vnode.text) // Textknoten erstellen insert(parentElm, vnode.elm, refElm) // In übergeordneten Knoten einfügen }
  
  ...
}

------------------------------------------------------------------

nodeOps:
Exportfunktion createElement(tagName) { // Einen Knoten erstellen return document.createElement(tagName)
}

Exportfunktion createComment(Text) { //Kommentarknoten erstellen return document.createComment(Text)
}

Exportfunktion createTextNode(text) { // Einen Textknoten erstellen return document.createTextNode(text)
}

function insert (parent, elm, ref) { //DOM-Operation einfügen if (isDef(parent)) { // Es gibt einen übergeordneten Knoten if (isDef(ref)) { // Es gibt einen Referenzknoten if (ref.parentNode === parent) { // Der übergeordnete Knoten des Referenzknotens ist gleich dem übergebenen übergeordneten Knoten nodeOps.insertBefore(parent, elm, ref) // Elm vor dem Referenzknoten im übergeordneten Knoten einfügen
      }
    } anders {
      nodeOps.appendChild(parent, elm) // Ulme zum übergeordneten Element hinzufügen}
  } // Nichts tun, wenn kein übergeordneter Knoten vorhanden ist}
Dies ist eine relativ wichtige Methode, da sie an vielen Stellen verwendet wird.

Bestimmen Sie nacheinander, ob es sich um einen Elementknoten, einen Kommentarknoten oder einen Textknoten handelt, erstellen Sie sie jeweils und fügen Sie sie dann in den übergeordneten Knoten ein. Hier führen wir hauptsächlich die Erstellung von Elementknoten ein, und die anderen beiden haben keine komplizierte Logik. Schauen wir uns die Definition der Methode createChild an:

Funktion createChild(vnode, children, insertedVnodeQueue) {
  if(Array.isArray(children)) { // ist ein Array for(let i = 0; i < children.length; ++i) { // durchlaufe jeden vnode createElm( // rufe rekursiv children[i] auf, 
        eingefügteVnodeQueue, 
        vnode.elm, 
        null, 
        true, //Nicht der Stammknoten zum Einfügen von untergeordneten Elementen, 
        ich
      )
    }
  } sonst wenn (isPrimitive(vnode.text)) { //typeof ist einer von string/number/symbol/booleannodeOps.appendChild( // Erstellen und in den übergeordneten Knoten einfügenvnode.elm, 
      nodeOps.createTextNode(String(vnode.text))
    )
  }
}

-------------------------------------------------------------------------------------------

nodeOps:
export default appendChild(Knoten, Kind) { // Kind hinzufügen node.appendChild(Knoten)
}

Beginnen Sie mit der Erstellung untergeordneter Knoten, durchlaufen Sie jedes Element des VNode und verwenden Sie die vorherige Methode createElm, um für jedes Element einen Dom zu erstellen. Wenn es sich bei einem Element um ein Array handelt, rufen Sie weiterhin „createChild“ auf, um einen untergeordneten Knoten des Elements zu erstellen. Wenn es sich bei einem Element nicht um ein Array handelt, erstellen Sie einen Textknoten und fügen Sie ihn dem übergeordneten Knoten hinzu. Verwenden Sie auf diese Weise Rekursion, um alle verschachtelten VNodes als echte Doms zu erstellen.

Nach dem Betrachten des Flussdiagramms sollten Sie viele Zweifel ausräumen können (hier leihe ich mir ein Kapitelbild aus dem Internet):

Um es einfach auszudrücken: Es geht darum, echte Doms einzeln von innen nach außen zu erstellen, sie dann in ihre übergeordneten Knoten einzufügen und schließlich die erstellten Doms in den Hauptteil einzufügen, um den Erstellungsprozess abzuschließen. Die Erstellung von Elementknoten ist relativ einfach. Als Nächstes sehen wir uns an, wie der Komponententyp erstellt wird.

Komponente VNode generiert Dom

{ // Komponente VNode
  tag: 'vue-component-1-app',
  Kontext: {...},
  Komponentenoptionen: {
    Ctor: function(){...}, // Unterkomponentenkonstruktor propsData: undefiniert,
    Kinder: undefiniert,
    Schlagwort: undefiniert
  },
  Daten: {
    ein: nicht definiert, // nativer Ereignis-Hook: { // Komponenten-Hook init: function(){...},
      einfügen: function(){...},
      Vorpatch: Funktion(){...},
      zerstören: function(){...}
    }
  }
}

----------------------------------------------

<template> // Vorlage in der App-Komponente <div>App-Text</div>
</Vorlage>

Schauen wir uns zunächst ein einfaches Flussdiagramm an. Lassen Sie einfach einen Punkt übrig, um später die logische Reihenfolge leichter zu bestimmen (hier leihe ich mir ein Bild aus dem Internet):

Verwenden Sie die Komponenten im vorherigen Kapitel, um VNode zu generieren, und sehen Sie, wie die Dom-Branch-Logik der Komponente in createElm erstellt wird:

Funktion createElm(vnode, insertedVnodeQueue, parentElm, refElm) { 
  ...
  if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) { // Komponentenzweig zurückgeben  
  }
  ...

Führen Sie die Methode createComponent aus. Wenn es sich um einen Elementknoten handelt, wird nichts zurückgegeben, sodass er undefiniert ist und die nächste Logik zum Erstellen eines Metaknotens fortgesetzt wird. Jetzt ist es an der Komponente. Schauen wir uns die Implementierung von createComponent an:

Funktion createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
  sei i = vnode.data
  wenn(isDef(i)) {
    wenn(isDef(i = i.hook) && isDef(i = i.init)) {
      i(vnode) // Init-Methode ausführen}
    ...
  }
}

Zuerst werden die vnode.data der Komponente i zugewiesen. Anhand der Existenz dieses Attributs lässt sich feststellen, ob es sich um einen Komponenten-vnode handelt. Das folgende if(isDef(i = i.hook) && isDef(i = i.init)) kombiniert Beurteilung und Zuweisung zu einem. Das i(vnode) im if ist die ausgeführte Komponentenmethode init(vnode). Schauen wir uns jetzt an, was die Init-Hook-Methode der Komponente macht:

importiere activeInstance // globale Variablen const init = vnode => {
  const Kind = vnode.componentInstance = 
    erstelleComponentInstanceForVnode(vnode, aktiveInstanz)
  ...
}

activeInstance ist eine globale Variable, die in der Update-Methode der aktuellen Instanz zugewiesen wird. Sie wird während des Patch-Prozesses der aktuellen Instanz als übergeordnete Instanz der Komponente übergeben und die Komponentenbeziehung wird während des initLifecycle der untergeordneten Komponente hergestellt. Das Ergebnis von createComponentInsanceForVnode wird vnode.componentInstance zugewiesen. Sehen wir uns also an, was es zurückgibt:

export createComponentInstanceForVnode(vnode, parent) { // parent ist die globale Variable activeInstance
  const options = { // Komponentenoptionen
    _isComponent: true, // Setze ein Flag, um anzuzeigen, dass es sich um eine Komponente handelt _parentVnode: vnode, 
    parent // Die übergeordnete VM-Instanz der untergeordneten Komponente, sodass durch die Initialisierung von initLifecycle eine übergeordnete-untergeordnete Beziehung hergestellt werden kann}
  
  return new vnode.componentOptions.Ctor(options) // Der Konstruktor der Unterkomponente wird als Ctor definiert
}

In der Init-Methode der Komponente wird zuerst die Methode craeeteComponentInstanceForVnode ausgeführt. Der Konstruktor der Unterkomponente wird innerhalb dieser Methode instanziiert. Da der Konstruktor der Unterkomponente alle Fähigkeiten der Basisklasse Vue erbt, entspricht dies der Ausführung von new Vue({…}). Als Nächstes wird die Methode ==_init ausgeführt, um eine Reihe von Initialisierungslogiken für die Unterkomponente auszuführen, und dann zur Methode _init== zurückzukehren, da es zwischen ihnen noch einige Unterschiede gibt:

Vue.prototype._init = Funktion(Optionen) {
  if(options && options._isComponent) { // Komponentenzusammenführungsoptionen, _isComponent ist der zuvor definierte Marker initInternalComponent(this, options) // Der Unterschied liegt darin, dass die zusammengeführten Elemente der Komponenten viel einfacher sind}
  
  initLifecycle(vm) // Eltern-Kind-Beziehung herstellen...
  callHook(vm, 'erstellt')
  
  if (vm.$options.el) { // Die Komponente hat kein el-Attribut, also hier aufhören vm.$mount(vm.$options.el)
  }
}

----------------------------------------------------------------------------------------

function initInternalComponent(vm, options) { // Unterkomponentenoptionen zusammenführen
  const opts = vm.$optionen = Objekt.erstellen(vm.konstruktor.optionen)
  opts.parent = options.parent // Komponenteninitialisierungszuweisung, globale Variable activeInstance
  opts._parentVnode = options._parentVnode // Komponenten-Init-Zuweisung, Komponenten-Vnode 
  ...
}

Vorher wurde alles gut ausgeführt, aber am Ende wurde es nicht gemountet, da kein el-Attribut vorhanden war, und die Methode createComponentInstanceForVnode wurde ausgeführt. Zu diesem Zeitpunkt kehren wir zur Init-Methode der Komponente zurück und vervollständigen die verbleibende Logik:

const init = vnode => {
  const child = vnode.componentInstance = // Komponenteninstanz abrufen createComponentInstanceForVnode(vnode, activeInstance)
    
  child.$mount(undefined) // Dann manuell mounten}

Wir mounten diese Komponente manuell in der Init-Methode und führen dann die Methode ==render()== der Komponente aus, um den Elementknoten VNode in der Komponente abzurufen. Anschließend führen wir vm._update() aus, um die Patch-Methode der Komponente auszuführen. Da die Methode $mount undefined übergibt, ist oldVnode ebenfalls undefiniert und die Logik in __patch_ wird ausgeführt:

Rückgabefunktion Patch (alter V-Knoten, V-Knoten) {
  ...
  wenn (isUndef(alterVnode)) {
    createElm(vnode, eingefügteVnodeQueue)
  }
  ...
}

Dieses Mal wird createElm ausgeführt, ohne den dritten Parameter parent node zu übergeben. Wo also sollte der von der Komponente erstellte Dom platziert werden, damit er wirksam wird? Es gibt keine übergeordnete Knotenseite zum Generieren von Dom. Zu diesem Zeitpunkt wird der Komponentenpatch ausgeführt, sodass der Parameter vnode der vnode des Elementknotens in der Komponente ist:

<template> // Vorlage in der App-Komponente <div>App-Text</div>
</Vorlage>

-------------------------

{ // Element-Vnode in der App
  Tag: 'div',
  Kinder: [
    {text: App-Text}
  ],
  parent: { // Die Beziehung, die durch Ausführen von initLifecycle hergestellt wird, wenn die Unterkomponente init ist. Tag: 'vue-component-1-app',
    Komponentenoptionen: {...}
  }
}

Offensichtlich handelt es sich zu diesem Zeitpunkt nicht um eine Komponente. Selbst wenn es eine Komponente ist, spielt das keine Rolle. Wir müssen höchstens noch die Logik von createComponent ausführen, um die Komponente zu erstellen, da es immer Komponenten geben wird, die aus Elementknoten bestehen. Zu diesem Zeitpunkt führen wir die Logik zum Erstellen von Elementknoten aus. Da kein übergeordneter Knoten mit drittem Parameter vorhanden ist, wird der Dom der Komponente erstellt, aber hier nicht eingefügt. Bitte beachten Sie, dass zu diesem Zeitpunkt die Initialisierung der Komponente abgeschlossen ist, die Methode createComponent der Komponente jedoch noch nicht abgeschlossen ist. Lassen Sie uns ihre Logik vervollständigen:

Funktion createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
  sei i = vnode.data;
  wenn (isDef(i)) {
    wenn (isDef(i = i.hook) und isDef(i = i.init)) {
      i(vnode) // init wurde abgeschlossen}
    
    if (isDef(vnode.componentInstance)) { //Wird beim Ausführen der Komponente init zugewiesen initComponent(vnode) //Weisen Sie vnode.elm den realen Dom zu
      
      insert(parentElm, vnode.elm, refElm) // Komponente Dom wird hier eingefügt …
      return true // Es wird also direkt zurückgegeben.
    }
  }
}

-----------------------------------------------------------------------------------

Funktion initComponent(vnode) {
  ...
  vnode.elm = vnode.componentInstance.$el // Der echte Dom, der von __patch__ zurückgegeben wurde
  ...
}

Unabhängig davon, wie tief die Komponenten verschachtelt sind, wird init ausgeführt, wenn eine Komponente angetroffen wird. Wenn während des Patch- Prozesses von init eine verschachtelte Komponente angetroffen wird, wird der init der verschachtelten Komponente erneut ausgeführt. Nachdem die verschachtelte Komponente __patch__ abgeschlossen hat, wird der echte Dom in seinen übergeordneten Knoten eingefügt. Nachdem der Patch der äußeren Komponente ausgeführt wurde, wird er erneut in seinen übergeordneten Knoten eingefügt und schließlich in den Body eingefügt, um den Erstellungsprozess der verschachtelten Komponente abzuschließen. Kurz gesagt, es ist ein Prozess von innen nach außen.

Wenn ich auf dieses Bild zurückblicke, wird es, glaube ich, leicht zu verstehen sein:

Vervollständigen Sie dann die Logik nach dem anfänglichen mountComponent in diesem Kapitel:

Exportfunktion mountComponent(vm, el) {
  ...
  const updateComponent = () => {
    vm._update(vm._render())
  }
  
  neuer Watcher(vm, updateComponent, noop, {
    vor() {
      wenn(vm._isMounted) {
        callHook(vm, 'vorUpdate')
      }
    }   
  }, WAHR)
  
  ...
  callHook(vm, 'gemountet')
  
  VM zurückgeben
}

Als nächstes wird updateComponent an eine Watcher-Klasse übergeben. Was diese Klasse macht, erklären wir im nächsten Kapitel. Als nächstes wird die gemountete Hook-Methode ausgeführt. An diesem Punkt ist der gesamte Prozess von New Vue abgeschlossen. Lassen Sie uns die Ausführungsreihenfolge überprüfen, beginnend mit dem neuen Vue:

neues Vue ==> vm._init() ==> vm.$mount(el) ==> vm._render() ==> vm.update(vnode) 

Abschließend beenden wir dieses Kapitel mit einer Frage:

Die übergeordneten und untergeordneten Komponenten definieren beide vier Hooks: beforeCreate, created, beforeMounte und mounted. In welcher Reihenfolge werden sie ausgeführt?

Antwort:

Zuerst wird der Initialisierungsprozess der übergeordneten Komponente ausgeführt, sodass beforeCreate und created nacheinander ausgeführt werden. Vor dem Mounten wird der beforeMount-Hook erneut ausgeführt. Wenn jedoch im __patch__-Prozess der Generierung des echten DOM verschachtelte untergeordnete Komponenten angetroffen werden, werden die Initialisierungs-Hooks beforeCreate und created der untergeordneten Komponente ausgeführt. Die untergeordnete Komponente führt beforeMounte vor dem Mounten aus und führt dann mounted aus, nachdem die Dom-Erstellung der untergeordneten Komponente abgeschlossen ist. Der Patchvorgang der übergeordneten Komponente wird abgeschlossen und schließlich wird der gemountete Hook der übergeordneten Komponente ausgeführt. Dies ist ihre Ausführungsreihenfolge. wie folgt:

übergeordnetes Element vor Erstellen
übergeordnetes Element erstellt
Elternteil vor Mounte
    Kind vor Erstellen
    Kind erstellt
    Kind vor Mounte
    Kind montiert
übergeordnet montiert

Dies ist das Ende dieses Artikels über die Konvertierung von Vue Virtual Dom in Real Dom. Weitere relevante Inhalte zu Vue Virtual Dom in Real Dom finden Sie in den vorherigen Artikeln von 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, dass jeder 123WORDPRESS.COM in Zukunft unterstützen wird!