一言兩答

Question

我是JavaScript新手。 我不知道在一個諾言中可以在哪里使用兩個拒絕項。 誰能告訴我在一個承諾中有兩個拒絕是不好的做法嗎？ 如果是，那么可選解決方案是什么？

這是我的代碼

async handler(ctx) {
                /*
                 * sheet_to_json method converts excel file to JSON format
                */
                let { s3Url, header } = ctx.params;
                return new Promise((resolve, reject) => {
                    request({method: 'GET',  uri: s3Url,encoding: null}, async function(err, res, data) {
                        if(err || res.statusCode !== 200) reject(err);
                        try{
                            const workbook = XLSX.read(data, {type:'buffer'});
                            const sheet_name_list = workbook.SheetNames;
                            let result = await XLSX.utils.sheet_to_json(workbook.Sheets[sheet_name_list[0]], {header});
                            resolve(result);
                        }
                        catch(error){
                            reject("Invalid File Cointaint");
                        }       
                    })
                });
            }

Answer 1

您可以在promise回調中有多個位置，稱為reject(err) 。 只有第一個執行。 后續對reject()調用將被忽略，因為一旦設置了Promise狀態，就不能再通過進一步調用reject()或resolve()來更改它。

通常最好的做法是在return時以return結束函數執行或在拒絕時使用else語句，因為繼續執行其他不會解決或拒絕的事情通常是沒有意義的，並且在某些情況下是有害的。

因此，在您的特定情況下，您可以添加如下所示的return ：

async handler(ctx) {
    /*
     * sheet_to_json method converts excel file to JSON format
     */
    let {s3Url,header} = ctx.params;
    return new Promise((resolve, reject) => {
        request({method: 'GET', uri: s3Url, encoding: null}, async function(err, res, data) {
            if (err || res.statusCode !== 200) return reject(err); // <==== return added here
            try {
                const workbook = XLSX.read(data, {type: 'buffer'});
                const sheet_name_list = workbook.SheetNames;
                let result = await XLSX.utils.sheet_to_json(workbook.Sheets[sheet_name_list[0]], {header});
                resolve(result);
            } catch (error) {
                reject("Invalid File Cointaint");
            }
        })
    });
}

或者，您可以添加一個else：

async handler(ctx) {
    /*
     * sheet_to_json method converts excel file to JSON format
     */
    let {s3Url, header} = ctx.params;
    return new Promise((resolve, reject) => {
        request({method: 'GET', uri: s3Url, encoding: null}, async function(err, res, data) {
            if (err || res.statusCode !== 200) {
                reject(err);
            } else {           // <======== else added here
                try {
                    const workbook = XLSX.read(data, {type: 'buffer'});
                    const sheet_name_list = workbook.SheetNames;
                    let result = await XLSX.utils.sheet_to_json(workbook.Sheets[sheet_name_list[0]], {header});
                    resolve(result);
                } catch (error) {
                    reject("Invalid File Cointaint");
                }
            }
        })
    });
}

Answer 2

是的，您可以在承諾中使用任意數量的reject 。 只是次品需要處於不同的流程。 意味着一個接一個的reject被reject行不通的。 作為一個resolve ，另一個resolve將不會。

另外，要確保其他代碼不會運行，最好在reject之前添加一個return 。

例如：

const checkIfRightPermission = new Promise((res, rej) =>{
    //let's say we are doing an http request.
    request.get('/getPermission?id=someid', function(err, res, body){
        if(err){
            //the request itself couldn't be completed SO
            return rej();
        }else{
            if(sufficientPermission(body)){

            }else{
                //again
                return rej()
            }
        }
    })

});

Answer 3

您應該嘗試在if else塊中保留每個解決方案並拒絕。

if (condition1) {
  resolve(true);
} else if (condition2) {
  reject(false);
} else {
  reject(false);
}

例如，如果您要執行此操作：

if (condition1) {
  resolve(true);
}
reject(false);

您應該改為：

if (condition1) {
  resolve(true);
  return;
}
reject(false);

Answer 4

使用許多次拒絕是沒有問題的，它完全取決於您的邏輯，並且可以通過這種方式使用。

我唯一建議您更改的是Promise中的try / catch塊，當您引發異常時，下一個promise.catch將處理它。

看一看：

https://medium.com/datafire-io/es6-promises-patterns-and-anti-patterns-bbb21a5d0918