There are several ways to declare variables in es6

es6 There are 6 ways to declare variables: 1. Use the keyword var to declare variables; 2. Use the keyword function to declare variables; 3. Use the keyword const to declare variables; 4. Use the keyword let to declare variables; 5. Use the keyword class to declare variables; 6. Use the keyword import to declare variables.

The operating environment of this tutorial: Windows 7 system, ECMAScript version 6, Dell G3 computer.

ES5 has only two ways to declare variables: the var command and the function command.

ES6 In addition to adding let and const commands, there are two ways to declare variables: import command and class command.

So, ES6 has a total of 6 ways to declare variables.

1. Use the keyword var to declare variables

var a ;　　//undefined
var b = 1;

• Variables defined by var can be modified. If not initialized, ## will be output. #undefined, no error will be reported
The variable declared by var is on the window. Use let or const to declare the variable. This variable will not be placed on the window.
• In many languages There is a block-level scope, but JS does not. It uses var to declare variables and use function to divide the scope. Curly brackets "{}" cannot limit the scope of var, so variables declared with var have
• Variable promotionEffect
The scope of the variable declared by var is global or function-level

2. Use the keyword function to declare the variable

function add(a) {
　　var sum = a + 1;
　　return sum;
}

A new variable named add is declared and a function definition is assigned to it. The content between
• {} is assigned to add
• The code inside the function will not be executed, but is just stored in the variable for future use

3. Declare the variable with the keyword const

const a;     //报错，必须初始化
const b = 1;

Variables defined by const cannot be modified and must be initialized
• The variable is a global variable, or a global variable within the module
• If a variable It is only assigned once when it is declared and will never be reassigned in other lines of code. Then const should be used, but the initial value of the variable may be adjusted in the future (constant variable)
• Create a read-only constant, which appears unmodifiable on different browsers; it is recommended not to modify it after declaration; it has block-level scope
• const
• constant representing a valueindex, that is to say, the pointer of the variable name in the memory cannot be changed , but the value pointing to this variable may change
const-defined variables cannot be modified , generally used or defined when requiring a module,
• global constants
• Constants can be declared in the global scope or within a function, but

  must initializeconstants

• A constant cannot have the same name as other variables or functions in its scope

4. Use the keyword let Declaring variables

let a;　　//undefined
let b = 1; 
function add(b) {
　　let sum = b + 1;
　　return sum;
}
let c = add(b);

requires "javascript strict mode":
• 'use strict';
There is no variable promotion
• Duplicate declarations are not allowed
• The variable scope declared by let is in the block-level domain. After the let definition is used inside the function, it has no impact on the outside of the function (
• Block-level scope)
You can assign a value to the variable when declaring it. The default value is undefined. You can also assign a value to the variable later in the script. It cannot be used before life (temporary dead zone)

5. Use the keyword class to declare variables

Regarding class, I will write a separate article in detail later. To introduce, here is a brief introduction: First, look at the constructor in ES5, and then use ES6 classes to implement it:

// ES5写法 ：
  function fun ( x, y ){
    this.x = x;
    this.y = y;
  };
  fun.prototype.GetHair = function(){
    return `${this.x}掉了两根头发，${this.y}说俺也一样！`;
  };
  let setHair = new fun('小明','老王');
  console.log(setHair.GetHair()); // 小明掉了两根头发，老王说俺也一样！

Let’s look at how ES6 classes are written:

 class Interest {
    constructor( x, y, e, z ){
      this.x = x;
      this.y = y;
      this.e = e;
      this.z = z;
    }
    MyInterest(){
      let arr = [];
      console.log(`我会${[...arr,this.x,this.y,this.e,this.z]}!`);
    }
  }
  let GetInterest = new Interest('唱','跳','rap','篮球');
  console.log(GetInterest.MyInterest());  //我会唱,跳,rap,篮球!

ES6 classes can be regarded as just syntax sugar , most of its functions can be achieved by ES5. The new class writing method only makes the object prototype writing method clearer and more like the syntax of object-oriented programming. The constructor method is the construction method, and the this keyword represents the instance object. . That is, the constructor Point of ES5 corresponds to the constructor method of the Point class of ES6.

6. Use the keyword import to declare variables

import is used to load files. What is received in curly brackets is One or more variable names. These variable names need to be the same as the variable names you want to import.

举个栗子：你想要导入action.js文件中的某一个变量，这个变量里保存了一段代码块，所以你要写成：import { Button } from 'action'，这个时候，你就从action.js中获取到了一个叫 Button 的变量，既然获取到了，你就可以对Button里的代码猥琐欲为了

如果想为输入的变量重新取一个名字，import命令要使用as关键字，将输入的变量重命名，比如：

import { NewButton as Button } from 'action.js';

上面的代码表示从action.js文件中，获取一个变量名称叫做Button的代码段，然后你又声明了一个变量 NewButton ，将 Button 保存在 NewButton

【相关推荐：javascript视频教程、web前端】

The above is the detailed content of There are several ways to declare variables in es6. For more information, please follow other related articles on the PHP Chinese website!