Bereich und Bereich auf Blockebene in Javascript

In diesem Artikel stellen wir Ihnen den Bereich und den Bereich auf Blockebene in Javascript vor. Der Bereich hat in jeder Programmiersprache immer höchste Priorität, da er die Sichtbarkeit und den Lebenszyklus von Variablen und Parametern steuert. Lassen Sie mich Ihnen den Bereich und den Bereich auf Blockebene in Javascript vorstellen. Freunde, die ihn benötigen, können darauf verweisen.

1. Beschreibung des Bereichs auf Blockebene

Bevor wir den JavaScript-Variablenbereich lernen, sollten wir einige Punkte klären:

a. Der Variablenbereich von JavaScript basiert auf seiner einzigartigen Bereichskette.

b. JavaScript hat keinen Gültigkeitsbereich auf Blockebene.

c. Die in der Funktion deklarierten Variablen werden in der gesamten Funktion definiert.

Der variable Umfang von Javascript unterscheidet sich von der häufig verwendeten C-ähnlichen Sprache, wie zum Beispiel dem Code in C#:

static void Main(string[] args)
{
   if(true)
   {
    int number=10;
   }
  Console.WriteLine(number);
}

Dieser Absatz Der Code kann nicht kompiliert werden, da „Nummer im aktuellen Kontext nicht vorhanden“ ist.

Da der Gültigkeitsbereich der Variablen hier durch geschweifte Klammern begrenzt ist, wird er als Gültigkeitsbereich auf Blockebene bezeichnet.

Im Bereich auf Blockebene liegen alle Variablen innerhalb der geschweiften Klammern der Definition. Sie können im Bereich vom Anfang der Definition bis zum Ende der geschweiften Klammern verwendet werden Dieser Bereich ist also

if（true）
{
  int number=10;
  Console.WriteLine(number);
}

Auf diesen kann zugegriffen werden, da die Definition und Verwendung der Variablen innerhalb derselben geschweiften Klammern liegen.

In JavaScript gibt es jedoch kein Konzept für den Bereich auf Blockebene.

2. Geltungsbereich in Javascript

1. Funktionsbegrenzter Variablenbereich

In Javascript, innerhalb der Funktion Die definierten Variablen Der Zugriff kann innerhalb der Funktion erfolgen, jedoch nicht außerhalb der Funktion. Code:

<script type="text/javascript">
  var num=function()
  {
   var number=10;
  };
  try{
    alert(number);
  }catch(e)
  {
    alert(e);
  } 
</script>

Wenn der Code ausgeführt wird, ist eine Ausnahme, die Variablennummer nicht definiert, da in einer Funktion definierte Variablen nicht außerhalb der Funktion verwendet werden können. Sie können innerhalb der Funktion beliebig verwendet werden, auch vor der Zuweisung:

<script type="text/javascript">
 var num=function(){
    alert(number);
    var number=10;
    alert(number);
 };
 try{
   num();
 }catch(e){
  alert(e);
 }
</script>

Nachher Wenn dieser Code ausgeführt wird, wird kein Fehler ausgegeben, nämlich undefiniert und 10

2. Die Subdomäne greift auf die übergeordnete Domäne zu

Eine Funktion kann Begrenzen Sie den Bereich einer Variablen, dann ist die Funktion in der Funktion eine Unterdomäne des Bereichs. Der Code in der Unterdomäne kann auf die Variablen in der übergeordneten Domäne zugreifen. Der Code lautet wie folgt:

<script type="text/javascript">
 var func=function(){
    var number=10;
    var sub_func=function(){
      alert(num);
    };
   sub_func();
};
func();
</script>

Das Ergebnis der Ausführung dieses Codes ist 10, aber der Zugriff auf den Code der übergeordneten Domäne in der Unterdomäne ist ebenfalls bedingt

<script type="text/javascript">
 var func=function(){
    var number=10;
    var sub_func=function(){
      var num=20;
      alert(num);
    };
   sub_func();
};
func();
</script>

Dieser Code hat ein „var num=20;“ mehr als der vorherige. Dieser Code befindet sich in der Subdomain, daher hat sich die Situation des Zugriffs der Subdomain auf die übergeordnete Domain geändert 20. Zu diesem Zeitpunkt ist die Anzahl, auf die die Subdomain zugreift, eine Variable in der Subdomain und nicht in der übergeordneten Domain. Es ist ersichtlich, dass es bei der Verwendung von Variablen in JavaScript zunächst prüft, ob eine Definition der Variablen im aktuellen Gültigkeitsbereich vorhanden ist. Wenn nicht, wird diese verwendet zur übergeordneten Domäne, um die Variable zu finden, und so weiter, bis der Bereich der obersten Ebene immer noch nicht gefunden wird, wird eine Ausnahme „Variable ist nicht definiert“ ausgelöst. Der Code lautet wie folgt:

<script type="text/javascript">
 (function (){
   var num=10;
   (function (){
     var num=20;
     (function(){
     alert(num);
      })();
   })();
  })();
</script>

Dieser Code wird nach der Ausführung 20 gedruckt. Wenn „var num=20“ entfernt wird, wird 10 gedruckt. Auch wenn „var num=10“ entfernt wird, wird ein undefinierter Fehler angezeigt wird auftreten.

Das Folgende ist eine Einführung in den JS-Bereich und den Bereich auf Blockebene

Der Bereich ist in jeder Programmiersprache immer das Wichtigste weil es die Sichtbarkeit und den Lebenszyklus von Variablen und Parametern steuert. Apropos: Verstehen Sie zunächst zwei Konzepte: den Umfang auf Blockebene und den Funktionsumfang.

Was ist der Umfang auf Blockebene?

Jeder Satz von Anweisungen in einem Paar geschweifter Klammern ({ und }) gehört zu einem Block. Alle darin definierten Variablen sind außerhalb des Codeblocks unsichtbar.

Der Funktionsumfang ist leicht zu verstehen (*^__^*). Die in der Funktion definierten Parameter und Variablen sind außerhalb der Funktion nicht sichtbar.

Die meisten C-ähnlichen Sprachen haben einen Gültigkeitsbereich auf Blockebene, JS jedoch nicht. Bitte sehen Sie sich die Demo unten an:

//C语言 
#include <stdio.h> 
void main() 
{ 
  int i=2; 
  i--; 
  if(i) 
  { 
    int j=3; 
  } 
  printf("%d/n",j); 
}

Wenn Sie diesen Code ausführen, wird die Fehlermeldung „Verwenden Sie eine undefinierte Variable:j“ angezeigt. Wie Sie sehen können, hat die Sprache C einen Geltungsbereich auf Blockebene, da j im if-Anweisungsblock definiert ist und daher außerhalb des Blocks nicht darauf zugegriffen werden kann.

Wie verhält sich JS? Schauen wir uns eine weitere Demo an:

functin test(){ 
 for(var i=0;i<3;i++){   
 } 
 alert(i); 
} 
test();

Führen Sie diesen Code aus und ein Popup wird angezeigt Erscheint „3“, ist ersichtlich, dass außerhalb des Blocks weiterhin auf die im Block definierte Variable i zugegriffen werden kann. Mit anderen Worten: JS unterstützt keinen Gültigkeitsbereich auf Blockebene, sondern nur den Funktionsbereich und Variablen, die an einer beliebigen Stelle in einer Funktion definiert sind, sind überall in der Funktion sichtbar.

那么我们该如何使JS拥有块级作用域呢？是否还记得，在一个函数中定义的变量，当这个函数调用完后，变量会被销毁，我们是否可以用这个特性来模拟出JS的块级作用域呢？看下面这个DEMO：

  function test(){ 
 (function (){ 
 for(var i=0;i<4;i++){ 
 } 
 })(); 
 alert(i); 
} 
test();

这时候再次运行，会弹出"i"未定义的错误，哈哈，实现了吧~~~这里，我们把for语句块放到了一个闭包之中，然后调用这个函数，当函数调用完毕，变量i自动销毁，因此，我们在块外便无法访问了。

JS的闭包特性is the most important feature((*^__^*) 大家懂的)。在JS中，为了防止命名冲突，我们应该尽量避免使用全局变量和全局函数。那么，该如何避免呢？不错，正如上文demo所示，我们可以把要定义的所有内容放入到一个

（function (){ 
//内容 
})();

相关推荐：

详解JavaScript作用域和闭包

js的解析顺序作用域严格模式的解析

JavaScript作用域与闭包的分析讲解

Das obige ist der detaillierte Inhalt vonBereich und Bereich auf Blockebene in Javascript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!