JavaScript promise

promise

• promise三种状态
  成功的 fulfilled/resolve
  失败的 reject
  等待中 pendding

• 处理promise返回结果有两种方式
  .then =>Promise返回一个成功的promise的时候。
  .catch =>Promise返回一个失败的promise的时候。

• promise的方法

Promise.all

处理多个Promise返回结果，如果多个返回结果都是成功的，那么返回的就是成功，反之有一个失败的，那么返回的结果就是失败的。

Promise.race
处理多个Promise返回结果，返回的是最先返回的promise,如果跑出来的是一个成功promise,那么返回成功promise，反之如果是失败的promise，那么返回的是失败的promise.

Promise.resolve
直接创建一个成功的promise

Promise.reject
直接创建一个失败的promise

iterator（迭代器）

for of ：不能遍历对象，可以遍历数组和集合
有iterato(迭代器)可以用for of

异步代码解决方案

1. asynh =>异步的
2. await =>等待
3. async,await 修饰的是 是generator的一个语法糖
4. async await 联合Promise一起使用

		fn()
        async function fn(){
            await console.log(111);
            await new Promise((resolve,reject)=>{
                setTimeout(() => {
                    console.log(222);
                }, 1000);
            })
            await console.log(333);
        }

使用async修修饰的函数,返回的结果一定是一个promise的结果,返回的数据看数据是不是是不是返回非promise的结果
1. 如果是非promsie
那么返回的结果一定是一个成功的promise
其结果就是那个返回的那个结果
如果在其中有异常的代码产生,那么返回的结果就是一个失败的Promise
其结果就是那个异常的结果
2. 如果返回的是promise,那么接受就是这个Promise
接受到的就是 你的return promise
如果返回一个成功的promise,那么接受到的就是成功的promise
其结果就是成功的promise的值
如果是一个失败的promise,那么接受到就是一个失败的promise
其结果就是一个失败的promie结果的值

async function fn(){
            throw new Error('11')
        }
        console.log(fn());

async function fn(){
            return Promise.reject('55')
        }
        console.log(fn());

原型仿push方法

push往数组末尾添加，返回值是新数组的长度

let arr = new Array(2,8,1,9,4,10)
        Array.prototype.push = function(data){
            this[this.length] = data
            return this.length
        }

        let res = arr.push(99)
        console.log(res, arr);

原型仿unshift方法

unshift往头部添加元素,返回值是新数组的长度

 let arr = new Array(1, 2, 3, 4)
        Array.prototype.unshift = function (data) {
            for (let i = arr.length - 1; i >= 0; i--) {
                this[i + 1] = this[i]
                //处理第一个元素
            }
            this[0] = data
            return this.length
        }
        let res = arr.unshift(9)
        console.log(res, arr);

原型仿shift方法

shift 删除头部元素返回值是被删除的元素

		let arr = new Array(2,8,1,9,4,10)
        Array.prototype.shift= function(){
            //记录被删除的元素
            let del = this[0]
            for(let i = 1;i<this.length;i++){
                this[i - 1] = this[i]
            }
            this.length--
            return del
        }
        let res = arr.shift()
        console.log(res, arr);

原型仿norepeat方法

norepeat数组去重
方法一

		let arr = new Array(1, 2, 3, 3, 2, 1, 4, 5, 6, 7, 8, 9, 9, 9, 8, 8, 4, 4, 5,)
        Array.prototype.norepeat = function () {
            let newArr = []
            for (let i = 0; i < this.length; i++) {
                if (newArr.indexOf(this[i]) == -1) {
                    newArr.push(this[i])
                }
                
            }
            return newArr
        }

        let res = arr.norepeat()
        console.log(res, arr);

方法二

 let arr = new Array(1, 2, 3, 3, 2, 1, 4, 5, 6, 7, 8, 9, 9, 9, 8, 8, 4, 4, 5,)
        Array.prototype.norepeat = function () {
            let newArr = []
            for (let i = 0; i < this.length; i++) {
                if(!newArr.includes(this[i])) {
                    newArr.push(this[i])
                }
                
            }
            return newArr
        }

        let res = arr.norepeat()
        console.log(res, arr);