Tags

  • AWS (7)
  • Apigee (3)
  • ArchLinux (5)
  • Array (6)
  • Backtracking (6)
  • BinarySearch (6)
  • C++ (19)
  • CI&CD (3)
  • Calculus (2)
  • DesignPattern (43)
  • DisasterRecovery (1)
  • Docker (8)
  • DynamicProgramming (20)
  • FileSystem (11)
  • Frontend (2)
  • FunctionalProgramming (1)
  • GCP (1)
  • Gentoo (6)
  • Git (15)
  • Golang (1)
  • Graph (10)
  • GraphQL (1)
  • Hardware (1)
  • Hash (1)
  • Kafka (1)
  • LinkedList (13)
  • Linux (27)
  • Lodash (2)
  • MacOS (3)
  • Makefile (1)
  • Map (5)
  • MathHistory (1)
  • MySQL (21)
  • Neovim (10)
  • Network (66)
  • Nginx (6)
  • Node.js (33)
  • OpenGL (6)
  • PriorityQueue (1)
  • ProgrammingLanguage (9)
  • Python (10)
  • RealAnalysis (20)
  • Recursion (3)
  • Redis (1)
  • RegularExpression (1)
  • Ruby (19)
  • SQLite (1)
  • Sentry (3)
  • Set (4)
  • Shell (3)
  • SoftwareEngineering (12)
  • Sorting (2)
  • Stack (4)
  • String (2)
  • SystemDesign (13)
  • Terraform (2)
  • Tree (24)
  • Trie (2)
  • TwoPointers (16)
  • TypeScript (3)
  • Ubuntu (4)
  • Home

    Bluebird - Why Promises?

    Published Feb 11, 2020 [  Node.js  ]

    You should use promises to turn this:

    fs.readFile("file.json", function (err, val) {
        if (err) {
            console.error("unable to read file");
        }
        else {
            try {
                val = JSON.parse(val);
                console.log(val.success);
            }
            catch (e) {
                console.error("invalid json in file");
            }
        }
    });
    

    Into this:

    fs.readFileAsync("file.json").then(JSON.parse).then(function (val) {
        console.log(val.success);
    })
    .catch(SyntaxError, function (e) {
        console.error("invalid json in file");
    })
    .catch(function (e) {
        console.error("unable to read file");
    });
    

    You might notice that the promise approach looks very similar to using synchronous I/O:

    try {
        var val = JSON.parse(fs.readFileSync("file.json"));
        console.log(val.success);
    }
    // Gecko-only syntax; used for illustrative purposes
    catch (e if e instanceof SyntaxError) {
        console.error("invalid json in file");
    }
    catch (e) {
        console.error("unable to read file");
    }
    

    This is the point - to have something that works like the return and throw in synchronous code.

    You can also use promises to improve code that was written with callbacks:

    //Copyright Plato https://stackoverflow.com/a/19385911/995876
    //CC BY-SA 2.5
    mapSeries(URLs, function (URL, done) {
        var options = {};
        needle.get(URL, options, function (error, response, body) {
            if (error) {
                return done(error);
            }
            try {
                var ret = JSON.parse(body);
                return done(null, ret);
            }
            catch (e) {
                done(e);
            }
        });
    }, function (err, results) {
        if (err) {
            console.log(err);
        } else {
            console.log('All Needle requests successful');
            // results is a 1 to 1 mapping in order of URLs > needle.body
            processAndSaveAllInDB(results, function (err) {
                if (err) {
                    return done(err);
                }
                console.log('All Needle requests saved');
                done(null);
            });
        }
    });
    

    This is far more readable when done with promise:

    Promise.promisifyAll(needle);
    var options = {};
    
    var current = Promise.resolve();
    Promise.map(URLs, function (URL) {
        current = current.then(function () {
            return needle.getAsync(URL, options);
        });
        return current;
    }).map(function (responseAndBody) {
        return JSON.parse(responseAndBody[1]);
    }).then(function (results) {
        return processAndSaveAllInDB(results);
    }).then(function () {
        console.log('All Needle requests saved');
    }).catch(function (e) {
        console.log(e);
    });
    

    References