1、return、break、continue、==

return:默认返回undefined，可以返回任意数据类型。立即结束函数
break:立即结束函数
continue：跳过当前
== ：转为数值在比较

2、立即执行函数

立即执行函数:可以传参只能执行一次

(function name(a) {
    console.log("立即执行！！！！！！！！！");
    console.log(a); // 1
})(1);

3、debug

/debuger/ 浏览器-》打断点-》刷新页面-》指向谁表示正要执行，还没执行

4.函数的this

只被被函数调用的位置所影响（函数、方法）
call、bind、apply

5.工厂函数

缺点-》通过工厂函数创建的对象，都是Object，没有办法区别

   function create(name, age, sex) {
      let obj = {};
      obj.name = name;
      obj.age = age;
      obj.sex = sex;
      return obj;
    }

    let one = create("hahahahh", 16, '男');
    let tow = create("hah呵呵呵呵呵hahh", 16, '男');
    let three = create("哇问啊啊我", 16, '男');
    console.log(one);
    console.log(tow);
    console.log(three);

6.构造函数

    // 创建构造函数：首字母大写
    // 1、先创建对象
    // 2、对象的this设置为函数的this（添加对象的属性）
    // 3、依次执行代码
    // 4、return 出Dog对象
    // instanceof：A  instanceof  B   -》A是否是B 的实例
    // in :检查对象中有没有这个属性
    // Obj.hasOwnProperty('key'):对象自己有没有属性，不包括prototype

 instanceof：A  instanceof  B   -》A是否是B 的实例
 in :检查对象中有没有这个属性
 Obj.hasOwnProperty('key'):对象自己有没有属性，不包括prototype

    function Dog(name, sex, age) {
        this.name = name
        this.age = age
        this.sex = sex
    }
      function Persion(name, sex, age) {
            this.name = name
            this.age = age
            this.sex = sex
        }
    let dog = new Dog("花花","母",18)
    let persion  = new Persion("hahahha", "女", 18)
    console.log(dog);
    console.log(persion);

    console.log(dog instanceof Dog);
    console.log(dog instanceof Object);

7.构造函数的原型对象

   // 每个函数都有prototype原型对象，普通函数的没有意义
        // 当是，构造函数所创建的实例时：会有一个隐含的属性指向构造函数的对象，可以通过
        // __proto__来访问 
        // 原型对象相当于一个公共的区域，所有一个类的实例都可以访问到这个原型的对象
        // 原型对象也是对象__proto__.__proto__/prototype，也有prototype，实例：先查找自身，自身没有再找原型,z
        // 直到没有找到返回undefined

 // 缺点：全局污染变量名
 function Dog(name, sex, age) {
            this.name = name
            this.age = age
            this.sex = sex
            this.fn = names
        }
        function Persion(name, sex, age) {
            this.name = name
            this.age = age
            this.sex = sex
            this.fn = names
        }
       
        function names( ) {
                console.log("name:", this.name);
            }
        let dog = new Dog("花花", "母", 18)
        let persion = new Persion("hahahha", "女", 18)

利用原型：

  function Dogs(name, sex, age) {
                this.name = name
                this.age = age
                this.sex = sex
            }
          Dogs.prototype.getNmae = function(){
              console.log(this.name);
          }
            let dogs1 = new Dogs("花花", "母", 18)
            let dogs2 = new Dogs("hahahha", "女", 18)
            // console.log(dogs1);
            // console.log(dogs1.getNmae());
            // console.log(dogs2);
            // console.log(dogs1.__proto__ === Dogs.prototype);
            // console.log(dogs1.__proto__);
            // console.log(dogs2.__proto__ === dogs1.__proto__);
            // console.log(dogs1.__proto__.__proto__);
            // console.log(Dogs.prototype);

8.toString

console.log():相当于是对象.toString()的返回值

function Dogs(name, sex, age) {
  this.name = name;
  this.age = age;
  this.sex = sex;
}
Dogs.prototype.getNmae = function () {
  console.log(this.name);
};
let dogs1 = new Dogs("花花", "母", 18);
// dogs1.toString = function(){
//     return (
//       "Dogs[name=" + this.name + ",age=" + this.age + ",sex=" + this.sex + "]"
//     );
// }



// toString
console.log(":::",dogs1);
// console.log(dogs1.toString());

9.垃圾回收机制

10、包装类：

把简数据类型转为引用数据类型：new Number()、new String()、new Boolea()

11、常用的数组方法

includes:includes( , 位置):是否有某个成员全等 === 但是NaN === NaN,

 console.log([1,2,3].includes('2')); //false
    console.log([1, 2, NaN].includes(NaN)); //true
    console.log(NaN ===NaN); //false
    应用 数组去重

转数组 Array.from('')：

第一个参数

// 只能转：：可遍历的数据、数组、字符串、Set、Map、Nodelist、argument
var s1 = "lcl"
var arry3 = ['’lcl','lcl']
var aa  = Array.from(arry3)   //相当于浅拷贝
console.log(aa);  //(2) ['’lcl', 'lcl']
arry3[0] = '1111'
console.log(arry3); //(2) ['1111', 'lcl']
console.log(Array.from('lclcl')); //(5) ['l', 'c', 'l', 'c', 'l']

拥有任何的length对象,对象的key必须为数字，length控制长度不够为undefined

  const obj = {
      '0':'lcl',
      '1':';;;',
      '2':'qwer',
      length:4
  }
  console.log(Array.from(obj));

2、第二个参数：作用类似于数组的map方法，用来对每个元素进行处理，将处理后的值放入返回的数组

 console.log('------------------------');
    console.log(Array.from('12',v => v*2 ));

第三个参数改变this的指向

 var objs = {name:'lcl',age:'13'}
 Array.from('12', function(v) {
        console.log(this);   //{name: 'lcl', age: '13'}
       return v * 2
    }, objs)

splice、slice、split、indexof、sort、push、new Set()
foreach：

用于调用数组的每个元素，并将元素传递给回调函数。
注意: forEach() 对于空数组是不会执行回调函数的。
tips: forEach()中不支持使用break(报错)和return(不能结束循环)，有需要时可使用常规的for循环。

map：

返回一个新数组，数组中的元素为原始数组元素按照顺序被处理后的值。
是否改变原数组：否
是否对空数组进行检测：否

filter:

创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。
是否改变原数组：否
是否对空数组进行检测：否

find() ：

通过测试（函数内判断）的数组的第一个元素的值。find() 方法为数组中的每个元素都调用一次函数执行：
当数组中的元素在测试条件时返回 true 时, find() 返回符合条件的元素，之后的值不会再调用执行函数。如果没有符合条件的元素返回 undefined
注意: find() 对于空数组，函数是不会执行的
注意: find() 并没有改变数组的原始值。

find：[].find(()=>(currentValue, index, arr),thisValue)

find(回调函数,改变this):找到满足条件的值，立即返回
findIndex(回调函数,改变this):找到满足条件的索引，立即返回
合并对象：Object.assign(): 相同的属性后面的会改变前面的，会返回第一个参数的对象

fill:

fill() 方法用于将一个固定值替换数组的元素。
**注意：fill() 不会对空数组进行填充。
注意： fill() 会改变原始数组。 应用生成新数组：new Array(4).fill(1).map((v)=>{name:"",age:""})

const arr1= [41, 91, 16, 25];
const b1 = arr1.fill(100);
const arr2= [41, 91, 16, 25];
const c1 = arr2.fill(100, 2, 4)  //** 2为开始填充的起始位置，4为结束位置（不包含）**
const arr3= [];
const d1 = arr3.fill(100);
console.log(arr1)   // [100, 100, 100, 100]
console.log(b1)  // [100, 100, 100, 100]
console.log(arr2)  // [41, 91, 100, 100]
console.log(c1)  // [41, 91, 100, 100]
console.log(arr3)  // []
console.log(d1)  // []

pop()：arr.pop()删除索引值最大的元素,并返回被删除的元素。
unshift(value)：在数组的头部添加一个或多个元素,并返回数组的新长度
shift();删除索引为0的元素，并返回删除的元素
concat()合并数组或元素，返回新的数组,原数组不会改变

12.常用的字符的方法：

trim方法用来删除字符串前后的空格
str.toLowerCase()
str.toUpperCase()
str.split(separator,limit); 参数1指定字符串或正则，参照2指定数组的最大长度

　　例：str.split(""); 每个字符都被分割 ['','','','']

　　　　str.split(); 整个字符串放到数组里 ['']

join
indexOf
replace
str.substring(start,end); 两个参数都为正数，返回值：[start,end) 也就是说返回从start到end-1的字符
str.slice(start,end); 两个参数可正可负，负值代表从右截取，返回值：[start,end) 也就是说返回从start到end-1的字符

13. 对象常用方法

hasOwnProperty()：`返回一个布尔值，指示对象自身属性中是否具有指定的属性（也就是，是否有指定的键）

 var object = { age:'lcl',a:'123'}
      console.log(object.hasOwnProperty('age')); //true

Object.assign()：

用于将所有可枚举属性的值从一个或多个源对象复制到目标对象。它将返回目标对象。
后面相同的健会覆盖前面对象的值
会返回一个新的对象和改变第一个对象

   var object = { age: 'lcl', a: '123' }
    var b = Object.assign(object)
    console.log(b); //{age: 'lcl', a: '123'}
    var n = { age: ' ', a: ' ' }
    console.log(Object.assign(object,n) ); //{age: ' ', a: ' '}
    console.log(object); //{age: ' ', a: ' '}
    console.log('-----------');

浅拷贝

  var object = { age: 'lcl', a: '123',bb:{aa:'123'} }
    console.log(object);  // { age: 'lcl', a: '123',bb:{aa:'aaaaaaaaaa'}  }
    object.name = 'adfsaf'
    object.bb.aa = 'aaaaaaaaaa'
    console.log(object); // { age: 'lcl', a: '123', name: 'adfsaf',bb:{aa:'aaaaaaaaaa'}  }

拿到key：Object.keys()；拿到view:Object.values；拿到entry:Object.entries

  var lcl = {hah:123,jjjj:'adfsa'}
        console.log(Object.keys(lcl));
        console.log(Object.values(lcl));
        console.log(Object.entries(lcl));
        for (const key in lcl) {
            console.log(key);  //key
        }

for key in obj ：空对象不执行
Object.keys(object)：返回[key,key]

14. 模板字符串与一般字符串

模板字符串可以放常量、变量、函数、
里面也可以做运算、只要最终可以得出一个值的都可以放

区别：

使用：

模板字符串：${}
一般字符串:""、''

 var obj = {name:"lcl"}
    var moban = `我的名字是：${obj.name}`

    var moban2 ='我的名字是：'+ obj.name
    var moban3 = "我的名字是：" + obj.name +""
    // console.log(moban);
    // console.log(moban2);
    // console.log(moban3);

换行：

模板字符串：\n、回车
一般字符串:\n

//     console.log("第一行\n第二行");
//     console.log(`第一行\n第二行`);
//     console.log(`第一行
// 第二行`);

输出特殊字符：转移字符 \

模板字符串特殊字符：(\、``)
一般字符串:(""、'')

  console.log(`\\`);
    console.log(`''`);
    console.log(`\`\``);

//  输出特殊字符(""、'')
    console.log("\"\"");

15.箭头函数不适用的使用场景

```
 作为构造函数
```
```
 需要this指向调用的时候
```

 使用arguments的时候，箭头函数没有arguments

  function name(){
        console.log(arguments);
    }
     name(1,23,4,3)
   var a =   ()=>{
        // console.log(arguments);  
    }
    a(1, 23, 4, 3)   //ReferenceError: arguments is not defined

```
  可以用剩余参数代替：
```
剩余参数 -》永远是个数组 ->只能放在最后一个参数的位置

    var fn = (a=1,b=1,...args)=>{
        console.log(a,b,args);
    }
    console.log(fn("lcl", "18", 12, 23, 13, 141));

  函数先用自己的变量，在用形参

16.解构赋值

模式匹配

数组：按照索引（不取的按照,跳过）
对象按照属性名相同，完成赋值

  // const [a,[,,b],c] = [1,[2,3,4],5]
    // console.log(a,b,c);   //1 4 5
    const obj = {name:'lcl',age:'15'}
    // const {name:name,age:age} = obj
    // console.log(name,age);

重命名 name为匹配，names为赋值，两个名字相同，可以省略

    const { name, age: ages } = obj
    console.log(name, ages);

数组解构默认值只有解构的 === undefined 才会生效

    const fn = ()=> '我被执行了！！！'
    const [a,b] = []
    // console.log(a,b); //默认值为undefined undefined
    const [c=fn(), d= 3] = [,1]  //我被执行了！！！ 1
    // console.log(c,d);

对象解构默认值只有解构的 === undefined 才会生效

    const { namel = fn(), agel=  fn()} = { namel:'lcl'}
    console.log(namel,agel);
    // 会继承属性
    const {toString}={}
    console.log(toString);  //ƒ toString() { [native code] }
    const [map] = []
    // console.log(map);  //undefined

    // 应用：函数传参
    const lcl = {ww:123,arry:[1,23,456],aa:1323}
    const lclv = ({ww,arry,aa,arry:[,vvv]})=>{
        // console.log(ww, arry, aa, vvv);
    }
    lclv(lcl)

字符串的解构赋值 :既可以使用数组，也可以使用对象

    var str = 'qwerwq'
    var [,qq] = str
    console.log(qq);
    var {0:aw,1:v,length} = str
    console.log(aw); //q
    console.log(v); //w
    console.log(length); //6

6.数值和布尔值的解构赋值原理：先用构造类转为对象，在匹配

17. 对象中属性和方法的简洁表示法

属性的简洁表示

    // 对象：1、字面量创建  2、new Object()创建
    var namess = {name:'六六'}
   console.log(JSON.stringify(namess));

    var age = { age: '27' }
    var obj1 = {name,age}
    var obj2 = { name:name, age:age }
    // console.log(obj1);
    // console.log(obj2);

2.对象的方括号的语法:要求把age做为key

[] 只要能得到值都能放
object.key:特殊语法-》key的标识符合法的时候使用 \ object[key]

   var  a = 'age'
    var aa = 'ages'
    var obj = {
        [aa]:123,
        [1===1?'lcl':lcls]:';c;',
        "2221safsdf":123
    }
     obj.a = 123   //不能
      obj[a] = 123
    //  obj['ages'] = 223

    console.log(obj);
    // console.log(obj.2221safsdf);
    console.log(obj["2221safsdf"]);

函数参数的默认值

    var asd = (a = 1,b = 2)=> a*b
    console.log(asd());
    console.log(asd(2,7));

    // 应用
    var  hahah = ({username12="lcl",age12=18}={})=>{
        console.log(username12,age12);
    }
    hahah()

18.展开运算符

数组展开运算符的应用(可以直接展开)
浅拷贝数组、对象

   var arr1 = [1, 23, 3, 4]
    // console.log(...arr1);
    var arr2 = [...arr1]
    arr1[0] = 123
    console.log(arr2);

合并数组、对象

  var arr3 = [...arr1,...arr2]
    console.log(arr3);

字符串转为数组、对象

  var a = "asdfsadfsdf"
    console.log([...a]);

伪数组转为数组

    var w = document.querySelectorAll("p")
    console.log(w); //报错
     console.log([...w]);

对象展开运算符的应用(必须在对象中展开) :展开的对象，后面相同的属性会覆盖前面的属性

  var lclobj = {name:'lcl',age:'12' }
        var lclobj1 = { name: 'lclll', age:'23'}
        console.log({ ...lclobj, lclobj1 });
        console.log({...lclobj,...lclobj1});

```
空对象展开还是空对象
```

非对象的展开:先转为对象，再将属性罗列出来

特殊：展开字符串会将索引作为key

    console.log("_______");
        //{0: '{', 1: 'n', 2: 'a', 3: 'm', 4: 'e', 5: ':', 6: 'l', 7: 'c', 8: 'l', 9: '}'}
        console.log({..."{name:lcl}"});

19: new Date

new Date():现在中国标准时间
new Date(year, month（0-11）, （day, hours, minutes, seconds, milliseconds）)
new Date(时间戳)：时间戳 -》中国标准时间

let myDate = new Date()

myDate.getFullYear()：返回年 myDate.getMonth() ：返回月（0-11） myDate.getDate()：返回月中第几天（1-31） myDate.getHours()：返回小时（0-23） myDate.getMinutes() 返回分钟（0-59） myDate.getSeconds() ：返回秒（0-59） myDate.getTime()：返回自 1970 年 1 月 1 日午夜 myDate.now():: 返回自 1970 年 1 月 1 日午夜以来的毫秒数。
myDate.parse(): 解析日期字符串并返回自 1970 年 1 月 1 日以来的毫秒数。 setMonth(-1):

期望值是 0-11，但允许其他值：
-1 将导致上一年的最后一个月
12 将导致明年的第一个月
13 将导致明年的第二个月 setDate(-1)
必需。整数，表示月中的某一天。预期值是 1-31，但允许其他值：
0 将导致上个月的最后一天
-1 将导致上个月的最后一天的前一天
如果一个月有 31 天, 32 将导致下个月的第一天
如果一个月有 30 天,32 将导致下个月的第二天 setHours(-1);
期望值是 0-23，但允许其他值：
-1 将导致前一天的最后一个小时
24 将导致第二天的第一个小时


      // 格式化存储的时间
      handleTime(now, name = '日', number = 0) {
        let getTimeData = [];
        if (name === '年') {
          let arry = [];
          for (let index = 0; index < number; index++) {
            if (index != 0) {
              now.setMonth(-1);
            }
            arry[index] = this.getTime(now, 'yy年');
          }
          getTimeData = [...arry];
        }
        if (name === '月') {
          let arry = [];
          for (let index = 0; index < number; index++) {
            if (index != 0) {
              now.setDate(-1);
            }
            arry[index] = this.getTime(now, 'yy-mm');
          }
          getTimeData = [...arry];
        }
        if (name === '日') {
          let arry = [];
          for (let index = 0; index < number; index++) {
            if (index != 0) {
              now.setHours(-1);
            }
            arry[index] = this.getTime(now, 'yy-mm-dd');
          }
          getTimeData = [...arry];
        }
        return [...getTimeData];
      },

      getTime(myDate, type) {
        var year = myDate.getFullYear();
        var month =
          myDate.getMonth() + 1 < 10 ? '0' + (myDate.getMonth() + 1) : myDate.getMonth() + 1;
        var day = myDate.getDate() < 10 ? '0' + myDate.getDate() : myDate.getDate();
        // var h = myDate.getHours() < 10 ? '0' + myDate.getHours() : myDate.getHours();
        // var m = myDate.getMinutes() < 10 ? '0' + myDate.getMinutes() : myDate.getMinutes();
        // var s = myDate.getSeconds() < 10 ? '0' + myDate.getSeconds() : myDate.getSeconds();
        let data = '';
        switch (type) {
          case 'yy年':
            data = year + '年';
            break;
          case 'yy-mm':
            data = year + '-' + month;
            break;
          case 'yy-mm-dd':
            data = year + '-' + month + '-' + day;
            break;

          default:
            data = 'yy-mm-dd ';
            break;
        }
        return data;
      },

w3c:->[www.w3school.com.cn/jsref/jsref…]
moment:->[momentjs.cn/docs/#/pars…]

20: Set和Map

数组：一系列有序的数据集合
Set：一系列无序、无重复的数据集合; 无法字面量添加,相当于伪数组

    var s = new Set([1,21,1])   
    // console.log([...s]);   //转为数组
    s.add(23)   //添加
    // console.log(s);
    var Ls = new Set([1, 1, 33, 222])

set的方法和属性方法：add、has、delete、clear

// console.log(Ls);
    // console.log(Ls.add(123));
    // console.log(Ls.has(123));
    // console.log(Ls.delete(123));
    // console.log(Ls);
    // Ls.clear()
    console.log(Ls);
    // foreach、size
    var obj = {name:'as'}
    Ls.forEach(function (index, view, set) {

// 注意：index == view

            // console.log(index == view);
            // console.log(index, view, set);
            // console.log(this);
        })

Ls.forEach(function(index, view, set){
    // 注意：index == view
    // console.log(this);
}, obj)

    Ls.forEach(  (index, view, set)=> {
        // 注意：index == view
        // console.log(this);
    }, obj)

4.应用: 相当于伪数组

数组去重
// console.log([...new Set([1, 1, 1, 2])]);
字符串去重
// console.log([...new Set('aaaaaaas')].join(''));

set判断重复的原理：利用 ===，但是在set中NaN === NaN,实际中NaN != NaN

// console.log(NaN === NaN);  //false
// console.log(null == null);   //true
// 注意
var fn  =  function name(params) {
    
}
// console.log(new Set([[],{},{},[], fn, fn])); //Set(5) {Array(0), {…}, {…}, Array(0), ƒ}

Map

Map:类似对象 -》区别：对象的key是字符串，合法的标识符。 Map可以是字符串也阔以是变量(引用数据类型，基本数据类型,函数、new Set())

 var newMap = new Map()
    // console.log('-----------------------------------------------------');
    // console.log(newMap.set(fn,234));

   var arry = [{name:'asd',a:'vae'},{ name: 'sfsdf', a: 'fsfsdf' }]
  function handleSelectData(arry) {
   return newArry=  arry.map((item)=>{
       return {label:item.name,value:item.a}
        })
    }

    var aaa =  handleSelectData(arry)
    // console.log(aaa.length);

map的方法:set() 获取成员变量 get() has() delete() clear() forEach()

    const m = new Map()  //里面阔以传二位数组、Set、Map 的实例对象等：必须体现键值对
    console.log('--------------');
    const sss = new Set([['name', 'lcl'], ['age', 15]])
    console.log(new Map(sss));
    console.log(new Map([['name', 'lcl'], ['age', 15]]));


    // console.log(m(new Set({name:"123123"})));
    m.set("name","liu").set('age',12).set('sex','男')
    // console.log(m.get('name'));
    // console.log(m.has('name'));
    // console.log(m.delete('name'));
    // console.log(m);
    // m.clear()
    // console.log(m);
    // console.log(m.size);

 map判断重复的原理：利用 ===，但是在set中NaN === NaN
 什么时候使用map，如果只需要key-》value的结构，或者需要字符串以外
 的值做健，使用Map更合适：foreach、size、get、has等
 只有模拟现实世界的实体时，才使用对象

应用
let [p1,p2,p3]= document.querySelectorAll('p') const mChange = new Map([[p1, 'red'], [p2, 'blue'], [p1, 'yellow']]) mChange.forEach((value,key,item)=>{ key.style.color = value })

21: iterator遍历器:可遍历对象

var arry = [1,23][Symbol.iterator]()
    // console.log(arry.next());
    // console.log(arry.next());
    // console.log(arry.next());

使用了iterator ：遍历器

数组的展开运算符
数组的结构赋值
Set和Map的构造函数
数组、Set、Map、函数的arguments对象
NodeList对象
for ..of：原理-》Symbol.iterator ->it>next() [1,23]Symbol.iterator

    const arr = [1,2,3]
//    获取索引
for (const index of arr.keys()) {
    console.log(index);
}
// 取值
  for (const value of arr.values()) {
        console.log(value);
    }          
//     获取索引，取值
    for (const [index,value] of arr.entries()) {
        console.log(index, value);
    } 
    for (const iterator of [1,3,4]) {
        // console.log(iterator);
    }

for of 可循环哪些数据

原生可便利：
有iterator-->数组、字符串、Set、Map、函数的arguments对象(伪数组)、nodelist(伪数组)
非原生可便利：

22.字符串的常用方法

includes('a',位置) console.log('asdfadf'.includes('asd',0)); //true
字符串补全

原来的字符串长度大于等于最大长度，不会削减原来的字符串。返回原来的字符串
用来补全的字符串超过了最大的长度，会截取用来补全的字符串
省略第二个字符差：会用空格代替

console.log('ss'.padStart('12', 'sfsd'));
console.log('ss'.padStart('12'));

// 应用显示日期格式 var mounth = '1' console.log(mounth.padStart(2,0)); //01

清除空格 trim()、trimStart()、trimEnd() // 应用：用来清除input框提交前清除空格

23.promise

1、 promise的构造函数 new Promise 2、三种状态实例完成为padding状态： pending(未完成状态)->resolve(执行状态)->fulfiled(完成状态)

        resluve('成功！！')
        reject('失败！！')
    } )

then方法->执行后会返回新的一个Promise(默认是返回成功)：可以接多个then。执行机制:return 相当于也是返回一个promise。执行谁，要看上一个then返回的哪一个函数

  p.then((v)=>{
        // console.log('第一个then：：',v);
        return new Promise((reslove,reject)=>{
            reject (new Error(`第二个then：：${v}`))
        })
    }).then((v) => {
        // console.log(v);
    },(err)=>{
        // console.log('err:',err);
    }).then((v) => {
        // console.log(v);
    }, (err) => {
        // console.log('err:', err);
    })
// pending->fulfiled,执行then第一个回调函数
// pending->rejected,执行then第二个回调函数

catch方法:捕获它前面的错误：可以接多个catch
了解finally

当Promise状态发生变化时，无论怎么变化都会执行
应用：当数据变化后->关闭数据库

Promise.resolve():成功状态的Promise的一种简写形式参数（不传返回undefined）：

一般参数、

new Promise((reslove)=>reslove('foo')).then((v)=>{
    // console.log(v);
})
Promise.resolve('foo').then((v)=>{
    // console.log(v);
})

传Promise ：后面的then会根据传递的promise对象的状态变化来接管then，来执行哪一个回调

const lcl = new Promise((resolve)=>{
    resolve('我被执行了')
})
Promise.resolve(lcl).then((data)=>{
    // console.log(data);
})
// console.log(Promise.resolve(lcl) === lcl);  //true

具有then方法的对象：里面会自动执行， reslove,reject会被then捕获

const abj = { then(reslove,reject) { 
    // reslove('reslove');
    // reject('reject');
    // console.log(1);  //会直接执行
        } }
  Promise.resolve(abj).then((data)=>{
      console.log(data);
  },(err)=>{
      console.log(err);
  })

// Promise.reject()

参数:所有的参数都会传递

Promise.reject('err').catch((err)=>{
    // console.log(err);
})

const lcl1 = new Promise((resolve,reject)=>{
    // resolve('成功！！')
    // reject('失败！！')
})
    
Promise.reject(lcl1).catch((err)=>{
    err.then((data)=>{
        console.log(data);   //成功！！
    }).catch((err)=>{
        console.log(err);   //失败！！
    })
    console.log(err);  //Promise {<fulfilled>: '成功！！'}
        
})

Promise.all():所有的状态变为成功的状态才为成功，第一个失败就为失败.作用：关注多个Promise状态的变化，传入多个Promise实例，包装成一个新的Promise实例返回

const delay = ms=>{
    return new  Promise(reslove=>{
        setTimeout(reslove,ms)
    })
}

    // let p1 = delay(1000).then(() => {
    //     console.log("p1完成");
    //     return 'p1'
    //     // return Promise.reject('p1')  //p2没返回
    // })
    // let p2 = delay(2000).then(() => {
    //     console.log("p2完成");
    //     // return 'p2'
    //     return Promise.reject('p2')   //p1没返回
    // })
    // let p3 = Promise.all([p1,p2])
    // p3.then(data=>{
    //     console.log(data);
    // },err=>{
    //     console.log(err);
    // })

8 .Promise.race：第一个成功就为成功，失败就认为失败。

let p1 = delay(1000).then(() => {
        console.log("p1完成");
        return 'p1'
        // return Promise.reject('err')  //p2没返回
    })
    let p2 = delay(2000).then(() => {
        console.log("p2完成");
         
    })
    let p3 = Promise.race([p1,p2])
    p3.then(data=>{
        console.log(data);
    },err=>{
        // console.log(err);
    })

注意：1、resolve与reject后面的代码还会执行.2、Promise.all/race的参数不是promise会转成promise对象，任何可遍历的都可以作为参数

模块

模块：一个一个局部作用域的代码块
模块系统：解决的问题：1、模块化的问题 2、消除全局变量 3、消除引入顺序的问题
模块系统 -> 需要服务器环境 -》插件live serve
es6 impot export ,在script标签上引入的时候加上 moudle

  <script src="./index.js" type ="moudle"></script>

export与import: 1. import：没有导出也能导入，被导入的代码仅会执行一遍（导入相同的也只会执行一遍） 2. import './modules.js' 不会暴露modules.js里面的变量 3. export default aaa import 名字随便取 './moudle.js'： 4. 一个模块只有一个export default 5. 全部导入和取别名：import * as obj from './moudle.js' 6. 同时导入(export default的必须在前面)：import name,aa,{a,b} obj from './moudle.js'
注意事项：
1. 模块顶层的this为undefined,不按模块的方式加载指向为window
2. import与 import(): import命令觉有提升的效果，会提升到整个模块的头部率先执行， import与export命令只能在模块的顶部执行，不能在代码中执行 import()可以按条件导入，可以在代码中执行
3. 导入导出的复合写法：age没办法在当前模块中使用

    export {age} from './module'
    =
    import {age} './module'
    export {age}

javaScript的补充：