async.waterfall TypeError：回调不是函数（复杂函数）

Question

我们遇到的问题是异步函数抛出回调不是函数的错误。我对此进行了很多研究，但不知道我们的代码发生了什么。这是完整的代码。我已经在我们的代码中标记了错误发生的位置，并带有此消息“触发时发生错误”。

我该如何解决这个问题？这不是第一次发生这种情况。

    async.waterfall([
        function(callback) {
            if (businessSlug) {
                Business.findOne({slug: businessSlug}).lean().exec(function (err, business) {
                    if (!err) {
                        if (business) {
                            if (business.location && business.location.length) {
                                var coordinates = {
                                    latitud: business.location[1],
                                    longitud: business.location[0]
                                }

                                callback(null, coordinates);
                            } else {
                                callback("Business does not have lat,lon locations");
                            }
                        } else {
                            callback("No business found with provided custom slug");
                        }
                    } else {
                        callback(err);
                    }
                });
            } else {
                callback('No business custom slug provided');
            }
        },
        function(coordinates, callback) {
            if (coordinates) {
                var options = {
                    url: endpoint,
                    method: 'POST',
                    json: true,
                    body: {
                        api_key: process.env.TOOKAN_API_KEY,
                        latitude: coordinates.latitud,
                        longitude: coordinates.longitud
                    }
                };

                request(options, function(err, response, body) {
                    if (!err && body.status === 200) {
                        var tookanDrivers = [];
                        for (var i = 0; i < body.data.length; i++) {
                            if (body.data[i].status == 0 || body.data[i].status == 2) {
                                tookanDrivers.push({
                                  name: body.data[i].name,
                                  phone: body.data[i].phone,
                                  status: body.data[i].status,
                                  team_id: body.data[i].team_id,
                                  fleet_id: body.data[i].fleet_id,
                                  latitude: body.data[i].latitude,
                                  distance: body.data[i].distance,
                                  team_name: body.data[i].team_name,
                                  longitude: body.data[i].longitude,
                                  is_available: body.data[i].is_available,
                                  total_rating: body.data[i].total_rating,
                                  transport_type: body.data[i].transport_type,
                                  distance_with_units: body.data[i].distance_with_units,
                                  last_updated_location_time: body.data[i].last_updated_location_time
                                });
                            }
                        };
                        var sortedDrivers = _.orderBy(tookanDrivers, ['distance'], ['asc']);

                        callback(null, sortedDrivers, coordinates);
                    } else {
                        callback(err);
                    }
                });
            } else {
                callback('Error validating latitude and longitude');
            }
        },
        function (drivers, coordinates, callback) {
            if (drivers && drivers.length) {
                var driversToFind = [];
                for (var i = 0; i < drivers.length; i++) {
                    driversToFind.push(drivers[i].fleet_id);
                };
                Driver.find({tookanId: driversToFind}).populate('currentTask').exec(function (err, driverInDb) {
                    if (!err) {
                        if (driverInDb) {
                            for (var i = 0; i < drivers.length; i++) {
                                driverInDb.forEach(function (driver) {
                                    if (drivers[i].fleet_id == driver.tookanId) {
                                        drivers[i].id = driver._id;
                                        drivers[i].humanityId = driver.humanityId;
                                        if (driver.currentTask) {
                                            drivers[i].currentTask = driver.currentTask.value;
                                            drivers[i].currentTaskId = driver.currentTask._id;
                                        }
                                        drivers[i].timeToFinishTask =  driver.timeToFinishCurrentTask;
                                    }
                                });
                            };
                            if (drivers && drivers.length && coordinates) {
                                callback(null, drivers, coordinates);
                            } else {
                                callback("No driver or cordinates found"); // <- Error occurred when this fires
                            }
                        } else {
                            if (drivers && drivers.length && coordinates) {
                                callback(null, drivers, coordinates);
                            } else {
                                callback("No driver or cordinates found");
                            }
                        }
                    } else {
                        callback(err);
                    }
                });
            } else {
                callback('Invalid Drivers Provided!!!');
            }
        },
        function (drivers, coordinates, callback) {
            if (drivers) {
                var s = moment();
                var e = moment();
                var startDate = moment(s).startOf('day');
                var endDate = moment(e).endOf('day');
                var driversToFind = [];
                for (var i = 0; i < drivers.length; i++) {
                    driversToFind.push(drivers[i].id);
                };
                Order.find({
                    date: {
                      $gte: new Date(startDate.toISOString()),
                      $lte: new Date(endDate.toISOString())
                    },
                    driver: driversToFind
                }).populate('driver').exec(function (err, data) {
                    if (!err) {
                        if (data) {
                            for (var i = 0; i < drivers.length; i++) {
                                var orderCounter = 0;
                                for (var x = 0; x < data.length; x++) {
                                    if(data[x].driver) {
                                        if (drivers[i].fleet_id == data[x].driver.tookanId) {
                                            orderCounter = orderCounter + 1;
                                        }
                                    }
                                };
                                drivers[i].orderCounter = orderCounter;
                            };
                            if (drivers && drivers.length && coordinates) {
                                callback(null, drivers, coordinates);
                            } else {
                                callback("No driver or cordinates found");
                            }
                        } else {
                            if (drivers && drivers.length && coordinates) {
                                callback(null, drivers, coordinates);
                            } else {
                                callback("No driver or cordinates found");
                            }
                        }
                    } else {
                        if (drivers && drivers.length && coordinates) {
                            callback(null, drivers, coordinates);
                        } else {
                            callback("No driver or cordinates found");
                        }
                    }
                });
            } else {
                callback('Invalid Drivers Provided!!!');
            }
        }
    ], function (err, drivers, coordinates) {
        if (!err) {
            res.render('partial', {
              layout: false,
              status: 200,
              message: 'success',
              drivers: drivers,
              coordinates: coordinates
            });
        } else {
            debugErr(err);
            res.render('partial', {
              layout: false,
              status: 401,
              message: 'Error '+ err,
              drivers: []
            });
        }
    });

服务器错误信息

/app/node_modules/newrelic/lib/shim/shim.js:1430
throw error // Rethrowing application error, this is not an agent error.
^
TypeError: callback is not a function
at /app/app/controllers/tookan.js:1961:33
at /app/node_modules/mongoose/lib/model.js:4598:16
at /app/node_modules/mongoose/lib/utils.js:264:16
at _hooks.execPost (/app/node_modules/mongoose/lib/query.js:4326:11)
at /app/node_modules/kareem/index.js:135:16
at Shim.applySegment (/app/node_modules/newrelic/lib/shim/shim.js:1424:20)
at wrapper (/app/node_modules/newrelic/lib/shim/shim.js:2065:17)
at process._tickCallback (internal/process/next_tick.js:61:11)
Emitted 'error' event at:
at /app/node_modules/mongoose/lib/model.js:4600:13
at /app/node_modules/mongoose/lib/utils.js:264:16
[... lines matching original stack trace ...]
at process._tickCallback (internal/process/next_tick.js:61:11)

Answer 1

根据the documentation，如果您的瀑布函数之一错误，您应该返回一个错误

但是，如果任何任务将错误传递给自己的回调，则不会执行下一个函数

所以不要像这样的行：

callback("Business does not have lat,lon locations");

你应该这样做：

callback(new Error("Business does not have lat,lon locations"));

确保一旦出现错误，你就把它变成错误，而不是字符串。

这段代码的结构也很糟糕，应该重构以去除深层嵌套。使用async/await 语法并在这里放弃async 库可能会有所帮助。