一. 声明变量的方法：

let 用来声明变量。

1.属于块级作用域，只在let命令所在的代码块内有效；
2.同时声明两个变量，会报错；
3.不可做变量提升；
4.let声明的变量不属于顶层对象属性，全局变量将逐步与顶层对象的属性脱钩。

const 用来声明常量。

1.初始化的时候必须有值；
2.不能重新赋值，重新赋值后会报错；
3.对于const声明的是数组或对象时，可更改属性，不可重新赋值；

import

class

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

//例题2:
function f() { console.log('I am outside!'); }
(function () {
  var f = undefined;
  if (false) {
    function f() { console.log('I am inside!'); }
  }

  f();
}());
//例题3
const a = [];
a.push('Hello'); 
a.length = 0;    
a = ['Dave'];    
//例题4
var a = 1;
window.a 
let b = 1;
window.b

二. 变量的解构赋值

数组的解构赋值 let [a, b, c] = [1, 2, 3];

1.基本用法，数组的元素是按次序排列的，变量的取值由它的位置决定；

let [foo, [[bar], baz]] = [1, [[2], 3]];
foo 
bar 
baz 

let [ , , third] = ["foo", "bar", "baz"];
third 

let [x, , y] = [1, 2, 3];
x 
y 

let [head, ...tail] = [1, 2, 3, 4];
head
tail

let [x, y, ...z] = ['a'];
x 
y
z 

let [foo] = [];            
let [bar, foo] = [1];  
foo
foo

let [x, y] = [1, 2, 3];
x 
y

let [a, [b], d] = [1, [2, 3], 4];
a 
b 
d 

2.解构赋值允许指定默认值,默认值是一个表达式，那么这个表达式是惰性求值的；

let [x, y = 'b'] = ['a']; 
x 
y

let [x, y = 'b'] = ['a', undefined]; 
x
y

function f() {
  console.log('aaa');
}
let [x = f()] = [1];

let [x = 1, y = x] = [];     
x
y

let [x = 1, y = x] = [2];    
x
y

let [x = 1, y = x] = [1, 2];
x
y

let [x = y, y = 1] = []; 
x
y

对象的解构赋值

1.对象的属性没有次序，变量必须与属性同名，才能取到正确的值。

let { foo, bar } = { foo: "aaa", bar: "bbb" }; 
bar 
foo
let { baz } = { foo: "aaa", bar: "bbb" };
baz 

2.变量名与属性名不一致的写法

let obj = { first: 'hello', last: 'world' };
let { first: f, last: l } = obj;
f 
l 

let { foo: baz } = { foo: "aaa", bar: "bbb" };
baz 
foo 

字符串的解构赋值

字符串也可以解构赋值。这是因为此时，字符串被转换成了一个类似数组的对象。
类似数组的对象都有一个length属性，因此还可以对这个属性解构赋值。

const [a, b, c, d, e] = 'hello';
a 
b 
c 
d 
e 
let {length : len} = 'hello';
len 

三.Promise对象

const promise = new Promise(function(resolve, reject) {
  // ... some code
  if (/* 异步操作成功 */){
    resolve(value);
  } else {
    reject(error);
  }
});

//Promise实例生成以后，可以用then方法分别指定resolved状态和rejected状态的回调函数。
promise.then(function(value) {
  // success
}, function(error) {
  // failure
});

1.Promise对象是一个构造函数，用来生成Promise实例。
2.Promise是实现异步编程的一种解决方案
3.Promise构造函数接受一个函数作为参数，该函数的两个参数分别是resolve和reject。 resolve的作用是从未完成变为成功（即从 pending 变为 resolved），reject的作用是从未完成变为失败（即从 pending 变为 rejected）

//例题：用Promise对象实现的 Ajax 操作的例子
const getJSON = function(url) {
  const promise = new Promise(function(resolve, reject){
    const handler = function() {
      if (this.readyState !== 4) {
        return;
      }
      if (this.status === 200) {
        resolve(this.response);
      } else {
        reject(new Error(this.statusText));
      }
    };
    const client = new XMLHttpRequest();
    client.open("GET", url);
    client.onreadystatechange = handler;
    client.responseType = "json";
    client.setRequestHeader("Accept", "application/json");
    client.send();

  });

  return promise;
};

getJSON("/posts.json").then(function(json) {
  console.log('Contents: ' + json);
}, function(error) {
  console.error('出错了', error);
});

4.调用resolve或reject并不会终结 Promise 的参数函数的执行。

new Promise((resolve, reject) => {
  resolve(1);
  console.log(2);
}).then(r => {
  console.log(r);
});

5.Promise.prototype.then()
promise实例具有then方法，也就是说，then方法是定义在原型对象Promise.prototype上的。then方法返回的是一个新的Promise实例（注意，不是原来那个Promise实例）。因此可以采用链式写法，即then方法后面再调用另一个then方法（第一个回调函数完成以后，会将返回结果作为参数，传入第二个回调函数）。

getJSON("/post/1.json").then(function(post) {
  return getJSON(post.commentURL);
}).then(function funcA(comments) {
  console.log("resolved: ", comments);
}, function funcB(err){
  console.log("rejected: ", err);
});
//箭头函数写更为简单
getJSON("/post/1.json").then(
  post => getJSON(post.commentURL)
).then(
  comments => console.log("resolved: ", comments),
  err => console.log("rejected: ", err)
);

6.Promise.prototype.catch()
如果 Promise 状态已经变成resolved，再抛出错误是无效的。

const promise = new Promise(function(resolve, reject) {
  resolve('ok');
  throw new Error('test');
});
promise
  .then(function(value) { console.log(value) })
  .catch(function(error) { console.log(error) });

不要在.then方法里面定义 Reject 状态的回调函数（即then的第二个参数），总是使用catch方法。.catch可以捕获前面then方法执行中的错误

// bad
promise
  .then(function(data) {
    // success
  }, function(err) {
    // error
  });

// good
promise
  .then(function(data) { //cb
    // success
  })
  .catch(function(err) {
    // 

Promise 内部的错误不会影响到 Promise 外部的代码。

const someAsyncThing = function() {
  return new Promise(function(resolve, reject) {
    // 下面一行会报错，因为x没有声明
    resolve(x + 2);
  });
};

someAsyncThing().then(function() {
  console.log('everything is great');
});

setTimeout(() => { console.log(123) }, 2000)

Promise 对象建议后面要跟catch方法，这样可以处理 Promise 内部发生的错误。catch方法返回的还是一个 Promise 对象，因此后面还可以接着调用then方法。

const someAsyncThing = function() {
  return new Promise(function(resolve, reject) {
    // 下面一行会报错，因为x没有声明
    resolve(x + 2);
  });
};

someAsyncThing()
.catch(function(error) {
  console.log('oh no', error);
})
.then(function() {
  console.log('carry on');
});

7.Promise.prototype.finally()
finally方法用于指定不管 Promise 对象最后状态如何，都会执行的操作。该方法是 ES2018 引入标准的。

promise
.then(result => {···})
.catch(error => {···})
.finally(() => {···});

8.Promise.all()
Promise.all方法用于将多个 Promise 实例，包装成一个新的 Promise 实例。

const p = Promise.all([p1, p2, p3]);

9.总结：
优点：Promise 的写法是回调函数的改进，使用then方法以后，异步任务的两段执行看得更清楚了。then将原来异步函数的嵌套关系转变为链式步骤

缺点：Promise 的最大问题是代码冗余，原来的任务被Promise 包装了一下，不管什么操作，一眼看去都是一堆 then，原来的语义变得很不清楚.