ECMAScript6.0

let&const

关键字	是否可重复声明	定义变/常量	作用域
let	否	变	块级作用域
const	否	常	块级作用域

箭头函数

let double = function(a){
    return 2*a;
}
// 等价于
let double = (a)=>{
    return 2*a;
}
// 当参数只有一个可以省略括号
let double = a=>{
    return 2*a;
}
// 当返回只有一个可以省略花括号+return
let double = a=>2*a

函数-参数

RestParameter

// 1.收集参数
function alert(a,b,...args){
	alert(args);
}
show(1,2,3,4,5) // alert 3,4,5
// RestParameter必须是最后一个参数

// 2. 数组展开
let show = (a,b,c)=>{
    alert(a);
    alert(b);
    alert(c);
}
// show(1,2,3);
//等价于
let arr = [1,2,3];
show(...arr);

默认参数

let show = (a,b=10,c=5)=>{
	return a+b+c;
}
show(1); // 16

解构赋值

• 左右两边结构必须一致
• 右边为实际参数
• 声明与赋值不可拆开

let arr = [1,2,3];
a= arr[0];
a= arr[1];
a= arr[2];
// 等价于
let[a,b,c] = [1,2,3];
// 其他类型只需两边结构保持一致即可

数组

1. map
2. reduce
3. filter
4. forEach

// map 映射
let arr = [1,2,3];
let res = arr.map(item=>item>=2?'good':'bad');// bad good good
// reduce 汇总
let res = arr.reduce((temp,item,index)=>temp+item); // 求和 6
let res = res/arr.length // 平均数  2
// filter
let res = arr.filter(item=>{
    if(item>2){
        return true;
    }else{
        return false;
    }
}) // 3
// forEach
arr.forEach((item,index)=>{
    console.log(item,index);
}) // 1 0 ,2 1,3 2

字符串

1. startsWith --- 判断地址协议
2. endsWith --- 判断文件类型
3. 模板字符串 `` --- 两个反单引号

面向对象

class User{
    constructor(name,pwd){
        this.name = name;
        this.pwd = pwd;
    }
    showName(){alert(this.name);}
    showPwd(){alert(this.pwd);}
}
let u1 = new User('name','pwd');
u1.showName(); // name
u1.showPwd(); // pwd
// 继承
class Vip extends User{
    constructor(name,pwd,level){
        super(name,pwd);
        this.level = level;
    }
    showLevel(){alert(this.level);}
}
let v1 = new Vip('name','pwd','level');
v1.showLevel(); // level

JSON

// 转换字符串
let json = {a:1,b:2}
let url = 'localhost/get?data='+encodeURIComponent(JSON.stringify(json));
// 解析
let jsonstr = '{"a":1,"b":2}';
JSON.parse(jsonstr);
// 当json名字值一样可以省 略值
let a = 1;
let b = 2;
let json = {a:a,b:b}
// 等价于
let json = {a,b}
let json = {
   a:1;
   show:function(){...}
	// 简写
	show(){...}
}

Promise

let p = new Promise((resolve,reject)=>{
    // 异步代码 在请求成功调用resolve 失败调用reject
    $.ajax({
        url:'arr.txt',
        dataType:'json',
        success(arr){
            resolve(arr);
        },
        error(err){
            reject(err);
        }
    })
})
p.then(function(arr){
    console.log(arr);
},function(err){
    console.log(err);
})
// 多异步结果判断
let p1 = new Promise((resolve,reject)=>{
    // 异步代码 在请求成功调用resolve 失败调用reject
    ...
});
let p2 = new Promise((resolve,reject)=>{
    // 异步代码 在请求成功调用resolve 失败调用reject
   ...
})
Promise.all([p1,p2]).then(res=>{},err=>{});
// 竞争资源
Promise.race(
	// 多异步操作 取最先返回的信息
);

Generator

// 生成器函数 在function和方法名之间加个*号
function* showGenerator(){
    alert(1);
    yield;
    alert(2);
}
// 返回一个对象 通过next()执行下一步 遇到yield暂停 默认不执行
let genObj = showGenerator();
genObj.next(); // alert(1)
genObj.next(); // alert(2)

// yield 传参
function* showGenerator(){
    console.log(1);
    let a = yield;
    console.log(a); // 2
    console.log(2);
}
let genObj = showGenerator();
genObj.next(1);
genObj.next(2);

// yield返回中间结果
function* showGenerator(){
    let a = 1;
    yield a;
    a = 2*a;
    return a;
}
let genObj = showGenerator();
let res1 = genObj.next(); // value:1 done:false
let res2 = genObj.next(); // value:2 done:true

Async --- Generator 函数的语法糖。

使用Generator 读取两个文件

const fs = require('fs');

const readFile = function (fileName) {
  return new Promise(function (resolve, reject) {
    fs.readFile(fileName, function(error, data) {
      if (error) return reject(error);
      resolve(data);
    });
  });
};
// gen函数
const gen = function* () {
  const f1 = yield readFile('/etc/fstab');
  const f2 = yield readFile('/etc/shells');
  console.log(f1.toString());
  console.log(f2.toString());
};
// async函数
const asyncReadFile = async function () {
  const f1 = await readFile('/etc/fstab');
  const f2 = await readFile('/etc/shells');
  console.log(f1.toString());
  console.log(f2.toString());
};