JavaScript声明变量的6种方法

1.var声明变量

var x = 1; //全局变量
function def(){
  var x = 2; //局部变量
  console.log(x)
}
def() //2
console.log(x) //1

-var在方法中定义的变量是局部变量，在全局作用域定义的变量是全局变量，var存在变量提升。
-ES5之前没有块级作用域的概念，只能通过函数作用域来解决全局变量的问题。没有块级作用域导致了if和for块级的问题，这也是JavaScript设计之初的缺陷。

按钮1
按钮2
按钮3
按钮4
按钮5

-全局作用域导致点击每一个按钮的变量i都是5，因为for没有块级作用域，所以在给按钮添加点击事件的时候就把i循环了5次，而点击事件是回调函数，因此每一个按钮的变量i都一样。

var btns = document.getElementsByTagName('button');
for (var i = 0; i < btns.length; i++) {
  (function (i) {
    btns[i].addEventListener('click', function () {
      console.log('第' + i + '个按钮被点击')
    })
  })(i)
}

-闭包就很好地解决了这个问题，闭包其实也是利用了作用域的概念，在每次定义函数的时候就执行一次，不会出现全局作用域的问题。

2.let声明变量

let不存在变量提升

-ES6 明确规定，如果区块中存在let和const命令，这个区块对这些命令声明的变量，从一开始就形成了封闭作用域。凡是在声明之前就使用这些变量，就会报错。

// var 的情况
console.log(foo); // 输出undefined
var foo = 2;

// let 的情况
console.log(bar); // 报错ReferenceError
let bar = 2;

let提供块级作用域

-在代码块内，使用let命令声明变量之前，该变量都是不可用的。这在语法上，称为“暂时性死区”

var a = [];
for (let i = 0; i < 10; i++) {
  a[i] = function () {
    console.log(i)
  }
}
a[6]();  //6

function f1() {
  let n = 5;
  if (true) {
    let n = 10;
  }
  console.log(n)
}
f1() //5

-let的暂时性死区也使得typeof不再是一个百分之百安全的操作

typeof x; // ReferenceError
let x;

-for循环有一个特别之处，设置循环变量的那部分是一个父作用域，而循环体内部是一个单独的子作用域。使用let也可以解决上面按钮点击事件的问题。

const btns = document.getElementsByTagName('button');
for (let i = 0; i < btns.length; i++) {
  btns[i].addEventListener('click', function () {
  console.log('第' + i + '个按钮被点击')
  })
}

不允许重复声明

let x = 1;
{
  var x = 2; // SyntaxError for re-declaration
}

-ES6 的块级作用域必须有大括号，如果没有大括号，JavaScript 引擎就认为不存在块级作用域。

// 第一种写法，报错
if (true) let x = 1;

// 第二种写法，不报错
if (true) {
  let x = 1;
}

3.const声明变量

const声明一个只读的常量。一旦声明，常量的值就不能改变。

const PI = 3.1415;
PI // 3.1415

PI = 3;
// TypeError: Assignment to constant variable.

const一旦声明变量，就必须立即初始化

const foo;
// SyntaxError: Missing initializer in const declaration

const也具有块级作用域

const实际上是保证变量指向的那个地址不能修改，而不是变量的值不能修改。对于简单类型的数据（数值、字符串、布尔值），值就保存在变量指向的那个内存地址。对于复合类型的数据（主要是对象和数组），保存的只是一个指向实际数据的指针。

const obj = {
  name: 'abc',
  age: 18,
  height: 1.88
}
obj.age = 20;
obj.prop = 123;

// 将 obj 指向另一个对象，就会报错
obj = {}; // TypeError: "obj" is read-only

4.function声明变量

//ES5之前表达形式
function() {}
//ES6表达形式
() => {}

-ES6允许为函数的参数设置默认值，即直接写在参数定义的后面。

function log(x , y = "World"){
  console.log(x,y);
}
log('Hello'); //Hello World

5.import声明变量

-ES6 模块不是对象，而是通过export命令显式指定输出的代码，再通过import命令输入。

Module 语法是 JavaScript 模块的标准写法，使用import取代require

import { func1, func2 } from 'moduleA';

导入导出时可以起别名

import {reallyReallyLongModuleExportName as shortName} from '/modules/my-module.js';

动态导入也可以适用

(async () => {
  if (somethingIsTrue) {
    // import module for side effects
    await import('/modules/my-module.js');
  }
})();

导入文件实例

//test.html

  

//common.js
let notUseUrl = ['material/submateriallist']
const add = (a, b = 6) => a + b
export function helloWorld(){
  console.log("Hello World")
}
export {
  notUseUrl,
  add
};

-html脚本使用import必须将type设置为module，必须开启服务器否则会发生跨域问题，没有后台服务器的同学可以安装Live Server插件，右键开启本地服务。

6.class声明变量

-ES6 的class可以看作只是一个语法糖，它的绝大部分功能，ES5 都可以做到，新的class写法只是让对象原型的写法更加清晰、更像面向对象编程的语法。

ES5类的定义

function Point(x, y) {
  this.x = x;
  this.y = y;
}

Point.prototype.toString = function () {
  return '(' + this.x + ', ' + this.y + ')';
};

var p = new Point(1, 2);

ES6类的定义

class Point {
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }

  toString() {
    return '(' + this.x + ', ' + this.y + ')';
  }
}

typeof Point // "function"
Point === Point.prototype.constructor // true

-ES5 的构造函数Point，对应 ES6 的Point类的构造方法
-类的数据类型就是函数，类本身就指向构造函数

类的实例

class Bar {
  doStuff() {
    console.log('stuff');
  }
}

var b = new Bar();
b.doStuff() // "stuff"

在类的实例上面调用方法，其实就是调用原型上的方法

class B {}
let b = new B();

b.constructor === B.prototype.constructor // true

Object.assign方法可以很方便地一次向类添加多个方法

class Point {
  constructor(){
    // ...
  }
}

Object.assign(Point.prototype, {
  toString(){},
  toValue(){}
});

类的内部所有定义的方法，都是不可枚举的

class Point {
  constructor(x, y) {
    // ...
  }

  toString() {
    // ...
  }
}

Object.keys(Point.prototype)
// []
Object.getOwnPropertyNames(Point.prototype)
// ["constructor","toString"]