Utilisez promesse pour traiter la valeur de retour MySQL dans node.js

Ça va être un peu dispersés, pardonnez-moi.

Tout d'abord, en supposant que ce code utilise le pilote mysql API correctement, voici une façon pour vous envelopper de travailler avec un natif promesse:

function getLastRecord(name)
{
    return new Promise(function(resolve, reject) {
        //The Promise constructor should catch any errors thrown on
        //this tick. Alternately, try/catch and reject(err) on catch.
        var connection = getMySQL_connection();

        var query_str =
        "SELECT name, " +
        "FROM records " +   
        "WHERE (name = ?) " +
        "LIMIT 1 ";

        var query_var = [name];

        connection.query(query_str, query_var, function (err, rows, fields) {
            //Call reject on error states,
            //call resolve with results
            if (err) {
                return reject(err);
            }
            resolve(rows);
        });
    });
}

getLastRecord('name_record').then(function(rows) {
    //now you have your rows, you can see if there are <20 of them
}).catch((err) => setImmediate(() => { throw err; })); //Throw async to escape the promise chain

Donc une chose: Vous avez encore des rappels. Les rappels sont que des fonctions que vous avez la main pour quelque chose que l'appel à un certain moment dans l'avenir avec des arguments de son choix. Donc les arguments de la fonction dans xs.map(fn)le (err, result) fonctions vues dans le nœud et la promesse de résultat et de gestionnaires d'erreurs sont tous les rappels. C'est un peu confus par des personnes se référer à un type spécifique de rappel "rappels," ceux de (err, result) utilisé dans le nœud de base dans ce qui est appelé "la continuation passing style", parfois appelé "nodebacks" par des gens qui ne sont pas vraiment comme eux.

Pour l'instant, au moins (async/await est à venir par la suite), vous êtes un peu coincé avec rappels, indépendamment de savoir si vous adoptez des promesses ou pas.

Aussi, je note que les promesses ne sont pas immédiatement, évidemment utile ici, vous avez toujours un rappel. Promet seulement vraiment briller lorsque vous les combinez avec Promise.all et la promesse d'accumulateurs à la Array.prototype.reduce. Mais ils ne briller parfois, et ils sont vaut la peine d'apprendre.

Je suis nouvelle Node.js et les promesses. J'étais à la recherche pendant un certain temps pour quelque chose qui va répondre à mes besoins et c'est ce que j'ai fini par utiliser après la combinaison de plusieurs exemples que j'ai trouvé. Je voulais la possibilité d'acquérir la connexion par requête et de le libérer juste après la requête se termine (querySql), ou pour obtenir une connexion à partir de la piscine et de l'utiliser à l'intérieur de la Promesse.à l'aide d'étendue ou de la libérer à chaque fois que je le voudrais (getSqlConnection).
En utilisant cette méthode, vous pouvez concat plusieurs requêtes l'une après l'autre sans nidification.

db.js

var mysql = require('mysql');
var Promise = require("bluebird");

Promise.promisifyAll(mysql);
Promise.promisifyAll(require("mysql/lib/Connection").prototype);
Promise.promisifyAll(require("mysql/lib/Pool").prototype);

var pool = mysql.createPool({
    host: 'my_aws_host',
    port: '3306',
    user: 'my_user',
    password: 'my_password',
    database: 'db_name'
});

function getSqlConnection() {
    return pool.getConnectionAsync().disposer(function (connection) {
        console.log("Releasing connection back to pool")
        connection.release();
    });
}

function querySql (query, params) {
    return Promise.using(getSqlConnection(), function (connection) {
        console.log("Got connection from pool");
        if (typeof params !== 'undefined'){
            return connection.queryAsync(query, params);
        } else {
            return connection.queryAsync(query);
        }
    });
};

module.exports = {
    getSqlConnection : getSqlConnection,
    querySql : querySql
};

usage_route.js

var express = require('express');
var router = express.Router();
var dateFormat = require('dateformat');
var db = require('../my_modules/db');
var getSqlConnection = db.getSqlConnection;
var querySql = db.querySql;
var Promise = require("bluebird");
function retrieveUser(token) {
var userQuery = "select id, email from users where token = ?";
return querySql(userQuery, [token])
.then(function(rows){
if (rows.length == 0) {
return Promise.reject("did not find user");
}
var user = rows[0];
return user;
});
}
router.post('/', function (req, res, next) {
Promise.resolve().then(function () {
return retrieveUser(req.body.token);
})
.then(function (user){
email = user.email;
res.status(200).json({ "code": 0, "message": "success", "email": email});
})
.catch(function (err) {
console.error("got error: " + err);
if (err instanceof Error) {
res.status(400).send("General error");
} else {
res.status(200).json({ "code": 1000, "message": err });
}
});
});
module.exports = router;

Pour répondre à votre question initiale: Comment cela peut-il être fait dans node.js dans un lisible?

Il y a une bibliothèque appelée coqui vous donne la possibilité d'écrire du code asynchrone en mode synchrone flux de travail. Juste un coup d'oeil et npm install co.

Le problème auquel vous êtes confronté très souvent avec cette approche, c'est que vous n'obtenez pas Promise de toutes les bibliothèques que vous utilisez. Si vous avez enveloppez-le vous-même (voir la réponse de @Joshua Holbrook) ou recherchez un wrapper (par exemple: npm install mysql-promise)

(Btw: sur la feuille de route pour ES7 à la prise en charge native pour ce type de flux de production avec les mots-clés async awaitmais ce n'est pas encore dans le nœud: le nœud de la liste des nouveautés.)

À l'aide du package promesse-mysql la logique serait de la chaîne promet l'aide d'alors(function(response){votre code})

et

catch(function(response){votre code}) pour détecter les erreurs de la "puis" blocs précédant le bloc catch.

Suivant cette logique, vous passerez des résultats de la requête dans des objets ou des tableaux à l'aide de retour à la fin du bloc. Le retour aidera à passer les résultats de la requête à l'autre bloc. Ensuite, le résultat sera trouvé en argument de la fonction (ici, il est test1). Selon cette logique, vous pouvez enchaîner plusieurs requêtes MySql et le code qui est nécessaire pour manipuler le résultat et de faire ce que vous voulez.

l'objet de Connexion est créée pour être mondial, car chaque objet et variable créée dans chaque bloc sont uniquement locales. N'oubliez pas que vous pouvez enchaîner plus "puis" blocs.

var config = {
host     : 'host',
user     : 'user',
password : 'pass',
database : 'database',
};
var mysql = require('promise-mysql');
var connection;
let thename =""; //which can also be an argument if you embed this code in a function
mysql.createConnection(config
).then(function(conn){
connection = conn;
let test = connection.query('select name from records WHERE name=? LIMIT 1',[thename]);
return test;
}).then(function(test1){
console.log("test1"+JSON.stringify(test1)); //result of previous block
var result = connection.query('select * from users'); //A second query if you want
connection.end();
connection = {};
return result;
}).catch(function(error){
if (connection && connection.end) connection.end();
//logs out the error from the previous block (if there is any issue add a second catch behind this one)
console.log(error);
});