这些参数是否“扩展”在 Promise 中解析和拒绝？

Question

I am reusing some code found on Github and I came up with some code that I am not sure what it is. This is the whole code;

const checkifRightPw = (ctx, next) => {
return new Promise((resolve, reject) => {
        users.getUserByEmail(ctx.params.user_email).then((users) => {
            if (users.length > 0) {
                resolve(users);
            } else {
                reject('email doesnt exist');
            }
        });
    }).then(
        (data, err) => (ctx.body = data),
        (err) => {
            ctx.response.status = 404;
            ctx.body = err;
        }
    );
}

I am wondering about these lines of code:

(data, err) => (ctx.body = data),
   (err) => {
   ctx.response.status = 404;
   ctx.body = err;
}

Does data and err stand for resolve and reject here? Normally in promises there is a function call after.then so I am a bit confused about this situation here.

Answer 1

OK, let's look at this:

.then(
        (data, err) => (ctx.body = data),
        (err) => {
            ctx.response.status = 404;
            ctx.body = err;
        }
 );

1. It's passing two fat arrow functions to .then() . The first is a function to be called if the promise is resolved, the second is a function to be called if it's rejected. Logically, the structure of this is .then(resolveCalback, rejectCallback) .
2. The first fat arrow function has two arguments, (data, err) . That's wrong. With any standard promise implementation, there is only one argument ever passed to a .then() handler. Fortunately, the implementation does not use the second argument which would always be undefined anyway.
3. That first fat arrow function just moves the resolved value from data to ctx.body . Apparently, the caller of the function that returns this promise will look for the resolved value in ctx.body .
4. The second fat arrow function is also setting up the ctx object with a status and error value. And, importantly, it is NOT rethrowing or returning a rejected promise. So, it's changing the promise from rejected to resolved. So, the caller will only ever get a resolved promise from this function and will apparently have to examine ctx.response.status to know if there is an error or not.

If the fat arrow functions are confusing you, then this snippet of code could be expressed like this using regular functions:

.then(function(data) {
    ctx.body = data;
    return data;
}, function(err) {
    ctx.response.status = 404;
    ctx.body = err;
});

---

Does data and err stand for resolve and reject here?

No. See my second point above. Only data is valid and it contains the resolved value of the promise. Having err as an argument to that first clalback is a programming error. It is not passed there. The reject callback is the second callback function.

Normally in promises there is a function call after.then so I am a bit confused about this situation here.

These are fat arrow functions (a different type of function declaration). So, there are two functions being passed to like .then(fn1, fn2) . You can read about fat arrow functions here on MDN and here on SitePoint . Their main purpose is a shortcut syntax and a different treatment for the value of this inside the function. In this case, the programmer likely used them for the shorter syntax since there are no references to this .