1. 删除数组中的某个固定项目

var ary = [1,2,3,4,5,6,7,8,9];
var data = {paramName:7};
ary.splice(ary.findIndex(item=>item == data.paramName),1)
console.log(ary)

删除数组中的某个固定项目.jpg

2.解构赋值

用于接口传参赋值

var a = {c2:2,c3:3,c4:4}
var {c1,c2,c3,c4,c5} = a

解构赋值.png

3.'...'运算符

用于数组拼接

const aAry = [1,2,3,4,5];
const bAry = [...aAry,6,7,8,9,10];
console.log(bAry)

'...'运算符.png

4.map遍历

常用于遍历操作对象数组，并返回你想要的结果
会直接修改原数组，而且需要注意 return
1>.给所有目标添加一个新属性

let ary1 = [{a:1,b:2,c:3},{a:11,b:22,c:33},{a:111,b:222,c:333}]
ary1.map(i => {
    Object.assign(i,{active:false}) 
    return i
})
console.log(ary1)

添加新属性

2>.修改所有对象的某个属性

let ary1 = [{a:1,b:2,c:3},{a:11,b:22,c:33},{a:111,b:222,c:333}]
ary1.map(i => {
    i.c = 4
    return i
})
console.log(ary1)

.修改所有对象的某个属性

3>.返回一个对象数组的某个或某些属性的新数组

let ary1 = [{a:1,b:2,c:3},{a:11,b:22,c:33},{a:111,b:222,c:333}]
let ary2 = ary1.map(i => {
    return i.a
})
let ary3 = ary1.map(i => {
    return {a:i.a,b:i.b}
})
console.log(ary2)
console.log(ary3)

返回一个对象数组的某个或某些属性的新数组

5.filter过滤

筛选出符合要求的结果,需要注意活用return
如果只是查找某个值，更推荐使用es6的find，因为找到结果会自动停止遍历，性能方面更优

let ary1 = [{a:1,active:true},{a:2,active:false},{a:3,active:true}]
let ary2 = ary1.filter(i => {
    return i.active
})
console.log(ary2)

filter过滤

6.Object.keys

说实话这个东西满冷门的，能用到的场景也比较少
我的理解就是用于操作不确定长度的对象，对每一个key和对应的value进行操作
有大神看到还希望能指点一二

const obj1 = {a:1,b:2,c:3}
Object.keys(obj1).forEach((key)=>{
  fnx(key,a[key])
})

7.非空运算符??

如果第一个参数不是 null/undefined，将返回第一个参数，否则返回第二个参数。

null ?? 1 // 1
undefined ?? 2 // 2
3 ?? 4 // 3
let x = null
let y = 5
x ??= y // 5
//相当于
x = (x ?? y) // 5

??与||的区别
||包含更多的类型判断，0、""、false、null、undefined
??只判断两种null、undefined

0 || 1 // 1
0 ?? 1 // 0
"" || 1 // 1
"" ?? 1 // ""
false || 1 // 1
false ?? 1 // false

常见用法，值的非空判断

if((val ?? "") !== ""){}

8.默认参数

仅当函数参数为undefined时，设置一个默认值

function a(v1=1,v2=2){
  return {v1,v2}
}
a(undefined, null) // {v1:1,v2:null}

9.Promise

只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。这也是 Promise 这个名字的由来，它的英语意思就是「承诺」，表示其他手段无法改变

状态

• pending:初始状态，不是成功或失败状态(单词意思“悬而未决的；待定”)
• fulfilled:操作完成(单词意思“完成”)
• rejected:操作失败(单词意思“被拒绝”)

优点

• 可以将异步操作以同步操作的流程表达出来，避免了层层嵌套的回调函数，解决回调地狱
• 代码变得扁平可读
• 更好进行错误捕捉

缺点

• 无法取消，一旦新建立即执行
• 如果不设置回调函数，内部抛出错误不会反应到外部
• 当出于pending状态时，无法得治进展到哪一阶段(不清楚刚刚开始还是即将完成)

var p1 = new Promise(function(resolve,reject){
  resolve();//解析
  reject();//拒绝  
})
//对于已经实例化过的 promise 对象可以调用 promise.then() 方法，传递 resolve 和 reject 方法作为回调。promise.then() 是 promise 最为常用的方法。
p1.then(onFulfilled,onRejected)
//或者
p1.then(onFulfilled).catch(onRejected)

Promise.prototype.then方法：链式操作

//Promise.prototype.then 方法返回的是一个新的 Promise 对象，因此可以采用链式写法
//使用 then 方法，依次指定了两个回调函数。第一个回调函数完成以后，会将返回结果作为参数，传入第二个回调函数。
getJSON("/posts.json").then(function(json) {
  return json.post;
}).then(function(post) {
  // proceed
});
//如果前一个回调函数返回的是Promise对象，这时后一个回调函数就会等待该Promise对象有了运行结果，才会进一步调用。
getJSON("/post/1.json").then(function(post) {
  return getJSON(post.commentURL);
}).then(function(comments) {
  // 对comments进行处理
});

Promise.prototype.catch方法：捕捉错误

Promise.prototype.catch 方法是 Promise.prototype.then(null, rejection) 的别名，用于指定发生错误时的回调函数。

getJSON("/posts.json").then(function(posts) {
  // some code
}).catch(function(error) {
  // 处理前一个回调函数运行时发生的错误
  console.log('发生错误！', error);
});
//Promise 对象的错误具有"冒泡"性质，会一直向后传递，直到被捕获为止。也就是说，错误总是会被下一个 catch 语句捕获。
getJSON("/post/1.json").then(function(post) {
  return getJSON(post.commentURL);
}).then(function(comments) {
  // some code
}).catch(function(error) {
  // 处理前两个回调函数的错误
});

Promise.all方法

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

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

• 只有所有Promise实例状态【都变成】fulfilled，p的状态才会变成fulfilled，此时返回值组成一个数组，传递给p的回调函数
• 只要实例之中有一个被rejected，p的状态就变成rejected，此时第一个被reject的实例的返回值，会传递给p的回调函数。

Promise.race

race单词的意思是'赛跑'，该方法同样是将多个 Promise 实例，包装成一个新的 Promise 实例

var p = Promise.race([p1,p2,p3]);

• 只要实例之中有一个实例【率先改变】状态，p的状态就跟着改变。那个率先改变的Promise实例的返回值，就传递给p的返回值。

10.ES2017的新玩意，async和await

async/await使得异步代码看起来像同步代码，这正是它的魔力所在
await只能放在async函数里

• 举个栗子
  你需要写一个循环调用接口获取用户信息的逻辑

//(()=>{})() 自执行函数
//我这里用了两个async和await
(async ()=> {
  const promise = Ary1.map(async (i) =>{
    await getUserInfor().then((res) => {
      Object.assign(i,{infor:res.data})
    })
    return i
  })
  const allInfor = await Promise.all(promise)
})()

11. some，every

every:一假即假
some:一真即真

var computers = [
    {name:"a",val:1},
    {name:"b",val:2},
    {name:"c",val:3},
];
//是否全部大于2
 var result= computers.every(function(computer){
   return computer.val > 2
})
console.log(result)//false;
//是否有一些值大于2？
var some = computers.some(function(computer){
   return computer.val > 2
})
console.log(some)//true;