JavaScript还是一门弱类型的、动态语言

• 弱类型：可以使用同一个变量保存不同类型的值
• 动态：定义变量不需要指定变量的类型，运行时js引擎自己会计算出来

var 关键字

var的基本使用

• var message

注意：不初始化的情况下，变量会保存一个特殊值undefined

• var message = "hi";

这里message被定义为一个保存字符串值hi的变量。但这样初始化变量并不会将它标识为字符串类型，只是一个简单复制而已。之后，不仅可以改变保存的值，也可以改变值的类型

• message = 100; // 合法，但不推荐

var 的声明作用域

局部作用域

• var定义的变量会成为包含它的函数的局部变量
• 使用var在一个函数内部定义一个变量，就意味着该变量将在函数退出时被销毁

function fun() { var test = "Hello World"; // 局部变量} fun(); console.log(test); // 出错！

全局变量

• 在当前代码中都生效的变量
• 创建全局变量

方法一：在最上层定义变量
var test;
function fun() { test = "Hello World"; } fun(); 方法二：不使用var关键字
function fun() { test = "Hello World"; } fun(); console.log(test); // "Hello World"

注意：虽然可以通过省略 var 操作符定义全局变量，但不推荐这么做。在局部作用域中定 义的全局变量很难维护，也会造成困惑。这是因为不能一下子断定省略 var 是不是有意而 为之。在严格模式下，如果像这样给未声明的变量赋值，则会导致抛出 ReferenceError。

声明提升

• 使用 var 时，关键字声明的变量会自动提升到函数作用域顶部。

function foo() { console.log(age); var age = 26; } foo(); // undefined 

之所以不会报错，是因为ECMAScript运行时把它看成等价于如下代码

function foo() { var age; console.log(age); age = 26; } foo(); // undefined

反复多次 使用 var 声明同一个变量也没有问题，最后都会被覆盖，以最后一个为准

function foo() { var age = 16; var age = 26; var age = 36; console.log(age); 
} 
foo(); // 36

let 关键字

基本使用

let 跟 var 的作用差不多，但有着非常重要的区别。最明显的区别是，let 声明的范围是块作用域， 而 var 声明的范围是函数作用域。

//let 作用域只能在块作用域里访问，不能跨块访问，
//也不能跨函数访问两者的对比会更加凸显不一// --- var ---if (true) { var name = 'king'; console.log(name); // Matt } console.log(name); // Matt​// --- let ---if (true) { let age = 26; console.log(age); // 26 } console.log(age); // ReferenceError: age 没有定义

冗余声明

• let 不允许同一个块作用域中出现冗余声明，且报错报错不会因混用let和var而受影响

var name; 
var name; 
let age; 
let age; // SyntaxError；标识符 age 已经声明过了var name; 
let name; // SyntaxError 
let age; 
var age; // SyntaxError

JavaScript 引擎会记录用于变量声明的标识符及其所在的块作用域，因此嵌套使用相同的标识符不会报错。

暂时性死区

• let 与 var 的另一个重要的区别，就是 let 声明的变量不会在作用域中被提升

// name 会被提升console.log(name); // undefined var name = 'vito'; ​// age 不会被提升console.log(age); // ReferenceError：age 没有定义let age = 26

在 let 声明之前的执行瞬间被称为“暂时性死区”（temporal dead zone），在此阶段引用任何后面才声明的变量都会抛出ReferenceError。

全局声明

• 与 var 关键字不同，使用 let 在全局作用域中声明的变量不会成为 window 对象的属性（var 声 明的变量则会）。

/* window.xx：在window对象中查找此属性(元素)*/var name = 'vito'; console.log(window.name); // 'vito' ​let age = 26; console.log(window.age); // undefined

但let声明仍然是在全局作用域中发生的，所以相应变量会在页面的生命周期内存续

条件声明

• 在使用 var 声明变量时，由于声明会被提升，JavaScript 引擎会自动将多余的声明在作用域顶部合 并为一个声明。
• 因为 let 的作用域是块，所以不可能检查前面是否已经使用 let 声明过同名变量，同 时也就不可能在没有声明的情况下声明它。

<script> var name = 'Nicholas'; let age = 26; </script> ​<script> // 假设脚本不确定页面中是否已经声明了同名变量// 那它可以假设还没有声明过var name = 'Matt'; // 这里没问题，因为可以被作为一个提升声明来处理// 不需要检查之前是否声明过同名变量let age = 36; // 如果 age 之前声明过，这里会报错</script>

注意：let不能进行条件式声明是件好事，因为条件声明是一种反模式，它让程序变得更难理解

for循环中的let

• 在let出现之前，for循环定义的迭代变量会渗透到循环体外部。

for (var i = 0; i < 5; ++i) { // 循环逻辑 
} 
console.log(i); // 5

• 改成使用let就不会有这个问题了，因为let迭代变量的作用域仅限于 for 循环块内部。

for (let i = 0; i < 5; ++i) { // 循环逻辑} console.log(i); // ReferenceError: i 没有定义

• 在使用 var 的时候，最常见的问题就是对迭代变量的奇特声明和修改。

for (var i = 0; i < 5; ++i) { setTimeout(() => console.log(i), 0) 
} 
// 你可能以为会输出 0、1、2、3、4 
// 实际上会输出 5、5、5、5、5//之所以会这样，是因为在退出循环时，迭代变量保存的是导致循环退出的值：5。
//在之后执行超时 逻辑时，所有的 i 都是同一个变量，因而输出的都是同一个最终值。

• 而在使用 let 声明迭代变量时，JavaScript 引擎在后台会为每个迭代循环声明一个新的迭代变量。 每个 setTimeout 引用的都是不同的变量实例，所以 console.log 输出的是我们期望的值，也就是循 环执行过程中每个迭代变量的值。

 for (let i = 0; i < 5; ++i) { setTimeout(() => console.log(i), 0) } // 会输出 0、1、2、3、4 

const 关键字

基本使用

• const跟let的行为差不多，但区别是用它声明变量时必须同时初始化变量，且尝试修改const声明的变量会导致运行时错误（一致性）

const 不可改值

const age = 26; age = 36; // TypeError

const 也不允许重复声明

const name = 'Lisa'; 
const name = 'Vito'; // SyntaxError

const 声明的作用域也是块

const name = 'apple'; if (true) { const name = 'avocado'; } console.log(name); // apple 

• const声明的限制只适用于它指向的变量的引用。换句话说，如果const变量引用的是一个对象，那么修改这个对象内部的属性并不违反const的限制

 const person = {}; person.name = 'vito'; // ok 

for循环中的 const

• JavaScript 引擎会为for循环中的let声明分别创建独立的变量实例，虽然const变量跟let变量很相似，但是不能用const来声明迭代变量（因为迭代变量会自增）

for (const i = 0; i < 10; ++i) {}  // TypeError 类型错误

• 不过，如果你只想用const声明一个不会被修改的for循环变量，那也是可以的。每次迭代只是创建一个新变量，这对for-of和for-in循环特别有意义的，如下：

 let i = 0; for (const j = 7; i < 5; ++i) { console.log(j); } // 7, 7, 7, 7, 7 ​for (const key in {a: 1, b: 2}) { console.log(key); } // a, b ​for (const value of [1,2,3,4,5]) { console.log(value); } // 1, 2, 3, 4, 5