既存のコールバックAPIをプログラムに変換する方法
私は約束をしたいのですが、私はコールバックAPIを次のような形式で持っています。
1. DOMロードまたはその他のワンタイムイベント
window.onload; // set to callback
...
window.onload = function() {
};
2.プレーンコールバック：
function request(onChangeHandler) {
...
}
request(function() {
// change happened
...
});
3.ノードスタイルコールバック（ "nodeback"）：
function getStuff(dat, callback) {
...
}
getStuff("dataParam", function(err, data) {
...
})
4.ノードスタイルのコールバックを持つライブラリ全体
API;
API.one(function(err, data) {
API.two(function(err, data2) {
API.three(function(err, data3) {
...
});
});
});
約束の中でAPIをどのように使用しますか、それをどのように「約束」しますか？
プロミスには状態があり、保留中として開始され、次のように解決できます。
- fulfilledは、計算が正常に完了したことを意味します。
- rejectedは、計算が失敗したことを意味します。
関数を返すことを約束 スローしない 、代わりに拒否を返す必要があります。 Promise Return関数からスローすると、} catch {and a .catchの両方を使用するように強制されます。約束されたAPIを使用している人々は、約束がスローされることを期待していません。 JSで非同期APIがどのように機能するかわからない場合は、最初に この回答を参照 してください.
1. DOMロードまたは他の1回限りのイベント：
したがって、プロミスの作成とは一般に、いつ決済するかを指定することを意味します。つまり、データが利用可能である（.thenでアクセスできる）ことを示すフルフィルメントまたはリジェクト段階に移動するタイミングを指定します。
ネイティブES6 PromiseのようなPromiseコンストラクターをサポートする最新のpromise実装では：
function load() {
return new Promise(function(resolve, reject) {
window.onload = resolve;
});
}
次に、結果のプロミスを次のように使用します。
load().then(function() {
// Do things after onload
});
遅延をサポートするライブラリを使用します（この例では$ qを使用しますが、後でjQueryも使用します）。
function load() {
var d = $q.defer();
window.onload = function() { d.resolve(); };
return d.promise;
}
または、jQueryのようなAPIを使用して、1回発生するイベントをフックします。
function done() {
var d = $.Deferred();
$("#myObject").once("click",function() {
d.resolve();
});
return d.promise();
}
2.プレーンコールバック：
これらのAPIは、JSではコールバックが一般的であるため、かなり一般的です。 onSuccessとonFailを持つ一般的なケースを見てみましょう。
function getUserData(userId, onLoad, onFail) { …
ネイティブES6 PromiseのようなPromiseコンストラクターをサポートする最新のpromise実装では：
function getUserDataAsync(userId) {
return new Promise(function(resolve, reject) {
getUserData(userId, resolve, reject);
});
}
遅延をサポートするライブラリを使用します（この例ではjQueryを使用しますが、上記の$ qも使用します）。
function getUserDataAsync(userId) {
var d = $.Deferred();
getUserData(userId, function(res){ d.resolve(res); }, function(err){ d.reject(err); });
return d.promise();
}
jQueryは$.Deferred(fn)フォームも提供します。これには、次のようにnew Promise(fn)フォームを非常に厳密にエミュレートする式を記述できるという利点があります。
function getUserDataAsync(userId) {
return $.Deferred(function(dfrd) {
getUserData(userId, dfrd.resolve, dfrd.reject);
}).promise();
}
注：ここでは、jQuery遅延オブジェクトのresolveおよびrejectメソッドが「取り外し可能」であるという事実を利用します。すなわち。これらは、jQuery.Deferred（）のinstanceにバインドされています。すべてのライブラリがこの機能を提供するわけではありません。
3. Nodeスタイルのコールバック（「ノードバック」）：
ノードスタイルのコールバック（ノードバック）には、コールバックが常に最後の引数であり、その最初のパラメーターがエラーである特定の形式があります。最初に手動で約束します。
getStuff("dataParam", function(err, data) { …
に：
function getStuffAsync(param) {
return new Promise(function(resolve, reject) {
getStuff(param, function(err, data) {
if (err !== null) reject(err);
else resolve(data);
});
});
}
遅延オブジェクトを使用すると、次の操作を実行できます（この例ではQを使用しますが、Qは新しい構文 これをお勧めします をサポートしています）：
function getStuffAsync(param) {
var d = Q.defer();
getStuff(param, function(err, data) {
if (err !== null) d.reject(err);
else d.resolve(data);
});
return d.promise;
}
一般に、手作業で多くの約束を立てるべきではありません。Nodeを念頭に置いて設計されたほとんどのpromiseライブラリとNode 8+のネイティブpromiseには、約束するための組み込みメソッドがあります。ノードバック。例えば
var getStuffAsync = Promise.promisify(getStuff); // Bluebird
var getStuffAsync = Q.denodeify(getStuff); // Q
var getStuffAsync = util.promisify(getStuff); // Native promises, node only
4.ノードスタイルのコールバックを備えたライブラリ全体：
ここには黄金のルールはありません、あなたはそれらを一つずつ約束します。ただし、一部のpromise実装では、たとえばBluebirdでこれを一括で行うことができます。ノードバックAPIをpromise APIに変換するのは次のように簡単です。
Promise.promisifyAll(API);
またはnative promises inNode：
const { promisify } = require('util');
const promiseAPI = Object.entries(API).map(([key, v]) => ({key, fn: promisify(v)}))
.reduce((o, p) => Object.assign(o, {[p.key]: p.fn}), {});
ノート：
- もちろん、
.thenハンドラーにいるときは、物事を約束する必要はありません。.thenハンドラーからプロミスを返すと、そのプロミスの値で解決または拒否されます。.thenハンドラーから投げることも良い習慣であり、約束を拒否します-これは有名な約束投げの安全性です。 - 実際の
onloadの場合、addEventListenerではなくonXを使用する必要があります。
今日、私はプレーンなJavascriptメソッドとしてNode.js内のPromiseを使用することができます。
Promiseの簡単で基本的な例（_ kiss _ way付き）：
Plain Javascript Async APIコード：
function divisionAPI (number, divider, successCallback, errorCallback) {
if (divider == 0) {
return errorCallback( new Error("Division by zero") )
}
successCallback( number / divider )
}
Promise Javascript Async APIコード：
function divisionAPI (number, divider) {
return new Promise(function (fulfilled, rejected) {
if (divider == 0) {
return rejected( new Error("Division by zero") )
}
fulfilled( number / divider )
})
}
（私は訪れることをお勧めします この美しい情報源 ）
また、Promiseをasync\awaitのES7と一緒に使用して、プログラムフローが次のようなfullfiledの結果を待つようにすることもできます。
function getName () {
return new Promise(function (fulfilled, rejected) {
var name = "John Doe";
// wait 3000 milliseconds before calling fulfilled() method
setTimeout (
function() {
fulfilled( name )
},
3000
)
})
}
async function foo () {
var name = await getName(); // awaits for a fulfilled result!
console.log(name); // the console writes "John Doe" after 3000 milliseconds
}
foo() // calling the foo() method to run the code
.then()メソッドを使用して同じコードで別の使用法
function getName () {
return new Promise(function (fulfilled, rejected) {
var name = "John Doe";
// wait 3000 milliseconds before calling fulfilled() method
setTimeout (
function() {
fulfilled( name )
},
3000
)
})
}
// the console writes "John Doe" after 3000 milliseconds
getName().then(function(name){ console.log(name) })
Promiseはreact-nativeのようなNode.jsに基づいているどんなプラットフォームでも使うことができます。
ボーナス：ハイブリッドメソッド
（コールバックメソッドはエラーと結果として2つのパラメータを持つと仮定されます）
function divisionAPI (number, divider, callback) {
return new Promise(function (fulfilled, rejected) {
if (divider == 0) {
let error = new Error("Division by zero")
callback && callback( error )
return rejected( error )
}
let result = number / divider
callback && callback( null, result )
fulfilled( result )
})
}
上記のメソッドは、昔ながらのコールバックとPromiseの使用法の結果に対応できます。
お役に立てれば。
約束どおりに関数を変換する前にNode.JSで
var request = require('request'); //http wrapped module
function requestWrapper(url, callback) {
request.get(url, function (err, response) {
if (err) {
callback(err);
}else{
callback(null, response);
}
})
}
requestWrapper(url, function (err, response) {
console.log(err, response)
})
変換後
var request = require('request');
function requestWrapper(url) {
return new Promise(function (resolve, reject) { //returning promise
request.get(url, function (err, response) {
if (err) {
reject(err); //promise reject
}else{
resolve(response); //promise resolve
}
})
})
}
requestWrapper('http://localhost:8080/promise_request/1').then(function(response){
console.log(response) //resolve callback(success)
}).catch(function(error){
console.log(error) //reject callback(failure)
})
複数のリクエストを処理する必要がある場合
var allRequests = [];
allRequests.Push(requestWrapper('http://localhost:8080/promise_request/1'))
allRequests.Push(requestWrapper('http://localhost:8080/promise_request/2'))
allRequests.Push(requestWrapper('http://localhost:8080/promise_request/5'))
Promise.all(allRequests).then(function (results) {
console.log(results);//result will be array which contains each promise response
}).catch(function (err) {
console.log(err)
});
@Benjaminによるwindow.onloadの提案は、ロード後に呼び出されるかどうかを検出しないため、常にうまくいくとは思いません。私はそのことに何度も噛まれてきました。これは常に動作するはずのバージョンです。
function promiseDOMready() {
return new Promise(function(resolve) {
if (document.readyState === "complete") return resolve();
document.addEventListener("DOMContentLoaded", resolve);
});
}
promiseDOMready().then(initOnLoad);
Node.js 8.0.0のリリース候補には、どんな機能を約束する能力をカプセル化した新しいユーティリティutil.promisify（私は util.promisify について書いた）があります。
他の回答で提案されているアプローチとそれほど違いはありませんが、コアメソッドであり、追加の依存関係を必要としないという利点があります。
const fs = require('fs');
const util = require('util');
const readFile = util.promisify(fs.readFile);
それからネイティブのreadFileを返すPromiseメソッドがあります。
readFile('./notes.txt')
.then(txt => console.log(txt))
.catch(...);
Node.js 8.0.0には、標準のNode.jsコールバックスタイルのAPIをPromiseを返す関数にラップすることを可能にする新しいutil.promisify() APIが含まれています。 util.promisify()の使用例を以下に示します。
const fs = require('fs');
const util = require('util');
const readFile = util.promisify(fs.readFile);
readFile('/some/file')
.then((data) => { /** ... **/ })
.catch((err) => { /** ... **/ });
Node JSではJavaScriptのネイティブな約束を使用できます。
My Cloud 9コードリンク： https://ide.c9.io/adx2803/native-promises-in-node
/**
* Created by dixit-lab on 20/6/16.
*/
var express = require('express');
var request = require('request'); //Simplified HTTP request client.
var app = express();
function promisify(url) {
return new Promise(function (resolve, reject) {
request.get(url, function (error, response, body) {
if (!error && response.statusCode == 200) {
resolve(body);
}
else {
reject(error);
}
})
});
}
//get all the albums of a user who have posted post 100
app.get('/listAlbums', function (req, res) {
//get the post with post id 100
promisify('http://jsonplaceholder.typicode.com/posts/100').then(function (result) {
var obj = JSON.parse(result);
return promisify('http://jsonplaceholder.typicode.com/users/' + obj.userId + '/albums')
})
.catch(function (e) {
console.log(e);
})
.then(function (result) {
res.end(result);
})
})
var server = app.listen(8081, function () {
var Host = server.address().address
var port = server.address().port
console.log("Example app listening at http://%s:%s", Host, port)
})
//run webservice on browser : http://localhost:8081/listAlbums
KriskowalによるQライブラリには、call-to-promise関数が含まれています。このような方法：
obj.prototype.dosomething(params, cb) {
...blah blah...
cb(error, results);
}
q.ninvokeで変換できます
Q.ninvoke(obj,"dosomething",params).
then(function(results) {
});
Promiseとasyncを組み込んでいるノードv7.6以降で：
// promisify.js
let promisify = fn => (...args) =>
new Promise((resolve, reject) =>
fn(...args, (err, result) => {
if (err) return reject(err);
return resolve(result);
})
);
module.exports = promisify;
使い方：
let readdir = require('fs').readdir;
let promisify = require('./promisify');
let readdirP = promisify(readdir);
async function myAsyncFn(path) {
let entries = await readdirP(path);
return entries;
}
普通の古いVanilla javaScriptを使って、これはAPIコールバックを約束するための解決策です。
function get(url, callback) {
var xhr = new XMLHttpRequest();
xhr.open('get', url);
xhr.addEventListener('readystatechange', function () {
if (xhr.readyState === 4) {
if (xhr.status === 200) {
console.log('successful ... should call callback ... ');
callback(null, JSON.parse(xhr.responseText));
} else {
console.log('error ... callback with error data ... ');
callback(xhr, null);
}
}
});
xhr.send();
}
/**
* @function promisify: convert api based callbacks to promises
* @description takes in a factory function and promisifies it
* @params {function} input function to promisify
* @params {array} an array of inputs to the function to be promisified
* @return {function} promisified function
* */
function promisify(fn) {
return function () {
var args = Array.prototype.slice.call(arguments);
return new Promise(function(resolve, reject) {
fn.apply(null, args.concat(function (err, result) {
if (err) reject(err);
else resolve(result);
}));
});
}
}
var get_promisified = promisify(get);
var promise = get_promisified('some_url');
promise.then(function (data) {
// corresponds to the resolve function
console.log('successful operation: ', data);
}, function (error) {
console.log(error);
});
Node.js 8では、このnpmモジュールを使って、 promisify オブジェクトメソッドオンザフライを実行できます。
https://www.npmjs.com/package/doasync
util.promisify および Proxies を使用するので、オブジェクトは変更されません。 Memoization もWeakMapsを使って行われます。ここではいくつかの例を示します。
オブジェクトを使って：
const fs = require('fs');
const doAsync = require('doasync');
doAsync(fs).readFile('package.json', 'utf8')
.then(result => {
console.dir(JSON.parse(result), {colors: true});
});
機能付き：
doAsync(request)('http://www.google.com')
.then(({body}) => {
console.log(body);
// ...
});
ネイティブなcallとapplyを使ってコンテキストをバインドすることもできます。
doAsync(myFunc).apply(context, params)
.then(result => { /*...*/ });
コールバックを受け取る関数がいくつかあり、代わりにpromiseを返すようにしたい場合は、この関数を使用して変換を行うことができます。
function callbackToPromise(func){
return function(){
// change this to use what ever promise lib you are using
// In this case i'm using angular $q that I exposed on a util module
var defered = util.$q.defer();
var cb = (val) => {
defered.resolve(val);
}
var args = Array.prototype.slice.call(arguments);
args.Push(cb);
func.apply(this, args);
return defered.promise;
}
}
コールバックスタイル 関数は常にこのようになっています（node.jsのほとんどすべての関数がこのスタイルです）。
//fs.readdir(path[, options], callback)
fs.readdir('mypath',(err,files)=>console.log(files))
このスタイルにも同じ機能があります。
コールバック関数は最後の引数で渡されます。
コールバック関数は、エラーオブジェクトを最初の引数として常に受け入れます。
だから、あなたはこのようなスタイルで関数を変換するための関数を書くことができます：
const R =require('ramda')
/**
* A convenient function for handle error in callback function.
* Accept two function res(resolve) and rej(reject) ,
* return a wrap function that accept a list arguments,
* the first argument as error, if error is null,
* the res function will call,else the rej function.
* @param {function} res the function which will call when no error throw
* @param {function} rej the function which will call when error occur
* @return {function} return a function that accept a list arguments,
* the first argument as error, if error is null, the res function
* will call,else the rej function
**/
const checkErr = (res, rej) => (err, ...data) => R.ifElse(
R.propEq('err', null),
R.compose(
res,
R.prop('data')
),
R.compose(
rej,
R.prop('err')
)
)({err, data})
/**
* wrap the callback style function to Promise style function,
* the callback style function must restrict by convention:
* 1. the function must put the callback function where the last of arguments,
* such as (arg1,arg2,arg3,arg...,callback)
* 2. the callback function must call as callback(err,arg1，arg2,arg...)
* @param {function} fun the callback style function to transform
* @return {function} return the new function that will return a Promise,
* while the Origin function throw a error, the Promise will be Promise.reject(error),
* while the Origin function work fine, the Promise will be Promise.resolve(args: array),
* the args is which callback function accept
* */
const toPromise = (fun) => (...args) => new Promise(
(res, rej) => R.apply(
fun,
R.append(
checkErr(res, rej),
args
)
)
)
より簡潔にするために、上記の例ではramda.jsを使用しました。 Ramda.jsは関数型プログラミングのための優れたライブラリです。上記のコードでは、 apply （javascript function.prototype.applyのように）およびappend（javascript function.prototype.Pushのように）を使用しました。そのため、コールバックスタイル関数をプロミススタイル関数に変換することができます。
const {readdir} = require('fs')
const readdirP = toPromise(readdir)
readdir(Path)
.then(
(files) => console.log(files),
(err) => console.log(err)
)
toPromise および checkErr 関数は berserk libraryが所有し、 ramda.js による関数型プログラミングライブラリフォークです（自分で作成）。
この答えがあなたに役立つことを願っています。
SetTimeoutを扱う例として、ES6では ネイティブPromise を使用できます。
enqueue(data) {
const queue = this;
// returns the Promise
return new Promise(function (resolve, reject) {
setTimeout(()=> {
queue.source.Push(data);
resolve(queue); //call native resolve when finish
}
, 10); // resolve() will be called in 10 ms
});
}
この例では、Promiseに失敗する理由はないため、reject()は呼び出されません。
あなたはこのようなことをすることができます
// @flow
const toPromise = (f: (any) => void) => {
return new Promise<any>((resolve, reject) => {
try {
f((result) => {
resolve(result)
})
} catch (e) {
reject(e)
}
})
}
export default toPromise
それを使う
async loadData() {
const friends = await toPromise(FriendsManager.loadFriends)
console.log(friends)
}
私のcallback関数の有望なバージョンはP関数です。
var P = function() {
var self = this;
var method = arguments[0];
var params = Array.prototype.slice.call(arguments, 1);
return new Promise((resolve, reject) => {
if (method && typeof(method) == 'function') {
params.Push(function(err, state) {
if (!err) return resolve(state)
else return reject(err);
});
method.apply(self, params);
} else return reject(new Error('not a function'));
});
}
var callback = function(par, callback) {
var rnd = Math.floor(Math.random() * 2) + 1;
return rnd > 1 ? callback(null, par) : callback(new Error("trap"));
}
callback("callback", (err, state) => err ? console.error(err) : console.log(state))
callback("callback", (err, state) => err ? console.error(err) : console.log(state))
callback("callback", (err, state) => err ? console.error(err) : console.log(state))
callback("callback", (err, state) => err ? console.error(err) : console.log(state))
P(callback, "promise").then(v => console.log(v)).catch(e => console.error(e))
P(callback, "promise").then(v => console.log(v)).catch(e => console.error(e))
P(callback, "promise").then(v => console.log(v)).catch(e => console.error(e))
P(callback, "promise").then(v => console.log(v)).catch(e => console.error(e))P関数は、コールバックシグネチャがcallback(error,result)であることを要求します。
以下は、関数（コールバックAPI）をプロミスに変換する方法の実装です。
function promisify(functionToExec) {
return function() {
var array = Object.values(arguments);
return new Promise((resolve, reject) => {
array.Push(resolve)
try {
functionToExec.apply(null, array);
} catch (error) {
reject(error)
}
})
}
}
// USE SCENARIO
function apiFunction (path, callback) { // Not a promise
// Logic
}
var promisedFunction = promisify(apiFunction);
promisedFunction('path').then(()=>{
// Receive the result here (callback)
})
// Or use it with await like this
let result = await promisedFunction('path');
es6-promisifyは、コールバックベースの関数をプロミスベースの関数に変換します。
const promisify = require('es6-promisify');
const promisedFn = promisify(callbackedFn, args);