Node.jsでコールバックをプロミスに置き換える
データベースに接続し、データを受信するためのいくつかの機能、たとえばこの機能を備えた単純なノードモジュールがあります。
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);
}
});
});
}
};
モジュールは、別のノードモジュールから次のように呼び出されます。
app.js：
import dbCon from './dbConnection.js';
dbCon.getUsers(console.log);
データを返すために、コールバックの代わりにプロミスを使用したいと思います。これまで、次のスレッドでネストされたプロミスについて読みました： Nested Promisesを使用したクリーンなコードの記述 promiseを使用してresultを返す正しい方法は何でしょうか？
Promiseクラスを使用する
MDNのPromise docs をご覧になることをお勧めします。これは、Promiseを使用するための良い出発点となります。または、オンラインで利用できる多くのチュートリアルがあると確信しています:)
注：最新のブラウザはすでにPromiseのECMAScript 6仕様をサポートしています（上記のMDNドキュメントを参照）。ネイティブ実装を使用し、サードパーティのライブラリ。
実際の例については...
基本原則は次のように機能します。
- APIが呼び出されます
- 新しいPromiseオブジェクトを作成します。このオブジェクトは、コンストラクターパラメーターとして1つの関数を取ります
- 提供された関数は、基礎となる実装によって呼び出され、その関数には2つの関数
resolveとrejectが与えられます - ロジックを実行したら、これらのいずれかを呼び出してPromiseをフルフィルするか、エラーで拒否します
これは多くのように見えるかもしれませんので、ここに実際の例があります。
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
})
Async/await言語機能の使用（Node.js> = 7.6）
Node.js 7.6では、v8 JavaScriptコンパイラが async/await support でアップグレードされました。関数をasyncとして宣言できるようになりました。これは、非同期関数が実行を完了すると解決されるPromiseを自動的に返すことを意味します。この関数内では、awaitキーワードを使用して、別のPromiseが解決するまで待機できます。
以下に例を示します。
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
}
bluebirdでは、 Promise.promisifyAll （および Promise.promisify ）を使用して、 Promise readyメソッドを任意のオブジェクトに追加します。
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')
});
};
そして、次のように使用します：
getUsersAsync().then(console.log);
または
// 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.
});
ディスポーザを追加する
Bluebirdは多くの機能をサポートしています。そのうちの1つはディスポーザです。これにより、Promise.usingおよびPromise.prototype.disposerの助けを借りて、接続が終了した後に安全に破棄できます。これが私のアプリの例です：
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();
});
}次に、次のように使用します。
exports.getUsersAsync = function () {
return Promise.using(getConnection()).then(function (connection) {
return connection.queryAsync('SELECT * FROM Users')
});
};Promiseが値で解決される（またはErrorで拒否される）と、これは自動的に接続を終了します。
Node.jsバージョン8.0.0 +：
ノードAPIメソッドを約束するために bluebird を使用する必要はもうありません。なぜなら、バージョン8以降では、ネイティブ til.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')
});
};
ここで、約束を行うためにサードパーティのライブラリを使用する必要はありません。
データベースアダプタAPIがPromises自体を出力しないと仮定すると、次のようなことができます。
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();
};
データベースAPIがPromisesをサポートしている場合、次のようなことができます：（ここでPromisesの力を見ると、callback fluffはほとんど消えます）
exports.getUsers = function () {
return connection.connect().then(function () {
return connection.query('SELECT * FROM Users');
});
};
.then()を使用して、新しい（ネストされた）promiseを返します。
で呼び出す：
module.getUsers().done(function (result) { /* your code here */ });
PromiseにモックアップAPIを使用しましたが、APIは異なる場合があります。あなたのAPIを見せてくれれば、私はそれを調整することができます。
プロミスを設定するとき、2つのパラメーター、resolveおよびrejectを使用します。成功した場合は結果でresolveを呼び出し、失敗した場合はエラーでrejectを呼び出します。
次に書くことができます：
getUsers().then(callback)
callbackは、getUsersから返されたプロミスの結果、つまりresultで呼び出されます
たとえば、Qライブラリを使用します。
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;
}
2019年：
ネイティブモジュールconst {promisify} = require('util');を使用して、単純な古いコールバックパターンを約束のパターンに変換し、async/awaitコードから利益を得ることができます。
const {promisify} = require('util');
const glob = promisify(require('glob'));
app.get('/', async function (req, res) {
var glob = promisify(require('glob'));
const files = await glob('src/**/*-spec.js');
res.render('mocha-template-test', {files});
});
以下のコードは、ノード-v> 8.xでのみ機能します
私はこれを使用します Node.jsのMySQLミドルウェアの約束
この記事を読む Node.js 8とAsync/Awaitを使用してMySQLデータベースミドルウェアを作成する
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
Node -v> 8.xをアップグレードする必要があります
awaitを使用するには、非同期関数を使用する必要があります。
例：
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)
}