Ersetzen von Rückrufen durch Versprechen in Node.js

Habe ich eine einfache Knoten-Modul, welches eine Verbindung zu einer Datenbank und hat mehrere Funktionen, um Daten zu empfangen, zum Beispiel diese Funktion:

dbConnection.js:

import mysql from 'mysql';

const connection = mysql.createConnection({
  host: 'localhost',
  user: 'user',
  password: 'password',
  database: 'db'
});

export default {
  getUsers(callback) {
    connection.connect(() => {
      connection.query('SELECT * FROM Users', (err, result) => {
        if (!err){
          callback(result);
        }
      });
    });
  }
};

Des Moduls aufgerufen werden würde, auf diese Weise von einem anderen Knoten, Modul:

app.js:

import dbCon from './dbConnection.js';

dbCon.getUsers(console.log);

Möchte ich nutzen, verspricht anstelle von Rückrufen, um die Daten zurückzugeben.
So weit ich gelesen habe, über verschachtelte verspricht in den folgenden thread: Schreiben Sauberen Code Mit Verschachtelten Verspricht, aber ich konnte nicht finden keine Lösung, die einfach genug für diesen Anwendungsfall.
Was wäre der richtige Weg, um wieder result mit einem Versprechen?

InformationsquelleAutor der Frage Lior Erez | 2015-02-10

Mit der `Promise` Klasse

Empfehle ich einen Blick auf MDN Versprechen docsdie bieten einen guten Ausgangspunkt für die Nutzung Verspricht. Alternativ, ich bin sicher, es gibt viele tutorials online verfügbar.:)

Hinweis: Moderne Browser unterstützen bereits ECMAScript-6-Spezifikation von Versprechungen (sehen Sie MDN docs weiter oben verlinkt), und ich nehme an, Sie wollen, verwenden Sie die native Implementierung, ohne 3rd-party-Bibliotheken.

Als für ein Aktuelles Beispiel...

Das Grundprinzip funktioniert wie folgt:

Ihre API aufgerufen wird
Erstellen Sie ein neues Promise-Objekt, dieses Objekt nimmt eine Funktion als Konstruktor-parameter
Ihre angegebene Funktion aufgerufen wird, die von der zugrunde liegenden Implementierung und die Funktion ist gegeben zwei Funktionen - resolve und reject
Nachdem Sie Ihre Logik, Sie rufen diese entweder erfüllen Sie das Versprechen oder ablehnen, es mit einem Fehler

Dies mag wie eine Menge, so ist hier ein Aktuelles Beispiel.

exports.getUsers = function getUsers () {
  //Return the Promise right away, unless you really need to
  //do something before you create a new Promise, but usually
  //this can go into the function below
  return new Promise((resolve, reject) => {
    //reject and resolve are functions provided by the Promise
    //implementation. Call only one of them.

    //Do your logic here - you can do WTF you want.:)
    connection.query('SELECT * FROM Users', (err, result) => {
      //PS. Fail fast! Handle errors first, then move to the
      //important stuff (that's a good practice at least)
      if (err) {
        //Reject the Promise with an error
        return reject(err)
      }

      //Resolve (or fulfill) the promise with data
      return resolve(result)
    })
  })
}

//Usage:
exports.getUsers()  //Returns a Promise!
  .then(users => {
    //Do stuff with users
  })
  .catch(err => {
    //handle errors
  })

Mithilfe der async/await-Sprache-Funktion (Node.js >=7.6)

In Node.js 7.6, die v8-JavaScript-compiler wurde aktualisiert mit async/await-Unterstützung. Können Sie jetzt erklären, die Funktionen als asyncwas bedeutet, dass Sie automatisch wieder ein Promise ist aufgelöst, wenn die asynchrone Funktion Ausführung abgeschlossen ist. Innerhalb dieser Funktion, die Sie verwenden können, die await Stichwort zu warten, bis ein anderes Versprechen löst.

Hier ist ein Beispiel:

exports.getUsers = async function getUsers() {
  //We are in an async function - this will return Promise
  //no matter what.

  //We can interact with other functions which return a
  //Promise very easily:
  const result = await connection.query('select * from users')

  //Interacting with callback-based APIs is a bit more
  //complicated but still very easy:
  const result2 = await new Promise((resolve, reject) => {
    connection.query('select * from users', (err, res) => {
      return void err ? reject(err) : resolve(res)
    })
  })
  //Returning a value will cause the promise to be resolved
  //with that value
  return result
}

InformationsquelleAutor der Antwort Robert Rossmann

Mit bluebird können Sie Versprechen.promisifyAll (und Versprechen.promisify) hinzufügen Versprechen bereit, Methoden auf jedes Objekt.

var Promise = require('bluebird');
//Somewhere around here, the following line is called
Promise.promisifyAll(connection);

exports.getUsersAsync = function () {
    return connection.connectAsync()
        .then(function () {
            return connection.queryAsync('SELECT * FROM Users')
        });
};

Und verwenden, wie diese:

getUsersAsync().then(console.log);

oder

//Spread because MySQL queries actually return two resulting arguments, 
//which Bluebird resolves as an array.
getUsersAsync().spread(function(rows, fields) {
    //Do whatever you want with either rows or fields.
});

Hinzufügen Entsorger

Bluebird unterstützt eine Menge von Funktionen, einer von Ihnen ist der Entsorger, es erlaubt Ihnen, sicher zu entsorgen, wird eine Verbindung, nachdem es endete mit der Hilfe von Promise.using und Promise.prototype.disposer. Hier ist ein Beispiel aus meiner app:

function getConnection(host, user, password, port) {
    //connection was already promisified at this point

    //The object literal syntax is ES6, it's the equivalent of
    //{host: host, user: user, ... }
    var connection = mysql.createConnection({host, user, password, port});
    return connection.connectAsync()
        //connect callback doesn't have arguments. return connection.
        .return(connection) 
        .disposer(function(connection, promise) { 
            //Disposer is used when Promise.using is finished.
            connection.end();
        });
}

Dann verwenden Sie es wie diese:

exports.getUsersAsync = function () {
    return Promise.using(getConnection()).then(function (connection) {
            return connection.queryAsync('SELECT * FROM Users')
        });
};

Dadurch wird automatisch die Verbindung, sobald das Versprechen aufgelöst wird, mit dem Wert (oder lehnt Sie mit einer Error).

InformationsquelleAutor der Antwort Madara Uchiha

Node.js version 8.0.0+:

Brauchen Sie nicht zu verwenden, bluebird zu promisify der node-API-Methoden mehr. Weil, von version 8+, die Sie verwenden können native util.promisify:

const util = require('util');

const connectAsync = util.promisify(connection.connectAsync);
const queryAsync = util.promisify(connection.queryAsync);

exports.getUsersAsync = function () {
    return connectAsync()
        .then(function () {
            return queryAsync('SELECT * FROM Users')
        });
};

Nun, nicht zu verwenden 3rd-party-lib zu tun die promisify.

InformationsquelleAutor der Antwort asmmahmud

Vorausgesetzt, Ihr Datenbank-adapter-API nicht ausgeben Promises selbst können Sie etwas tun:

exports.getUsers = function () {
    var promise;
    promise = new Promise();
    connection.connect(function () {
        connection.query('SELECT * FROM Users', function (err, result) {
            if(!err){
                promise.resolve(result);
            } else {
                promise.reject(err);
            }
        });
    });
    return promise.promise();
};

Wenn die Datenbank-API unterstützt Promises Sie könnten etwas tun wie: (hier sehen Sie die macht von Versprechen, Ihre callback-fluff ziemlich viel verschwindet)

exports.getUsers = function () {
    return connection.connect().then(function () {
        return connection.query('SELECT * FROM Users');
    });
};

Mit .then() um wieder eine neue (geschachtelte) Versprechen.

Anruf mit:

module.getUsers().done(function (result) { /* your code here */ });

Habe ich eine mockup-API für mein Versprechen, Ihre API anders sein kann. Wenn Sie mir zeigen, Ihre API kann ich es individuell.

InformationsquelleAutor der Antwort Halcyon

2

Beim einrichten eines Versprechen, Sie nehmen zwei Parameter resolve und reject. Im Falle von Erfolg, rufen Sie resolve mit dem Ergebnis, im Falle des Scheiterns nennen reject mit dem Fehler.

Dann können Sie schreiben:
```
getUsers().then(callback)
```
callback aufgerufen werden, mit dem Ergebnis, das Versprechen zurück von getUsersd.h. result

InformationsquelleAutor der Antwort Tom

Mit Hilfe der Q-Bibliothek Beispiel:

function getUsers(param){
    var d = Q.defer();

    connection.connect(function () {
    connection.query('SELECT * FROM Users', function (err, result) {
        if(!err){
            d.resolve(result);
        }
    });
    });
    return d.promise;   
}

InformationsquelleAutor der Antwort satchcoder

Code unten funktioniert nur bei Knoten -v - > 8.x

Ich diese Promisified MySQL middleware für Node.js

Lesen Sie diesen Artikel Erstellen der MySQL-Datenbank-Middleware mit Node.js 8 und Async/Await

database.js

var mysql = require('mysql'); 

//node -v must > 8.x 
var util = require('util');


// !!!!! for node version < 8.x only  !!!!!
//npm install util.promisify
//require('util.promisify').shim();
//-v < 8.x  has problem with async await so upgrade -v to v9.6.1 for this to work. 



//connection pool https://github.com/mysqljs/mysql   [1]
var pool = mysql.createPool({
  connectionLimit : process.env.mysql_connection_pool_Limit, //default:10
  host     : process.env.mysql_host,
  user     : process.env.mysql_user,
  password : process.env.mysql_password,
  database : process.env.mysql_database
})


//Ping database to check for common exception errors.
pool.getConnection((err, connection) => {
if (err) {
    if (err.code === 'PROTOCOL_CONNECTION_LOST') {
        console.error('Database connection was closed.')
    }
    if (err.code === 'ER_CON_COUNT_ERROR') {
        console.error('Database has too many connections.')
    }
    if (err.code === 'ECONNREFUSED') {
        console.error('Database connection was refused.')
    }
}

if (connection) connection.release()

 return
 })

//Promisify for Node.js async/await.
 pool.query = util.promisify(pool.query)



 module.exports = pool

Müssen Sie ein upgrade node-v > 8.x

müssen Sie async-Funktion nutzen zu können, erwarten Sie.

Beispiel:

   var pool = require('./database')

  //node -v must > 8.x, --> async /await  
  router.get('/:template', async function(req, res, next) 
  {
      ...
    try {
         var _sql_rest_url = 'SELECT * FROM arcgis_viewer.rest_url WHERE id='+ _url_id;
         var rows = await pool.query(_sql_rest_url)

         _url  = rows[0].rest_url //first record, property name is 'rest_url'
         if (_center_lat   == null) {_center_lat = rows[0].center_lat  }
         if (_center_long  == null) {_center_long= rows[0].center_long }
         if (_center_zoom  == null) {_center_zoom= rows[0].center_zoom }          
         _place = rows[0].place


       } catch(err) {
                        throw new Error(err)
       }

InformationsquelleAutor der Antwort hoogw

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Mit der Promise Klasse

Mithilfe der async/await-Sprache-Funktion (Node.js >=7.6)

Hinzufügen Entsorger

Mit der `Promise` Klasse