JS中使用Promise.all控制所有的异步请求都完成后，在执行后续逻辑

使用场景为，在js中连续的几个异步耗时操作，后面的耗时操作需要使用第一个操作的返回结果。例如调用ajax异步接口，需要先创建完主表，然后拿到主表id在去循环创建明细表，等全部创建完成后，弹出提示来，或者失败提示。

通常情况，在耗时操作完成后在去调用，需要将异步方法转成同步方法，结合回调函数，像ajax请求可以直接设置为同步，然后再调用完成的回调函数里继续去调用另一个逻辑代码，但这样就会导致代码嵌套比较多，不易拓展和维护，使用Promise.all可以减少代码里的不断嵌套，直接上代码，具体的一看代码就明白了，promise的使用有单独的笔记整理。

QueryOrderInfo(orderId).then((orderResult) => {
            if (!orderResult.success) {
                Xrm.Utility.alertDialog(`查询所选订单的信息及明细信息失败！【${orderResult.message}】`);
                return
            }
            let shippingId = commonUtil.delBrackets(Xrm.Page.data.entity.getId())
            let promiseArray = []
            orderResult.details.forEach((p, idx) => {
                promiseArray.push(CreateShippingOrderDetailPromise(p, orderResult.order, shippingId))
            })
            Promise.all(promiseArray).then((res) => {
                console.log(res);
                let failReqs = Object.entries(res).filter((a) => !(a[1].success))
                if (failReqs.length) {
                    Xrm.Utility.alertDialog(failReqs.map(e => e[1].message).join('\n'))
                }
                window.top.location.reload()
            })
        }).catch((err) => { console.error(err) })
        
        
/**
 * 根据整车订单id查询整车销售订单明细
 * @param {any} orderId  整车订单数据id
 */
function QueryOrderInfo(orderId) {
    return new Promise((resolve, reject) => {
        let queryPromises = [GetOrderInfo(orderId), GetOrderDetails(orderId)]
        Promise.all(queryPromises).then((res) => {
            let orderRes = res[0]
            let detailRes = res[1]
            resolve({
                success: res.every(r => r.success),
                message: (orderRes.success ? "" : `[${orderRes.message}]`) + (detailRes.success ? "" : `[${detailRes.message}]`),
                order: orderRes.data,
                details: detailRes.data
            })
        })
    })
}
/**
 * 通过销售订单ID查询销售订单的付款方式（new_paymentmethod）以及对应销售合同的合同号（new_sales_contract_number）
 * @param {any} orderId
 * @returns
 */
function GetOrderInfo(orderId) {
    return new Promise((resolve, reject) => {
        let queryUrl = `/new_orders(${orderId})?$select=new_paymentmethod&$expand=new_sales_contractid($select=new_sales_contract_number)`
        let result = { success: false, message: '未能正确查找', data: null }
        commonUtil.queryWithUrl(queryUrl, function (res) {
            if (!res) {
                result.message = '查询销售订单信息异常，添加订舱信息反馈单明细失败！'
            } else if (!res.success) {
                result.message = res.message
            } else if (res.data) {
                result.success = true
                result.data = {
                    new_paymentmethod: res.data["new_paymentmethod@OData.Community.Display.V1.FormattedValue"],
                    new_contractno: res.data.new_sales_contractid && res.data.new_sales_contractid.new_sales_contract_number
                }
            }
            resolve(result)
        }, false);
    })
}

/**
 * 根据销售订单ID查询相关的销售订单明细记录
 * @param {any} orderId
 * @returns
 */
function GetOrderDetails(orderId) {
    return new Promise((resolve, reject) => {
        let selFields = 'new_count,new_name,new_order_detailid,new_expected_output_time,_new_product_fourthid_value,_new_way_of_packagingid_value'
        let queryUrl = `/new_order_details?$select=${selFields}&$expand=new_way_of_packagingid($select=new_high,new_long,new_wide)&$filter=_new_order_value eq ${orderId}`
        let result = { success: false, message: '未能正确查找', data: null }
        commonUtil.queryWithUrl(queryUrl, function (obj) {
            if (!obj) {
                result.message = '查询销售订单明细异常，添加订舱信息反馈单明细失败！'
            } else if (!obj.success) {
                result.message = obj.message
            } else if (obj.data && obj.data.length) {
                result.success = true
                result.data = obj.data
            }
            resolve(result)
        }, false);
    })
}


/**
 * 根据销售订单明细创建反馈单明细记录
 * @param {any} orderDetail  销售明细数据
 */
function CreateShippingOrderDetailPromise(orderDetail, order,shippingId) {
    return new Promise((resolve, reject) => {
        //包装方式
        var wayOfPackaging = orderDetail.new_way_of_packagingid
        let shippingOrderDetail = {
            "new_shipping_orderid_new_shipping_order@odata.bind": `/new_shipping_orders(${shippingId})`,       // 订舱信息反馈单ID
            "new_order_detailid@odata.bind": `/new_order_details(${orderDetail.new_order_detailid})`,          // 整车销售订单明细
            "new_productcode@odata.bind": `/new_product_fourths(${orderDetail._new_product_fourthid_value})`,  // 产品代码
            new_numberofsets: orderDetail.new_count,                                                           // 台数
            new_timespan: new Date(orderDetail.new_expected_output_time).toISOString(),                        // 预计入库时间
            new_paymentmethod: order.new_paymentmethod,                                                        // 付款方式
            new_contractno: order.new_contractno,                                                              // 合同号
        }
        if (wayOfPackaging) {
            //包装方式
            shippingOrderDetail["new_way_of_packagingid@odata.bind"] = `/new_way_of_packagings(${orderDetail._new_way_of_packagingid_value})`
            //单台长
            shippingOrderDetail.new_singlelong = wayOfPackaging.new_long
            //单台宽
            shippingOrderDetail.new_singlelwide = wayOfPackaging.new_wide
            //单台高
            shippingOrderDetail.new_singlehigh = wayOfPackaging.new_high
        }
        Xrm.WebApi.createRecord("new_shipping_order_detail", shippingOrderDetail).then(
            function success(result) {
                resolve({ success: true })
            },
            function (error) {
                resolve({ success: false, message: error.message })
            }
        );
    })
}

思路就是，将所有的异步耗时操作都封装成Promise对象返回，Promise可以将异步转成同步，在执行完成后结果返回到then中，然后使用Promise.all将promise对象数组一起执行，全部执行完成后再统一返回信息。