CODEWITHSUNDEEP
exceloffice-js
Charles Williams
Charles Williams

Reputation: 23520

Why does this Context.Sync not work?

Why does this code snippet not write the values back to Excel unless I un-comment the range.values=range.values line?

$('#run').click(function() {
    invokeRun()
        .catch(OfficeHelpers.logError);
});
function invokeRun() {
    return Excel.run(function(context) {
        var range = context.workbook.worksheets.getItem("Sheet1").getRange("A1:B3");
        range.load('values');
        return context.sync()
            .then(function() {
               range.values[1][1]=99;
               console.log(JSON.stringify(range.values));
                //range.values=range.values
                return context.sync();
        });
    });
}

Upvotes: 1

Views: 660

Answers (1)

Michael Zlatkovsky
Michael Zlatkovsky

Reputation: 8670

Array properties are special. I have added a page on my website to describe the topic: Reading and writing array properties.

Summarizing from there, the way that the proxy-object model works, whenever you set a property on an object, the Office.js runtime has a hook into the setter and getter, which is used to intercept the call and add the command to the queue.

Let's take an example of a regular property first. Per the above, whenever you set something like range.format.fill.color = "red", the setter for the color property intercepts the request and internally adds a command into the queue to set the range fill color to red (to be dispatched with the next context.sync)

On the other hand, if all you had was var color = range.format.fill.color (after a load and a sync, of course), the getter would fire instead of the setter, and the color variable would get the range's current fill color.

Now, that was regular properties. Whenever you set an element of the array, you are effectively accessing the array value as a getter. From a runtime perspective, this line is no different from a slightly more verbose version:

var array = range.values;
array[r][c] = '-';

Because the getter for range.values returns a perfectly plain JS array object, accessing it and then setting its value does nothing to propagate it back to the original Range object.

If you want the values to get reflected back, the best thing is to get a reference to the array right after the sync (i.e., var array = range.values, just as above), then set the values on the array as needed, and then finally set it back to the object: range.values = array.

It means you could also modify the values array in place, and then assign the values property back to itself at the completion of the loop (range.values = range.values). However, this looks awkward, as if it’s a no-op, whereas in reality it is not. So personally, I prefer to retrieve the array at the beginning and assign it to its own variable, then do any necessary modifications, and finally set the full array back.

UPDATE to clarify the above:

To be very clear, the arrays returned by accessing the .values, .formulas, etc., ARE pure vanilla JS arrays. That's actually the crux of the problem: that in order for Office.js to return pure objects, it means that those pure objects can't be "spiked" with the ability to reflect changes.

For what it's worth, we actually have an upcoming feature that should be rolling out in a month or two, where we will be introducing an object.set syntax, as in:

range.set({
   values: [[1, 2], [3, 4]],
   format: {
       fill: {
           color: "purple"
       }
   }
}

This will make it more convenient to set multiple properties on the same object, but it might also make the array properties easier to deal with.

Upvotes: 3

Related Questions