Detaillierte Erläuterung der Bereichsverwendung in js

Dieses Mal erkläre ich Ihnen ausführlich, welche Vorsichtsmaßnahmen bei der Verwendung von js Scope zu beachten sind.

Bezüglich der Verwendung von JavaScript sind sich viele Menschen möglicherweise nicht ganz im Klaren über den Umfang und den Umfang auf Blockebene. Hier ist ein Artikel, der Ihnen eine detaillierte Erklärung gibt Schauen Sie gemeinsam vorbei, wenn Sie mehr darüber wissen.

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 Code kann nicht kompiliert werden, da „Nummer im aktuellen Kontext nicht existiert“.

Da der Gültigkeitsbereich der

-Variable 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. Außerhalb dieses Bereichs ist kein Zugriff möglich 🎜>

Dies ist zugänglich, da die Variable in denselben geschweiften Klammern definiert und verwendet wird.

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

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

2. Geltungsbereich in Javascript

1. Funktion begrenzt den Variablenbereich

In JavaScript kann auf in einer Funktion definierte Variablen innerhalb der Funktion zugegriffen werden, jedoch nicht außerhalb der Funktion. Code:

Wenn der Code ausgeführt wird, wird eine Ausnahme ausgelöst. Die Variablennummer ist nicht definiert. Dies liegt daran, dass in der Funktion definierte Variablen nicht außerhalb der Funktion verwendet werden können, auch vor der Zuweisung:

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

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

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

2. Die Subdomain greift auf die übergeordnete Domain

zu Eine Funktion kann den Bereich einer Variablen einschränken, 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:

Das Ergebnis der Ausführung dieses Codes ist 10, aber der Code, der auf die übergeordnete Domäne in der Unterdomäne zugreift, ist ebenfalls bedingt

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

Dieser Code hat eine „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. Das Ergebnis ist 20. Die Subdomäne. Die Anzahl der Zugriffe ist eine Variable in der untergeordneten Domäne, nicht in der übergeordneten Domäne. Es ist ersichtlich, dass es bei der Verwendung von Variablen in JavaScript zunächst nach der Definition der Variablen im aktuellen Gültigkeitsbereich sucht. Wenn nicht, sucht er nach der Variablen in der übergeordneten Domäne usw., bis der Bereich der obersten Ebene immer noch nicht gefunden wird, wird eine Ausnahme „Variable ist undefiniert“ ausgelöst. Der Code lautet wie folgt:

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

Nachdem dieser Code ausgeführt wurde, wird 20 gedruckt. Wenn „

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

“ entfernt wird, wird 10 gedruckt. Auch wenn „

“ entfernt wird, tritt ein undefinierter Fehler auf. var num=20var num=10 Lassen Sie uns den JS-Bereich und den Bereich auf Blockebene vorstellen

Der Umfang ist in jeder

Programmiersprache

immer das Wichtigste, da er die Sichtbarkeit und den Lebenszyklus von Variablen und Parametern steuert. Apropos: Verstehen Sie zunächst zwei Konzepte: den Bereich auf Blockebene und den Funktionsbereich. Was ist der Bereich auf Blockebene?

Jeder Satz von Anweisungen innerhalb eines geschweiften Klammerpaares ({ und }) gehört zu einem Block, und alle darin definierten Variablen sind außerhalb des Codeblocks unsichtbar. Wir nennen dies den Bereich auf Blockebene.

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); 
}

运行这段代码，会出现“use an undefined variable:j”的错误。可以看到，C语言拥有块级作用域，因为j是在if的语句块中定义的，因此，它在块外是无法访问的。 

而JS是如何表现的呢，再看另一个demo:

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

运行这段代码，弹出"3"，可见，在块外，块中定义的变量i仍然是可以访问的。也就是说，JS并不支持块级作用域，它只支持函数作用域，而且在一个函数中的任何位置定义的变量在该函数中的任何地方都是可见的。

那么我们该如何使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 (){ 
//内容 
})();

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

推荐阅读：

JS+canvas做出围绕旋转动画

JS实现五子棋小游戏

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Bereichsverwendung in js. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!