


In der vorherigen Einführung wissen wir bereits, dass Javascript keinen Gültigkeitsbereich auf Blockebene hat, sondern nur einen Gültigkeitsbereich auf Funktionsebene.
function test() { // ein Bereich
for(var i = 0; i // zählen
}
console.log(i); // 10
}
Außerdem gibt es in Javascript keine expliziten Namespaces, was bedeutet, dass alles im globalen Bereich definiert ist. Jedes Mal, wenn auf eine Variable verwiesen wird, durchläuft Javascript den gesamten globalen Bereich, bis es die Variable findet. Wenn die Variable nach dem Durchlaufen des gesamten globalen Bereichs nicht gefunden wird, wird ein ReferenceError ausgelöst.
Bitte geben Sie eine Bildbeschreibung ein
Implizite globale Variablen
// Skript A
foo = '42';
// Skript B
var foo = '42'
Die beiden oben genannten Beispiele erzeugen unterschiedliche Effekte. Der erste definiert die Variable foo im globalen Bereich, während der zweite die Variable foo im aktuellen Bereich definiert.
Wir müssen beachten, dass die Nichtverwendung des Schlüsselworts var unerwartete Auswirkungen haben wird.
// globaler Geltungsbereich
var foo = 42;
Funktionstest() {
// lokaler Geltungsbereich
foo = 21;
}
test();
foo; // 21
Da var nicht zum Definieren der Variablen foo im Funktionstest verwendet wird, wird die globale Variable foo außerhalb der Funktion überschrieben. Obwohl dies kein großes Problem zu sein scheint, kann es bei Tausenden von Codezeilen schwierig sein, diesen Fehler aufzuspüren.
// globaler Geltungsbereich
var items = [/* some list */];
for(var i = 0; i subLoop();
}
Funktion subLoop() {
// Umfang von subLoop
for(i = 0; i // Mach tolle Sachen!
}
}
Im obigen Beispiel stoppt die äußere Schleife bei ihrer ersten Ausführung, da die Variable i innerhalb der Unterschleifenfunktion die äußere globale Variable i überschreibt. Wir müssen nur eine Variable innerhalb der Funktion hinzufügen, um diesen Fehler zu vermeiden. Daher dürfen wir beim Definieren von Variablen nicht vergessen, das Schlüsselwort Var hinzuzufügen. Es sei denn, wir wollen wirklich externe globale Variablen beeinflussen.
Lokale Variablen
Lokale Variablen in Javascript können nur auf zwei Arten generiert werden: Zum einen durch die Deklaration über das Schlüsselwort var und zum anderen als formaler Parameter einer Funktion.
// globaler Geltungsbereich
var foo = 1;
var bar = 2;
var i = 2;
Funktionstest(i) {
// lokaler Umfang des Funktionstests
i = 5;
var foo = 3;
bar = 4;
}
test(10);
Zu diesem Zeitpunkt sind die Variablen i und foo im Funktionstest lokale Variablen, und bar überschreibt die externe globale Variable bar.
Heben
Javascript hebt Variablendeklarationen an, was bedeutet, dass Variablenausdrücke und Funktionsdeklarationen an die Spitze des Gültigkeitsbereichs gehoben werden.
bar();
var bar = function() {};
var someValue = 42;
test();
Funktionstest(Daten) {
Wenn (falsch) {
goo = 1;
} sonst {
var goo = 2;
}
for(var i = 0; i var e = data[i];
}
}
Bevor der obige Code ausgeführt wird, werden der var-Ausdruck und die Deklaration des Funktionstests nach oben verschoben, sodass das Programm normal ausgeführt wird und kein Fehler gemeldet wird.
// var-Anweisungen wurden hierher verschoben
var bar, someValue; // Standardwert ist „undefiniert“
// Die Funktionsdeklaration wurde ebenfalls nach oben verschoben
Funktionstest(Daten) {
var goo, i, e; // fehlender Blockbereich verschiebt diese hierher
Wenn (falsch) {
goo = 1;
} sonst {
goo = 2;
}
for(i = 0; i e = data[i];
}
}
bar(); // schlägt mit einem TypeError fehl, da bar immer noch „undefiniert“ ist
someValue = 42; // Zuweisungen sind vom Hochziehen nicht betroffen
bar = function() {};
test();
Da Javascript keinen Gültigkeitsbereich auf Blockebene hat, erhöht dies nicht nur den var-Ausdruck, sondern macht auch die if-Struktur weniger intuitiv.
Obwohl es im obigen Beispiel so aussieht, als ob die globale Variable goo bearbeitet wird, handelt es sich tatsächlich um eine lokale Variable, die geändert wird, da die Variable goo heraufgestuft wird.
Ohne die Heberegeln zu verstehen, könnten Sie denken, dass der folgende Code einen ReferenceError auslöst.
// prüfen, ob SomeImportantThing initialisiert wurde
if (!SomeImportantThing) {
var SomeImportantThing = {};
}
Natürlich ist der obige Code fehlerfrei, da der var-Ausdruck vor der Ausführung des Codes nach oben verschoben wurde.
var SomeImportantThing;
// Anderer Code könnte SomeImportantThing hier initialisieren oder auch nicht
// Stellen Sie sicher, dass es da ist
if (!SomeImportantThing) {
SomeImportantThing = {};
}
Ich möchte den Blogbeitrag „Understanding JavaScript (2)“ von @nightire Fan Ge empfehlen, in dem die Verbesserung sehr ausführlich erklärt wird.
Reihenfolge der Namensauflösung
Beim Versuch, innerhalb eines Funktionsbereichs auf eine foo-Variable zuzugreifen, sucht Javascript in der folgenden Reihenfolge:
Ob es im aktuellen Geltungsbereich eine Definition von var foo gibt.
Ob der Funktionsparameter eine foo-Variable enthält.
Ob die Funktion selbst foo heißt.
Springen Sie zur äußeren Domäne und suchen Sie ab dem ersten Teil.
Namensraum
Eines der häufigsten Probleme sind Namenskonflikte, die dadurch verursacht werden, dass Javascript nur einen globalen Gültigkeitsbereich hat. Dieses Problem kann jedoch durch anonyme externe Funktionen gelöst werden.
(function() {
// ein eigenständiger „Namespace“
window.foo = function() {
// ein freigelegter Verschluss
};
})(); // Funktion sofort ausführen
Die anonymen Funktionen im obigen Beispiel gelten als Ausdrücke und werden daher ausgeführt.
( // Werte die Funktion innerhalb der Klammern aus
function() {}
) // und das Funktionsobjekt zurückgeben
() // Ergebnis der Auswertung aufrufen
Natürlich können wir Funktionsausdrücke auch auf andere Weise aufrufen, mit unterschiedlicher Struktur, aber gleicher Wirkung.
// Ein paar andere Stile zum direkten Aufrufen von
!function(){}()
function(){}()
(function(){}());
// und so weiter...
Zusammenfassung
Es wird empfohlen, anonyme externe Funktionen zu verwenden, um den Code in einen Raum zu kapseln. Dies kann nicht nur Namespace-Konflikte lösen, sondern auch die Modularisierung des Programms erleichtern.
Darüber hinaus ist die Verwendung globaler Variablen keine gute Praxis, da die Wartung kostspielig und fehleranfällig ist.
Namespace-Typen, Funktionen, Variablen, Vorlagen usw. gehören alle zu Entitäten.
Das Wichtigste, was Entitäten gemeinsam haben, ist, dass sie Namen haben können. (Außerdem kann ein Label auch einen Namen haben, ist aber keine Entität.)
Der Namespace-Bereich ist ein allgemeiner Begriff für einen Bereichstyp, der dem Block-Bereich, dem Klassen-Bereich, dem Funktions-Prototyp-Bereich und dem Funktions-Bereich gegenübergestellt wird (nur gültig für Labels). Innerhalb eines Namespace deklarierte Namen liegen im Namespace-Gültigkeitsbereich. Globale Namen gelten als im impliziten globalen Namespacebereich liegend.
Die Rolle eines Namespace ist zwar ein Bereich, unterscheidet sich jedoch von einem einfachen Bereich. Sie können denselben Namespace mehrmals an mehreren Stellen deklarieren, der Inhalt kann jedoch nicht neu definiert werden. Sie werden schließlich zu einem Namen zusammengefasst. Leerzeichen, genau wie Standard, Makrodefinitionen überall

去掉重复并排序的方法:1、使用“Array.from(new Set(arr))”或者“[…new Set(arr)]”语句,去掉数组中的重复元素,返回去重后的新数组;2、利用sort()对去重数组进行排序,语法“去重数组.sort()”。

本篇文章给大家带来了关于JavaScript的相关知识,其中主要介绍了关于Symbol类型、隐藏属性及全局注册表的相关问题,包括了Symbol类型的描述、Symbol不会隐式转字符串等问题,下面一起来看一下,希望对大家有帮助。

怎么制作文字轮播与图片轮播?大家第一想到的是不是利用js,其实利用纯CSS也能实现文字轮播与图片轮播,下面来看看实现方法,希望对大家有所帮助!

本篇文章给大家带来了关于JavaScript的相关知识,其中主要介绍了关于对象的构造函数和new操作符,构造函数是所有对象的成员方法中,最早被调用的那个,下面一起来看一下吧,希望对大家有帮助。

本篇文章给大家带来了关于JavaScript的相关知识,其中主要介绍了关于面向对象的相关问题,包括了属性描述符、数据描述符、存取描述符等等内容,下面一起来看一下,希望对大家有帮助。

方法:1、利用“点击元素对象.unbind("click");”方法,该方法可以移除被选元素的事件处理程序;2、利用“点击元素对象.off("click");”方法,该方法可以移除通过on()方法添加的事件处理程序。

本篇文章给大家带来了关于JavaScript的相关知识,其中主要介绍了关于BOM操作的相关问题,包括了window对象的常见事件、JavaScript执行机制等等相关内容,下面一起来看一下,希望对大家有帮助。

本篇文章整理了20+Vue面试题分享给大家,同时附上答案解析。有一定的参考价值,有需要的朋友可以参考一下,希望对大家有所帮助。


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

WebStorm-Mac-Version
Nützliche JavaScript-Entwicklungstools

Dreamweaver CS6
Visuelle Webentwicklungstools

SublimeText3 Mac-Version
Codebearbeitungssoftware auf Gottesniveau (SublimeText3)

DVWA
Damn Vulnerable Web App (DVWA) ist eine PHP/MySQL-Webanwendung, die sehr anfällig ist. Seine Hauptziele bestehen darin, Sicherheitsexperten dabei zu helfen, ihre Fähigkeiten und Tools in einem rechtlichen Umfeld zu testen, Webentwicklern dabei zu helfen, den Prozess der Sicherung von Webanwendungen besser zu verstehen, und Lehrern/Schülern dabei zu helfen, in einer Unterrichtsumgebung Webanwendungen zu lehren/lernen Sicherheit. Das Ziel von DVWA besteht darin, einige der häufigsten Web-Schwachstellen über eine einfache und unkomplizierte Benutzeroberfläche mit unterschiedlichen Schwierigkeitsgraden zu üben. Bitte beachten Sie, dass diese Software

Senden Sie Studio 13.0.1
Leistungsstarke integrierte PHP-Entwicklungsumgebung
