8.变量

• let用来声明可变变量。
• const用来声明常量（不可变变量）。

let i;
i = 0;
i = i + 1;
assert.equal(i, 1);

let i = 0

const i = 0;// 必须立即初始化
assert.throws({
    name: 'TypeError',
    message: 'Assignment to constant variable.',//赋值给常量
})

const obj = { prop: 0 };
//允许： obj的prop属性值改变
obj.prop = obj.prop + 1;
assert.equal(obj.prop, 1);
// 不允许： 给obj赋值
assert.throws(
    () => { obj = {} },
    {
        name: 'TypeError',
        message: 'Assignment to constantvariable.',
    }
);

const arr = ['hello', 'world'];
for (const elem of arr) {
    console.log(elem);
}
// Output:
// 'hello'
// 'world'

const arr = ['hello', 'world'];
for (let i=0; i<arr.length; i++) {
    const elem = arr[i];
    console.log(elem);
}

• const意味着固定的绑定，变量的值永远不会改变。用const就没错了。
• let表示变量的值发生变化。仅在不能使用const时才使用它。

{ // // Scope A.  x（直接作用域）可被访问
  const x = 0;
  assert.equal(x, 0);
  { // Scope B. x, y可被访问
    const y = 1;
    assert.equal(x, 0);
    assert.equal(y, 1);
    { // Scope C. x, y, z可被访问
      const z = 2;
      assert.equal(x, 0);
      assert.equal(y, 1);
      assert.equal(z, 2);
    }
  }
}
//作用域外.  x, y, z不可被访问
assert.throws(
  () => console.log(x),
  {
    name: 'ReferenceError',
    message: 'x is not defined',
  }
);

• 作用域A是x的直接作用域。
• 作用域B和C在嵌套在作用域A的内部。
• 作用域A在作用域B和C的外面。

assert.throws(
  () => {
    eval('let x = 1; let x = 2;');
  },
  {
    name: 'SyntaxError',
    message: "Identifier 'x' has already been declared",
  });

assert.throws(
  () => {
    eval('let x = 1; let x = 2;');
  },
  {
    name: 'SyntaxError',
    message: "Identifier 'x' has already been declared",
  });

const x = 1;
assert.equal(x, 1);
{
    const x = 2;
    assert.equal(x, 2);
}
assert.equal(x, 1);

• 静态： 某些内容与源码有关，在不执行代码的情况下确定。
• 动态： 表示运行时。

function f() {
  const x = 3;
  // ···
}

function g(x) {}
function h(y) {
  if (Math.random()){// (A)
    g(y);
  }
}

{
  console.log(x); // 这里将会打印什么
  let x;
}

1. 该变量被解析在当前作用域的作用域范围内。
2. 如果读取变量，你会得到undefined。你也可以给变量赋值。 （这就是var的工作原理。）
3. 抛出错误。

• 在此期间，变量被认为是未初始化的（就好像它是一个特殊值）。
• 如果访问未声明的变量，则会得到ReferenceError。
• 到变量声明后，变量获得初始值（通过赋值符号指定）或undefined - 如果没有赋初值。

if (true) { // `tmp`作用域的起点, TDZ starts
  // `tmp` 未被初始化:
  assert.throws(() => (tmp = 'abc'), ReferenceError);
  assert.throws(() => console.log(tmp), ReferenceError);
  let tmp; // TDZ ends
  assert.equal(tmp, undefined);
}

if (true) { // `myVar`作用域起点, TDZ starts
  const func = () => {
    console.log(myVar); // 稍后执行
  };
  // TDZ 内部:
  // 访问 `myVar` 会抛出 `ReferenceError`
  let myVar = 3; // TDZ 结束
  func(); // OK, 在 TDZ外调用
}

assert.equal(func(), 123); // Works!
function func() {
  return 123;
}

function func() {
  return 123;
}
assert.equal(func(), 123);

• 最外层的全局作用域是特殊的：它的变量可以通过对象（全局对象）的属性所被访问。全局对象在浏览器环境中被称为window和self。此作用域的变量通过以下方式创建的：
  • 作为全局对象的属性
  • var和function在脚本的最上面声明的变量（script 被浏览器支持。它们是简单的代码片段以及模块的前身。有关详细信息，请参阅 第六章：模块化 。）
• 嵌套在这个作用域内是脚本的全局作用域。此作用域中的变量由let，const和class在脚本的最上面声明。
• 嵌套在该作用域的是模块的作用域。每个模块都有自己的全局作用域。变量在该作用域被最上面的模块声明。

• 如果在最外层的作用域中创建变量，则全局对象将获取新属性。如果更改这个全局变量，那么这个属性也会更改。
• 如果你创建或删除全局对象的属性，那么相应的也会创建或删除相应的全局变量。如果更改全局对象的属性，则相应的全局变量将更改。

• window：是引用全局对象的经典方式。但它只适用于普通的浏览器，不适用于Node.js 和Web Workers （与浏览器代码同时运行的进程;有关详细信息，请参阅 第八章：异步 章节）。
• self：在浏览器环境中随处可用，包括 Web Workers。但是 Node.js 不支持它。
• global：仅在 Node.js 中可用。

// 在脚本的最上面
var myGlobalVariable = 123;
assert.equal('myGlobalVariable' in self, true);
delete self.myGlobalVariable;
assert.throws(() => console.log(myGlobalVariable), ReferenceError);
// 随便在哪儿创建一个全局变量:
if (true) {
  self.anotherGlobalVariable = 'abc';
}
assert.equal(anotherGlobalVariable, 'abc');

• 通常，网页上所有脚本都是全局变量的话造成命名冲突。
• 通过全局对象，你可以在任何地方创建和删除全局变量。这样做会使代码无法预测，因为通常在嵌套作用域中无法进行此类更改。

window.encodeURIComponent(str); // no
encodeURIComponent(str); // yes

• 绑定变量： 在作用域内声明。它们是参数或局部变量。
• 自由变量： 在作用域外声明。它们也被称为非局部变量。

function func(x) {
  const y = 123;
  console.log(z);
}

闭包是一个函数加上与“出生地”存在的变量的连接。

function funcFactory(value) {
  return () => {
    return value;
  };
}
const func = funcFactory('abc');
assert.equal(func(), 'abc'); // (A)

function createInc(startValue) {
  return (step) => { // (A)
    startValue += step;
    return startValue;
  };
}
const inc = createInc(5);
assert.equal(inc(2), 7);

function createInc(startValue) {
  let index = -1;
  return (step) => {
    startValue += step;
    index++;
    return [index, startValue];
  };
}
const inc = createInc(5);
assert.deepEqual(inc(2), [0, 7]);
assert.deepEqual(inc(2), [1, 9]);
assert.deepEqual(inc(2), [2, 11]);

• 对于初学者来说，它们只是静态作用域的实现。因此，它们为回调提供上下文数据。
• 函数也可以使用它们来存储跨函数调用持久存在的状态。 createInc()就是一个例子。
• 并且它们可以为对象提供私有数据（通过字面值或类生成）。有关其工作原理的详细信息，请参见“探索 ES6”。