Zusammenfassung der benutzerdefinierten JavaScript-Objektmethoden

Zusammenfassung der benutzerdefinierten JavaScript-Objektmethoden

1. Verwenden Sie Objekt, um ein Objekt zu erstellen

<Skript>
        // Ein Objekt erstellen var stu = new Object()
        // Füge dem Objekt das Attribut stu.name='jibu' hinzu
        stu[9527] = 'jibu' //Spezielle Attributnamen verwenden Klammern //Methoden zu Objekten hinzufügen stu.study = function(){
            console.log('Lernen')
        }
        // Objekteigenschaften und Methoden aufrufen console.log(stu.name,stu['name'])
        //Methode stu.study() aufrufen
    </Skript>

2. Verwenden Sie den Konstruktor, um ein Objekt zu erstellen

<Skript>
        // 1. Definieren Sie einen Konstruktor, um eine Objektfunktion Student() { zu erstellen.
            // Objekteigenschaft this.name = "jibu"
            dieses.Alter = 18
                //Objektmethode this.study = function() {
                console.log('Lernen…')
            }
        }
        // 2. Rufen Sie den Konstruktor auf, um ein Objekt zu erstellen var stu = new Student()
        Konsole.log(stu.name)
        stu.studie()

        // Einen Konstruktor mit Parametern definieren // Einen Konstruktor zum Erstellen einer Objektfunktion definieren Student(name, age) {
            // Objekteigenschaft this.name = name
            this.age = Alter
                //Objektmethode this.study = function() {
                console.log('Lernen…')
            }
        }
        //Rufen Sie den Konstruktor auf, um das Objekt zu erstellen var stu = new Student('tom', 18)
        Konsole.log(stu.name)
        stu.studie()
    </Skript>

Drei wörtliche Objekte

var stu = {
            Name: 'jibu',
            Alter: 100,
            'Spezielle Variablen': 1111
            Studie: Funktion() {
                console.log('Lernen')
            },
            anzeigen: function() {
                console.log('Mein Name ist' + dieser.Name, 'Alter:' + dieses.Alter)
            }
        }
        Konsole.log(stu.name)
        console.log(stu['spezielle Variable']

Vier dieser Schlüsselwörter

Dies stellt das aktuelle Objekt dar

  • this bezieht sich in einer Funktion auf das aktuelle Objekt, das die Funktion aufruft.
  • this gibt in der anonymen Rückruffunktion der Ereignisbindung die Ereignisquelle an
  • Dies stellt im Konstruktor das aktuelle Objekt dar, das in Zukunft new erstellt wird

Beispiel 1

<Skript>
        // dies bezieht sich in der Funktion auf den Aufrufer der Funktion var a = 1

        Funktion f1() {
            var a = 2
            console.log(dies)
                // Lösen Sie das Problem, dass lokale und globale Variablen den gleichen Namen haben console.log('local variable: ', a)
            console.log('Globale Variablen: ', window.a)
            console.log('Globale Variablen: ', this.a)

        }
        f1()
    </Skript>

Beispiel 2

 <Skript>
        fenster.onload = funktion() {
            Dokument.QuerySelector('#btn').onclick = Funktion() {
                console.log(this) //Hier stellt dies das Zielelement der Ereignisquelle dar, die das Ereignis auslöst}
        }
    </Skript>
</Kopf>

<Text>
    <button id="btn">Schaltfläche</button>
</body>

Beispiel 3

<Skript>
        Funktion Student(Name, Alter) {
            // dies stellt im Konstruktor das aktuelle Objekt dar, das in Zukunft neu erstellt wird this.name = name
            this.age = Alter
        }
    </Skript>

Fünf grundlegende Datentypen und Referenzdatentypen

Grundlegende Datentypen

Zeichenfolge, Zahl, Boolesch, undefiniert, null

<Skript>
        var a = 5
        var b = a
        b = 8
        konsole.log(a)
        console.log(b)
    </Skript>

Das Erstellen einer Variablen a und b die auf a verweisen, entspricht dem Zuweisen einer Kopie, und Änderungen wirken sich nicht gegenseitig aus

Referenzdatentypen

Objekt, Array, Student…

<Skript>
        var stu1 = {
            Name: 'Tom',
            Alter: 18
        }
        var stu2 = stu1; //weise die Adresse von stu1 stu2 zu
        stu1.name = "alice"
        console.log(stu1.name)
        console.log(stu2.name)
    </Skript>

Sie werden feststellen, dass die Operationen dieselben sind wie bei den grundlegenden Datentypen, die Ergebnisse jedoch unterschiedlich sind und sich gegenseitig beeinflussen.
Dabei handelt es sich um das Speicherproblem

Es gibt zwei Arten von Speicher:

Stapelspeicher:

Variablen grundlegender Datentypen und Verweise auf Variablen von Referenzdatentypen werden im Stapelspeicher gespeichert und die Zugriffsgeschwindigkeit ist relativ schnell.

Heap-Speicher:

Variablen von Referenzdatentypen werden im Heap-Speicher gespeichert und die Zugriffsgeschwindigkeit ist langsam

Variablen von Referenzdatentypen werden im Stapel (Speicheradresse) gespeichert, und ihre Objekte werden im Heap gespeichert. Stu2, das auf Stu1 verweist, ist tatsächlich dieselbe Speicheradressenreferenz, und die Ergebnisse sind dieselben, wenn alle Änderungen vorgenommen werden.

Variablen und Werte grundlegender Datentypen werden im Stapel gespeichert. Der Wert von a wird an b übergeben und alle Änderungen wirken sich nicht gegenseitig aus.

Sechs Schließungen

Wie ist Abschluss zu verstehen?

  • Eine Funktion wird innerhalb einer Funktion definiert. Diese Funktion wird als Closure bezeichnet.
  • Closures sind Funktionen, die Variablen innerhalb anderer Funktionen lesen können.
  • Ein Abschluss ist eine in einem Bereich definierte Funktion, die auf alle Variablen in diesem Bereich zugreifen kann.
  • Funktional gesehen ist ein Abschluss eine Brücke, die die internen und externen Funktionen einer Funktion verbindet.

Verwendung von Verschlüssen

  • Innerhalb der Funktion können Sie die Variablen innerhalb der Funktion lesen
  • Behalten Sie den Wert der Variablen im Speicher

Verwendung von Verschlüssen

   <Skript>
        Funktion add() {
            für (var i = 1; i <= 5; i++) {
                var li = document.createElement('li')
                li.innerText = 'li' + i
                li.onclick = Funktion() {
                    console.log('Geklickt' + i + 'li')
                }
                document.getElementById('myul').appendChild(li)
            }
        }
    </Skript>
    <Stil>
        ul {
            Breite: 300px;
            Höhe: 300px;
            Rand: 1px durchgezogen #ccc;
        }
    </Stil>
</Kopf>

<Text>
    <button onclick="add()">Element hinzufügen</button>
    <ul id="meinul">

    </ul>
</body>



Da die Schleife endet, wenn auf die Schaltfläche des Elements geklickt wird, wird nur das letzte Element erhalten, das einen Abschluss bildet

Lösung 1:

Definieren Sie es nicht innerhalb der Funktion, definieren Sie die Funktion außerhalb und rufen Sie sie innerhalb der Funktion auf

<Skript>
        Funktion add() {
            für (var i = 1; i <= 5; i++) {
                var li = erstelleLi(i)
                document.getElementById('myul').appendChild(li)
            }
        }

        Funktion erstelleLi(num) {
            var li = document.createElement('li')
            li.innerText = 'li' + num
            li.onclick = Funktion() {
                console.log('Geklickt' + num + 'li')
            }
            Rückkehr li
        }

Lösung 2:

Fügen Sie Elementen Attribute hinzu, um Variablen zu speichern

<Skript>
        Funktion add() {
            für (var i = 1; i <= 5; i++) {
                var li = document.createElement('li')
                li.innerText = 'li' + i
                li.num = i; //Daten speichern li.onclick = function() {
                    console.log('Geklickt' + this.num + 'li')
                }
                document.getElementById('myul').appendChild(li)
            }
        }
    </Skript>

Lösung 3:

Definieren von Variablen mit let

Im Bereich auf Blockebene wird der Bereich, in dem die Variablen deklariert sind, nicht von externen Faktoren beeinflusst. Dies wird als vorübergehender Tod bezeichnet.

<Skript>
        Funktion add() {
            für (lass i = 1; i <= 5; i++) {
                var li = document.createElement('li')
                li.innerText = 'li' + i
                li.onclick = Funktion() {
                    console.log('Geklickt' + i + 'li')
                }
                document.getElementById('myul').appendChild(li)
            }
        }
    </Skript>

Sieben Json

JavaScript Object Notation ist ein einfaches Datenaustauschformat zur Darstellung von JavaScript Objekten. Es verwendet ein von der Programmiersprache unabhängiges Textformat, das sich leicht schreiben und lesen sowie leicht analysieren und generieren lässt.

Grundlegende Verwendung

{“屬性名”:“屬性值”,“屬性名”:“屬性值”…}

Beachten:

  • Die Json Struktur besteht aus einer Reihe von Schlüssel-Wert-Paaren, die Json -Objekt bezeichnet werden.
  • Verwenden Sie doppelte Anführungszeichen für Attributnamen
  • Der Unterschied zwischen JSON- und Objektliteralen: JSON-Attribute müssen doppelte Anführungszeichen verwenden, während Objektliterale ohne doppelte Anführungszeichen sein können.

Attribute einhalten

<Skript>
        //Der zusammengesetzte Attributwert ist ein JSON-Objekt var user = {
            "Name": {
                "Vorname": "ji",
                "Nachname": "bu"
            },
            "Alter": 100
        }
        console.log(Benutzername.Vorname)
    </Skript>

Sammlung von JSON-Objekten

<Skript>
        //Der zusammengesetzte Attributwert ist ein JSON-Objekt var user = [{
                    "Ich würde": 1,
                    "Vorname": "ji",
                    "Nachname": "bu"
                }, {
                    "Ich würde": 1,
                    "Vorname": "ji",
                    "Nachname": "bu"
                }, {
                    "Ich würde": 1,
                    "Vorname": "ji",
                    "Nachname": "bu"
                },

            ]
            //Schleife für (var i = 0; i < Benutzerlänge; i++) {
            console.log(Benutzer[i])
        }
    </Skript>

JSON-Operationen

 <Skript>
        //JSon-Objekt in String umwandeln var stu = {
            "Ich würde": 1,
            "Name": "jibu"
        }
        console.log(Typ von stu)
        var str = JSON.stringify(stu);
        console.log(Typ von str)


        //Konvertiere den String in JSON
        var str = '{"id": 1,"name": "jibu"}'
        console.log(Typ von str)

        var obj = JSON.parse(str)
        console.log(Objekttyp)
    </Skript>



Dies ist das Ende dieses Artikels über benutzerdefinierte JavaScript Objekte. Weitere relevante benutzerdefinierte JavaScript-Objekte 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:
  • Objekte in JavaScript verstehen
  • Detaillierte Erklärung von Objekten in Javascript
  • Detaillierte Zusammenfassung der JavaScript-Objekte
  • Fünf Möglichkeiten, um festzustellen, ob ein Objektattribut in JS vorhanden ist
  • JavaScript entfernt unnötige Eigenschaften eines Objekts
  • Wenn die Springboot-Post-Schnittstelle JSON akzeptiert und es in ein Objekt konvertiert wird, sind alle Eigenschaften null.
  • 5 häufig verwendete Objekte in JavaScript
  • Implementierung der Konvertierung komplexer JSON-Zeichenfolgen in verschachtelte Java-Objekte
  • Erlernen Sie die Anwendung und Beispiele zum Hinzufügen, Löschen, Ändern und Abfragen von Javascript-Objekten.

<<:  Eine kurze Analyse der Grundkonzepte von HTML-Webseiten

>>:  Docker-Installation von RocketMQ und Lösungen für während der Installation aufgetretene Probleme

Artikel empfehlen

So beheben Sie den Fehler "ERROR 1045 (28000)" beim Anmelden bei MySQL

Heute habe ich mich beim Server angemeldet und mi...

Detaillierte Erklärung zur Installation von MySQL in der Alibaba Cloud

Als leichte Open-Source-Datenbank wird MySQL häuf...

So verwenden Sie Docker, um Containerressourcen zu begrenzen

Problem beim Gucken Angenommen, der IIS-Dienst st...

So verwenden Sie den Flat Style zum Gestalten von Websites

Das Wesen einer flachen Website-Struktur liegt in...

Vite2.0 Fallstricke

Inhaltsverzeichnis Optimierung des Vite-Projektau...

Zwei Arten von Tab-Anwendungen im Webdesign

Heutzutage werden Registerkarten häufig im Webdes...

Analyse der Prinzipien der MySQL Slow Query-bezogenen Parameter

MySQL Slow Query, dessen vollständiger Name „Slow...

Vue + SSM realisiert den Vorschaueffekt beim Hochladen von Bildern

Die aktuelle Anforderung lautet: Es gibt eine Sch...