es6（入门笔记）

Symbol()    表示独一无二的的值
Map            对象保存键值对。            任何值(对象或者原始值) 都可以作为一个键或一个值。
Set              对象允许你存储任何类型的唯一值，        无论是原始值或者是对象引用。

Proxy 与 Reflect 是 ES6 为了操作对象引入的 API 。

Proxy

Proxy 可以对target对象的读取、函数调用等操作进行拦截，然后进行操作处理

let target={  name:'tom',  age:24      }
let handler={ get:function(target,key){return target[key];},        //key=target的属性名
              set:function(target,key,value){target[key]=value;}    
            }

//Proxy构造函数
let proxy = new Proxy(target,handler)  //构造函数生产实例对象必选参数
                                       //target目标对象  handle方法
                                       //浅拷贝
                                       //proxy作用：根据handler对象对target进行数据过滤操作
proxy.name;
proxy.name=5;

get(target,propKey,receiver){}



//proxy构造函数的应用
//对于用户输入的数据进行筛选在set入对象中（一般用在写API中）
let validator = {
    set: function(obj, prop, value) {
        if (prop === 'age') {
            if (!Number.isInteger(value)) {
                throw new TypeError('The age is not an integer');
            }
            if (value > 200) {
                throw new RangeError('The age seems invalid');
            }
        }
        // 对于满足条件的 age 属性以及其他属性，直接保存
        obj[prop] = value;
    }
};
let proxy= new Proxy({}, validator)
proxy.age = 100;
proxy.age           // 100
proxy.age = 'oppps' // 报错
proxy.age = 300     // 报错

obj[prop] = receiver;
<ref *1> { name: [Circular *1] }

obj[prop] = value;
{ name: 'Tom' }

//严格模式下，set代理如果没有返回true，就会报错。

Promise对象

Promise是一个对象，它可以获取异步操作的消息

状态：pending fulfilled rejected

状态缺点：Promise内部抛出的错误，无法反映到外部

                  无法断点：当处于 pending 状态时，无法得知目前进展到哪一个阶段

                  大多数浏览器中不能终止的 Promise 链里的 rejection，

                   建议后面都跟上 .catch(error => console.log(error));

const readFile = function (path) {
    return new Promise((resolve, reject) => {
        fs.readFile(path, (err, data) => {
            if (err) reject(err);
            resolve(data);
        });
    });
};

then方法

接受两个函数作为参数

特点：

1：在 JavaScript 事件队列的当前运行完成之前，回调函数永远不会被调用。

//在主线程里所有的时间运行完成后，异步操作在另一个线程做完等待,在调用then
const p = new Promise(function(resolve,reject){
  resolve('success');
});
 
p.then(function(value){
  console.log(value);
});
 
console.log('first');
// first
// success

2：可以添加多个回调函数，它们会按照插入顺序并且独立运行。

3：then 方法将返回一个 resolved 或 rejected 状态的 Promise 对象用于链式调用，

      且 Promise 对象的值就是这个返回值。

4：注意总是返回或终止 Promise 链。

//创建新 Promise 但忘记返回它时，对应链条被打破  
//导致 p4 会与 p2 和 p3 同时进行
const p1 = new Promise(function(resolve,reject){
    resolve(1);
  }).then(function(result) {
          p2(result).then(newResult => p3(newResult));
        }).then(() => p4());

async

语法：

async function name([param[, param[, ... param]]]) { statements }

返回值：

async 函数返回一个 Promise 对象，可以使用 then 方法添加回调函数。

async function helloAsync(){
    return "helloAsync";
  }
  
console.log(helloAsync())  // Promise {<resolved>: "helloAsync"}
 
helloAsync().then(v=>{
   console.log(v);         // helloAsync
})

await：

1.async 函数执行时，如果遇到 await 就会先暂停执行 ，

   等到触发的异步操作完成后，恢复 async 函数的执行并返回解析值。

2.await 关键字仅在 async function 中有效  else err

function testAwait(){
   return new Promise((resolve) => {
       setTimeout(function(){
          console.log("testAwait");
          resolve();
       }, 1000);
   });
}
 
async function helloAsync(){
   console.log("helloAsyncfront");		//1输出helloAsyncfront
   await testAwait();					//等1000毫秒后输出testAwait
   console.log("helloAsync");			//等2输出后在输出
 }
helloAsync();
//helloAsyncfront
//等待1000毫秒
// testAwait
// helloAsync

await 命令 后面是一个  Promise 对象   异步处理

await针对所跟不同表达式的处理方式：

 

        Promise 对象：await 会暂停执行，等待 Promise 对象 resolve，

                                  然后恢复 async 函数的执行并返回解析值。

        非 Promise 对象：直接返回对应的值。