例子：

	const promisic = function (func) {
    
    
	    return function (params = {
     
     }) {
    
    
	      let a= new Promise((resolve, reject) => {
    
    
	        const args = Object.assign(params, {
    
    
	          success (res)  {
    
    
	            resolve(res);
	          },
	          fail: (error) => {
    
    
	            reject(error);
	          }
	        });
	        func(args);
	      });
	      return a
	    };
	  };
	
	  export{
    
    
	      promisic
	  }

1、Promise 是什么 怎么用

Promise是JS中进行异步编程的新的解决方案。
Promise是个构造函数，Promise对象用来封装一个异步操作，并可以获得其结果。

        const p = new Promise((resolve, reject) => {
    
    
            console.log("z1")       
            setTimeout(() => {
    
    
                resolve({
    
     a: 100 })
                // reject("zzz2")
            }, 1000)
        })

        console.log(p)  //promise

        p.then(value => {
    
     console.log(value) }).catch(
            reason => {
    
     console.log(reason) }
        )  //object

2、assign 是什么 怎么用

将所有可枚举和自有属性从一个或多个源对象复制到目标对象，返回修改后的对象。

const target = {
    
     a: 1, b: 2 };
const source = {
    
     b: 4, c: 5 };

const returnedTarget = Object.assign(target, source);

console.log(target);
// expected output: Object { a: 1, b: 4, c: 5 }

console.log(returnedTarget);
// expected output: Object { a: 1, b: 4, c: 5 }

3、promistic函数的含义

避免回调地狱，回调函数嵌套回调函数。

4、回调函数 callback

4.1 小程序里为什么要使用回调函数？

首先，入口函数里的代码需要封装，不可能所有的函数都写在主界面
比如：入口：调用主题对象里获取图片的方法得到一个主题图片——》主题对象：调用封装的HTTTP请求——》HTTP请求：调用微信小程序的http请求。

然后，由于入口需要给界面赋值，必须等到获取函数的返回值才能赋值，那么存在一个先后顺序，先等待请求结束 后赋值。不可能直接用普通的函数获取，如果是普通函数，那么由于js的异步性，无法获取到请求的数据就会给界面赋值。
因此 需使用 回调函数。

4.2 什么是回调函数

	 function fn1(callback) {
    
     //可以不用callback命名 ，比如 f1 a m 都是可以的
	     a = 1000
	     callback(a)
	 }
	
	 var b = 9
	
	 fn1(a => {
    
       //匿名函数 作为回调函数
	     let c = a + b
	     console.log(c)
	 })

5、async 和 await

async 修饰的函数返回一个promise

        async function add() {
    
    
            return 1    
            //throw 2       
            //return Promise.reject(3)
            //return Promise.resolve(4)
            // return new Promise((resolve,reject)=>{
    
    
            //     setTimeout(() => {
    
    
            //         resolve(5)
            //     }, 1000)
            // })
        }

        const a = add()

        a.then(
            value => console.log("resolve", value)  //1 4
        ).catch(
            reason => {
    
    
                console.log("rejected",reason) //2 3 5
            }
        )

await 必须写在 async 函数中
await 修饰的函数 如果返回的是 promise 那么await 将获取 promise resove 的值
如果返回的是 reject 必须使用 try catch捕获 如果不捕获将抛出异常 可在async 外层捕获
如果返回的不是 promise ，将返回函数的值
如果函数报错 通过try catch 捕获

        function fn2() {
    
    
            return new Promise((resolve, reject) => {
    
    
                setTimeout(() => {
    
    
                    reject(1)
                }, 1000);
            })
        }

        function fn4() {
    
    
            throw 2
            //return 3
        }

        async function fn3() {
    
    
            // try {
    
    
                 const vlaue = await fn2()
                 return vlaue
            // } catch (error) {
    
    
            // }

            // try {
    
    
            //     const value = await fn4()
            // } catch (error) {
    
    
            //     console.log(error)
            // }
        }