Quelles sont les 4 façons de déclarer des variables en javascript

Quatre façons de déclarer des variables en JavaScript : 1. Utilisez "var" pour déclarer des variables, telles que "var a;" 2. Utilisez "function" pour déclarer des variables, telles que "function Fun (num)". {}"; 3. Utilisez "let" pour déclarer des variables; 4. Utilisez "const" pour déclarer des variables.

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

Comment déclarer des variables

Les façons de déclarer des variables en JavaScript sont les suivantes :

• Avant ES6, c'était var et function
• Nouveau dans ES6 L'ajout des fonctions let et const

est-il un moyen de déclarer des variables ?

Vérifions-le

Première méthode de vérification :

    function repeatFun (num) {
      return num;
    }

    repeatFun(10); // 10

    var repeatFun = 1;

    repeatFun(2); // Uncaught TypeError: repeatFun is not a function

Cette méthode utilise var pour déclarer des variables à plusieurs reprises, mais l'écrasement de cette dernière écrasera la première

Voyons jetez un oeil à ce qui se passe ici :

• Tout d'abord, une fonction est déclarée, son nom est repeatFun
• Elle est appelée une fois et le résultat est 10
• Après ça, RepeatFun est déclaré à nouveau avec var et initialisé à 1
• La fonction RepeatFun est appelée une dernière fois
• Le résultat est une erreur, contenu : RepeatFun n'est pas une fonction

Sur la base des résultats de l'exécution, nous pouvons déduire qu'il existe une variable repeatFun dans la mémoire du navigateur. C'était une fonction auparavant et a ensuite été redéclarée par un mot-clé var et initialement modifiée en 1.

Deuxième méthode de vérification :

    {
      let repeatFun = 1;
      function repeatFun (num) {
        return num
      }
    }
    // Uncaught SyntaxError: Identifier 'repeatFun' has already been declared

La deuxième méthode consiste à utiliser une syntaxe de

ES6 : en utilisant la fonctionnalité de let qui ne peut pas être déclarée à plusieurs reprises pour prouver que la fonction est également une variable déclarée La différence entre

---

var, let et const :

• Promotion de déclaration de variable

  • var a une promotion de déclaration de variable Les fonctions peuvent être utilisées d'abord puis déclarées, et vice versa
  • let et const n'ont pas la fonction de promotion de déclaration de variable. Elles doivent d'abord être déclarées avant de pouvoir être utilisées
  <. 🎜>
• La déclaration répétée
  var peut être déclarée à plusieurs reprises, et cette dernière couvre la première
  let et const ne peuvent pas être déclarés à plusieurs reprises
• portée La portée de
  var est délimitée par les fonctions
  let et const sont des portées de bloc
  var peut définir des variables globales et les variables locales, let et const ne peuvent définir que des variables locales
• La particularité de const
  ne peut pas être modifiée après déclaration (il y a quelques différences dans le comportement des types de référence et des types de base) Différent)

---

Promotion de la déclaration de variable

var a la fonction de déclaration de variable promotion, qui peut être utilisée en premier puis déclarée
let et const n'ont pas la fonction de déclaration de variable promotion. Elles doivent être déclarées avant de pouvoir être utilisées

Exemple 1. , vérifiez la promotion de la variable var :

var b = a + 1; // b： NaN 
var a = 1; // a： 1

Tout d'abord, déclarez-la d'abord. Une variable b est initialisée et initialisée à a + 1 (quelle est la valeur de a ?)

Ensuite, une variable a est déclarée et initialisée à 1
Voici à quoi ressemble le code en surface. En faisant simplement ces choses, ce qui est réellement fait est ceci :

Chaque fois qu'une variable est déclarée, sa déclaration est placée en haut de le code, et ils doivent tous être exécutés. Une fois initialisés, la valeur est : indéfinie, mais la position assignée ne changera pas
Effectuez ensuite d'autres opérations

Le même effet. peut être obtenu en écrivant ce qui suit

var b;
var a;

b = a +1; // b： NaN 
a = 1; // a： 1

let et const se comportent différemment de var

Exemple 2, vérifiez s'il y a une promotion de variable dans let :

let b = a + 1; // Uncaught ReferenceError: a is not defined
let a = 1;

Une erreur de portée sera être lancé directement lors de l'exécution, si vous le modifiez comme ceci, il n'y a pas d'erreur :

let a = 1; // a： 1
let b = a + 1; // b： 2

const a les mêmes performances que let en termes de promotion de variable

---

Déclaration répétée

var peut être déclaré à plusieurs reprises, ce dernier remplaçant le premier
• let et const ne peuvent pas être des déclarations répétées
  Exemple 1, vérifiez la déclaration répétée de var :

  var a = 1;
  var a = 2;
  var b = a + 1; // 3

  Tout d'abord, déclarez la variable a et initialisez-la Déclarez à nouveau la variable a comme 1
  , initialisez-la comme 2
  Enfin, déclarez la variable b, sa valeur initiale est a + 1
  Exemple 2, vérifier let Déclaration répétée :

  let a = 1;
  let a = 2; // Uncaught SyntaxError: Identifier 'a' has already been declared

  var a = 1;
  let a = 2; //Uncaught SyntaxError: Identifier 'a' has already been declared

  Évidemment, les variables déclarées à l'aide de let dans le même environnement d'exécution ne peuvent pas être déclarées à plusieurs reprises, sinon une erreur sera être lancé
  • Les performances de const et let dans les déclarations répétées sont cohérentes
    

---

scope scope

La portée de var est délimitée par la fonction
let et const ont la portée du bloc
var peut définir des variables globales et des variables locales, let et const ne peuvent définir que des variables locales

encapsule une factorielle fonction à titre d'exemple, sans utiliser la récursion de queue, c'est-à-dire utilisez la combinaison de for et if pour implémenter

Exemple 1, portée de vérification de la fonction factorielle :

  var num = 5;

  function factorial(num) {

      var result = 1，resultValue = 0;

      for (let i = num - 1; i >= 1; i--) {

        if (i === num - 1) {
          resultValue = num * i;
        }else{
          resultValue = num * i / num;
        }

        result *= resultValue;
      }

      // i 是用 let 进行定义它的作用域仅仅被限制在 for 循环的区域内
      // i++;// Uncaught ReferenceError: i is not defined

      return result;
  }

  // result 是用 var 进行定义，他的活动区域在 factorial 函数内
  // result++; // var的作用域.html:34 Uncaught ReferenceError: result is not defined

  factorial(num); // 120

const et laissez se comporter de la même manière dans la portée

Exemple 2, vérification Portée de const :

  {
    const NUM_1 = 10;
  }

  let b = NUM_1 + 1;  // Uncaught ReferenceError: NUM_1 is not defined

Exemple 3, vérifiez que var peut définir des variables globales, let et const ne peuvent définir que des variables locales

  // 可以挂载到全局作用域上
  // var name = 'window scoped';

  let name = 'let scoped'; //是不挂载到全局作用域中

  let obj = {
    name: 'myName',
    sayName () {

       return function () {
        console.log(this.name); // 打印出来为空
      };
    }
  }

  obj.sayName()();
  console.log(window); //name 这个属性的值没有，如下图

若这样改一下就可以得到我们想要的值：

• 把用 var 定义的 name 的代码取消注释，把用 let 定义的 name 的代码注释。

这个同时也涉及到新问题 this 的指向。后面的文章再详细举例验证

---

const 的特殊之处

const 与 let , var 其实还是有些地方不一样的

例子1：验证 const 的特殊之处（一）<br/>

const NUM = 100; 
 NUM = 1000; // Uncaught TypeError: Assignment to constant variable

• 经过 const 方式进行声明，之后赋值完毕，则不可以进行改变，否则会报错

但是也有例外

例子二：验证 const 的特殊之处（二）

  const obj = {
    name: 'xiaoMing',
    sayName () {
      return this.name
    }
  };
  obj.sayName(); // xiaoMing

  obj.name = 'xiaoHong';
  obj.sayName(); // xiaoHong

• 使用 const 首先声明一个变量 obj , 并且这个变量指向我们在内存中创建的对象，你会发现我们改变里面的属性是没有任何问题

若这样改一下： <br/> 例子三：验证 const 的特殊之处（三）

  const obj = {
    name:'xiaoMing',
    sayName(){
      return this.name
    }
  };

  obj = {}; // Uncaught TypeError: Assignment to constant variable

• 若改变该变量的指向的对象，则就会报错。这种错误和 「 验证 const 的特殊之处（一）」的错误是一样的

更多编程相关知识，请访问：编程视频！！

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!