मैं मौजूदा कॉलबैक API को वादों में कैसे बदलूं?
मैं वादों के साथ काम करना चाहता हूं लेकिन मेरे पास प्रारूप में एक कॉलबैक एपीआई है जैसे:
1. डोम लोड या अन्य एक समय घटना:
window.onload; // set to callback
...
window.onload = function() {
};
2. सादा कॉलबैक:
function request(onChangeHandler) {
...
}
request(function() {
// change happened
...
});
3. नोड शैली कॉलबैक ("नोडबैक"):
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) {
...
});
});
});
मैं वादों में एपीआई के साथ कैसे काम कर सकता हूं, मैं इसे कैसे "प्रॉमिस" करूं?
जवाब
वादे में राज्य है, वे लंबित के रूप में शुरू करते हैं और इसके लिए व्यवस्थित हो सकते हैं:
- पूरा जिसका अर्थ है कि गणना सफलतापूर्वक पूर्ण हुआ।
- अस्वीकार कर दिया कि अभिकलन विफल हो गया।
वादा वापसी कार्यों को कभी नहीं फेंकना चाहिए, उन्हें बदले में अस्वीकार करना चाहिए। एक वादा वापसी समारोह से फेंकना आपको ए } catch { और ए दोनों का उपयोग करने के लिए मजबूर करेगा .catch। प्रॉमिस किए गए API का उपयोग करने वाले लोग वादे को फेंकने की उम्मीद नहीं करते हैं। यदि आप सुनिश्चित नहीं हैं कि JS में async API कैसे काम करती है - तो कृपया इस उत्तर को पहले देखें।
1. डोम लोड या अन्य एक समय घटना:
इसलिए, वादे करने का मतलब आम तौर पर निर्दिष्ट होता है जब वे बसते हैं - इसका मतलब है कि जब वे डेटा उपलब्ध है (और साथ पहुँचा जा सकता है .then) इंगित करने के लिए पूर्ण या अस्वीकार किए गए चरण पर जाते हैं ।
आधुनिक वादे के कार्यान्वयन के साथ, जो Promiseनिर्माणकर्ता को मूल ES6 वादों का समर्थन करता है:
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 के साथ, एक बार हो रही घटना पर हुकिंग:
function done() {
var d = $.Deferred();
$("#myObject").once("click",function() {
d.resolve();
});
return d.promise();
}
2. सादा कॉलबैक:
ये API अच्छी तरह से सामान्य हैं ... जेएस में कॉलबैक सामान्य हैं। आइए देखते हैं कि आम मामला क्या है onSuccessऔर onFail:
function getUserData(userId, onLoad, onFail) { …
आधुनिक वादे के कार्यान्वयन के साथ, जो Promiseनिर्माणकर्ता को मूल ES6 वादों का समर्थन करता है:
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 () के उदाहरण के लिए बाध्य हैं । सभी लिबास इस सुविधा की पेशकश नहीं करते हैं।
3. नोड शैली कॉलबैक ("नोडबैक"):
नोड शैली कॉलबैक (नोडबैक) का एक विशेष प्रारूप है जहां कॉलबैक हमेशा अंतिम तर्क होता है और इसका पहला पैरामीटर त्रुटि है। आइए पहले एक मैन्युअल रूप से प्रचारित करें:
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;
}
सामान्य तौर पर, आपको मैन्युअल रूप से बहुत अधिक चीजों का वादा नहीं करना चाहिए, अधिकांश वादा पुस्तकालयों को जो नोड के साथ-साथ नोड 8+ में मूल वादों को ध्यान में रखते हुए डिजाइन किए गए थे, में नोडबैक को बढ़ावा देने के लिए एक अंतर्निहित विधि है। उदाहरण के लिए
var getStuffAsync = Promise.promisify(getStuff); // Bluebird
var getStuffAsync = Q.denodeify(getStuff); // Q
var getStuffAsync = util.promisify(getStuff); // Native promises, node only
4. नोड शैली कॉलबैक के साथ एक पूरी लाइब्रेरी:
यहां कोई सुनहरा नियम नहीं है, आप उन्हें एक-एक करके प्रॉमिस करते हैं। हालाँकि, कुछ वादे क्रियान्वयन आपको थोक में ऐसा करने की अनुमति देते हैं, उदाहरण के लिए ब्लूबर्ड में, एक नोड एपीआई को एक वादा एपीआई में परिवर्तित करना उतना ही सरल है:
Promise.promisifyAll(API);
या नोड में देशी वादों के साथ :
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।
आज, मैं एक सादे जावास्क्रिप्ट विधि के रूप Promiseमें उपयोग कर सकता हूं Node.js।
करने के लिए एक सरल और बुनियादी उदाहरण Promise(के साथ KISS रास्ता):
सादा जावास्क्रिप्ट Async एपीआई कोड:
function divisionAPI (number, divider, successCallback, errorCallback) {
if (divider == 0) {
return errorCallback( new Error("Division by zero") )
}
successCallback( number / divider )
}
Promise जावास्क्रिप्ट Async एपीआई कोड:
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किसी भी प्लेटफ़ॉर्म पर इस्तेमाल किया जा सकता है जो कि Node.js पर आधारित है react-native।
बोनस : एक संकर विधि
(कॉलबैक पद्धति को त्रुटि और परिणाम के रूप में दो मानदंड हैं)
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 )
})
}
उपरोक्त विधि पुराने फैशन कॉलबैक और प्रोमिस usages के लिए परिणाम का जवाब दे सकती है।
उम्मीद है की यह मदद करेगा।
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)
});
मुझे नहीं लगता कि window.onload@Benjamin द्वारा सुझाव हर समय काम करेगा, क्योंकि यह पता नहीं लगाता है कि यह लोड के बाद कहा जाता है या नहीं। मुझे वह कई बार काट चुका है। यहाँ एक संस्करण है जो हमेशा काम करना चाहिए:
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()API शामिल है जो मानक Node.js कॉलबैक शैली 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 8.0.0 के लिए जारी करने वाले उम्मीदवार में, एक नई उपयोगिता है, util.promisify(मैंने use.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(...);
आप नोड जेएस के साथ जावास्क्रिप्ट देशी वादों का उपयोग कर सकते हैं।
मेरा क्लाउड 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
सादे पुराने वेनिला जावास्क्रिप्ट के साथ, यहाँ एक एपि कॉलबैक को बढ़ावा देने के लिए एक समाधान है।
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);
});
Kriskowal द्वारा Q लाइब्रेरी में कॉलबैक-टू-वादा कार्य शामिल हैं। इस तरह एक विधि:
obj.prototype.dosomething(params, cb) {
...blah blah...
cb(error, results);
}
Q.ninvoke के साथ परिवर्तित किया जा सकता है
Q.ninvoke(obj,"dosomething",params).
then(function(results) {
});
जब आपके पास कुछ कार्य होते हैं जो कॉलबैक लेते हैं और आप चाहते हैं कि वे एक वादा वापस करें, तो आप इस फ़ंक्शन का उपयोग रूपांतरण करने के लिए कर सकते हैं।
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;
}
}
नोड v7.6 + के तहत जो वादे और async में बनाया गया है:
// 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;
}
Node.js 8 में आप इस npm मॉड्यूल का उपयोग करके मक्खी पर ऑब्जेक्ट विधियों का वादा कर सकते हैं :
https://www.npmjs.com/package/doasync
यह use.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 => { /*...*/ });
सेट टाइमआउट से निपटने के लिए आप ES6 में मूल वचन का उपयोग कर सकते हैं :
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
});
}
इस छूट में, वादे के असफल होने का कोई कारण नहीं है, इसलिए reject()इसे कभी नहीं कहा जाता है।
कॉलबैक शैली (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 कार्यात्मक प्रोग्रामिंग के लिए एक उत्कृष्ट पुस्तकालय है। उपरोक्त कोड में, हम यह प्रयोग किया जाता है लागू (जावास्क्रिप्ट की तरह function.prototype.apply) और संलग्न (जावास्क्रिप्ट की तरह function.prototype.push)। तो, अब हम कॉलबैक शैली फ़ंक्शन को शैली फ़ंक्शन का वादा करने के लिए बदल सकते हैं:
const {readdir} = require('fs')
const readdirP = toPromise(readdir)
readdir(Path)
.then(
(files) => console.log(files),
(err) => console.log(err)
)
.Promise और checkErr फ़ंक्शन berserk पुस्तकालय द्वारा स्वयं का है , यह ramda.js द्वारा एक कार्यात्मक प्रोग्रामिंग लाइब्रेरी कांटा है (मेरे द्वारा बनाएं)।
आशा है कि यह उत्तर आपके लिए उपयोगी है।
आप ऐसा कुछ कर सकते हैं
// @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)
}
es6-promisify कॉलबैक-आधारित फ़ंक्शंस को प्रोमिस-आधारित फ़ंक्शंस में कनवर्ट करता है।
const promisify = require('es6-promisify');
const promisedFn = promisify(callbackedFn, args);
किसी 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)।
नीचे एक कार्यान्वयन (कॉलबैक एपीआई) कैसे एक वादा में परिवर्तित किया जा सकता है का कार्यान्वयन है।
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');
भविष्य से 😄
एक सामान्य जेनेरिक फ़ंक्शन जिसका मैं सामान्य रूप से उपयोग करता हूं।
const promisify = (fn, ...args) => {
return new Promise((resolve, reject) => {
fn(...args, (err, data) => {
if (err) {
return reject(err);
}
resolve(data);
});
});
};
इसे कैसे उपयोग करे
promisify(fn, arg1, arg2)
आप शायद इस उत्तर को नहीं देख रहे हैं, लेकिन यह उपलब्ध बर्तनों के आंतरिक कामकाज को समझने में मदद करेगा