es6总结

1.模块化

/*关于模块化的了解 非模块化有以下缺点： 1.命名冲突 2.文件依赖

前端流行的模块化：AMD requirejsCMD seajs服务器端的模块化 CommonJS-----Node.js

一个文件即一个模块模块的导出 通过exports 和module.exports*/

var addTwo=function(a,b){ return parseInt(a)+parseInt(b);}/通过exports//exports.addTwo=addTwo;//module.exports/module.exports=addTwo;

//引入模块
var module=require('filePath');
模块文件的后缀： .js .json .node

加载优先级（不写后缀的情况下）.js->.json->.node

2.ES6

关于声明变量let和const

//1.let声明的变量不存在预解析
//2.let声明的变量不允许重复（在一个块级作用域内）
//3.ES6引入了块级作用域，在块级作用域中使用let 和const定义的变量，外部不可以访问
//4.const 用来声明常量，不允许重新赋值，声明时必须初始化。
解构赋值：

/变量的结构赋值/
//数组的结构赋值
let [a,b,c,d]=[1,2,3,5];
console.log(a,b,c,d);
/对象的结构赋值/
/let {name,age}={name:'小明',age:20};
console.log(name,age);/
// 对象属性别名
let {name:firstName,age}={name:'小明',age:20};
console.log(firstName,age);
let {sin,cos}=Math;
console.log(typeof sin);
console.log(typeof cos);
/字符串的结构赋值/
let[h,g,j]='jefiwi';
console.log(h,g,j);
字符串的相关扩展：

1.includes()//判断字符串是否包含字符串，第一个参数要判断的字符串，第二个参数从索引为多少开始。

startsWith() endsWith()

2.模板字符串：

let person={
name:'xiaoming',
age:18,
school:'hanzhong'
}
let div=

${person.name} ${person.age} ${person.school} ${1+20}

console.log(div);
函数扩展：

1.默认值. 2.参数解构赋值，3.rest参数 4...扩展符.

//默认值
function print(a=10,b=2,c=1){
let result=a+b+c;
console.log(result);
}
print();
//解构赋值
function foo({name='小明',age=18}={}){
console.log(name,age);
}
foo();
foo({name:'小红',age:20});
//rest参数
function restParam(a,b,...param){
console.log(a);
console.log(b);
console.log(param);
​
}
restParam(1,2,3,56,6,9,45,12);
1
2
[ 3, 56, 6, 9, 45, 12 ]
//...扩展符 在函数调用时将数组转换为单个参数。
function restParam(a,b,c,d,e){
console.log(a+b+c+d+e);
​
}
let arr=[20,30,45,56,30]
restParam(...arr);
//合并数组
let arr1=[12,5];
let arr2=[45,89];
let arr3=[...arr1,...arr2]
​
箭头函数：

let foo=()=>console.log('你好');
foo();
//多个参数需要使用（）包裹。
let foo=(a,b)=>{
let c=10;
console.log(a+b+c);
}
foo(20,30);
/作为匿名函数传递/
let arr=[20,30,45,56,30];
​
arr.forEach((element,index)=>{
console.log(element);
})
//箭头函数的注意事项：
1.this取决于函数的定义，而不是调用。
2.箭头函数不用new关键字
3.箭头函数不可以使用arguments获得参数列表，可以使用rest参数代替
let foo=(...param)=>{
console.log(param);
}
foo(12,56);
​

js中apply的用法。

尽管js的apply方法在平常的使用中并不多见，但是在某些地方使用的还是很有帮助性的，这里就和大家说两个比较实用的例子： 1.数组最大最小值:var min = Math.min.apply(null, arr);

求数组中的最大最小值，js有相应的方法：Math.min(),Math.max(),但是这两个方法有个不方便的地方就是其参数不能是数组，而是单个元素值，即(para1,para2,para3....)。所以使用就没有那么方便了，但是我们可以使用这个方法：

2.数组合并。数组的合并也和求最值一样，我们可以使用简单的push(para1);进行循环push.但我们也可以使用比较简单的方法：Array.prototype.push.apply(arrA, arrB); ``//将数组arrB push到数组 arrA中。

call和this的使用:

ECMAScript规范为所有函数都包含两个方法(这两个方法非继承而来), call 和 apply 。这两个函数都是在特定的作用域中调用函数,能改变函数的作用域，实际上是改变函数体内 this 的值 。

call 和 apply

语法 定义 说明
call(thisObj，Object) 调用一个对象的一个方法，以另一个对象替换当前对象。 call 方法可以用来代替另一个对象调用一个方法。call 方法可将一个函数的对象上下文从初始的上下文改变为由 thisObj 指定的新对象.如果没有提供 thisObj 参数，那么 Global 对象被用作 thisObj
apply(thisObj，[argArray]) 应用某一对象的一个方法，用另一个对象替换当前对象。 如果 argArray 不是一个有效的数组或者不是 arguments 对象，那么将导致一个 TypeError。如果没有提供 argArray 和 thisObj 任何一个参数，那么 Global 对象将被用作 thisObj， 并且无法被传递任何参数
arguments返回的是一个参数列表对象，使用时类似与数组，但不同于数组。

ES6之前的Promise

在ES6中，Promise终于成为了原生对象，可以直接使用。但是在这之前，小伙伴们想要使用Promise，一般会借助于第三方库，或者当你知道其中的原理以后，也可以手动实现一个简易的Promise

当然，为了防止不可预知的bug，在生产项目中最好还是不要使用原生的或者自己编写的Promise（目前为止并不是所有浏览器都能很好的兼容ES6），而是使用已经较为成熟的有大量小伙伴使用的第三方Promise库，下面就为小伙伴推荐一个—— Bluebird

Promise的基本用法

声明一个Promise对象

// 方法1
let promise = new Promise ( (resolve, reject) => {
    if ( success ) {
        resolve(a) // pending ——> resolved 参数将传递给对应的回调方法
    } else {
        reject(err) // pending ——> rejectd
    }
} )

// 方法2
function promise () {
    return new Promise ( function (resolve, reject) {
        if ( success ) {
            resolve(a)
        } else {
            reject(err)
        }
    } )
}

注意：实例化的Promise对象会立即执行

Promise.prototype.then() VS Promise.prototype.catch()

.then()方法使Promise原型链上的方法，它包含两个参数方法，分别是已成功resolved的回调和已失败rejected的回调

promise.then(
    () => { console.log('this is success callback') },
    () => { console.log('this is fail callback') }
)

.catch()的作用是捕获Promise的错误，与then()的rejected回调作用几乎一致。但是由于Promise的抛错具有冒泡性质，能够不断传递，这样就能够在下一个catch()中统一处理这些错误。同时catch()也能够捕获then()中抛出的错误，所以建议不要使用then()的rejected回调，而是统一使用catch()来处理错误

promise.then(
    () => { console.log('this is success callback') }
).catch(
    (err) => { console.log(err) }
)

同样，catch()中也可以抛出错误，由于抛出的错误会在下一个catch中被捕获处理，因此可以再添加catch()

使用rejects()方法改变状态和抛出错误 throw new Error() 的作用是相同的

当状态已经改变为resolved后，即使抛出错误，也不会触发then()的错误回调或者catch()方法

then() 和 catch() 都会返回一个新的Promise对象，可以链式调用

promise.then(
    () => { console.log('this is success callback') }
).catch(
    (err) => { console.log(err) }
).then(
    ...
).catch(
    ...
)

Promise实例的异步方法和then()中返回promise有什么区别？

// p1异步方法中返回p2
let p1 = new Promise ( (resolve, reject) => {
    resolve(p2)
} )
let p2 = new Promise ( ... )

// then()中返回promise
let p3 = new Promise ( (resolve, reject) => {
    resolve()
} )
let p4 = new Promise ( ... )
p3.then(
    () => return p4
)

p1异步方法中返回p2

p1的状态取决于p2，如果p2为pending，p1将等待p2状态的改变，p2的状态一旦改变，p1将会立即执行自己对应的回调，即then()中的方法针对的依然是p1

then()中返回promise

由于then()本身就会返回一个新的promise，所以后一个then()针对的永远是一个新的promise，但是像上面代码中我们自己手动返回p4，那么我们就可以在返回的promise中再次通过 resolve() 和 reject() 来改变状态

Promise的其他api

Promise.resolve() / Promise.reject()

用来包装一个现有对象，将其转变为Promise对象，但Promise.resolve()会根据参数情况返回不同的Promise：

参数是Promise：原样返回
参数带有then方法：转换为Promise后立即执行then方法
参数不带then方法、不是对象或没有参数：返回resolved状态的Promise

Promise.reject()会直接返回rejected状态的Promise

Promise.all()

参数为Promise对象数组，如果有不是Promise的对象，将会先通过上面的Promise.resolve()方法转换

var promise = Promise.all( [p1, p2, p3] )
promise.then(
    ...
).catch(
    ...
)

当p1、p2、p3的状态都变成resolved时，promise才会变成resolved，并调用then()的已完成回调，但只要有一个变成rejected状态，promise就会立刻变成rejected状态

Promise.race()

var promise = Promise.race( [p1, p2, p3] )
promise.then(
    ...
).catch(
    ...
)

“竞速”方法，参数与Promise.all()相同，不同的是，参数中的p1、p2、p3只要有一个改变状态，promise就会立刻变成相同的状态并执行对于的回调

Promise.done() / Promise. finally()

Promise.done() 的用法类似 .then() ，可以提供resolved和rejected方法，也可以不提供任何参数，它的主要作用是在回调链的尾端捕捉前面没有被 .catch() 捕捉到的错误

Promise. finally() 接受一个方法作为参数，这个方法不管promise最终的状态是怎样，都一定会被执行

ES6模块导出和引入

2018年10月10日 22:36:40 weixin_42554311 阅读数：399

导出模块的方式有两种：

(1)export default (默认导出)一个模块里面只能有一个默认导出

const apikey="123key";

export default apikey;

引入模块：

import kkkk from '路径'；

(2)命名导出

const apikey="123key";

const name="Marray";

function greet(name){

console.log(name)

}

export {apikey,name,greet};//这种方式导出的模块引入的时候必须是这个名称如下：

import {apikey，name,greet} from '路径'

注：导出和引入模块的时候都可以使用别名，如export {apikey as key,name,greet};当我们引入模块的时候必须使用别名

import {key，name,greet} from '路径'