ES6部分总结

数组解构

const arr = [100, 200, 300];

const [a, b, c] = arr;
console.log(a, b, c);

const [, , d] = arr;
console.log(d);

const [e, ...rest] = arr;
console.log(rest);

const path = '/a/b/c';
const [, f, g, h] = path.split('/');
console.log(f, g, h);

对象解构

var age = 20;
const obj = {
    name: 'zhang',
    age: '18',
    fullName: function (a) {
        console.log(a);
    },
    fullAge: function () {
        console.log(this.age);
    }
}


const { name: objName, age } = obj;
console.log(objName, age);

const { fullName, fullAge } = obj;
fullName(1);
obj.fullAge();//18
fullAge();//20

模板字符串

const str = `hello`;
console.log(str);

const myName = "ton";
const msg = `hey,${myName}`
console.log(msg);

带标签的模板字符串

const str = console.log`hello World`;

const name = 'tom';
const gender = true;

//strings 为非插值语法的包含静态内容的数组
function myTagFunc(strings,name,gender){
    // console.log(strings,name,gender);
    const sex = gender ? 'man':'woman';
    return strings[0] + name + strings[1] + sex + strings[2];
}

const result = myTagFunc`hey,${name} is a ${gender}`;
console.log(result);

字符串扩展方法

const msg = 'Error: foo is not defined.'
console.log(
    //是否以该字符串开头
    msg.startsWith("Error"),
    //是否以该字符串结尾
    msg.endsWith("."),
    //是否包含该字符串
    msg.includes("foo")
);

参数默认值

//enable只会在调用时没有传递实参时赋值
function foo(bar,enable = true){
    console.log("1111");
    console.log(enable);
}
foo();

剩余参数

// function foo(){
//     //参数数组
//     console.log(arguments);
// }

function foo(...args){
    //参数数组
    console.log(args);
}
foo(1,2,3)

展开数组

const arr = ['1','2','3'];
console.log(...arr);

对象字面量增强

const bar = '123';

const obj = {
    foo:123,
    // bar:bar,
    bar,
    // method1:function(){

    // }
    method1(){
        console.log('method1');
    },

    [Math.random()] : 123,

    [bar] : 123
}

console.log(obj);

//计算属性名
obj[Math.random()] = 123;

Promise

const p = new Promise((resolve, reject) => {
    setTimeout(() => {
        // console.log("数据");
        resolve("数据");
    }, 1000)
})
//then方法返回一个Promise对象 对象状态由回调函数的执行结果决定
//如果回调函数返回的是非promise类型的属性，状态为成功，返回值为对象的成功的值
const result = p.then(value => {
    console.log(value);
    // 1.非promise类型的值
    // return "ok";

    // 2.是promise对象
    //新的promise的状态决定then方法返回的promise状态
    // return new Promise((resolve,reject)=>{
        // resolve('succ');
        // reject('error');
    // })

    // 3.抛出错误
    throw new Error('出错了')


}, reson => {
    console.warn(reason);
})
console.log(result);

Promise链式调用

const fs = require("fs");

const p = new Promise((resolve, reject) => {
    fs.readFile("./book1.md", (error, data) => {
        // console.log(data.toString());
        resolve(data);
    });
});
p.then(value => {
    // console.log(value);
    return new Promise((resolve,reject) => {
        fs.readFile("./book2.md",(error,data) => {
            resolve([value,data]);
        });
    });
}).then(value => {
    return new Promise((resolve,reject) => {
        fs.readFile("./book3.md",(error,data) => {
            value.push(data);
            resolve(value);
        });
    });
}).then(value => {
    console.log(value.join());
})