JavaScript-Abschlüsse – Blockbereich und private Variablen

Bereich auf Blockebene

Der Bereich auf Blockebene bezieht sich auf den Bereich innerhalb des Codeblocks, der in geschweifte Klammern eingeschlossen ist. In JavaScript gibt es keinen Blockbereich. Um dieses Konzept zu verstehen, schauen Sie sich das folgende Beispiel an:

for(var i = 0;i < 10; i++){
  ......
}
alert(i); //结果会输出10

Im obigen Code definieren wir die Variable i in der for-Schleife. In Programmiersprachen wie C++ und Java. Nachdem die Schleifenausführung beendet ist, wird die for Die i-Variable in der Schleife wird sofort durch Müll gesammelt. In JavaScript sind Variablen jedoch immer vorhanden, unabhängig davon, ob eine Schleife oder eine Beurteilung verwendet wird. Aus den Druckergebnissen können wir ersehen, dass der nach dem Ende der for-Schleife gedruckte Wert 10 ist.

Wenn eine Variable in der globalen Umgebung für Schleifen oder Beurteilungen verwendet wird, kann sich diese Variable auf die Variablen in der Funktion auswirken. Verwenden Sie daher keine globalen Variablen, außer unter besonderen Umständen, und globale Variablen befinden sich in der Bereichskette Die oberste Ebene hat den langsamsten Zugriff.

Die Lösung zum Blockieren des Bereichs besteht in der Verwendung anonymer Funktionen. Schauen wir uns den Code unten an.

(function(){
  for(var i = 0; i < 10; i++){
    ......
  }
})();
 
// 直接打印i值会报错：i没有定义
alert(i);
 
// i is not defined
function fn(){
  alert(i);
}
fn();

Im obigen Code haben wir den Codeblock in eine anonyme Funktion eingefügt und dann sofort die anonyme Funktion aufgerufen. Beachten Sie das Klammerpaar nach der anonymen Funktion, das den Aufruf der anonymen Funktion angibt. Sie können diesen Schreibstil in vielen JavaScript-Programmen sehen. Zu diesem Zeitpunkt werden die Variablen in der anonymen Funktion nach der Verwendung recycelt, und auf diese Variablen kann außerhalb der anonymen Funktion nicht zugegriffen werden.

Wenn wir eine Teamentwicklung durchführen, müssen wir möglicherweise globale Variablen mit demselben Namen definieren. Daher müssen wir während der Entwicklung die folgenden Gewohnheiten entwickeln: Fügen Sie den Code der globalen Variablen sofort in eine anonyme Funktion ein Durch den Aufruf anonymer Funktionen kann auch der Code globaler Variablen ausgeführt werden, diese Variablen werden jedoch in dem Bereich gesteuert, den wir steuern möchten.

Private Variablen

Als wir zuvor ein Objekt definiert haben, haben wir das Schlüsselwort this verwendet, um die Eigenschaften des Objekts festzulegen. Die auf diese Weise festgelegten Eigenschaften werden als öffentliche Eigenschaften bezeichnet, und wir können direkt über das Objekt auf diese Eigenschaften zugreifen.

In Programmiersprachen wie C++ und Java wird das Schlüsselwort private verwendet, um die privaten Eigenschaften eines Objekts zu definieren. Auf private Eigenschaften kann das Objekt nicht direkt zugreifen. Wie definieren Sie also private Eigenschaften (private Variablen) in JavaScript? Tatsächlich ist es sehr einfach. Wir müssen nur ein Paar Set- und Get-Methoden für das Objekt bereitstellen. Zum Beispiel der folgende Code:

function Person(name){
  //此时就没有方法直接访问name这个属性，因为没有this.name
  //要访问name只能通过this.getName和this.setName来访问
  this.setName = function(value){
    name = value;
  }
  this.getName = function(){
    return name;
  }
}
 
var p = new Person("Leon");
alert(p.getName());

Wir verwenden die Methode this.setName(), um das Namensattribut für das Objekt festzulegen, und verwenden die Methode this.getName, um das Namensattribut des Objekts abzurufen. Auf diese Weise kann nicht direkt auf das Namensattribut des Objekts zugegriffen werden, da kein this.name-Attribut vorhanden ist.

Das Problem beim Erstellen privater Variablen auf die oben beschriebene Weise besteht darin, dass jedes Objekt eine große Anzahl von Funktionen speichert, was viel Speicher verbraucht. Die Lösung für dieses Problem besteht darin, statische private Variablen zu verwenden. Der Code lautet wie folgt:

var name = "";
var Person= function(value){
  name = value;
}
Person.prototype.setName = function(value){
  name = value;
}
Person.prototype.getName = function(){
  return name;
}
 
var p1 = new Person("Leon");
alert(p1.getName());
p1.setName("Ada");
alert(p1.getName());

Durch Einfügen der Methoden setName() und getName() in die Prototypenkette des Objekts kann das Problem mehrerer Kopien der Methode gelöst werden. Der obige Code birgt jedoch einige Sicherheitsrisiken, nämlich die zuvor erwähnten Probleme mit dem Bereich auf Blockebene. Ebenso können wir diesen Code in eine anonyme Funktion einfügen, um dieses Problem zu lösen.

(function(){
  //name在函数结束之后就被回收，在外面是没有方法接收的
  var name = "";
  Person= function(value){
    name = value;
  }
  Person.prototype.setName = function(value){
    name = value;
  }
  Person.prototype.getName = function(){
    return name;
  }
})();
 
var p1 = new Person("Leon");
alert(p1.getName());
p1.setName("Ada");
alert(p1.getName());

Fügen Sie die Definition der Person-Klasse in eine anonyme Funktion ein und führen Sie die anonyme Funktion dann sofort aus. Dies stellt nicht nur sicher, dass das Objekt nicht für den direkten Zugriff auf Eigenschaften verwendet werden kann, sondern stellt auch sicher, dass jedes Objekt dieselbe Kopie der Methode verwendet.

Das Obige ist der Inhalt des JavaScript-Bereichs auf Abschlussblockebene und privater Variablen. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!