Preventing the callback nightmare in nodeJs / Sharing variables with nested functions

Question

Preventing the callback nightmare in nodeJs / Sharing variables with nested functions

Let's simplify this scenario:

const generateUrl = (req, res) => {
    const id = req.query.someParameter;

    const query = MyMongooseModel.findOne({'id': id});
    query.exec((err, mongooseModel) => {
        if(err) {
            //handle error
        }

        if (!mongooseModel) {
            generateUrl(id, (err, text, url) => {
                if (err) {
                    res.status(HttpStatus.INTERNAL_SERVER_ERROR).send(err);
                    return;
                }
                const newMongooseModel = new AnotherMongooseModel();
                newMongooseModel.id = id;

                newMongooseModel.save((err) => {
                    if (err) {
                        res.status(HttpStatus.INTERNAL_SERVER_ERROR).send(err);
                    } else {
                        res.send({url: url, text: text});
                    }
                });
            });
        } else {
            //handle existing model
        }
    });
};

I've read other answers suggesting the use of named functions, but they don't address passing variables or using jQuery's queue. I'm unable to utilize either in my code.

I know that replacing anonymous functions with named ones is an option, but I'm unsure how to manage variables that need to be passed around. For example, how would an inner function access the res variable if it's defined elsewhere?

javascript node.js express callback mongoose

Answer 1

Answer №1

Your question centers around a crucial concept:

You are aware that you can substitute your anonymous functions with named functions, but then the challenge arises of passing variables around. How would an inner function access 'res' for example if the function is defined elsewhere?

The solution lies in using a function factory.

In essence, transforming this:

function x (a) {
    do_something(function(){
        process(a);
    });
}

can be achieved by converting it to this:

function x (a) {
    do_something(y_maker(a)); // take note that we're calling y_maker,
                              // rather than passing it as a callback
}

function y_maker (b) {
    return function () {
        process(b);
    };
}

In the provided code snippet, y_maker is a function that produces another function named 'y'. In my personal code, I utilize the naming convention of .._maker or generate_.. to indicate that I'm utilizing a function factory. However, this is merely a personal preference and not a widely adopted standard.

Therefore, for your code, you can refactor it as follows:

exports.generateUrl = function (req, res) {
    var id = req.query.someParameter;

    var query = MyMongooseModel.findOne({'id': id});
    query.exec(make_queryHandler(req,res));
};

function make_queryHandler (req, res) {
    return function (err, mongooseModel) {
        if(err) {
            //handle error
        }
        else if (!mongooseModel) {
            generateUrl(Id,make_urlGeneratorHandler(req,res));
        } else {
            //handle existing condition
        }
}}

function make_urlGeneratorHandler (req, res) {
    return function (err, text, url) {
        if (err) {
            res.status(HttpStatus.INTERNAL_SERVER_ERROR).send(err);
            return;
        }
        var newMongooseModel = new AnotherMongooseModel();
        newMongooseModel.id = id;
        newMongooseModel.save(make_modelSaveHandler(req,res));
}}

function make_modelSaveHandler (req, res) {
    return function (err) {
        if (err) res.status(HttpStatus.INTERNAL_SERVER_ERROR).send(err);
        else res.send({url: url, text: text});
}}

This restructuring eliminates the nested callbacks and provides the added benefit of clearly defining the purpose of each function, which is considered a good coding practice.

Furthermore, employing named functions in this manner results in significantly faster execution compared to using anonymous callbacks (whether through nested callbacks or promises – although using named functions with promise.then() yields similar speed enhancements). An earlier Stack Overflow inquiry highlighted that named functions in node.js are more than twice as fast (if memory serves me right, it was over 5 times faster) than anonymous functions.

Answer 2

Your question centers around a crucial concept:

You are aware that you can substitute your anonymous functions with named functions, but then the challenge arises of passing variables around. How would an inner function access 'res' for example if the function is defined elsewhere?

The solution lies in using a function factory.

In essence, transforming this:

function x (a) {
    do_something(function(){
        process(a);
    });
}

can be achieved by converting it to this:

function x (a) {
    do_something(y_maker(a)); // take note that we're calling y_maker,
                              // rather than passing it as a callback
}

function y_maker (b) {
    return function () {
        process(b);
    };
}

In the provided code snippet, y_maker is a function that produces another function named 'y'. In my personal code, I utilize the naming convention of .._maker or generate_.. to indicate that I'm utilizing a function factory. However, this is merely a personal preference and not a widely adopted standard.

Therefore, for your code, you can refactor it as follows:

exports.generateUrl = function (req, res) {
    var id = req.query.someParameter;

    var query = MyMongooseModel.findOne({'id': id});
    query.exec(make_queryHandler(req,res));
};

function make_queryHandler (req, res) {
    return function (err, mongooseModel) {
        if(err) {
            //handle error
        }
        else if (!mongooseModel) {
            generateUrl(Id,make_urlGeneratorHandler(req,res));
        } else {
            //handle existing condition
        }
}}

function make_urlGeneratorHandler (req, res) {
    return function (err, text, url) {
        if (err) {
            res.status(HttpStatus.INTERNAL_SERVER_ERROR).send(err);
            return;
        }
        var newMongooseModel = new AnotherMongooseModel();
        newMongooseModel.id = id;
        newMongooseModel.save(make_modelSaveHandler(req,res));
}}

function make_modelSaveHandler (req, res) {
    return function (err) {
        if (err) res.status(HttpStatus.INTERNAL_SERVER_ERROR).send(err);
        else res.send({url: url, text: text});
}}

This restructuring eliminates the nested callbacks and provides the added benefit of clearly defining the purpose of each function, which is considered a good coding practice.

Furthermore, employing named functions in this manner results in significantly faster execution compared to using anonymous callbacks (whether through nested callbacks or promises – although using named functions with promise.then() yields similar speed enhancements). An earlier Stack Overflow inquiry highlighted that named functions in node.js are more than twice as fast (if memory serves me right, it was over 5 times faster) than anonymous functions.

Answer 3

Answer №2

Consider utilizing promises in your code. By incorporating Q and mongoose-q, you can achieve something similar to the following:

exports.generateUrl = function (req, res) {
    var id = req.query.someParameter;
    var text = "";

    var query = MyMongooseModel.findOne({'id': id});
    query.execQ().then(function (mongooseModel) {

        if (!mongooseModel) {
            return generateUrl(Id);
     }).then(function (text) {
         var newMongooseModel = new AnotherMongooseModel();
         newMongooseModel.id = id;
         text = text;

         newMongooseModel.saveQ()
     }).then(function (url) {
         res.send({url: url, text: text});
     }).fail(function(err) {
         res.status(HttpStatus.INTERNAL_SERVER_ERROR).send(err);
     });
};

Answer 4

Consider utilizing promises in your code. By incorporating Q and mongoose-q, you can achieve something similar to the following:

exports.generateUrl = function (req, res) {
    var id = req.query.someParameter;
    var text = "";

    var query = MyMongooseModel.findOne({'id': id});
    query.execQ().then(function (mongooseModel) {

        if (!mongooseModel) {
            return generateUrl(Id);
     }).then(function (text) {
         var newMongooseModel = new AnotherMongooseModel();
         newMongooseModel.id = id;
         text = text;

         newMongooseModel.saveQ()
     }).then(function (url) {
         res.send({url: url, text: text});
     }).fail(function(err) {
         res.status(HttpStatus.INTERNAL_SERVER_ERROR).send(err);
     });
};

Answer 5

Answer №3

When it comes to executing named functions, they operate within the same scope as anonymous functions and have access to all variables currently in use. While this method can make your code less nested and more readable (a definite plus), it still falls under the category of "callback hell". To steer clear of such scenarios, consider wrapping your asynchronous libraries with a promise library like Promise Library. In my opinion, promises offer a clearer depiction of the execution flow.

To avoid ambiguity regarding variable origins, you can bind parameters to your named function using the bind method. Here's an example:

function handleRequest(res, err, text, url) {
    if (err) {
        res.status(HttpStatus.INTERNAL_SERVER_ERROR).send(err);
        return;
    }
    var newMongooseModel = new AnotherMongooseModel();
    newMongooseModel.id = id;

    newMongooseModel.save(function (err) {
        if (err) {
            res.status(HttpStatus.INTERNAL_SERVER_ERROR).send(err);
        } else {
            res.send({url: url, text: text});
        }
    });
}

...
generateUrl(Id, handleRequest.bind(null, res));

Answer 6

When it comes to executing named functions, they operate within the same scope as anonymous functions and have access to all variables currently in use. While this method can make your code less nested and more readable (a definite plus), it still falls under the category of "callback hell". To steer clear of such scenarios, consider wrapping your asynchronous libraries with a promise library like Promise Library. In my opinion, promises offer a clearer depiction of the execution flow.

To avoid ambiguity regarding variable origins, you can bind parameters to your named function using the bind method. Here's an example:

function handleRequest(res, err, text, url) {
    if (err) {
        res.status(HttpStatus.INTERNAL_SERVER_ERROR).send(err);
        return;
    }
    var newMongooseModel = new AnotherMongooseModel();
    newMongooseModel.id = id;

    newMongooseModel.save(function (err) {
        if (err) {
            res.status(HttpStatus.INTERNAL_SERVER_ERROR).send(err);
        } else {
            res.send({url: url, text: text});
        }
    });
}

...
generateUrl(Id, handleRequest.bind(null, res));

Preventing the callback nightmare in nodeJs / Sharing variables with nested functions

Answer №1

Answer №2

Answer №3

Similar questions

Developing a table with JavaScript by parsing JSON data

Exploring ways to create simulated content overflow using react-testing-library

Unable to refresh HTML table using Vuex data in Vue JS

Interacting with a third-party application via OAuth using Node server to send REST requests

Using Jest to mimic API requests in a NodeJs environment

What could be the reason my code isn't successfully performing addition within the input field?

Enhance an existing webpage by integrating ajax with jquery-ui

Get rid of numerous div elements in a React.js application with the help of a Remove button

Clearing a leaflet layer after a click event: Step-by-step guide

Securing and Authorizing API Access

Setting a checkbox to true within the MUI Data Grid using my input onChange event - how can I achieve this?

Using inertia-links within the storybook framework

Struggling with implementing private npm modules using require() and import

What steps can be taken to manage obsolete packages that are needed by a dependency in the package-lock.json file?

The window.onload function is ineffective when implemented on a mail client

I am having difficulty accessing the dataset on my flashcard while working with React/Next JS

Utilizing tag keys for inserting text and adjusting text sizes within a Web application

Array contains a copy of an object

Utilize Node.js to call the Windows SetWinEventHook function

What is the best way to trigger the onclick event before onblur event?