


Javascript-Studiennotizen – Funktionen (3): Abschlüsse und Referenzen_Grundkenntnisse
Eine der wichtigsten Funktionen in Javascript ist die Verwendung von Verschlüssen. Aufgrund der Verwendung von Abschlüssen kann der aktuelle Bereich immer auf externe Bereiche zugreifen. Da Javascript keinen Gültigkeitsbereich auf Blockebene, sondern nur einen Funktionsumfang hat, ist die Verwendung von Abschlüssen eng mit Funktionen verknüpft.
Mock Private Variables
Funktion Counter(start) {
var count = start;
Geben Sie {
zurück inkrementieren: function() {
Zählen ;
},
get: function() {
Rückgabeanzahl;
}
}
}
var foo = Counter(4);
foo.increment();
foo.get(); // 5
Hier gibt Counter zwei Abschlüsse zurück: Funktionen inkrementieren und get. Diese beiden Funktionen behalten den Zugriff auf den Counter-Bereich bei, sodass sie immer auf die im Counter-Bereich definierte Variablenanzahl zugreifen können.
Wie private Variablen funktionieren
Da Javascript keine Bereiche zuweisen oder darauf verweisen kann, gibt es im obigen Beispiel keine Möglichkeit, von außen direkt auf die interne Anzahl privater Variablen zuzugreifen. Der einzige Weg, darauf zuzugreifen, besteht darin, einen Abschluss zu definieren.
var foo = new Counter(4);
foo.hack = function() {
Anzahl = 1337;
};
Der obige Code ändert den Wert der Zählvariablen im Zählerbereich nicht, da der Hack nicht im Zähler definiert ist. Der obige Code erstellt oder überschreibt nur die globale Variablenanzahl.
Abschluss innerhalb einer Schleife
Einer der häufigsten Fehler ist die Verwendung von Verschlüssen innerhalb von Schlaufen.
for(var i = 0; i < 10; i ) {
setTimeout(function() {
console.log(i);
}, 1000);
}
Der obige Code gibt nicht 0 bis 9 aus, sondern 10 Mal kontinuierlich.
Durch die obige Anonymität bleibt immer ein Verweis auf die Variable i erhalten. Wenn die Funktion console.log aufgerufen wird, um die Ausgabe zu starten, ist die Schleife beendet und die Variable i ist bereits 10.
Um den oben genannten Fehler zu vermeiden, müssen wir bei jedem Schleifendurchlauf eine Kopie des Werts der Variablen i erstellen.
Zitierfehler vermeiden
Um den Wert der Variablen in der Schleife zu kopieren, ist es am besten, eine anonyme Funktion zur sofortigen Ausführung in der äußeren Ebene hinzuzufügen.
for(var i = 0; i < 10; i ) {
(Funktion(e) {
setTimeout(function() {
console.log(e);
}, 1000);
})(i);
}
Diese äußere anonyme Funktion empfängt die Schleifenvariable i als ersten Parameter und kopiert ihren Wert in ihren eigenen Parameter e.
Die externe anonyme Funktion übergibt den Parameter e an setTimeout, sodass setTimeout einen Verweis auf den Parameter e hat. Und der Wert dieses Parameters e ändert sich nicht aufgrund externer Schleifenänderungen.
Es gibt eine andere Möglichkeit, den gleichen Effekt zu erzielen, nämlich die Rückgabe einer anonymen Funktion in der anonymen Funktion innerhalb von setTimeout:
for(var i = 0; i < 10; i ) {
setTimeout((function(e) {
return function() {
console.log(e);
}
})(i), 1000)
}
Darüber hinaus kann dies auch durch die Bind-Methode erreicht werden.
for(var i = 0; i < 10; i ) {
setTimeout(console.log.bind(console, i), 1000);
}
Lassen Sie uns am Ende des Artikels zusammenfassen:
(1) Schließung ist ein Designprinzip, das die Aufrufe des Benutzers durch die Analyse des Kontexts vereinfacht und es dem Benutzer ermöglicht, sein Ziel zu erreichen, ohne es zu wissen
(2) Die gängigen Artikel zur Verschlussanalyse im Internet widersprechen tatsächlich dem Verschlussprinzip. Wenn Sie die Details des Verschlusses kennen müssen, ist der Verschluss ein Konstruktionsfehler
(3) Lernen Sie so wenig wie möglich.

Heiße KI -Werkzeuge

Undresser.AI Undress
KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover
Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Undress AI Tool
Ausziehbilder kostenlos

Clothoff.io
KI-Kleiderentferner

AI Hentai Generator
Erstellen Sie kostenlos Ai Hentai.

Heißer Artikel

Heiße Werkzeuge

Notepad++7.3.1
Einfach zu bedienender und kostenloser Code-Editor

SublimeText3 chinesische Version
Chinesische Version, sehr einfach zu bedienen

Senden Sie Studio 13.0.1
Leistungsstarke integrierte PHP-Entwicklungsumgebung

Dreamweaver CS6
Visuelle Webentwicklungstools

SublimeText3 Mac-Version
Codebearbeitungssoftware auf Gottesniveau (SublimeText3)

Heiße Themen

In C++ ist ein Abschluss ein Lambda-Ausdruck, der auf externe Variablen zugreifen kann. Um einen Abschluss zu erstellen, erfassen Sie die äußere Variable im Lambda-Ausdruck. Abschlüsse bieten Vorteile wie Wiederverwendbarkeit, Ausblenden von Informationen und verzögerte Auswertung. Sie sind in realen Situationen nützlich, beispielsweise bei Ereignishandlern, bei denen der Abschluss auch dann noch auf die äußeren Variablen zugreifen kann, wenn diese zerstört werden.

C++-Lambda-Ausdrücke unterstützen Abschlüsse, die Funktionsbereichsvariablen speichern und sie für Funktionen zugänglich machen. Die Syntax lautet [capture-list](parameters)->return-type{function-body}. Capture-Liste definiert die zu erfassenden Variablen. Sie können [=] verwenden, um alle lokalen Variablen nach Wert zu erfassen, [&], um alle lokalen Variablen nach Referenz zu erfassen, oder [Variable1, Variable2,...], um bestimmte Variablen zu erfassen. Lambda-Ausdrücke können nur auf erfasste Variablen zugreifen, den ursprünglichen Wert jedoch nicht ändern.

Ein Abschluss ist eine verschachtelte Funktion, die auf Variablen im Bereich der äußeren Funktion zugreifen kann. Zu ihren Vorteilen gehören Datenkapselung, Zustandserhaltung und Flexibilität. Zu den Nachteilen gehören der Speicherverbrauch, die Auswirkungen auf die Leistung und die Komplexität des Debuggens. Darüber hinaus können Abschlüsse anonyme Funktionen erstellen und diese als Rückrufe oder Argumente an andere Funktionen übergeben.

Zu den Vorteilen von Funktionen, die Referenztypen in C++ zurückgeben, gehören: Leistungsverbesserungen: Durch die Übergabe als Referenz wird das Kopieren von Objekten vermieden, wodurch Speicher und Zeit gespart werden. Direkte Änderung: Der Aufrufer kann das zurückgegebene Referenzobjekt direkt ändern, ohne es neu zuzuweisen. Einfachheit des Codes: Die Übergabe als Referenz vereinfacht den Code und erfordert keine zusätzlichen Zuweisungsvorgänge.

Die Auswirkungen von Funktionszeigern und -abschlüssen auf die Go-Leistung sind wie folgt: Funktionszeiger: Etwas langsamer als direkte Aufrufe, aber verbessert die Lesbarkeit und Wiederverwendbarkeit. Schließungen: Normalerweise langsamer, kapseln aber Daten und Verhalten. Praktischer Fall: Funktionszeiger können Sortieralgorithmen optimieren und Abschlüsse können Ereignishandler erstellen, aber sie bringen Leistungseinbußen mit sich.

Referenzen und Zeiger sind in C++ beide Methoden zur Übergabe von Funktionsparametern, es gibt jedoch Unterschiede. Eine Referenz ist ein Alias für eine Variable. Durch Ändern der Referenz wird die ursprüngliche Variable geändert, während der Zeiger die Adresse der Variablen speichert. Wenn Sie sich für die Verwendung einer Referenz oder eines Zeigers entscheiden, müssen Sie Faktoren berücksichtigen, z. B. ob die ursprüngliche Variable geändert werden muss, ob ein Nullwert übergeben werden muss, und Leistungsaspekte.

Durch die Verwendung von Zeigern und Referenzen kann die Speichernutzung in C++ optimiert werden: Zeiger: Speichern Adressen anderer Variablen und können auf andere Variablen verweisen, wodurch Speicher gespart wird, aber möglicherweise wilde Zeiger generiert werden. Referenz: Alias für eine andere Variable, zeigt immer auf dieselbe Variable, generiert keine Platzhalter und ist für Funktionsparameter geeignet. Die Optimierung der Speichernutzung kann die Effizienz und Leistung des Codes verbessern, indem unnötige Kopien vermieden, Speicherzuweisungen reduziert und Platz gespart werden.

Abschlüsse in Java ermöglichen es inneren Funktionen, auf äußere Bereichsvariablen zuzugreifen, selbst wenn die äußere Funktion beendet wurde. Durch anonyme innere Klassen implementiert, enthält die innere Klasse einen Verweis auf die äußere Klasse und hält die äußeren Variablen aktiv. Schließungen erhöhen die Codeflexibilität, Sie müssen sich jedoch des Risikos von Speicherverlusten bewusst sein, da Verweise auf externe Variablen durch anonyme innere Klassen diese Variablen am Leben halten.
