Was sind die Schlüsselwörter zum Deklarieren von Variablen in Javascript?

Die Schlüsselwörter zum Deklarieren von Variablen in JavaScript sind var, let und const. Mit var deklarierte Variablen können zum Speichern aller Arten von Werten verwendet werden. Der Gültigkeitsbereich der let-Deklaration ist der Blockgültigkeitsbereich. Bei der Deklaration einer Variablen mit const muss die Variable gleichzeitig initialisiert werden Der Wert kann nach der Initialisierung nicht mehr geändert werden.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, ECMAScript Version 6, Dell G3-Computer.

Deklarieren Sie die Variablenschlüsselwörter var, let und const

ECMAScript-Variablen sind lose typisiert, d . Schlüsselwort 1.var JavaScript kann beim Definieren von Variablen auch Werte zuweisen. Da JavaScript eine dynamische Sprache ist, wird der Bezeichner nicht initialisiert zugewiesen werden, was nur eine einfache Zuweisung ist. Dann kann nicht nur der gespeicherte Wert geändert werden, sondern auch der Typ des Werts:

var message = "hi";
	message = 100;

1.1.var Deklarationsumfang

Variablen definiert mit Der var-Operator wird zu einer lokalen Variablen der Funktion, die ihn enthält. Die Verwendung von var zum Definieren einer Variablen innerhalb einer Funktion bedeutet beispielsweise, dass die Variable zerstört wird, wenn die Funktion beendet wird. Ich denke, das nennt man Garbage Collection:

function test( ) {
		vart message = "hi";	//局部变量
	}
test( );
console.log(message);	//报错！

Nach dem Aufruf der Funktion wird die Variable zufällig zerstört , sodass in der letzten Zeile ein Fehler gemeldet wird. Sie können jedoch eine

globale Variable

erstellen, wenn Sie beim Definieren von Variablen in einer Funktion den Operator var weglassen:

function test( )  {
	message = "hi";	//全局变量
}
test( );
console.log(message);	//"hi"

Solange die Funktion test() einmal aufgerufen wird, wird die globale Variablennachricht definiert und kann von außen abgerufen werden die Funktion. Da im lokalen Bereich definierte globale Variablen jedoch schwierig zu verwalten sind, wird dies im Allgemeinen nicht empfohlen. undefined），像其他语言一样在javascript在定义变量的同时还可以对变量进行赋值，该变量被定义为一个保存所赋值的值的变量，因为javascript是动态语言，在初始化变量的时候不会将它标识为所赋值的数据类型，只是一个简单的赋值而已。随后不仅可以改变保存的值，还可以改变值的类型：

function fool( ) {
	console.log(age);
	var age = 28;
}
fool( );	//undefined

1.1.var声明作用域

    使用var操作符定义的变量会成为包含它的函数的局部变量。比如，使用var在函数内部定义一个变量，就意味这该变量将在函数退出时被销毁，我觉得这就是所说的垃圾回收：

function fool( ) {
	var age;
	console.log(age);
	age = 28;
}
fool( );	//undefined

    函数调用之后变量会随机被销毁，因此最后一行会报错。不过，在函数定义变量时省略var操作符时可以创建一个全局变量：

if (true) {
	let age = 26;
	console.log(age);	//26
}
console.log(age);	//ReferceError:age没有定义

    只要调用一次函数test( )就会定义message这一全局变量，并且可以在函数外部访问。但是由于在局部作用域中定义的全局变量很难维护，所以一般不推荐这样做。

1.2.var声明提升

    使用var关键字声明的变量会自动提升函数作用域顶部，即所谓的“提升”(hoist),也就是把所有变量声明都拉到函数作用域的顶部：

var name;
var name;
let age;
let age;	//SyntaxError;标识符age已经声明过了

    这里是不会报错的，而是显示undefined,ECMAScript在运行是会把它看成等价于如下的代码：

//name会提升
console.log(name);	//undefined
var name = 'matt';

//name不会提升
console.log(name);	//ReferenceError:name没有定义
let name = 'matt';

2.let声明

    let跟var的作用差不多，但有着非常重要的区别。最明显的区别是let声明的范围是块作用域，而var声明的范围是函数作用域：

var name = 'matt';
console.log(window.name);	//'matt'

let name = 'matt';
console.log(window.name);	//undefined

    age变量的作用域仅限于该块内部，所以不能在if块外部被引用。块作用域是函数作用域的子集，所以适用于var的作用域限制也同样适用于let。

    let也不允许同一块作用域中出现冗余声明（var可以）:

for(var i = 0; i < 5; ++i) {
	setTimeout( () => console.log(i) ,0)
}
//你可能以为会输出0、1、2、3、4
//实际上输出的是5、5、5、5、5

    此外，对声明冗余报错不会因混用var和let而受影响。这两个关键字声明的并不是不同类型的变量，他们只是指出变量在相关作用域如何存在。

2.1.暂时性死区

    let与var的另一个重要区别是let声明的变量不会在作用域中被提升：

for(let i = 0; i < 5; ++i) {
	setTimeout( () => console.log(i) ,0)
}
//会输出0、1、2、3、4

2.2.全局声明

    与var不同，使用let在全局作用域中声明的变量不会成为window对象的属性(var声明的变量则会)：

const person = { };
person.name = 'matt';

    不过，let声明仍然是在全局作用域中发生的，相应变量会在页面的声明周期内存续。

2.3.条件声明

    let的作用域是块，所以不可能检查前面是否已经使用let声明过同名变量，同时也就不可能在没有声明的情况下声明它。使用try/catch或typeof操作符也不能解决，因为条件块中let声明的作用域仅限于该块。为此，对于let这个新的ES6声明关键字不能依赖条件声明模式。

2.4.for循环中的let声明

    在使用var的时候，最常见的问题就是对迭代变量的奇特声明和修改：

rrreee

    在退出循环的时候迭代变量保存的是导致循环退出的值：5。在之后执行setTimeout1.2. Hochziehen der Var-Deklaration

🎜🎜🎜 Variablen, die mit dem Schlüsselwort var deklariert wurden, werden automatisch 🎜an die Spitze des Funktionsumfangs🎜 gehoben. namens „hoisting“(hoist), d Äquivalent beim Ausführen im folgenden Code: 🎜rrreee🎜🎜🎜2.let-Deklaration🎜🎜🎜🎜 Let hat ähnliche Funktionen wie var, es gibt jedoch einen sehr wichtigen Unterschied. Der offensichtlichste Unterschied besteht darin, dass der Geltungsbereich der let-Deklaration der 🎜Block-Geltungsbereich🎜 ist, während der Geltungsbereich der var-Deklaration der Funktions-Geltungsbereich ist: 🎜rrreee🎜 Der Geltungsbereich der Altersvariablen ist auf das Innere des Blocks beschränkt kann nicht außerhalb des if-Blocks referenziert werden. Der Blockbereich ist eine Teilmenge des Funktionsbereichs, daher gelten die für var geltenden Bereichseinschränkungen auch für let. 🎜🎜 Let erlaubt auch keine redundanten Deklarationen im gleichen Bereich (var can):🎜rrreee🎜 Darüber hinaus werden redundante Deklarationsfehler durch das Mischen von var und let nicht beeinträchtigt. Diese beiden Schlüsselwörter deklarieren keine Variablen unterschiedlichen Typs, sondern geben lediglich an, wie die Variablen im relevanten Bereich existieren. 2.1. Temporäre tote Zone 🎜🎜2.2. Globale Deklaration🎜🎜🎜🎜 Im Gegensatz zu var werden im globalen Bereich mit let deklarierte Variablen nicht zu Attributen des Fensterobjekts (var-deklarierte Variablen werden): 🎜rrreee🎜 Die let-Deklaration erfolgt jedoch weiterhin im globalen Bereich und die entsprechende Variable bleibt innerhalb des Deklarationszyklus der Seite bestehen. 🎜🎜🎜2.3. Bedingte Deklaration🎜🎜🎜🎜 Der Gültigkeitsbereich von let ist ein Block, daher ist es unmöglich zu überprüfen, ob zuvor eine Variable mit demselben Namen deklariert wurde let, und es ist auch unmöglich, es ohne eine Erklärung zu deklarieren. Die Verwendung von try/catch- oder typeof-Operatoren kann das Problem nicht lösen, da der Umfang der let-Deklaration im bedingten Block auf diesen Block beschränkt ist. Aus diesem Grund kann sich das neue ES6-Deklarationsschlüsselwort let nicht auf das bedingte Deklarationsmuster verlassen. 🎜🎜🎜2.4. let-Deklaration in der for-Schleife 🎜🎜🎜🎜 Bei der Verwendung von var ist das häufigste Problem die seltsame Deklaration und Änderung von Iterationsvariablen: 🎜rrreee 🎜 Beim Beenden In der Schleife speichert die Iterationsvariable den Wert, der zum Beenden der Schleife geführt hat: 5. Wenn die Timeout-Logik setTimeout später ausgeführt wird, ist i dieselbe Variable, sodass die endgültige Ausgabe denselben Wert hat. 🎜

    使用let声明迭代变量时，JavaScript引擎在后台会为每个迭代循环声明一个新的迭代变量，每个setTimeout引用的都是不同的变量实例：

for(let i = 0; i < 5; ++i) {
	setTimeout( () => console.log(i) ,0)
}
//会输出0、1、2、3、4

【相关推荐：javascript学习教程】

3.const声明

    const的行为与let基本相同，唯一一个重要区别是它声明变量时必须同时初始化变量，且尝试修改const声明的变量会导致运行错误。

    const声明的限制只适用于它指向的变量的引用。如果const变量引用的是一个对象，那么修改这个对象内部的属性并不违反const的限制：

const person = { };
person.name = 'matt';

4.使用建议

let和const是ES6中新增的，从客观上为JavaScript更精确地声明作用域和语义提供更好的支持。

4.1.不使用var

    限制自己只使用let和const有助于提升代码质量，因为变量有了明确的作用域、声明位置，以及不变的值。

4.2.const优先，let次之

    使用const声明可以让浏览器运行时强制保持变量不变，也可以让静态代码分析工具提前发现不合法的赋值操作。因此，我们应该优先使用const来声明变量，只有在提前知道未来会有修改时再使用let。

更多编程相关知识，请访问：编程入门！！

Das obige ist der detaillierte Inhalt vonWas sind die Schlüsselwörter zum Deklarieren von Variablen in Javascript?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!