Can es6 use var to declare variables?

es6 can use var to declare variables. Var is a keyword for declaring variables. Variables declared using the var keyword have two scopes: global scope and function scope. Since var supports variable promotion, global variables declared with var are included in the entire script code. Valid, local variables declared using var are valid throughout the function.

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, there are 6 ways to declare variables in ES6:

• Use the keyword var to declare variables

• Use the key Use the word function to declare variables

• Use the keyword const to declare variables

• Use the keyword let to declare variables

• Declare variables with the keyword class

• Declare variables with the keyword import

Declare variables with the keyword var

var is a keyword for declaring variables. Declaration method:

var 变量名;

A few examples:

var str;  //用来存储字符串
var age;  //用来存储年龄
var prePage;  //用来存储上一页

When defining variables, you can define one or more variables at a time. If you define multiple variables, you need to use commas to separate the variable names, as shown in the following example:

var a, b, c;    // 同时声明多个变量

After the variables are defined, if no values ​​are assigned to the variables, then these variables will be Assign an initial value - undefined.

After the variable is defined, you can use the equal sign = to assign a value to the variable. The left side of the equal sign is the name of the variable, and the right side of the equal sign is the value to be assigned to the variable, as shown in the following example:

var num;    // 定义一个变量 num
num = 1;    // 将变量 num 赋值为 1

In addition, you can also assign values ​​to variables while defining them, as shown in the following example:

var num = 1;                // 定义一个变量 num 并将其赋值为 1
var a = 2, b = 3, c = 4;    // 同时定义 a、b、c 三个变量并分别赋值为 2、3、4
// var a = 2,               // 为了让代码看起来更工整，上一行代码也可以写成这样
//     b = 3,
//     c = 4;

Note:

• Variables defined by var can be modified. If it is not initialized, undefined will be output and 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.

• Many languages ​​have block-level scope, but JS does not. It uses var to declare variables and function to divide the scope. The curly brackets "{}" cannot limit the scope of var. Therefore, variables declared with var have the effect of variable promotion

• The scope of variables declared with var is global or function-level

Extended knowledge:

let and const keywords declare variables

Before 2015, JavaScript could only declare variables through the var keyword , after the release of ECMAScript6 (ES6), two new keywords, let and const, were added to declare variables. Among them:

• Variables declared using the let keyword are only used in the code where they are located. Valid in a block (similar to local variables), and in this code block, variables with the same name cannot be declared repeatedly;

• const keyword has the same function as let, but uses the const keyword Declared variables also have another characteristic, that is, variables defined with the const keyword cannot be modified once defined (that is, variables defined with the const keyword are constants).

Note: IE10 and below versions do not support the let and const keywords.

The sample code is as follows:

let name = "小明";      // 声明一个变量 name 并赋值为“小明”
let age  = 11;          // 声明一个变量 age
let age  = 13;          // 报错：变量 age 不能重复定义
const PI = 3.1415       // 声明一个常量 PI，并赋值为 3.1415
console.log(PI)         // 在控制台打印 PI

The scope of var, let and const

The scope of variables declared using var has the global scope and Function scope; variables declared using let and const have global scope, local scope and block-level scope.

Since var supports variable promotion, the global scope of the var variable is valid for the script code of the entire page; while let and const do not support variable promotion, so the global scope of the let and const variables refers to the script code from The entire area between the beginning of the declaration statement and the end of the script code of the entire page, and the area before the declaration statement is invalid.

Similarly, because var supports variable promotion, but let and const do not support variable promotion, local variables declared using var are valid throughout the function, while local variables declared using let and const are valid from the beginning of the declaration statement to The area between the end of the function is valid. It should be noted that if the local variable and the global variable have the same name, in the function scope, the local variable will overwrite the global variable, that is, the local variable will work in the function body; outside the function body, the global variable will work, and the local variable will work. The variable is invalid, and a syntax error will occur when referencing local variables.

Declare a variable using the keyword function

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

• Declares a new variable named add and assigns it a function definition# The content between

• ##{} is assigned to add

• The code inside the function will not be executed, but is just stored in the variable for later use In the future, use

to declare variables using the keyword class

Regarding class, I will write a separate article later to introduce it in detail, here Let’s talk about it briefly: 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 take a look at how to write ES6 classes:

 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 的class可以看作只是一个语法糖，它的绝大部分功能，ES5 都可以做到，新的class写法只是让对象原型的写法更加清晰、更像面向对象编程的语法而已，constructor方法就是构造方法，而this关键字则代表实例对象。也就是ES5 的构造函数Point，对应 ES6 的Point类的构造方法。

用关键字import声明变量

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 Can es6 use var to declare variables?. For more information, please follow other related articles on the PHP Chinese website!