Was sind die Unterschiede zwischen der Variablendeklaration var und let.const?

Dieses Mal werde ich Ihnen die Unterschiede zwischen der Verwendung der Variablendeklaration var und let.const vorstellen. Was sind die Vorsichtsmaßnahmen bei der Verwendung der Variablendeklaration var und let.const? Werfen wir einen Blick darauf.

var-DeklarationDer Gültigkeitsbereich einer Variablenist auf den Kontext ihrer Deklarationsstelle beschränkt

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）变量。

let Eine deklarierte Variable ist nur im Block oder Unterblock verfügbar var Der Geltungsbereich 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 unterliegen Let-Bindungen nicht dem Hochziehen von Variablen, was bedeutet, dass Let-Deklarationen nicht an die Spitze des aktuellen Ausführungskontexts gehoben werden .
Bevor die Variable im Block initialisiert wird, führt ein Verweis darauf zu einem ReferenceError (im Gegenteil, die Verwendung von var zum Deklarieren einer Variablen ist undefiniert).
Bei Verwendung in einem Block wird der Gültigkeitsbereich der Variablen durch let eingeschränkt zu diesem Block. 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, const. var deklariert globale Variablen. Mit anderen Worten: Die in der

for-Schleife

deklarierten Variablen können auch nach dem Verlassen 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 dann die Summenvariable verwenden, wird ein Fehler gemeldet. Die Variable hat nur den Gültigkeitsbereich des Codeblocks, zu dem sie derzeit 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 '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:

So verwenden Sie von Vue berechnete Eigenschaften und Methoden-Listener

So deklarieren Sie JS-Variablen var, let .const

Das obige ist der detaillierte Inhalt vonWas sind die Unterschiede zwischen der Variablendeklaration var und let.const?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!