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!