Differing ways to make executeQueryAsync calls - Function.createDelegate (is old IE8 code)

Question

I want some understanding on two programming patterns I've seen and when to employ them. The question is about callbacks and delegate.

In the first code there are two distinct functions, success and fail, something I've always used, but the second code is different.

 function loadWebs() {

       var clientContext = new SP.ClientContext.get_current();

       this.webs = clientContext.get_web().get_webs();

       clientContext.load(this.webs);

       clientContext.executeQueryAsync(Function.createDelegate(this, this.onWebsLoaded), Function.createDelegate(this, this.onQueryFailed));

    }

    function onQueryFailed(sender, args) {

       alert('request failed ' + args.get_message() + '\n' + args.get_stackTrace());

    }

    function onWebsLoaded(sender, args) {

       for (var i = 0; i < this.webs.get_count(); i++) {

       alert(this.webs.itemAt(i).get_title());

       }    
    }

and the second code doesn't appear to use callbacks for the success, instead the success is wrapped in the parent function.

  myCtx.load(webs, "Include(Id, Lists)");

    myCtx.executeQueryAsync(function () {
        // push new SP.ListItemCollections into an array and tell the ctx to fetch them
        for (var i = 0; i < webs.get_data().length; i++) {
            var web = webs.get_data()[i], itms;  
     if (checkForProjectsList(web)) {
                itms = webs.get_data()[i].get_lists()
                           .getByTitle("Projects").getItems(query);
                queryItemCollections.push(itms);
                myCtx.load(itms);
            }



        }


    myCtx.executeQueryAsync(function () {
            queryItemCollections.forEach(function (item) {
                // do work with individual list items here
                console.log(item.getItemAtIndex(0).get_item("Title"));
            });
        }, genericFailHandler);
    }, genericFailHandler);


function genericFailHandler(sender, args) {
        console.log(args.get_message());
    }

Thanks

Answer 1

• https://msdn.microsoft.com/en-us/library/office/dn168907.aspx

states:

SP.ClientContext.executeQueryAsync( succeededCallback , failedCallback )

So in both your examples you are referencing a function (callback) as parameter.
The only difference being the declaration of the function.

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions

With

clientContext.executeQueryAsync(
    function () {
        queryItemCollections.forEach(function (item) {
            console.log(item.getItemAtIndex(0).get_item("Title"));
        });
    }
  , genericFailHandler
);

you create a (anonymous) Success function callback (expression) which can not be (re)used by any other code.

While with:

clientContext.executeQueryAsync(
  Function.createDelegate(this, this.onWebsLoaded),
  Function.createDelegate(this, this.onQueryFailed)
);

you have declared seperate functions, so you could use that function (declaration) for other calls as well.

Function.createDelegate

Is (old, never a official standard) JavaScript code to bind the outer function this context to your function, it is supported in all browsers.
.bind(this) is standard ES5 JavaScript code
IE9 was the first IE version to support this .bind() notation. You need a Polyfill to support older IE browsers

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/this

So

clientContext.executeQueryAsync(
  this.onWebsLoaded.bind(this),
  this.onQueryFailed.bind(this)
);

is a more modern notation

But in your examples above you do nothing with the this context inside the Fail function.

So you might as well write:

clientContext.executeQueryAsync(
  this.onWebsLoaded.bind(this),
  this.onQueryFailed
);

And since your first example declares those functions as Global functions, you can write:

clientContext.executeQueryAsync(
  onWebsLoaded.bind(this),
  onQueryFailed
);

Learning this

• http://www.sitepoint.com/inner-workings-javascripts-this-keyword/

Is a cool blog which also lets you play with this in JSBins

---

Great explanation (including modern Arrow Functions):

http://2ality.com/2017/12/alternate-this.html

---

J1 J5 JSOM JX iBind