es6+ 记录

let

｛块级元素 /作用域｝

const

常量
特性与let一样，定义完变量，必须有值，不能后赋值，不能修改，但是对象数组是可以增加的，非得需要不能添加可加入，但是引用地址可以更改

freeze()  冻结

结构赋值

1.输入默认值

字符串

字符串查找

1. str.indexOf(要找的东西) 返回索引（位置）没找到返回-1
2. str.includes（要找的东西）返回值 true/false

字符串检测

1. 字符串是否谁先开头/结尾 str.startsWith（检测东西）/str.endsWith()
2. 对数据进行复制 ，重复字符串 str.repeat（次数）

三个点的作用

1. [1,2,3,4]->—…[1,2,3,4]->1,2,3,4
2. 1,2,3,4,5 ->…1,2,3,4,5 ->[1,2,3,4,5]
3. 剩余参数： 必须放到最后

箭头函数

this 指向的是它的父级

1.()=>{ 语句 return }
2.普通写法

var  id=10;
let json={
    id: 1,
    time:function(){
        setTimeout(function(){
            alert(this.id)//this指定到当前的函数，当前函数未定义，setTimeout是指到window
        }, 200);
    }
    
}
    json.time();//10

3. 使用箭头呈现

// An highlighted block
var  id=10;
let json={
    id: 1,
    time:function(){
        setTimeout(() => {
            alert(this.id)// this定义所在函数的范围，不是当前对象
        }, 200);
    }
    
}
    json.time();//1

3.箭头不能当成构造函数

 function gz(){
        this.name='ans';
    }//此处成立

    let gz=()=>{
        this.name='ans'
    }//失败

    
    let s=new show();
    alert(s.name);

4.箭头函数里面没有arguments，用‘…’

数组循环

1.arr.forEach/map/fiter/some/every(循环回调函数，this指向谁)
2.arr.forEach代替普通的for
3.arr.map() 做数据的交互“映射”，需要配合return,返回一个新的数组，如果没有return，相当于.arr.forEach，具备重新整理数据结构的功能
4. arr.filter()过滤元素，如果回调函数未true就留下

let arr=['苹果','相机','这种']    
        arr.forEach(function(val,index,arr){
            console.log(val,index,arr)
        })
        // arr.forEach(function(val,index,arr){
        //     console.log(this,val,index,arr)
        // },123)
        // arr.forEach((val,index,arr)=>{})--箭头函数
      

5.arr.song():类似查找，数组里面某一个符合的元素，返回true
6.arr.every(): 数组里面的所有元素符合条件没，才返回true
7.arr.reduce(),求数组的和，阶层
8.arr.reduceRight()

//进行求和计算，数组，阶层
        let resarr=[2,2,3];
        let res=resarr.reduce((prev,cur,index,arr)=>{
           // return Math.pow(prev,cur)
           return prev**cur;
        })
        console.log(res+'n');//64

        //反过来求
        let resarr1=[2,2,3];
        let res1=resarr1.reduceRight((prev,cur,index,arr)=>{
           // return Math.pow(prev,cur)
           return prev**cur;
        })
        console.log(res1+'r');//84

for…of…

1.arr.key() 数组的下标
2.arr.entries() 数组某一项

 for(let val of arr){
            console.log(val)
        }

1. arr.find() 找出第一个符合条件的数组成员，没找到，返回undefined
2. arr.findIndex(),找的是位置，没找到返回-1
3. arr.fill() 填充（填充的东西，开始的位置，结束的位置）

Object

1.Objiect.is()====输出false/true

2.Object.assign() 复制新的一个对象，合并参数

promise

承诺，解决异步回调函数

// 解决异步
        ajax(url,{  //获取token
            ajax(url,()=>{ //获取用户信息
                ajax(url,()=>{
                    //获取用户相关新闻
                })

            })
        })

实例：then和catch配合使用

let a=1;
        let promise = new Promise(function(resolve,reject){
            if(a==10){
                resolve('成功');
            }else{
                reject('失败')
            }
        })
 promise.then(res=>{//返回结果的值
  	console.log(res);
 }).catch(err=>{//异常捕获
     console.log(err)
 });

let p1=Promise.resolve('aaaa');
    let p2=Promise.reject('bbb');
    let p3=Promise.resolve('ccccc');
    
    Promise.all([p1,p2,p3]).then(res=>{
        console.log(res);//bbb
    }).catch(err=>{
        console.log(err);
    })

Promise 出现带来的变化

1. Promise 解决回调信任问题

   • 调用回调过早
     对一个Promise 调用then()的时候，即使这个Promise 已经决议，提供给then()的回调也总会被异步调用。
   • 调用回调过晚（或不被调用）
     Promise创建对象调用resolve()或reject()时，这个Promise 的then()注册的观察回调就会被自动调度。可确信，这些被调度的回调在下一个异步事件点上一定会被触发。 Promise 立即执行，不可逆
   • 调用回调次数过少或过多
     Promise 只能被决议一次，所以任何通过then()注册的（每个）回调就只会被调用一次
   • 未能传递所需的环境和参数
     Promise至多只能有一个决议值（完成或拒绝）。如果要传递多个值，你就必须要把它们封装在一个数组或对象中。
   • 吞掉可能出现的错误和异常
     catch 和 resolve() 返回

2. 回调地狱问题

3. 可读性的问题

三个参数

1. resolve （抛出成功）
2. reject （抛出状态）
3. pending （当前状态）

特点

1. 对象状态不受外界影响
2. 一旦状态改变，就不会再变，状态会被凝固

模块化

1.export 声明的，都需要花括号引用
2.export default 声明的 ，不需要花括号

 <!-- js模块内的写法 -->
    export const a=12; 

//引用
 <script type="module">
    import {a,b,c} from './moduc/xxx.js';
    import './moduc/xxx.js';
    </script>
    

第二种写法

export {
        a as aaa,
        b as bbb,
        c as ccc
    }
//引用
 import * as modTwo from './moduc/xxx.js';
    console.log(modTwo.aaa)