Verständnis der Ablehnung von Versprechen in node.js

Question

Ich versuche Versprechungen in node.js zu verstehen. Hier ist ein Beispielcode

con.queryReturnPromise("SELECT * FROM bookings WHERE driverId = " + accId + " AND bookingStatus = " + config.get('BOOKING_STATUS_ACTIVE') + " LIMIT 1") 
    .catch((err) => { 

    callback({ 
     "message": "Success", 
     "error": true, 
    }); 
    console.log("mysql query error"); 
    return Promise.reject(); 
    }) 
    .spread((rows, fields) => { 
    if (rows.length != 1) { 
     return Promise.reject(); 
    } 
    mBooking = rows[0]; 
    var query = "INSERT INTO locations SET timeStamp = " + timeStamp + " latitude = " + lat + ", longitude = " + lng + ", bookingId = " + mBooking.id; 
    return con.queryReturnPromise(query) 
    }) 
    .catch((err) => { 
    if (err) 
     console.log("Adding Location error" + err); 
    return Promise.reject(); 
    }) 
    .spread(() => { 
    return funcs.getBooking(con, mBooking.id) 
    }) 
    .then((booking) => { 
    if (mBooking.userId.toString() in userSockets) { 
     userSockets[mBooking.userId].emit(config.get('EVENT_USER_UPDATE_BOOKING'), { 
     "message": "Success", 
     "error": false, 
     "booking": booking 
     }); 
     userId = mBooking.userId.toString(); 
    } 
    callback({ 
     "message": "Success", 
     "error": false, 
     "booking": booking 
    }); 
    }) 
    .catch((err) => { 
    if (err) 
     console.log(err); 
    }); 

Der Code ist recht einfach. Allerdings habe ich eine Verwirrung. Wenn return Promise.reject() aufgerufen wird, wohin würde die Funktion führen, welcher Code wird aufgerufen. Zum Beispiel, wenn die erste catch-Klausel aufgerufen und ruft sie zurückkehren Promise.reject(), wo ein Teil des Code unten danach

Promises in for-Schleife

data = JSON.parse(data); 
      var promisesArray = []; 
      for (var i = 0; i < data.length; i++) 
      { 
       var location = data[i]; 
       var lng  = location.lng; 
       var lat  = location.lat; 
       var bearing = location.bearing; 
       var deltaTime = location.deltaTime; 
       var timeStamp = location.timeStamp; 

       var query = "INSERT INTO locations SET timeStamp = " + timeStamp + " latitude = " + lat + ", longitude = " + lng + ", bookingId = " + mBooking.id; 


       var promise = con.queryReturnPromise(query)      
         .then(() => {        
         }); 

       promisesArray[] = promise; 
      } 

      Promise.all(promisesArray) 
      .then(function(results) 
      { 
        callback({ 
         "error": false, 
        });    
      }); 

Answer 1

Jedesmal, wenn Sie tun return Promise.reject(), die nächsten .catch() Handler ausgeführt wird in dieser Kette wird aufgerufen. Es werden alle .then() Handler bis zum nächsten .catch() Handler übersprungen.

Wenn Sie ein Ablehnungsversprechen von einem -Handler oder einem .catch()-Handler zurückgeben, wird die aktuelle Versprechungskette zurückgewiesen. Wenn mehr Handler in der Kette angetroffen werden, wird der nächste Reject-Handler in der Kette aufgerufen.

Wenn Sie einen .catch() Handler treffen, was danach passiert, .catch() hängt davon ab, was die .catch() tut. Wenn es eine abgelehnte Zusage abgibt oder zurückgibt, bleibt die Zusage im abgelehnten Status und die nächste .catch() in der Kette wird ausgeführt. Wenn es nichts oder keinen regulären Wert zurückgibt (außer einem Versprechen, das letztendlich ablehnt), dann wird das Versprechen gelöst (nicht mehr zurückgewiesen) und dann wird der nächste Handler in der Kette ausgeführt.

Hier ist ein Beispiel:

a().then(function() { 
    // makes promise chain assume rejected state 
    return Promise.reject(); 
}).then(function() { 
    // this will not get called because promise is in rejected state 
}).catch(function() { 
    // this will get called 
    // returning a reject promise will keep the promise in the reject state 
    return Promise.reject(); 
}).then(function() { 
    // this will not get called because promise is in rejected state 
}).catch(function() { 
    // this will get called 
    return 2; 
}).then(function(val) { 
    // this will get called because prior `.catch()` "handled" the rejection 
    // already 
    console.log(val); // logs 2 
}).catch(function() { 
    // this is not called because promise is in resolved state 
});