字符串扩展

includes()：返回布尔值，表示是否找到了参数字符串

startsWith()：返回布尔值，表示参数字符串是否在原字符串的头部。

endsWith()：返回布尔值，表示参数字符串是否在原字符串的尾部

解构表达式

let arr = [1,2,3]
const [x,y,z] = arr; // x，y，z将与arr中的每个位置对应来取值
console.log(x,y,z); //1 2 3 

对象解构

const person = {
    name:"jack",
    age:21,
    language: ['java','js','css']
}
const {name,age,language} = person;
想要用其它变量接收 : {name:n}：name是person中的属性名，冒号后面的n是解构后要赋值给的变量。
console.log(name);
console.log(age);
console.log(language);

函数优化

函数参数默认值

function add(a , b = 1) {
    return a + b;
}
// 传一个参数
console.log(add(10));

箭头函数

var print2 = obj => console.log(obj);//一个参数
var sum2 = (a,b) => a+b; //多个参数：
var sum3 = (a,b) => {//代码不止一行，可以用{}括起来
    return a + b;
}

map和reduce

map()：接收一个函数，将原数组中的所有元素用这个函数处理后放入新数组返回。

let arr = ['1','20','-5','3'];
arr = arr.map(s => parseInt(s));
console.log(arr) ;// [1,20,-5,3]

reduce()：接收一个函数（必须）和一个初始值（可选），该函数接收两个参数：

第一个参数是上一次reduce处理的结果
第二个参数是数组中要处理的下一个元素
reduce()会从左到右依次把数组中的元素用reduce处理，并把处理的结果作为下次reduce的第一个参数。如果是第一次，会把前两个元素作为计算参数，或者把用户指定的初始值作为起始参数

const arr = [1,20,-5,3]
arr.reduce((a,b)=>a+b)//19
指定初始值：
arr.reduce((a,b)=>a*b)//-300
arr.reduce((a,b)=>a*b,-1)//300

promise

我们可以通过Promise的构造函数来创建Promise对象，并在内部封装一个异步执行的结果。

const p = new Promise(function (resolve, reject) {
    // 这里我们用定时任务模拟异步
    setTimeout(() => {
        const num = Math.random();
        // 随机返回成功或失败
        if (num < 0.5) {
            resolve("成功！num:" + num)
        } else {
            reject("出错了！num:" + num)
        }
    }, 300)
})

// 调用promise
p.then(function (msg) {//等待异步执行完成
    console.log(msg);
}).catch(function (msg) {//异步执行失败的事件
    console.log(msg);
})

模块化

const util = {
    sum(a,b){
        return a + b;
    }
}
export util;

/ 导入util
import util from 'hello.js'
// 调用util中的属性
util.sum(1,2)

对象扩展

keys(obj)：获取对象的所有key形成的数组
values(obj)：获取对象的所有value形成的数组
entries(obj)：获取对象的所有key和value形成的二维数组。格式：[[k1,v1],[k2,v2],...]
assian(dest, ...src) ：将多个src对象的值 拷贝到 dest中（浅拷贝）。

 const obj = { name: 1, old: 2, stu: 3 }
 let keys = Object.keys(obj)
 let values = Object.values(obj)
let entries = Object.entries(obj)
console.log(keys);//["name", "old", "stu"]
console.log(values);// [1, 2, 3]
console.log(entries);//[['name',1],['old',2],['stu',3]]

数组扩展

find(callback)：把数组中的元素逐个传递给函数callback执行，如果返回true，则返回该元素
findIndex(callback)：与find类似，不过返回的是品牌到的元素的索引
includes（callback）：与find类似，如果匹配到元素，则返回true，代表找到了。
filter() 返回的是数组，数组内是所有满足条件的元素， 如果条件不满足，filter()返回的是一个空数组

 const arr = [1, 2, 3, 4, 5]

 var find = arr.find(value => value > 3)
 console.log(find);//4     没找到返回undefined

回调函数有三个参数。value：当前的数组元素。index：当前索引值。arr：被查找的数组
const myArr=[1,2,3,4,5,6];
var v=myArr.find((value,index,arr)=>{
    return index==4
});
console.log(v);// 5

var findIndex = arr.findIndex(value => value > 3)
console.log(findIndex);//3    没找到返回-1

var includes = arr.includes(3)
console.log(includes);//true   没找到返回false

var myArr = [1,3,4,5,6,3,7,4];
console.log(myArr.filter((value,index,arr)=>arr.indexOf(value)===index));
//[ 1, 3, 4, 5, 6, 7 ]

文章只做自己笔记使用