Quel mot-clé javascript utilise-t-il pour déclarer des variables ?

En js, vous pouvez utiliser les déclarations de mots-clés var, let et const. Les variables déclarées par var peuvent être utilisées pour enregistrer n'importe quel type de valeur, et la portée est la portée de la fonction ; les variables déclarées par let sont utilisées dans {}, et la portée de la variable est limitée au domaine de niveau bloc ; pour modifier les constantes, et la position de déclaration n'est pas limitée.

L'environnement d'exploitation de ce tutoriel : système Windows 7, JavaScript version 1.8.5, ordinateur Dell G3.

Déclarez les mots-clés de variable var, let et const

Les variables ECMAScript sont mal typées, c'est-à-dire que les variables peuvent être utilisées pour enregistrer n'importe quel type de données, et chaque variable n'est qu'une variable utilisée pour enregistrer tout espace réservé nommé A pour la valeur.

Mot-clé 1.var

Les variables déclarées avec var peuvent être utilisées pour enregistrer tout type de valeur (une valeur spéciale non définie sera enregistrée si elle n'est pas initialisée), comme les autres langages en javascript Quand en définissant une variable, vous pouvez également attribuer une valeur à la variable. La variable est définie comme une variable qui enregistre la valeur attribuée. JavaScript étant un langage dynamique, lors de l'initialisation d'une variable, elle ne sera pas identifiée comme le type de données attribué. juste Juste une simple mission. Ensuite, non seulement la valeur enregistrée peut être modifiée, mais le type de la valeur peut également être modifié :

var message = "hi";
	message = 100;

Portée de la déclaration 1.1.var

Une variable définie à l'aide de l'opérateur var deviendra une variable locale variable de la fonction qui la contient. Par exemple, utiliser var pour définir une variable à l'intérieur d'une fonction signifie que la variable sera détruite à la sortie de la fonction. Je pense que c'est ce qu'on appelle le garbage collection :

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

La variable sera détruite aléatoirement après la fonction. est appelé. Par conséquent, la dernière ligne signalera une erreur. Cependant, vous pouvez créer une variable globale lorsque vous omettez l'opérateur var lors de la définition d'une variable dans une fonction :

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

Tant que la fonction test() est appelée une fois, le message de la variable globale sera défini et pourra être accessible en dehors de la fonction. Cependant, étant donné que les variables globales définies dans une portée locale sont difficiles à maintenir, cela n'est généralement pas recommandé.

1.2. Levage de la déclaration Var

Les variables déclarées à l'aide du mot-clé var seront automatiquement hissées en haut de la portée de la fonction, ce qu'on appelle le "hoist", c'est-à-dire toutes les variables. les déclarations seront hissées. Allez en haut de la portée de la fonction :

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

Aucune erreur ne sera signalée ici, mais ECMAScript le traitera comme équivalent au code suivant lors de son exécution :

.

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

Déclaration 2 .let

Let a des fonctions similaires à var, mais il existe des différences très importantes. La différence la plus évidente est que la portée de la déclaration let est la portée du bloc, tandis que la portée de la déclaration var est la portée de la fonction :

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

La portée de la variable age est limitée à l'intérieur du bloc. , il ne peut donc pas être référencé en dehors du bloc if . La portée du bloc est un sous-ensemble de la portée de la fonction, donc les mêmes restrictions de portée qui s'appliquent à var s'appliquent également à let.

let n'autorise pas non plus les déclarations redondantes dans la même portée (var can) :

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

De plus, les erreurs de déclaration redondantes ne seront pas affectées par le mélange de var et let. Ces deux mots-clés ne déclarent pas de variables de types différents, ils indiquent simplement comment les variables existent dans la portée concernée.

2.1. Zone morte temporaire

Une autre différence importante entre let et var est que les variables déclarées par let ne seront pas promues dans le scope :

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

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

2.2. 🎜>

Contrairement à var, les variables déclarées dans la portée globale à l'aide de let ne deviendront pas des attributs de l'objet window (les variables déclarées avec var le seront) :

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

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

Cependant, la déclaration let est toujours si elle se produit dans la portée globale, la variable correspondante persistera dans le cycle de déclaration de la page.

2.3. Déclaration conditionnelle

La portée de let est un bloc, il est donc impossible de vérifier si une variable du même nom a été précédemment déclarée en utilisant let, et il est également impossible de déclarez-le sans déclaration. L'utilisation des opérateurs try/catch ou typeof ne peut pas le résoudre, car la portée de la déclaration let dans le bloc conditionnel est limitée à ce bloc. Pour cette raison, le nouveau mot-clé de déclaration ES6 let ne peut pas s'appuyer sur le modèle de déclaration conditionnelle.

2.4. let instruction dans la boucle for

Lors de l'utilisation de var, le problème le plus courant est la déclaration étrange et la modification des variables d'itération :

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

Après avoir quitté la boucle. temps, la variable d'itération contient la valeur qui a provoqué la sortie de la boucle : 5. Lorsque la logique de délai d'attente setTimeout est exécutée ultérieurement, i est la même variable, donc la sortie finale est la même valeur.

Lors de l'utilisation de let pour déclarer une variable d'itération, le moteur JavaScript déclarera une nouvelle variable d'itération pour chaque boucle d'itération en arrière-plan. Chaque setTimeout fait référence à une instance de variable différente :

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

3 . déclaration const

Le comportement de const est fondamentalement le même que celui de let. La seule différence importante est que lorsqu'il déclare une variable, il doit initialiser la variable en même temps et essayer de modifier une variable déclarée par const. provoquera une erreur d’exécution.

    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。

【推荐学习：javascript高级教程】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!