What is the best way to handle responses from several asynchronous calls?

Question

What is the best way to handle responses from several asynchronous calls?

Looking for advice on handling asynchronous calls within a loop, similar to the question addressed here. The key difference is that in this scenario, the asynchronous function is called multiple times within a loop.

The challenge lies in returning the value of 's'. Currently, the code returns undefined. This function is invoked within a for loop and utilizes the Bookshelfjs ORM library. Any suggestions or tips would be greatly appreciated!

function getUsernameFromDBAsync(userId) {
    var s = "moo";

    new Model.Users({
            idUser: userId
        })
        .fetch()
        .then(function(u) {
            var prenom = u.get('firstName');
            var nom = u.get('familyName');
            s = prenom + " " + nom;
            return s;
        });
}

javascript asynchronous promise bookshelf.js

Answer 1

Answer №1

You're not really providing a clear example of how you're running the loop, so it's a bit difficult to suggest what to do. Assuming that .fetch().then() returns a promise, here's a basic idea using standard ES6 promises in node.js:

function getUsernameFromDBAsync(userId) {
    var s = "moo";

    return new Model.Users({
        idUser: userId
    }).fetch().then(function (u) {
        var firstName = u.get('firstName');
        var familyName = u.get('familyName');
        s = firstName + " " + familyName;
        return s;
    });
}

var userIds = [...];
var promises = [];
for (var i = 0; i < userIds.length; i++) {
    promises.push(getUsernameFromDBAsync(userIds[i]));
}

// set up a .then() handler for when all promises are completed
Promise.all(promises).then(function(names) {
    // handle names array here
}, function(err) {
    // handle error here
});

If you are using the Bluebird promise library, you can simplify it like this:

function getUsernameFromDBAsync(userId) {
    var s = "moo";

    return new Model.Users({
        idUser: userId
    }).fetch().then(function (u) {
        var firstName = u.get('firstName');
        var familyName = u.get('familyName');
        s = firstName + " " + familyName;
        return s;
    });
}

var userIds = [...];
Promise.map(userIds, getUsernameFromDbAsync).then(function(names) {
    // handle names array here
}, function(err) {
    // handle error here
});

Answer 2

You're not really providing a clear example of how you're running the loop, so it's a bit difficult to suggest what to do. Assuming that .fetch().then() returns a promise, here's a basic idea using standard ES6 promises in node.js:

function getUsernameFromDBAsync(userId) {
    var s = "moo";

    return new Model.Users({
        idUser: userId
    }).fetch().then(function (u) {
        var firstName = u.get('firstName');
        var familyName = u.get('familyName');
        s = firstName + " " + familyName;
        return s;
    });
}

var userIds = [...];
var promises = [];
for (var i = 0; i < userIds.length; i++) {
    promises.push(getUsernameFromDBAsync(userIds[i]));
}

// set up a .then() handler for when all promises are completed
Promise.all(promises).then(function(names) {
    // handle names array here
}, function(err) {
    // handle error here
});

If you are using the Bluebird promise library, you can simplify it like this:

function getUsernameFromDBAsync(userId) {
    var s = "moo";

    return new Model.Users({
        idUser: userId
    }).fetch().then(function (u) {
        var firstName = u.get('firstName');
        var familyName = u.get('familyName');
        s = firstName + " " + familyName;
        return s;
    });
}

var userIds = [...];
Promise.map(userIds, getUsernameFromDbAsync).then(function(names) {
    // handle names array here
}, function(err) {
    // handle error here
});

Answer 3

Answer №2

It is unnecessary to use variable s. You can simply return the concatenated "first name last name" string from the success callback of the function.

function fetchUserNameFromDatabaseAsync(userId) {
    return new Model.Users({
        idUser: userId
    }).fetch().then(function (user) {
        return user.get('firstName') + ' ' + user.get('familyName');
    });
}

To handle your "loop", you can utilize Array.prototype.map() to create an array of promises. Follow this by using Promise.all(promises).then(...) to receive and process an array of names once all promises are resolved.

var promiseArray = userIds.map(function(userId) {
    return fetchUserNameFromDatabaseAsync(userId);
});
Promise.all(promiseArray).then(function(names) {
    // Perform actions with `names`, which contains an array of 'first name last name' strings.
}, function(error) {
    // Handle errors, for example ...
    console.error(error);
});

An even more concise approach:

Promise.all(userIds.map(fetchUserNameFromDatabaseAsync)).then(function(names) {
    // Perform actions with `names`, an array of 'first name last name' strings.
}, function(err) {
    // Handle errors, for example ...
    console.error(err);
});

Answer 4

It is unnecessary to use variable s. You can simply return the concatenated "first name last name" string from the success callback of the function.

function fetchUserNameFromDatabaseAsync(userId) {
    return new Model.Users({
        idUser: userId
    }).fetch().then(function (user) {
        return user.get('firstName') + ' ' + user.get('familyName');
    });
}

To handle your "loop", you can utilize Array.prototype.map() to create an array of promises. Follow this by using Promise.all(promises).then(...) to receive and process an array of names once all promises are resolved.

var promiseArray = userIds.map(function(userId) {
    return fetchUserNameFromDatabaseAsync(userId);
});
Promise.all(promiseArray).then(function(names) {
    // Perform actions with `names`, which contains an array of 'first name last name' strings.
}, function(error) {
    // Handle errors, for example ...
    console.error(error);
});

An even more concise approach:

Promise.all(userIds.map(fetchUserNameFromDatabaseAsync)).then(function(names) {
    // Perform actions with `names`, an array of 'first name last name' strings.
}, function(err) {
    // Handle errors, for example ...
    console.error(err);
});

What is the best way to handle responses from several asynchronous calls?

Answer №1

Answer №2

Similar questions

Achieve iframe resizing using only pure JavaScript, no reliance on jQuery required

What is the method for activating the on collapse event with a bootstrap navbar?

Error: The function 'addToCart' is not defined in React.js

Unveil the power of the "Enter" key with these jQuery hacks

How to add texture to a three.js element

I am seeking a way to eliminate double quotation marks from a string without using the replace function

Is there a way to access the value variable from a JavaScript file located in the javascript folder and bring it to the routes/index.js file in a Node.js and Express application?

Function is not triggered in React component

Is there a way to make elasticX() and elasticY() only affect the upper bound in dc.js?

When a button on a form is disabled using form.submit, it will not be included in the data that is

The nodejs events function is being triggered repeatedly

Automatically compile files while performing an npm install or update

What is the best way to display the next and restart buttons at the bottom of every question?

Challenges encountered with the "load" event handler when creating a Firefox Extension

Inserting data into a table using variables in Mssql database management system

In order to properly set up an AutoNumeric object, it is essential to have at least one valid parameter provided

What is the best way to showcase a JSON array in a tabular layout?

AngularJS directive not registering event after model update

I'm facing an issue with binding keyboard events in Vue - any suggestions on how to resolve

Verify the input in text fields and checkboxes using JavaScript