Details zu den Überwachungseigenschaften der Uhr in Vue

Details zu den Überwachungseigenschaften der Uhr in Vue

Stellen Sie zunächst sicher, dass die Uhr ein Objekt ist, und verwenden Sie sie als solches.

Schlüssel: Das ist der, den Sie überwachen möchten;

Wert: kann eine Funktion sein. Wenn sich das überwachte Objekt ändert, muss die Funktion ausgeführt werden. Diese Funktion hat zwei Parameter.

Der erste ist der aktuelle Wert (neuer Wert), der zweite ist der Wert vor der Aktualisierung (alter Wert).

Der Wert kann auch ein Funktionsname sein: Der Funktionsname muss jedoch in einfache Anführungszeichen eingeschlossen sein.

Der Wert ist ein Objekt, das Optionen enthält: Es gibt drei Optionen.

  • 1. Der erste handler : Sein Wert ist eine Rückruffunktion. Das heißt, die Funktion soll ausgeführt werden, wenn eine Änderung erkannt wird.
  • 2. Der Zweite ist deep : Sein Wert ist wahr oder falsch; bestätigen Sie, ob eine tiefe Überwachung erfolgen soll. (Normalerweise können Sie während der Überwachung keine Änderungen der Objekteigenschaftswerte hören, aber Sie können Änderungen der Array-Werte hören.)
  • 3. Der dritte ist immediate : sein Wert ist wahr oder falsch; bestätigen Sie, ob die Handler-Funktion mit dem aktuellen Anfangswert ausgeführt werden soll.

1.watch überwacht Änderungen in allgemeinen Daten (numerische Werte, Zeichenfolgen, Boolesche Werte)

Zum Beispiel:

1. Zahlenwert

Wenn wir im data num durch das Klickereignis ändern, überwachen wir ihre Änderungen durch watch

<div id="app">
        <p>{{Anzahl}}</p>
        <button @click="num++">Klicken, um einen hinzuzufügen</button>
    </div>
      lass vm = neues Vue({
            el:'#app',
            Daten:{
                Zahl: 0
            },
            betrachten:{
            // Aktueller Wert (geänderter Wert) newval alter Wert oldval
                Num:Funktion(neuerWert,alterWert){
                    console.log("Der neue Wert ist: "+newval);
                    console.log("Alter Wert ist: "+oldval);
                }
            }
        })


Wenn wir auf die Schaltfläche klicken, überprüfen Sie die Konsole:

Hinweis: Es gibt zwei weitere Methoden in der Uhr

 betrachten:{
            // Aktueller Wert (geänderter Wert) newval alter Wert oldval
                // Num(neuer Wert,alter Wert){
                // console.log("Der neue Wert ist: "+newval);
                // console.log("Alter Wert ist: "+oldval);
                // }
                Zahl:{
                    Handler (neuer Wert, alter Wert) {
                    console.log("Der neue Wert ist: "+newval);
                    console.log("Alter Wert ist: "+oldval);
                    }
                }
            }


Die Ausgabeergebnisse sind konsistent. Die folgenden Beispiele verwenden alle die dritte Methode, also die Methode mit einem handler .

2. Saiten

<div id="app">
        <Eingabetyp="Text" v-Modell="mes">
        <p>Der Eingabeinhalt ist: {{mes}}</p>
    </div>
 lass vm = neues Vue({
            el:'#app',
            Daten:{
                mes:''
            },
            betrachten:{
                mes:{
                    Handler (neuer Wert, alter Wert) {
                        console.log("Neuer Inhalt: "+newval);
                        console.log("alter Inhalt: "+oldval);
                    }
                }
            }
        })


Wenn wir Inhalt in das Textfeld eingeben:

Sehen Sie sich die Ausgabe an:

3. Boolesche Werte

<div id="app">
        <p v-show="isShow">Anzeigen und Ausblenden durch Ändern des Booleschen Werts</p>
        <button @click="isShow = !isShow">Klicken, um den Booleschen Wert zu ändern</button>
    </div>
 

lass vm = neues Vue({
            el:'#app',
            Daten:{
                isShow:true
            },
            betrachten:{
                istAnzeigen:{
                    Handler (neuer Wert, alter Wert) {
                        console.log("Neuer Wert: "+newval);
                        console.log("alter Wert: "+oldval);
                    }
                }
            }
        })

Wenn die Schaltfläche angeklickt wird, überprüfen Sie die Konsole:

2.watch überwacht Änderungen in komplexen Datentypen

Deep-Attribut: Objektänderungen gründlich überwachen (gibt an, ob eine gründliche Überwachung erfolgen soll). Wenn Sie die Änderungen eines Objekts überwachen müssen, kann die normale Überwachungsmethode die Änderungen der internen Eigenschaften des Objekts nicht überwachen. Zu diesem Zeitpunkt ist das Deep-Attribut erforderlich, um das Objekt gründlich zu überwachen.

1. Gegenstand

<div id="app">
        <Eingabetyp="Text" v-Modell="mes.name">
        <p>Der Eingabeinhalt ist: {{mes.name}}</p>
    </div>
lass vm = neues Vue({
            el:'#app',
            Daten:{
                mes:{name:''}
            },
            betrachten:
                mes:{
                    // Beim Beobachten der Überwachungseigenschaft des Überwachungsobjekts sind die neuen und alten Werte identisch handler(newval){
                        console.log("Neuer Wert: "+this.mes.name);
                    },
                    tief:wahr
                }
            }
        })


Nachdem Sie etwas in das Textfeld eingegeben haben, überprüfen Sie die Konsole:

Sie können dem Objekt auch num hinzufügen, den Wert von num über den Schieberegler steuern und zuhören:

 <Eingabetyp="Bereich" v-Modell="mes.num">
 Daten:{
                mes:{name:'',num:''}
            },
 
betrachten:
                mes:{
                    // Beim Beobachten der Überwachungseigenschaft des Überwachungsobjekts sind die neuen und alten Werte identisch handler(newval){
                        console.log("num neuer Wert: "+this.mes.num);
                    },
                    tief:wahr
                }
            }


Sehen Sie sich die Ausgabe beim Sliden an:

2. Anordnung

<Text>
    
    <div id="app">
        <ul>
            <li v-for="(Artikel,Index) in arr">{{Artikel}}</li>
        </ul>
        <!-- Fügen Sie eine Schaltfläche hinzu, die beim Klicken dem Array neuen Inhalt hinzufügt -->
        <button @click="add()">Zum Hinzufügen klicken</button>
    </div>
 
    <script src="./js/vue.js"></script>
    <Skript>
        lass vm = neues Vue({
            el:'#app',
            Daten:{
                arr:[1,2,3,4,5]
            },
            Methoden:{
                hinzufügen(){
                    // Den aktuellen Maximalwert des Arrays abrufen let cont = this.arr[this.arr.length-1];
                    // Selbstinkrementierung cont++;
                    // Füge an der letzten Position des Arrays ein Element hinzu this.arr.push(cont);
                }
            },
            betrachten:
                arr:{
            // Wenn Sie ein Array überwachen, ist keine umfassende Überwachung erforderlich.
                    Handler (neuer Wert) {
                        console.log("Das neue Array ist: "+newval);
                    }
                }
            }
        })
    </Skript>
</body>


Nachdem Sie auf „Element hinzufügen“ geklickt haben, überprüfen Sie die Ausgabe:

3. Objekt-Array

<Text>
    
    <div id="app">
        <ul>
            <li v-for="Element in Liste">
                {{item.id}}--{{item.name}}
            </li>
        </ul>
        <!-- Definieren Sie das Textfeld und fügen Sie dem Array ein neues Objekt hinzu -->
        <Eingabetyp="Text" v-Modell="id">
        <Eingabetyp="Text" v-Modell="Name">
        <button @click="add()">Hinzufügen</button>
    </div>
 
    <script src="./js/vue.js"></script>
    <Skript>
        lass vm = neues Vue({
            el:'#app',
            Daten:{
                Liste:[
                    {id:1,name:"Geburtstag"},
                    {id:2,name:"Geburtstagsgeschenk"},
                    {id:3,name:"Geburtstagsgeschenk"}
                ],
                Ausweis:"",
                Name:''
            },
            Methoden: {
                // Die empfangene Eingabe dem Array hinzufügen add(){
                    diese.list.push({id:diese.id,name:dieser.name});
                    // Löschen Sie den Inhalt des Textfelds this.id=this.name=''
                }
            },
            betrachten:{
                // Hinweis: Die im Überwachungsobjekt überwachten Daten müssen die Daten sein, die bereits in den Daten des Rechenzentrums vorhanden sind. // Die neuen und alten Werte des Überwachungsarray-Objekts der Überwachung sind gleich, aber bei der Überwachung des Arrays ist keine gründliche Überwachung erforderlich!
                Liste:{
                    Handler (neuer Wert) {
                        neuer Wert.fürJeden((Artikel)=>{
                            Konsole.log(Elementname);
                        })                       
                    }
                }
            }
        })
    </Skript>
</body>


Sehen Sie sich die Ausgabe nach dem Hinzufügen eines neuen Elements an:

4. Eigenschaften von Objekt-Arrays

<Text>
    
    <div id="app">
        <ul>
            <li v-for="x in Liste">
                {{x.id}}---{{x.name}} &emsp;
                <button @click="mod(x.id)">Ändern</button>
            </li>
        </ul>
    </div>
 
    <script src="./js/vue.js"></script>
    <Skript>
        lass vm = neues Vue({
            el:'#app',
            Daten:{
                Liste:[
                    {id:1,name:'ww'},
                    {id:2,name:'ee'},
                    {id:3,name:'qq'}
                ],
            },
            Methoden: { 
                mod(id,name){
                    diese.Liste.fürJeden((Element)=>{
                        // Treffen Sie während des Durchlaufs eine Entscheidung. Wenn die angeklickte ID die Daten sind, die Sie gerade bearbeiten, if (item.id == id) {
                            item.name = "Altes Eisen"
                            konsole.log(Element);
                        }
                    })
                }
            },
            betrachten:
                Liste:{
                    handler(x,y){
                        x.fürJedes((element)=>{
                            Konsole.log(Element.Name);
                        })
                    },
                    tief:wahr
                }
            }
        })
    </Skript>
</body>


Wenn Sie auf „Ändern“ klicken, sehen Sie sich die Ausgabe an:

Dies ist das Ende dieses Artikels über die Details der Überwachungseigenschaften in Vue. Weitere relevante Inhalte zu den Überwachungseigenschaften in Vue finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, Sie werden 123WORDPRESS.COM auch in Zukunft unterstützen!

Das könnte Sie auch interessieren:
  • Detaillierte Erklärung zur Verwendung von watch zum Überwachen von Datenänderungen in Miniprogrammen
  • Detaillierte Erläuterung der Änderungen der Überwachungsdaten in Vue und der einzelnen Attribute in der Uhr
  • Datenänderungen im Vue-Projekt werden von Watch überwacht und verarbeitet

<<:  Eine kurze Diskussion darüber, ob CSS das Rendern von Seiten blockiert

>>:  Einführung in die Verwendung des HTML-Elements Noscript

Artikel empfehlen

Anfänger verstehen das MySQL-Deadlock-Problem anhand des Quellcodes

Nach vielen schwierigen Einzelschritt-Debuggings ...

Grafisches Tutorial zur Installation und Konfiguration von MySQL 5.7.17

Der Blogger sagte : Ich habe eine Reihe von Blogb...

Implementierung einer Fuzzy-Abfrage wie %% in MySQL

1, %, steht für beliebige 0 oder mehr Zeichen. Es...

Verwenden Sie nginx + sekundären Domänennamen + https-Unterstützung

Schritt 1: Fügen Sie dem primären Domänennamen vo...

Docker-Pull-Image und Tag-Vorgang Pull | Tag

Ich habe den Quellcode des Fabric-Projekts noch e...

Einführung in MySQL-Rollenfunktionen

Inhaltsverzeichnis Vorwort: 1. Einführung in die ...

mysql5.6.zip-Format komprimierte Version Installations-Grafik-Tutorial

Vorwort: MySQL ist ein relationales Datenbankverw...

Eine kurze Diskussion über die Rolle von Vue3 defineComponent

Inhaltsverzeichnis defineComponent-Überladungsfun...

Details zum MySQL-Index-Pushdown

Inhaltsverzeichnis 1. Prinzip des ganz linken Prä...