chaining

I'm trying to chain nested .then functions and call the success functions, but call back is calling in the starting itself. //public method fn function fn(callback) { //calling the 1st API request fn1() .then(function(response) { //2nd API request function call1(response); }, function(error) { return $q.reject({ responseStatus: error.status }); }) // Returning response .then(function(response) { callback({ responseStatus: 200 }); }, function(error) { callback({ responseStatus: 500 }); }); } function call1(response) { //2nd API fn2() .then(function(response) { //3rd API request function call2

I have an object ( foo ) that exposes several methods as promises (using JQuery deferred). The way I did it ended up with this kind of code: var foo = createNewFoo(); $.when(foo.method1(arg)) .then(foo.method2) .then(foo.method3); I wish to refactor my code to something nicer, like this: var foo = createNewFoo() .method1(arg) .method2() .method3(); But I'm not sure how to implement foo so it would be possible. Yes sure, you just need to extend your Deferred s to have these methods: function MyRpc { // if you can use ES2015 - this should be a `class` this._deferred = new $.Deferred(); } //

I want to make a function that add an item to my localStorage object. E.g.: alert(localStorage.getItem('names').addItem('Bill').getItem('names')); The first method is getItem which gets the item for localStorage objects... but addItem would be a custom function. This chain of functions would finally alert Bill. So, how would I make this function chain to localStorage? This is possible if you create a wrapper/decorator object that makes chaining possible. This is how jQuery works for example. But it is useless in this case . I made a possible implementation, though. But getItem will break the

I'm trying to learn how to use promises, but am having trouble comprehending the chaining. I assume that with this code, both promises will run. Then when I call test.then() it should know that test has resolved and pass the resolve data to then(). Once that function finishes, it goes onto the next then(), repeating the same process with the test2 promise. However, I can only get it to print out the first promise results, not the second. Any ideas what is missing here? var test = new Promise(function(resolve, reject){ resolve('done1'); }); var test2 = new Promise(function(resolve, reject){

I have a component which first need to call a service that POST something. Then in the same component I want to wait until the POST is done, to call another service which GETs data. How can I make the GET call wait for the POST call to finish? In new-version.component.ts: private createNewVersion(value) { ... // create new version, then call on all available versions // POST call this._newVersionService.createNewVersion(vnr); // GET call this._versionService.getAvailableVersions(); ... } In new-version.service.ts: export class NewVersionService { response$: Subject<any>; constructor(private

I've seen a slide that presented Fab , a node.js framework. Is this JavaScript? Could someone explain what is going on in that code? I'm all lost. Is plain JavaScript, it is a function chaining pattern. The first line, ( fab = require("fab") ) includes the fab function and returns a reference to it. All the subsequent parentheses are function calls, each function invocation returns probably the same function again and again. The pattern probably looks like this simplified example: var foo = function (arg) { // detect what the argument is if (typeof arg == 'function') { // do something with arg

Given this following sample code which clones a table row, sets some properties and then appends it to a table: $("#FundTable").append( objButton.parents("tr").clone() .find(".RowTitle").text("Row " + nAddCount).end() .find(".FundManagerSelect").attr("id", "FundManager" + nAddCount) .change(function() { ChangeFundRow(); }).end() .find(".FundNameSelect").attr("id", "FundName" + nAddCount).end() ); Does anyone have any suggestions as to how this might be formatted to be easier on the eye? Is there any accepted convention for doing this? It would be useful to have a set of rules that can be

I have got the following prototype chain SuperSuperClass SuperClass Class each with a method named do . What is the common approach for calling the respective super class method? For the moment I use <ClassName>.prototype.__proto__.<methodName>.call(this) but that looks odd. Using the following code the console prints (as expected): Class.prototype.do SuperClass.prototype.do SuperSuperClass.prototype.do SuperSuperClass = function SuperSuperClass() {} SuperSuperClass.prototype.do = function() { console.log('SuperSuperClass.prototype.do'); }; function SuperClass() { SuperSuperClass.call(this); }