Welche Methoden zur Variablendeklaration gibt es in JS?

Dieses Mal zeige ich Ihnen, welche Methoden zum Deklarieren von Variablen in JS verfügbar sind und welche Vorsichtsmaßnahmen für das Deklarieren von Variablen in JS gelten. Das Folgende ist ein praktischer Fall, schauen wir uns das an.

var x = 0; // x是全局变量，并且赋值为0。
console.log(typeof z); // undefined，因为z还不存在。
function a() { // 当a被调用时，
 var y = 2;  // y被声明成函数a作用域的变量，然后赋值成2。
 console.log(x, y);  // 0 2 
 function b() {    // 当b被调用时，
  x = 3; // 全局变量x被赋值为3，不生成全局变量。
  y = 4; // 已存在的外部函数的y变量被赋值为4，不生成新的全局变量。
  z = 5; // 创建新的全局变量z，并且给z赋值为5。 
 }     // (在严格模式下（strict mode）抛出ReferenceError)
 b();   // 调用b时创建了全局变量z。
 console.log(x, y, z); // 3 4 5
}
a();          // 调用a时同时调用了b。
console.log(x, z);   // 3 5
console.log(typeof y); // undefined，因为y是a函数的本地（local）变量。

Mit let deklarierte Variablen sind nur in dem Block oder Unterblock verfügbar, in dem sie deklariert sind. Der Gültigkeitsbereich von var ist die gesamte umschließende Funktion.

function varTest() {
 var x = 1;
 if (true) {
  var x = 2; // 同样的变量!
  console.log(x); // 2
 }
 console.log(x); // 2
}
function letTest() {
 let x = 1;
 if (true) {
  let x = 2; // 不同的变量
  console.log(x); // 2
 }
 console.log(x); // 1
}

In ECMAScript 2015 ist die Bindung let unterliegt keiner Variablen-Promotion-Einschränkung, was bedeutet, dass die let-Deklaration nicht an die Spitze des aktuellen Ausführungskontexts gehoben wird.
Bevor die Variable im Block initialisiert wird, führt ein Verweis darauf zu einem ReferenceError (im Gegenteil, wenn var zum Deklarieren einer Variablen verwendet wird, ist der Wert der Variablen undefiniert).
Bei Verwendung in einem Block wird let gebracht Der Gültigkeitsbereich der Variablen ist auf diesen Block beschränkt. Beachten Sie, dass der Gültigkeitsbereich von var innerhalb der Funktion liegt, in der es deklariert wird. Eine Konstante muss ihren Wert zum Zeitpunkt der Deklaration angeben. Die

const-Deklaration erstellt einen schreibgeschützten Wert Verweis auf einen Wert. Dies bedeutet jedoch nicht, dass der darin enthaltene Wert unveränderlich ist (z. B. wenn der Referenzinhalt ein Objekt ist), aber der Variablenbezeichner kann nicht den gleichen Namen wie andere Variablen oder Funktionen in seinem Gültigkeitsbereich haben

var a = 1;
var b = 2;
if (a === 1) {
 var a = 11; // the scope is global
 let b = 22; // the scope is inside the if-block
 console.log(a); // 11
 console.log(b); // 22
} 
console.log(a); // 11
console.log(b); // 2

Im Folgenden werden die drei Möglichkeiten zum Deklarieren von Variablen in JavaScript vorgestellt: var, let und const. var deklariert globale Variablen. Mit anderen Worten: Variablen, die in einer for-Schleife deklariert werden, können auch außerhalb der for-Schleife verwendet werden.

// 注意: 常量在声明的时候可以使用大小写，但通常情况下全部用大写字母。 
// 定义常量MY_FAV并赋值7
const MY_FAV = 7;
// 报错
MY_FAV = 20;
// 输出 7
console.log("my favorite number is: " + MY_FAV);
// 尝试重新声明会报错 
const MY_FAV = 20;
// MY_FAV 保留给上面的常量，这个操作会失败
var MY_FAV = 20; 
// 也会报错
let MY_FAV = 20;
// 注意块范围的性质很重要
if (MY_FAV === 7) { 
  // 没问题，并且创建了一个块作用域变量 MY_FAV
  // (works equally well with let to declare a block scoped non const variable)
  let MY_FAV = 20;
  // MY_FAV 现在为 20
  console.log('my favorite number is ' + MY_FAV);
  // 这被提升到全局上下文并引发错误
  var MY_FAV = 20;
}
// MY_FAV 依旧为7
console.log("my favorite number is " + MY_FAV);
// 常量要求一个初始值
const FOO; // SyntaxError: missing = in const declaration
// 常量可以定义成对象
const MY_OBJECT = {"key": "value"};
// 重写对象和上面一样会失败
MY_OBJECT = {"OTHER_KEY": "value"};
// 对象属性并不在保护的范围内，下面这个声明会成功执行
MY_OBJECT.key = "otherValue";
// 也可以用来定义数组
const MY_ARRAY = [];
// It's possible to push items into the array
// 可以向数组填充数据
MY_ARRAY.push('A'); // ["A"]
// 但是，将一个新数组赋给变量会引发错误
MY_ARRAY = ['B']

Die in der for-Schleife deklarierte Summe kann beim Verlassen der for-Schleife verwendet werden, und das normale Popup-Ergebnis wird nicht gemeldet.

let: Deklarieren Sie Variablen auf Blockebene , also lokale Variablen.

Wenn Sie im obigen Beispiel aus der for-Schleife springen und die Summenvariable erneut verwenden, wird ein Fehler gemeldet. Die Variable hat nur den Gültigkeitsbereich des Codeblocks, zu dem sie aktuell gehört. Dieselbe Variable kann nicht wiederholt definiert und nicht deklariert werden. Wenn sie zuvor aufgerufen wird, muss sie vor der Verwendung definiert werden, und es wird ein Fehler gemeldet. Sie können let

im Schleifenkörper verwenden. Hinweis: Sie müssen deklarieren 'use strict'; bevor Sie let zum Deklarieren von Variablen verwenden können, werden die Ergebnisse sonst beim Durchsuchen nicht angezeigt.

const: wird zum Deklarieren von Konstanten verwendet, hat auch einen Gültigkeitsbereich auf Blockebene und kann auch unter deklariert werden Blockebene.

for(var i=0;i<=1000;i++){ 
var sum=0; 
sum+=i; 
} 
alert(sum);

Es ist dasselbe wie let und dieselbe Variable kann nicht wiederholt definiert werden. Sobald const definiert ist, kann sie nicht geändert werden.

Ich glaube, dass Sie die Methode beherrschen, nachdem Sie den Fall in diesem Artikel gelesen haben. Weitere spannende Informationen finden Sie in anderen verwandten Artikeln auf der chinesischen PHP-Website!

Empfohlene Lektüre:

Verwenden von Vue zum dynamischen Festlegen von Routing-Parametern

Detaillierte Erläuterung der von Vue berechneten Eigenschaften und praktische Projekte für Hörer

Das obige ist der detaillierte Inhalt vonWelche Methoden zur Variablendeklaration gibt es in JS?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!