Quels sont les mots-clés pour déclarer des variables en javascript

Les mots-clés pour déclarer des variables en JavaScript sont var, let et const. Les variables déclarées par var peuvent être utilisées pour enregistrer n'importe quel type de valeur. La portée de la déclaration est la portée de la fonction ; la portée de la déclaration let est la portée du bloc. Lors de la déclaration d'une variable avec const, la variable doit être initialisée en même temps. temps, et la valeur ne peut pas être modifiée après l’initialisation.

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

Déclarer 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 tout type de data , chaque variable n'est rien de plus qu'un espace réservé nommé utilisé pour contenir une valeur arbitraire.

Mot-clé 1.var

Les variables déclarées par var peuvent être utilisées pour enregistrer toute valeur de type (sans A La valeur spéciale undefined sera enregistrée lors de l'initialisation. Comme d'autres langages, JavaScript peut également attribuer des valeurs aux variables lors de la définition des variables. La variable est définie comme un qui enregistre la valeur attribuée par les variables, car JavaScript. est un langage dynamique, lors de l'initialisation d'une variable, elle ne sera pas identifiée comme le type de données attribué, c'est juste une simple affectation. 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;

1.1. Portée de la déclaration var

Utilisez l'opérateur var. Une variable définie devient locale à la fonction contenant. 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

garbage collection :

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

après la fonction. Les variables d'appel seront détruites de manière aléatoire, donc la dernière ligne signalera une erreur. Cependant, lorsque l'opérateur var est omis lors de la définition des variables dans une fonction, une

variable globale peut être créée :

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

Tant que la fonction test() est appelée une fois, la variable globale Le message sera défini, et il peut s'agir d'une fonction d'accès externe. 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. Promotion de la déclaration Var

Les variables déclarées à l'aide du mot-clé var seront automatiquement promues

haut de la portée de la fonction, Le soi-disant "levage" (hoist), c'est-à-dire tirer toutes les déclarations de variables vers le haut de la portée de la fonction :

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

Ici, aucune erreur ne sera signalée, mais undéfini sera affiché. Lorsque ECMAScript est en cours d'exécution, il sera considéré comme équivalent au code suivant :

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

2 let instruction

Le rôle de. let et var À peu près pareils, mais avec des différences très importantes. La différence la plus évidente est que la portée de la déclaration let est

block scope, 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é à l'extérieur du bloc if. La portée du bloc est un sous-ensemble de la portée de la fonction, donc les 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 la variable

déclarée par let ne sera pas utilisée Promu dans le domaine  :

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

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

2.2 Déclaration globale

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

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

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

Cependant, laissez les déclarations se produire toujours dans la portée globale, et les variables correspondantes persisteront 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 a été précédemment déclaré en utilisant let, et en même temps il est également impossible de le déclarer sans le déclarer. 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 des variables d'itération et la modification :

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

Lors de la sortie de la boucle, la variable d'itération stocke la valeur qui a provoqué la sortie de la boucle : 5. Lorsque la logique de délai d'attente

sera exécutée plus tard, je serai setTimeout la même variable, donc la sortie finale sera la même valeur.

    使用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。

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

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!