मैं प्रश्न के जेएस वादा भाग के लिए स्कैला भविष्य का जवाब देने की कोशिश करूंगा। जैसा कि आपने कोई उदाहरण प्रदान नहीं किया है। मैं यहां रूपांतरण के साथ एक प्रदान करूंगा। हम कहते हैं कि हम एक भविष्य स्काला में इस तरह से लागू किया है, तो:
val f: Future = Future {
session.getX()
}
f onComplete {
case Success(data) => println(data)
case Failure(t) => println(t.getMessage)
}
तत्पश्चात JavaScript/ES6 में इसी कोड ऐसा दिखाई दे सकता:
var f = new Promise(function(resolve, reject) {
session.getX();
});
f.then((data) => {
console.log(data);
}).catch((t) => {
console.log(t);
}));
मैं जानता हूँ कि इस स्काला नहीं है, लेकिन मैं इसे पूर्णता के लिए शामिल करना चाहता था। यह Promise को Future की मैपिंग Scala.js डॉक्स से लिया है:
+-----------------------------------+------------------------+-------------------------------------------------------------------------------------------------------+
| Future | Promise | Notes |
+-----------------------------------+------------------------+-------------------------------------------------------------------------------------------------------+
| foreach(func) | then(func) | Executes func for its side-effects when the future completes. |
| map(func) | then(func) | The result of func is wrapped in a new future. |
| flatMap(func) | then(func) | func must return a future. |
| recover(func) | catch(func) | Handles an error. The result of func is wrapped in a new future. |
| recoverWith(func) | catch(func) | Handles an error. func must return a future. |
| filter(predicate) | N/A | Creates a new future by filtering the value of the current future with a predicate. |
| zip(that) | N/A | Zips the values of this and that future, and creates a new future holding the tuple of their results. |
| Future.successful(value) | Promise.resolve(value) | Returns a successful future containing value |
| Future.failed(exception) | Promise.reject(value) | Returns a failed future containing exception |
| Future.sequence(iterable) | Promise.all(iterable) | Returns a future that completes when all of the futures in the iterable argument have been completed. |
| Future.firstCompletedOf(iterable) | Promise.race(iterable) | Returns a future that completes as soon as one of the futures in the iterable completes. |
+-----------------------------------+------------------------+-------------------------------------------------------------------------------------------------------+
विवरण नहीं है, लेकिन सबसे आसान विकल्प कार्यों से जे एस तरफ वादा बनाना है। उदाहरण के लिए क्यू वादा लाइब्रेरी में है: q.promise (फ़ंक्शन (हल करें, अस्वीकार करें) {...}) –
क्या आपने देखा है कि Scala.js कैसे स्केल फ्यूचर्स को जेएस के वादे में परिवर्तित करता है और परिवर्तित करता है? –
मुझे लगता है कि प्ले फ्रेमवर्क के लिए एक पुस्तकालय है। play.lib.F.Promise में एक विधि 'लपेटें' है जो एक भविष्य में लिपटे वादे बनाता है, और 'लपेटा' जो भविष्य में लपेटा गया वादा करता है। – Chronos