Question

如果分支 caseA 正在运行，我将得到'undefined'作为承诺结果。

有什么更好的方法来处理这种情况？

    function getNumsPromiseCall(){
        nums = [1,2,3]
        if (caseA) {
            var nestedPromiseResult = Promise.all(mainTasks).then(function(response){
                var secondLevelPromises = prepare(response);
                Promise.all(secondLevelPromises).then(function(subResponses)){
                    subResponses.forEach(function(r){
                        nums.push(r);
                    })
                    return nums;
                }
            })
            return Promise.resolve(nestedPromiseResult);
        } else {
            return Promise.resolve(nums);
        }    
    }

    getNumsPromiseCall.then(function(nums){
        // I will be only getting undefined for nums for the case A branch.    
    })

Answer 1

返回内部的嵌套承诺，并确保nums是最深层嵌套的承诺的返回值：

function getNumsPromiseCall() {
    let nums = [1,2,3];
    if (caseA) {
        return Promise.all(mainTasks).then(function(response){
            let secondLevelPromises = prepare(response);
            return Promise.all(secondLevelPromises).then(function(subResponses) {
                subResponses.forEach(function(r){
                    nums.push(r);
                });
                return nums;
            });
        });
    } else {
        return Promise.resolve(nums);
    }    
}

getNumsPromiseCall.then(function(nums){
    // You  will see nums here    
});

只要.then()处理程序中有新的诺言，就需要返回该诺言以将其链接到父链。这样可以确保父承诺等待内部承诺，并允许内部代码控制链的最终解析值（通过返回承诺并从内部.then()返回值）。

一个没有从.then()处理程序返回的内部诺言变成了一个完全独立的诺言链（我称其为即发即忘），而父级不等待并且不会影响已解决的值的错误，并且其错误可以忽略（几乎总是编码错误）。

当您明确不希望父级等待它并且不想从单独的promise链传递回值或错误时，很少有合理的理由不返回内部promise。我在代码中看到的唯一示例是某种清理操作（如关闭文件），如果它仍然引起错误并且不需要父级等待，则您将无济于事它完成。

仅供参考，这是一些代码，可以从使用async/await中受益（可读性强）：

async function getNumsPromiseCall() {
    let nums = [1,2,3];
    if (caseA) {
        let responses = await Promise.all(mainTasks);
        let secondLevelPromises = prepare(responses);
        let subResponses = await Promise.all(secondLevelPromises);
        subResponses.forEach(function(r) {
            nums.push(r);
        });
    }    
    return nums;
}

Answer 2

typedef struct LinkedList LinkedList;

LinkedList* createLinkedList(){
    LinkedList* rslt = malloc(sizeof(Node*)); //Allocate memory for LL
    //rslt->head = calloc(1,sizeof(Node*)); //Allocate memory for head with default Node* value (NULL)
    return rslt;
}

void add_end_LinkedList(LinkedList* x, int v){

    //Special case: LinkedList is empty
    if(x->head == NULL)
        x->head = createNode(v);

    else{
        //Traversing to end of list
        Node* p;
        for(p = x->head; p->next != NULL; p = p->next){1;}
        p->next = createNode(v);
    }
}

void add_beg_LinkedList(LinkedList* x, int v){
    Node* p;

    //Special case: LinkedList is empty
    if(x->head == NULL)
        x->head = createNode(v);

    else{
        p = createNode(v);
        p->next = x->head;
        x->head = p;
    }
}

int isIn_LinkedList(LinkedList* x, int v){
    for(Node* p = x->head; p != NULL; p = p->next){
        if(p->val == v) return 1;
    }

    return 0;
}

void print_LinkedList(LinkedList* x){
    for(Node* p = x->head; p != NULL; p = p->next){
        print_Node(p);
        printf(", ");
    }
    printf("\n");
    return;
}

//HASHTABLE_____________________________________________________________

struct HashTable{
    LinkedList** table;

};

typedef struct HashTable HashTable;

HashTable* createTable(){
    HashTable* rslt = {calloc(9,sizeof(LinkedList*))};

    for(int i = 9; i < 9; i++)
        rslt->table[i] = createLinkedList();

    return rslt;
}

int compute_hash(int v){
    return v%9;
}

int isIn_HashTable(HashTable* x, int v){
    return isIn_LinkedList(x->table[compute_hash(v)], v);
}

int insert_HashTable(HashTable* x, int v){
    if(isIn_HashTable(x, v)){
        return 0;
    }

    add_beg_LinkedList(x -> table[compute_hash(v)], v);
    return 1;
}

int main(void){
    HashTable* a = createTable();
    insert_HashTable(a, 6);
    return 0;
}

我该如何处理两个级别的嵌套承诺的结果？

2 个答案: