js中promise方案、async和await方案和传统方案来处理异步回调的问题

自从去了新公司之后，重温了下传统处理异步请求结果的方法，那就是回调函数，举个例子：

// 传统的解决异步回调方案

	//模拟接口请求
   function timeout(callBack) {
            setTimeout(callBack, 3000, '200');
    }
    
        timeout(function (res) {
            if (res === '200') {
            //如果有多层回调继续调用timeout方法
                timeout(
                    function (res) {
                        if (res === '200') {
                            //依次类推
                            timeout(....)
                        }
                    }
                )
            }
        })
// 用promise来解决

//模拟接口请求
function timeout(callBack) {
  return new Promise((resolve, reject) => {
    setTimeout(resolve, 3000, '200');
  });
}

        timeout().then(res => {
            if (res === '200') {
                console.log(1)
                 //如果有多层回调继续调用timeout方法
                 return timeout()
            }
        }
        ).then(
        	//上面return的timeout方法的回调
            res => {
                if (res === '200') {
                    //如果有多层回调继续调用timeout方法
                    return timeout()
                    console.log(2)    
                }
            }
        ).then(
            //依次类推
        )
   // 使用async和await
        //模拟接口请求
        function timeout() {
            return new Promise((resolve, reject) => {
                setTimeout(resolve, 3000, '200');
            });
        }

        const asyncFun = async () => {
            const res = await timeout()
            console.log(1)
            console.log(res)
            if (res === '200') {
                const res = await timeout()
                console.log(2)
                if (res === '200') {
                    // 依次类推
                }
            }
        }
        asyncFun()

通过以上两种方案的对比，发现promise的使用更人性化，直观。如果面临多层回调函数的嵌套的话，
promise也会比传统的解决方案好。另外还有个async和await，会发现它的写法更加简洁，它是一种用同步式的写法来处理异步回调。