ES6

let与const
let：局部变量声明

1. 只能再一对{}里用

2.不能重复声明

3.不会变量提升（在变量声明前访问会报错）

const：常量声明

1.声明必须赋值

2.赋值不能修改（简单数据类型）

3.建议变量名 大小

解构

对象

let{name,age} = {name:"cyang",age:18}

let{name:foo} ={name:"cyang"}
//foo值就是cyang

剩余值：…rest

默认值

let{name,age,leg=2} ={name:"cyang",age:18}

没有顺序
变量名必须和对象的键名一致

数组
基础

let[a,b] =[12,18]
//a=12
//b=18

嵌套

let[a,b,[c,d]] = [1,2,[3,4]]
//a=1  b=2  c=3  d=4

可忽略

let[a,,b] =[1,2,3]
//a=1 b=3

剩余值

let[a...rest]=[1,2,3,4]
//a=1  rest[2,3,4]

字符串

let[a,b,c,d] = "武汉加油"
//a=武  b=汉  c =加  d=油

默认值

let[a,b,c=3]=[1,2]
//a=1  b=2
如果解析出来的值是underfind就会用默认值代替

trim() :去掉两端空白

trimLeft() :去掉左侧空白

trimRight() :去掉右侧空白

检测包含

includes(s) :字符串是否包含s

startsWith(s) : 是否以s开头

endsWith(s) : 是否以s结束

重复

repeat(n) : 字符串重复n次

填充

padStart(len,s) :从开头以s字符串补齐len长度

padEnd(len,s) :从结尾以s字符串补齐len长度

模板

1.符号 ``

2.可以在字符串模板里任意换行

3.单双引号 特殊符号不需要转义

4.添加变量 ${变量名}

var name ="cyang“
var age =19
var str =`大家好我是${name},
我今年${age}岁了`;

数字

Number.isNaN()
检测是不是NaN

Number.isinsteger()
检测是不是整数

x**y
x的y次方

Number.parseInt 转换为整数
Number.parseFloat 转换为浮点数

数组

迭代方法

map():返回一个数组
通过原来的数组映射出新的数组

filter()：返回一个数组
如果遍历时返回的值为true，则最终返回时保留该值
如果遍历时返回的值为false，则最终返回时过滤该值

reduce(function(a,b){})
a:上一次遍历时的结果
b:当前遍历元素

some() ：返回一个bool
如果遍历的值有一个返回为true，那么最终返回结果为true
如果遍历的值所有都返回为false，最终返回为false

every() :
如果遍历的值有一个返回为false，最终返回结果为false
如果遍历的值都返回为true，最终返回true

查找

find()
查找数组中符合条件的元素

findIndex()
查找数组中符合条件的元素的下标

flat(n)
扁平化数组 n为扁平的层级

includes(el)
查找数组是否包含el元素

函数

箭头函数：函数的简写

特点

1. => 左边是函数的参数

2. => 右边是函数的执行语句，也是返回值

arr.forEach(item=>console.log(item))

arr.map(item=> item*2)

3. => 如果参数不止一个用()包裹参数

arr.reduce((a,b)=>a+b)
arr.forEach((item,index)=>{
 console.log(item);
console.log(index)
})

4. => 如果执行语句有多条用{}

5. => 如果执行语句有多条，返回用return关键字

6. 如果返回的是对象要用（）括住

7. => 箭头函数的this指向当前的执行环境

默认

function add(a=1,b=2){
alert(a+b)
}
add(3,4)
add()

不定参

function add(...ab){
	ab.reduce((a,b)=>a+b)
alert(ab);
}
add(1,3,5);
add(2,4,5,6,6)
add(3,4,22,14,4,5)

对象

1.对象的简写(变量名和对象的键一致时)

2. 对象属性的表达式 []

3. 对象的拷贝合并 Object.assign()

4. 对象扩展 …

{…a,…b}
复制与合并对象

map

特点

1.有顺序

2. 键名可以是任意数据类型

3. size长度

初始化

var map = new Map([[k,v],[k2,v2]])

方法

set(k,v) 设置

get(k) 获取

delete(k) 删除

has(k) 检测是否拥有

属性

size 长度

遍历

for of

for(let [k,v] of map){
//k 键名
//v 值
}

转数组

Array.from(map)

展开合并

[…map1,…map2]

set

不重复的数组

初始化 new set[]

方法

add() 添加

has() 检测

delete() 删除

clear() 清空

属性 size：长度

转数组

[…set]

Array.from(set)

遍历 for of

for(let v of set){
console.log(v)
}

for of
ES6 的新的遍历方法

可以遍历的有： Set Map Array Strng

可迭代方法

keys() 键的集合

values() 值得集合

entries() 键与值

类

定义：创建实例对象的一个模板

class类名{}

class Animal{}

constructor(){}
构造函数

constructor(name,age){}
new Animal(“虎”,5)

say(){}
一般方法

var d1 = new Animal()
d1.say();

静态方法
static toNAme(){}

调用：Animal.toName()

静态属性
static price =100

调用：Animal.price

j继承
class 类名 extends 父类名{
super()
}

class Dog extends Animal{
constructor(){
super();
}
}

getter setter

1.成对出现
2.不能直接赋值，不能设置已经有的属性

constructor(age){
this.age=age;
}

get Age(){
return this.age;
}
d1.Age调用大写的Age属性会返回小写的age的值

set Age(val){
this.age = val;
}
当d1.Age=15抵用set Age 这个方法
最终设置是小写age的值

模块

1.导出
export

1.基本

export{name,fun,age,Animal}

2.使用as
export{Animal as An}

3.default 默认
export default Animal

2.导入
import

1.基本

import{name,age,fun,Animal} from './xx.js'

import{An} from 'xx.js'
import 也可以使用as
import{Animal as An} from 'xx.js'
var a1 = new An()

3.import Animal from ‘./xx.js’

Promise：承诺

定义：返回一个延期的承诺，用then来接收结果

resolve：解决（兑现）
reject：拒绝

作用

2.避免回调函数多层嵌套

race 有一个selove就调用 then

all等所有结果都resolve才调用then方法

基本写法

new Promise((resolve,reject)=>{
	resolve(结果)
reject(原因)
})
.then(res=>{//获取结果},
err=>{//捕捉错误}
)
.catch(err=>{console.log(err)})

race

Promise.race([多个异步调用])
.then(list=>{所有的resolve结果列表})

all

promise.all([多个异步调用])
.then(list=>{所有的resolve结果列表})

generator
生成器

定义

遇到yield会挂起(暂停)

执行时候next()再次开始执行

通常去做异步请求

function* say(){
	yield "1";
yield "2";
yield "3"
}

var it = say();
it.next() //{value:"1",done:false}
it.next() //{value:"2",done:false}
it.next() //{value:"3",done:true}
it.next() //{value:underfined,done:true}

async：异步
await:等待

异步编程

function say(){return new Promise()}

async function doit(){
	await say();
await say();
await say();
}

proxy :代理

可以对目标对象的读取调用…进行拦截

1.目标对象

let target = {name:“cayng”,age:18}

2.处理

let handler={
get(target,key){},
(taret,key,value,receiver{})
}

处理函数

set

get

has()

ownkeys

apply
…

Reflect

对对象进行一些操作，方便代理处理

常用

Reflect.ownKeys(obj):

Reflect.get(obj,key):获取对象的值

Reflect.has(obj,key):检测是否有某个值